PyPI - QuantumChecker - Versions diffs - 0.2.6__tar.gz → 0.2.7__tar.gz - Mend

QuantumChecker 0.2.6tar.gz → 0.2.7tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

{quantumchecker-0.2.6 → quantumchecker-0.2.7}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuantumChecker
-Version: 0.2.6
+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.6 → quantumchecker-0.2.7}/QuantumCheck/powerbi_evaluator.py RENAMED Viewed

@@ -13,9 +13,20 @@ from dotenv import load_dotenv
 from PIL import Image
 import io
 import base64
-import PyPDF2  # Added for PDF validation
-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__)
@@ -25,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:
@@ -63,89 +67,61 @@ 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)
-            try:
-                with Image.open(img) as pil_img:
-                    if pil_img.size[0] == 0 or pil_img.size[1] == 0:
-                        logger.error("Invalid image dimensions for %s", img.name)
-                        raise ProcessingError(f"Invalid image dimensions for {img.name}")
-                    pil_img.thumbnail((1024, 1024))
-                    img_buffer = io.BytesIO()
-                    pil_img.save(img_buffer, format="PNG")
-                    parts.append({
-                        "inline_data": {
-                            "mime_type": "image/png",
-                            "data": base64.b64encode(img_buffer.getvalue()).decode('utf-8')
-                        }
-                    })
-            except Exception as e:
-                logger.error("Failed to process image %s: %s", img.name, str(e))
-                raise ProcessingError(f"Failed to process image {img.name}: {str(e)}")
+            with Image.open(img) as pil_img:
+                pil_img.thumbnail((1024, 1024))
+                img_buffer = io.BytesIO()
+                pil_img.save(img_buffer, format="PNG")
+                parts.append({
+                    "inline_data": {
+                        "mime_type": "image/png",
+                        "data": base64.b64encode(img_buffer.getvalue()).decode('utf-8')
+                    }
+                })
         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",
-            "issues": []
+            "feedback": feedback_match.group(1).strip() if feedback_match else "No visual feedback generated"
         }
-        if not score_match:
-            result["issues"].append("Failed to parse score from visual API response")
-            logger.warning("Failed to parse score from visual API response")
-        if not feedback_match:
-            result["issues"].append("Failed to parse feedback from visual API response")
-            logger.warning("Failed to parse feedback from visual API response")
-        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")
@@ -157,150 +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}")
-            # Validate PDF
-            try:
-                with open(pdf_path, "rb") as f:
-                    pdf_reader = PyPDF2.PdfReader(f)
-                    if len(pdf_reader.pages) == 0:
-                        logger.error("PDF is empty: %s", pdf_path)
-                        raise ProcessingError(f"PDF is empty: {pdf_path}")
-                    logger.info("PDF validated, contains %d pages", len(pdf_reader.pages))
-            except Exception as e:
-                logger.error("Invalid PDF file: %s", str(e))
-                raise ProcessingError(f"Invalid PDF file: {str(e)}")
-            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=min(num_pages, len(pdf_reader.pages)))
-            if not pages:
-                logger.error("No pages converted from PDF: %s", pdf_path)
-                raise ProcessingError(f"No pages converted from PDF: {pdf_path}")
+            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))
+            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: {str(e)}")
-        finally:
-            logger.debug("Not removing PDF file to allow debugging: %s", pdf_path)
+            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:
@@ -308,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()
@@ -363,72 +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)
-                        if not image_paths:
-                            logger.error("No images generated from PDF: %s", pdf_path)
-                            raise ProcessingError("No images generated from PDF")
-                        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 with Power BI visuals is provided")
-                    except Exception as e:
-                        logger.error("Unexpected error during visual evaluation: %s", str(e))
-                        result["issues"].append(f"Visual evaluation failed: {str(e)}")
-                        result["recommendations"].append("Check PDF file and API connectivity")
+                        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))
@@ -437,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.6 → quantumchecker-0.2.7}/QuantumCheck/prompts.py RENAMED Viewed

@@ -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.6 → quantumchecker-0.2.7}/QuantumChecker.egg-info/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuantumChecker
-Version: 0.2.6
+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.6 → quantumchecker-0.2.7}/QuantumChecker.egg-info/requires.txt RENAMED Viewed

@@ -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.6 → quantumchecker-0.2.7}/setup.py RENAMED Viewed

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 setup(
     name="QuantumChecker",
-    version="0.2.6",
+    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.6 → quantumchecker-0.2.7}/tests/test.py RENAMED Viewed

@@ -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)