QuantumChecker 0.2.5__tar.gz → 0.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuantumChecker
-Version: 0.2.5
+Version: 0.2.7
 Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
 Author: Qobiljon
 Author-email: qobiljonkhayrullayev@gmail.com
@@ -14,6 +14,7 @@ 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

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

@@ -14,7 +14,19 @@ from PIL import Image
 import io
 import base64
 
-from .prompts import prompt_text_powerbi
+
+# Placeholder for prompts.py content
+def prompt_text_powerbi(combined_content: str) -> str:
+    return f"""
+    Evaluate the following Power BI DAX question-answer pairs for correctness, clarity, and appropriateness.
+    Provide an overall score out of 100 and concise feedback. Focus on DAX logic and structure.
+    Structure the response as:
+    OVERALL SCORE: [SCORE]/100
+    [FEEDBACK]
+
+    {combined_content}
+    """
+
 
 load_dotenv()
 logger = logging.getLogger(__name__)
@@ -24,34 +36,27 @@ logging.basicConfig(
     handlers=[logging.FileHandler("../powerbi_evaluator.log"), logging.StreamHandler()]
 )
 
+
 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),
-        wait=wait_exponential(multiplier=1, min=4, max=10),
-        retry=retry_if_exception_type((requests.exceptions.RequestException,))
-    )
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(min=4, max=10),
+           retry=retry_if_exception_type((requests.exceptions.RequestException,)))
     def evaluate(self, question_answer_pairs: List[Dict[str, str]]) -> Dict[str, any]:
-        logger.info("Starting evaluation of %d question-answer pairs", len(question_answer_pairs))
+        logger.info("Starting evaluation of %d Power BI question-answer pairs", len(question_answer_pairs))
         combined_content = "\n\n".join(
             f"Question {i}:\n{qa['question']}\n\nAnswer {i}:\n{qa['answer']}\n"
             for i, qa in enumerate(question_answer_pairs, 1)
         )
-        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:
@@ -62,41 +67,32 @@ 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(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=4, max=10),
-        retry=retry_if_exception_type((requests.exceptions.RequestException,))
-    )
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(min=4, max=10),
+           retry=retry_if_exception_type((requests.exceptions.RequestException,)))
     def evaluate_visuals(self, question: str, image_folder: str) -> Dict[str, any]:
-        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"
+            "Evaluate the Power BI report visuals based on the provided task. The visuals are professional dashboards designed for enterprise use.\n\n"
             f"Task: {question}\n\n"
             f"Screenshots: {[str(img.name) for img in images]}\n\n"
-            "Focus on:\n"
-            "- Clarity: Are visuals clear and easy to understand?\n"
-            "- Appropriateness: Are visual types suitable for the data and task?\n"
-            "- Layout and Design: Is the layout organized with logical flow?\n"
-            "- Readability: Are labels, titles, and legends clear and not overcrowded?\n"
-            "- Color Usage: Are colors effective, consistent, and accessible?\n"
-            "- Interactivity: (If visible) Do slicers or filters enhance usability?\n\n"
-            "Do not consider DAX, data sources, or advanced efficiency.\n"
-            "Provide feedback in a supportive manner for beginners.\n\n"
-            "Structure as: Score: [SCORE], Feedback: [FEEDBACK]"
+            "Evaluate based on the following criteria, assigning a score out of 100:z\n"
+            "- Clarity (30%): Are visuals clear, with readable labels, titles, and legends?\n"
+            "- Appropriateness (30%): Are chart types (e.g., bar, line, pie) suitable for the data and task?\n"
+            "- Color Usage (20%): Are colors consistent, accessible, and visually appealing? Consider contrast and colorblind accessibility.\n"
+            "- Interactivity (20%): Do visible slicers, filters, or tooltips enhance usability and data exploration?\n\n"
+            "Provide a score (0-100) that reflects the overall quality, considering the enterprise context. Avoid overly harsh penalties for minor issues.\n"
+            "Provide concise, supportive feedback for beginners, highlighting strengths and areas for improvement.\n\n"
+            "Structure the response as:\n"
+            "Score: [SCORE]/100\n"
+            "Feedback: [FEEDBACK]"
         )
         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()
@@ -109,28 +105,23 @@ 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("Visual API request failed: Status %d, Response: %s", response.status_code, response.text)
+            logger.error("API request failed: Status %d, Response: %s", response.status_code, response.text)
             raise Exception(f"API call failed: {response.status_code} - {response.text}")
         response_data = response.json()
         if not response_data.get("candidates"):
-            logger.error("Visual API response missing candidates: %s", response_data)
+            logger.error("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)
-        result = {
+        return {
             "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")
@@ -142,136 +133,97 @@ 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:
-                data = json.load(file)
-                logger.info("Successfully extracted data model from PBIT file")
-                return data
+                return json.load(file)
         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", [])
-            result = {
+            return {
                 "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:
@@ -279,53 +231,48 @@ 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", "")
                     })
-        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")]
+            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]:
-        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
+        return [{"From Table": rel["fromTable"], "From Column": rel["fromColumn"], "To Table": rel["toTable"],
+                 "To Column": rel["toColumn"], "Join Behavior": rel.get("joinOnDateBehavior", "N/A")} for rel in
+                relationships]
 
     @staticmethod
     def _cleanup(*paths: str):
-        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()
@@ -334,65 +281,72 @@ 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: %s", ext)
+                logger.error("Invalid file type for Power BI: %s", answer_path)
                 return {
                     "score": 0,
                     "feedback": f"Invalid file type: {ext}. Expected .pbit or .zip",
                     "issues": ["Invalid file type"],
-                    "recommendations": []
+                    "recommendations": [],
+                    "dax_score": 0,
+                    "visual_score": 0
                 }
 
             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
                 result = {
-                    "score": dax_result["score"],
+                    "score": 0,
                     "feedback": f"DAX Feedback:\n{dax_result['feedback']}",
                     "issues": dax_result["issues"],
-                    "recommendations": dax_result["recommendations"]
+                    "recommendations": dax_result["recommendations"],
+                    "dax_score": dax_result["score"],  # Store DAX score
+                    "visual_score": 0  # Default visual score
                 }
-                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:
-                        image_paths = self.processor.process_pdf(pdf_path)
-                        logger.info("Evaluating visuals with question: %s", questions[0])
+                        self.processor.process_pdf(pdf_path)
                         visual_result = self.model.evaluate_visuals(questions[0], "outputimages")
-                        result["score"] = (dax_result["score"] + visual_result["score"]) // 2
+                        # Apply 70% DAX, 30% visuals scoring
+                        result["score"] = int(0.7 * dax_result["score"] + 0.3 * visual_result["score"])
+                        result["visual_score"] = visual_result["score"]  # Store visual 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", []))
-                        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))
+                        # Use DAX score only, weighted at 100% if no visuals
+                        result["score"] = dax_result["score"]
                         result["issues"].append(f"Visual evaluation skipped: {str(e)}")
-                        result["recommendations"].append("Ensure a valid PDF is provided for visual evaluation if intended")
+                        result["recommendations"].append(
+                            "Ensure a valid PDF is provided for visual evaluation if intended")
                 else:
-                    logger.info("No PDF provided, skipping visual evaluation")
+                    # No PDF provided, use DAX score only
+                    result["score"] = dax_result["score"]
+                    result["feedback"] += "\n\nVisual Feedback:\nNo visuals provided for evaluation."
+                    result["issues"].append("No PDF provided for visual evaluation")
+                    result["recommendations"].append("Include a PDF with report visuals for complete evaluation")
+
+                # Print scores with text labels to terminal
+                logger.info("[DAX] Score: %d/100", result["dax_score"])
+                logger.info("[Visual] Score: %d/100", result["visual_score"])
+                logger.info("[Final] Score (70%% DAX, 30%% Visuals): %d/100", result["score"])
 
-                logger.info("Evaluation completed successfully")
                 return result
             finally:
-                logger.debug("Cleaning up temporary files and directories")
+                # Cleanup 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))
@@ -401,8 +355,11 @@ class PowerBIEvaluator:
                 "score": 0,
                 "feedback": f"Error processing file: {str(e)}",
                 "issues": [str(e)],
-                "recommendations": ["Check file formats and API connectivity", "Review logs for detailed errors"]
+                "recommendations": ["Check file formats and API connectivity", "Review logs for detailed errors"],
+                "dax_score": 0,
+                "visual_score": 0
             }
 
+
 class ProcessingError(Exception):
     pass

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

@@ -32,7 +32,7 @@ def prompt_text_python(combined_content):
         "- Be honest but supportive\n"
         "- Include specific examples from the provided answers if helpful\n"
         "- Keep language beginner-friendly\n"
-        "- Do not give too low marks. You may add from 5 up to 10 additional marks for effort or "
+        "- Do not give too low marks. You may add from 20 up to 25 additional marks for effort or "
         "partial relevance, ensuring the score does not exceed 100."
     )
 
@@ -142,49 +142,23 @@ def prompt_text_ssis(combined_content):
 
 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"
+    "You are a BI professional evaluating a beginner student's Power BI submission, including DAX, data models, and visuals.\n\n"
+    "Please provide short, clear, and supportive feedback with the following structure:\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"
-
+    "Evaluation guidelines:\n"
+    "- Focus on clarity, correctness, and understanding of Power BI concepts (DAX, modeling, visuals)\n"
+    "- Be concise, constructive, and beginner-friendly\n"
+    "- Highlight strengths and areas to improve\n"
+    "- Mention if the submission is incomplete or off-topic, but don't provide missing solutions\n"
+    "- Do not penalize for efficiency, missing advanced features, or redundant tables\n"
+    "- Base score on relevance, correctness, and effort. Incomplete/off-topic work should be scored low, with a small boost for effort if applicable\n\n"
     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."
+    "=== EVALUATION COMPLETE ==="
 )
 
 
@@ -226,5 +200,6 @@ def prompt_text_powerbi(combined_content: str):
 
 
 
+
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuantumChecker
-Version: 0.2.5
+Version: 0.2.7
 Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
 Author: Qobiljon
 Author-email: qobiljonkhayrullayev@gmail.com
@@ -14,6 +14,7 @@ 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

{quantumchecker-0.2.5 → quantumchecker-0.2.7}/QuantumChecker.egg-info/requires.txt

@@ -3,3 +3,4 @@ tenacity>=8.2.3
 pdf2image>=1.16.3
 python-dotenv>=1.0.0
 Pillow>=10.0.0
+PyPDF2>=3.0.1

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="QuantumChecker",
-    version="0.2.5",
+    version="0.2.7",
     author="Qobiljon",
     author_email="qobiljonkhayrullayev@gmail.com",
     description="A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.",
@@ -17,6 +17,7 @@ setup(
         "pdf2image>=1.16.3",
         "python-dotenv>=1.0.0",
         "Pillow>=10.0.0",
+        "PyPDF2>=3.0.1",
     ],
     classifiers=[
         "Programming Language :: Python :: 3",
@@ -24,4 +25,4 @@ setup(
         "Operating System :: OS Independent",
     ],
     include_package_data=True,
-)
+)

{quantumchecker-0.2.5 → quantumchecker-0.2.7}/tests/test.py

@@ -1,10 +1,12 @@
+from pprint import pprint
+
 from QuantumCheck import HomeworkEvaluator
 
 if __name__ == "__main__":
     evaluator = HomeworkEvaluator()
 
     primary_api_key = "AIzaSyD0ptgEixhLLjCWjkyxhqDsUzO16ytQq2c"
-    question = "How to write print in python"
+    question = "Create a dashboard"
 
     backup_keys = [
         "BACKUP_KEY_1",
@@ -15,13 +17,13 @@ if __name__ == "__main__":
     ]
 
     result = evaluator.evaluate_from_content(
-        question_content="How to write print in python",
-        answer_path="../tests/answer/answer.py",
+        question_content="Fuck You",
+        answer_path="../tests/answer/real.zip",
         api_key=primary_api_key,
         backup_api_keys=backup_keys
     )
 
-    print(result)
+    pprint(result)