QuantumChecker 0.1.0__tar.gz

quantumchecker-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Qobiljon Xayrullayev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quantumchecker-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: QuantumChecker
+Version: 0.1.0
+Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
+Author-email: Qobiljon <qobiljonkhayrullayev@gmail.com>
+Project-URL: Homepage, https://github.com/yourusername/homework_evaluator
+Project-URL: Repository, https://github.com/yourusername/homework_evaluator
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tenacity>=8.2.3
+Requires-Dist: pdf2image>=1.16.3
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: Pillow>=10.0.0
+Dynamic: license-file
+
+# HomeworkEvaluator
+
+A Python package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS formats.
+
+## Installation
+
+```bash
+pip install homework-evaluator

quantumchecker-0.1.0/QuantumCheck/main.py

@@ -0,0 +1,72 @@
+import logging
+import os
+from typing import List, Dict
+from python_evaluator import PythonEvaluator
+from sql_evaluator import SQLEvaluator
+from powerbi_evaluator import PowerBIEvaluator
+from ssis_evaluator import SSISEvaluator
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+class HomeworkEvaluator:
+    EXTENSION_TO_TYPE = {
+        ".py": "python",
+        ".sql": "sql",
+        ".zip": "powerbi",
+        ".dtsx": "ssis",
+        ".DTSX": "ssis",
+        ".txt": "text",
+        ".md": "text"
+    }
+
+    @staticmethod
+    def parse_questions(md_content: str) -> List[str]:
+        questions = [q.strip() for q in md_content.strip().split("\n\n") if q.strip()]
+        if not questions:
+            raise ValueError("No valid questions found in the question content")
+        return questions
+
+    def evaluate_from_content(self, question_content: str, answer_path: str, api_key: str) -> Dict[str, any]:
+        try:
+            questions = self.parse_questions(question_content)
+        except Exception as e:
+            logger.error("Failed to parse question content: %s", str(e))
+            raise ValueError(f"Failed to parse question content: {str(e)}")
+
+        answer_path = answer_path.strip()
+        logger.info("Processing answer_path: %s", answer_path)
+        _, ext = os.path.splitext(answer_path)
+        ext = ext.lower()
+        logger.info("Extracted extension: %s", ext)
+        file_type = self.EXTENSION_TO_TYPE.get(ext, "text")
+        logger.info("Detected file type: %s for file: %s", file_type, answer_path)
+
+        if not os.path.exists(answer_path):
+            logger.error("Answer file not found: %s", answer_path)
+            raise FileNotFoundError(f"Answer file not found: {answer_path}")
+
+        if file_type == "python":
+            evaluator = PythonEvaluator(api_key)
+            evaluation = evaluator.evaluate(questions, answer_path)
+        elif file_type == "sql":
+            evaluator = SQLEvaluator(api_key)
+            evaluation = evaluator.evaluate(questions, answer_path)
+        elif file_type == "powerbi":
+            evaluator = PowerBIEvaluator(api_key)
+            evaluation = evaluator.evaluate(questions, answer_path)
+        elif file_type == "ssis":
+            evaluator = SSISEvaluator(api_key)
+            evaluation = evaluator.evaluate(questions, answer_path)
+        else:
+            logger.warning("Unrecognized file type '%s', defaulting to text (Python parser)", file_type)
+            evaluator = PythonEvaluator(api_key)
+            evaluation = evaluator.evaluate(questions, answer_path)
+
+        return {
+            "mark": evaluation["score"],
+            "feedback": evaluation["feedback"]
+        }
+
+

quantumchecker-0.1.0/QuantumCheck/powerbi_evaluator.py

@@ -0,0 +1,327 @@
+import json
+import logging
+import os
+import re
+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 PIL import Image
+import io
+import base64
+
+from prompts import prompt_text_powerbi
+
+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()]
+)
+
+# GeminiFlashModel class remains unchanged
+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
+        if not api_key:
+            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"
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, 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 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)
+        )
+
+        headers = {"Content-Type": "application/json"}
+        data = {"contents": [{"parts": [{"text": prompt_text_powerbi(combined_content)}]}]}
+        response = requests.post(f"{self.endpoint}?key={self.api_key}", headers=headers, json=data)
+
+        if response.status_code != 200:
+            logger.error("API request failed: Status %d, Response: %s", response.status_code, response.text)
+            raise Exception(f"API call failed: {response.status_code} - {response.text}")
+        response_data = response.json()
+        if not response_data.get("candidates"):
+            logger.error("API response missing candidates: %s", response_data)
+            raise ValueError("No candidates in API response")
+        generated_text = response_data["candidates"][0]["content"]["parts"][0]["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,))
+    )
+    def evaluate_visuals(self, question: str, image_folder: str) -> Dict[str, any]:
+        folder_path = Path(image_folder)
+        images = list(folder_path.glob("*.png"))[:3]
+        if not images:
+            raise ProcessingError(f"No PNG images found in {image_folder}")
+        prompt = (
+            "Evaluate the Power BI report visuals based on the given task.\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]"
+        )
+        parts = [{"text": prompt}]
+        for img in images:
+            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}]}
+        response = requests.post(f"{self.endpoint}?key={self.api_key}", headers=headers, json=data)
+        if response.status_code != 200:
+            logger.error("API request failed: Status %d, Response: %s", response.status_code, response.text)
+            raise Exception(f"API call failed: {response.status_code} - {response.text}")
+        response_data = response.json()
+        if not response_data.get("candidates"):
+            logger.error("API response missing candidates: %s", response_data)
+            raise ValueError("No candidates in API response")
+        output_text = response_data["candidates"][0]["content"]["parts"][0]["text"]
+        score_match = re.search(r"Score:\s*(\d+)(?:/100)?", output_text)
+        feedback_match = re.search(r"Feedback:\s*(.*)", output_text, re.DOTALL)
+        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"
+        }
+
+    def _parse_response(self, text: str) -> Dict[str, any]:
+        result = {"score": 0, "feedback": "Evaluation not returned by API.", "issues": [], "recommendations": []}
+        try:
+            lines = text.split("\n")
+            score_found = False
+            feedback_lines = []
+            for line in lines:
+                line = line.strip()
+                if not score_found and line.startswith("OVERALL SCORE:") and "/100" in line:
+                    try:
+                        result["score"] = int(line.split(":")[1].split("/")[0].strip())
+                        score_found = True
+                    except ValueError:
+                        result["issues"].append("Failed to parse score from API response")
+                        continue
+                elif score_found:
+                    feedback_lines.append(line)
+            if feedback_lines:
+                result["feedback"] = "\n".join(feedback_lines).strip()
+            return result
+        except Exception as e:
+            result["issues"].append(str(e))
+            return result
+
+class PowerBIProcessor:
+    def extract_datamodel(self, pbit_file_path: str) -> Dict:
+        if not os.path.exists(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")
+        self._cleanup(zip_file, export_path)
+        try:
+            os.rename(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:
+                zip_ref.extractall(export_path)
+            schema_path = os.path.join(export_path, "DataModelSchema")
+            txt_path = os.path.join(export_path, "DataModelSchema.txt")
+            os.rename(schema_path, txt_path)
+            with open(txt_path, "r", encoding="utf-16-le") as file:
+                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:
+            raise ProcessingError(f"Failed to extract DataModelSchema: {e}")
+        finally:
+            self._cleanup(zip_file, export_path)
+
+    def extract_model_data(self, data: Dict) -> Dict:
+        try:
+            tables = data.get("model", {}).get("tables", [])
+            relationships = data.get("model", {}).get("relationships", [])
+            return {
+                "Calculated Measures": self._get_measures(tables),
+                "Tables": self._get_tables_and_columns(tables),
+                "Relationships": self._get_relationships(relationships)
+            }
+        except Exception as 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]:
+        try:
+            if not os.path.exists(pdf_path):
+                raise ProcessingError(f"PDF file not found: {pdf_path}")
+            os.makedirs(output_dir, exist_ok=True)
+            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")
+                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}")
+
+    def extract_zip(self, zip_path: str, extract_path: str) -> tuple[str, str | None]:
+        try:
+            if not os.path.exists(zip_path):
+                raise ProcessingError(f"ZIP file not found: {zip_path}")
+            if not zipfile.is_zipfile(zip_path):
+                raise ProcessingError(f"File is not a valid ZIP: {zip_path}")
+            os.makedirs(extract_path, exist_ok=True)
+            with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                zip_ref.extractall(extract_path)
+            pbit_files = list(Path(extract_path).glob("*.pbit"))
+            pdf_files = list(Path(extract_path).glob("*.pdf"))
+            if not pbit_files:
+                raise ProcessingError("ZIP file must contain at least one .pbit file")
+            if len(pbit_files) > 1:
+                raise ProcessingError("ZIP file contains multiple .pbit files")
+            pdf_path = str(pdf_files[0]) if pdf_files else None
+            return str(pbit_files[0]), pdf_path
+        except Exception as e:
+            raise ProcessingError(f"Failed to extract ZIP file: {e}")
+
+    @staticmethod
+    def _get_measures(tables: List[Dict]) -> List[Dict]:
+        measures = []
+        for table in tables:
+            if "measures" in table:
+                for measure in table["measures"]:
+                    measures.append({
+                        "Table": table["name"],
+                        "Name": measure["name"],
+                        "Expression": " ".join(measure.get("expression", "")) if isinstance(measure.get("expression"), list) else measure.get("expression", ""),
+                        "FormatString": measure.get("formatString", "")
+                    })
+        return measures
+
+    @staticmethod
+    def _get_tables_and_columns(tables: List[Dict]) -> List[Dict]:
+        table_info = []
+        for table in tables:
+            columns = [{"Column Name": col["name"], "Data Type": col.get("dataType", "Unknown"), "Source Column": col.get("sourceColumn", "N/A"), "Calculated": col.get("type") == "calculated"} for col in table.get("columns", [])]
+            expressions = [part["source"]["expression"] for part in table.get("partitions", []) if part["source"].get("expression")]
+            table_info.append({"Table Name": table["name"], "Columns": columns, "Expressions": expressions})
+        return table_info
+
+    @staticmethod
+    def _get_relationships(relationships: List[Dict]) -> List[Dict]:
+        return [{"From Table": rel["fromTable"], "From Column": rel["fromColumn"], "To Table": rel["toTable"], "To Column": rel["toColumn"], "Join Behavior": rel.get("joinOnDateBehavior", "N/A")} for rel in relationships]
+
+    @staticmethod
+    def _cleanup(*paths: str):
+        for path in paths:
+            if os.path.exists(path):
+                if os.path.isfile(path):
+                    os.remove(path)
+                else:
+                    shutil.rmtree(path, ignore_errors=True)
+
+class PowerBIEvaluator:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.model = GeminiFlashModel(api_key)
+        self.processor = PowerBIProcessor()
+
+    def evaluate(self, questions: List[str], answer_path: str) -> Dict[str, any]:
+        try:
+            _, ext = os.path.splitext(answer_path)
+            ext = ext.lower()
+            extract_path = os.path.join(os.path.dirname(answer_path), "temp_extract")
+            pbit_path = None
+            pdf_path = None
+
+            # Handle input file type
+            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
+            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",
+                    "issues": ["Invalid file type"],
+                    "recommendations": []
+                }
+
+            try:
+                # Extract and process the data model from .pbit
+                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)])
+
+                # Initialize result with DAX evaluation
+                result = {
+                    "score": dax_result["score"],
+                    "feedback": f"DAX Feedback:\n{dax_result['feedback']}",
+                    "issues": dax_result["issues"],
+                    "recommendations": dax_result["recommendations"]
+                }
+
+                # Process PDF and evaluate visuals if present
+                if pdf_path:
+                    try:
+                        self.processor.process_pdf(pdf_path)
+                        visual_result = self.model.evaluate_visuals(questions[0], "outputimages")
+                        result["score"] = (dax_result["score"] + visual_result["score"]) // 2
+                        result["feedback"] += f"\n\nVisual Feedback:\n{visual_result['feedback']}"
+                        result["issues"].extend([f"Visual: {i}" for i in visual_result.get("issues", [])])
+                        result["recommendations"].extend(visual_result.get("recommendations", []))
+                    except ProcessingError as e:
+                        logger.warning("Failed to process PDF, proceeding with DAX evaluation only: %s", str(e))
+                        result["issues"].append(f"Visual evaluation skipped: {str(e)}")
+                        result["recommendations"].append("Ensure a valid PDF is provided for visual evaluation if intended")
+
+                return result
+            finally:
+                # 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))
+            self.processor._cleanup(extract_path, "outputimages")
+            return {
+                "score": 0,
+                "feedback": f"Error processing file: {str(e)}",
+                "issues": [str(e)],
+                "recommendations": ["Check file formats and API connectivity", "Review logs for detailed errors"]
+            }
+
+class ProcessingError(Exception):
+    pass

quantumchecker-0.1.0/QuantumCheck/prompts.py

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

quantumchecker-0.1.0/QuantumCheck/python_evaluator.py

@@ -0,0 +1,95 @@
+import logging
+import requests
+from prompts import prompt_text_python
+from typing import List, Dict
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+logger = logging.getLogger(__name__)
+
+class GeminiFlashModel:
+    def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
+        if not api_key:
+            raise ValueError("API key is required.")
+        self.api_key = api_key
+        self.model_name = model_name
+        self.endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{self.model_name}:generateContent"
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, 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 Python 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)
+        )
+
+
+        headers = {"Content-Type": "application/json"}
+        data = {"contents": [{"parts": [{"text": prompt_text_python(combined_content)}]}]}
+
+        response = requests.post(f"{self.endpoint}?key={self.api_key}", headers=headers, json=data)
+
+        if response.status_code != 200:
+            raise Exception(f"API call failed: {response.status_code} - {response.text}")
+
+        response_data = response.json()
+        if not response_data.get("candidates"):
+            raise ValueError("No candidates in API response")
+
+        generated_text = response_data["candidates"][0]["content"]["parts"][0]["text"]
+        return self._parse_response(generated_text)
+
+    def _parse_response(self, text: str) -> Dict[str, any]:
+        result = {"score": 0, "feedback": "Evaluation not returned by API.", "issues": [], "recommendations": []}
+        try:
+            lines = text.split("\n")
+            score_found = False
+            feedback_lines = []
+            for line in lines:
+                line = line.strip()
+                if not score_found and line.startswith("OVERALL SCORE:") and "/100" in line:
+                    try:
+                        result["score"] = int(line.split(":")[1].split("/")[0].strip())
+                        score_found = True
+                    except ValueError:
+                        result["issues"].append("Failed to parse score from API response")
+                        continue
+                elif score_found:
+                    feedback_lines.append(line)
+            if feedback_lines:
+                result["feedback"] = "\n".join(feedback_lines).strip()
+            return result
+        except Exception as e:
+            result["issues"].append(str(e))
+            return result
+
+class PythonAnswerParser:
+    @staticmethod
+    def parse(content: str, question_count: int) -> List[str]:
+        answers = [a.strip() for a in content.strip().split("\n\n") if a.strip()]
+        if not answers:
+            logger.warning("No valid answers found, returning placeholders")
+        return answers + ["No answer provided."] * (question_count - len(answers))
+
+class PythonEvaluator:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.model = GeminiFlashModel(api_key)
+
+    def evaluate(self, questions: List[str], answer_path: str) -> Dict[str, any]:
+        try:
+            with open(answer_path, "r", encoding="utf-8") as file:
+                content = file.read()
+        except Exception as e:
+            logger.error("Failed to read answer file %s: %s", answer_path, str(e))
+            return {"score": 0, "feedback": f"Error reading file: {str(e)}", "issues": [str(e)]}
+
+        answers = PythonAnswerParser.parse(content, len(questions))
+        if len(answers) != len(questions):
+            logger.warning("Mismatch: %d questions but %d answers", len(questions), len(answers))
+
+        return self.model.evaluate([{"question": q, "answer": a} for q, a in zip(questions, answers)])

quantumchecker-0.1.0/QuantumCheck/sql_evaluator.py

@@ -0,0 +1,97 @@
+import logging
+import requests
+from typing import List, Dict
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+from prompts import prompt_text_sql
+
+logger = logging.getLogger(__name__)
+
+class GeminiFlashModel:
+    def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
+        if not api_key:
+            raise ValueError("API key is required.")
+        self.api_key = api_key
+        self.model_name = model_name
+        self.endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{self.model_name}:generateContent"
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, 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 SQL 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)
+        )
+
+
+
+        headers = {"Content-Type": "application/json"}
+        data = {"contents": [{"parts": [{"text": prompt_text_sql(combined_content)}]}]}
+
+        response = requests.post(f"{self.endpoint}?key={self.api_key}", headers=headers, json=data)
+
+        if response.status_code != 200:
+            raise Exception(f"API call failed: {response.status_code} - {response.text}")
+
+        response_data = response.json()
+        if not response_data.get("candidates"):
+            raise ValueError("No candidates in API response")
+
+        generated_text = response_data["candidates"][0]["content"]["parts"][0]["text"]
+        return self._parse_response(generated_text)
+
+    def _parse_response(self, text: str) -> Dict[str, any]:
+        result = {"score": 0, "feedback": "Evaluation not returned by API.", "issues": [], "recommendations": []}
+        try:
+            lines = text.split("\n")
+            score_found = False
+            feedback_lines = []
+            for line in lines:
+                line = line.strip()
+                if not score_found and line.startswith("OVERALL SCORE:") and "/100" in line:
+                    try:
+                        result["score"] = int(line.split(":")[1].split("/")[0].strip())
+                        score_found = True
+                    except ValueError:
+                        result["issues"].append("Failed to parse score from API response")
+                        continue
+                elif score_found:
+                    feedback_lines.append(line)
+            if feedback_lines:
+                result["feedback"] = "\n".join(feedback_lines).strip()
+            return result
+        except Exception as e:
+            result["issues"].append(str(e))
+            return result
+
+class SQLAnswerParser:
+    @staticmethod
+    def parse(content: str, question_count: int) -> List[str]:
+        answers = [a.strip() for a in content.strip().split("\n\n") if a.strip()]
+        if not answers:
+            logger.warning("No valid answers found, returning placeholders")
+        return answers + ["No answer provided."] * (question_count - len(answers))
+
+class SQLEvaluator:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.model = GeminiFlashModel(api_key)
+
+    def evaluate(self, questions: List[str], answer_path: str) -> Dict[str, any]:
+        try:
+            with open(answer_path, "r", encoding="utf-8") as file:
+                content = file.read()
+        except Exception as e:
+            logger.error("Failed to read answer file %s: %s", answer_path, str(e))
+            return {"score": 0, "feedback": f"Error reading file: {str(e)}", "issues": [str(e)]}
+
+        answers = SQLAnswerParser.parse(content, len(questions))
+        if len(answers) != len(questions):
+            logger.warning("Mismatch: %d questions but %d answers", len(questions), len(answers))
+
+        return self.model.evaluate([{"question": q, "answer": a} for q, a in zip(questions, answers)])

quantumchecker-0.1.0/QuantumCheck/ssis_evaluator.py

@@ -0,0 +1,136 @@
+import logging
+import requests
+import xml.etree.ElementTree as ET
+from typing import List, Dict
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+from prompts import prompt_text_ssis
+
+logger = logging.getLogger(__name__)
+
+class GeminiFlashModel:
+    def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
+        if not api_key:
+            raise ValueError("API key is required.")
+        self.api_key = api_key
+        self.model_name = model_name
+        self.endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{self.model_name}:generateContent"
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, 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 SSIS 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)
+        )
+
+        headers = {"Content-Type": "application/json"}
+        data = {"contents": [{"parts": [{"text": prompt_text_ssis(combined_content)}]}]}
+
+        response = requests.post(f"{self.endpoint}?key={self.api_key}", headers=headers, json=data)
+
+        if response.status_code != 200:
+            raise Exception(f"API call failed: {response.status_code} - {response.text}")
+
+        response_data = response.json()
+        if not response_data.get("candidates"):
+            raise ValueError("No candidates in API response")
+
+        generated_text = response_data["candidates"][0]["content"]["parts"][0]["text"]
+        return self._parse_response(generated_text)
+
+    def _parse_response(self, text: str) -> Dict[str, any]:
+        result = {"score": 0, "feedback": "Evaluation not returned by API.", "issues": [], "recommendations": []}
+        try:
+            lines = text.split("\n")
+            score_found = False
+            feedback_lines = []
+            for line in lines:
+                line = line.strip()
+                if not score_found and line.startswith("OVERALL SCORE:") and "/100" in line:
+                    try:
+                        result["score"] = int(line.split(":")[1].split("/")[0].strip())
+                        score_found = True
+                    except ValueError:
+                        result["issues"].append("Failed to parse score from API response")
+                        continue
+                elif score_found:
+                    feedback_lines.append(line)
+            if feedback_lines:
+                result["feedback"] = "\n".join(feedback_lines).strip()
+            return result
+        except Exception as e:
+            result["issues"].append(str(e))
+            return result
+
+class SSISAnswerParser:
+    @staticmethod
+    def parse(filepath: str, question_count: int) -> List[str]:
+        try:
+            tree = ET.parse(filepath)
+            root = tree.getroot()
+            summary = []
+
+            for elem in root.iter():
+                if "Executable" in elem.tag or "task" in elem.tag.lower():
+                    task_name = elem.get("Name", "Unnamed Task")
+                    task_type = elem.tag.split("}")[-1] if "}" in elem.tag else elem.tag
+                    summary.append(f"Task: {task_name} ({task_type})")
+
+            for conn in root.findall(".//DTS:ConnectionManager", namespaces={"DTS": "www.microsoft.com/SqlServer/Dts"}):
+                conn_name = conn.get("DTS:ObjectName", "Unnamed Connection")
+                conn_type = conn.find(".//DTS:ObjectData", namespaces={"DTS": "www.microsoft.com/SqlServer/Dts"})
+                if conn_type is not None:
+                    if "FlatFileConnectionManager" in conn_type.tag:
+                        file_path = conn_type.find(".//Property[@Name='FileName']").text
+                        columns = [col.find(".//Property[@Name='Name']").text for col in conn_type.findall(".//Column")]
+                        summary.append(f"Flat File Connection: {conn_name} (File: {file_path}, Columns: {', '.join(columns)})")
+                    elif "OleDbConnectionManager" in conn_type.tag:
+                        conn_string = conn_type.find(".//Property[@Name='ConnectionString']").text
+                        summary.append(f"SQL Server Connection: {conn_name} (ConnectionString: {conn_string})")
+
+            for component in root.findall(".//component"):
+                comp_name = component.get("name", "Unnamed Component")
+                comp_type = component.get("componentClassID", "").split(".")[-1]
+                if comp_type == "FlatFileSource":
+                    summary.append(f"Flat File Source: {comp_name}")
+                elif comp_type == "DataConversion":
+                    output_cols = [col.get("name") for col in component.findall(".//outputColumn")]
+                    summary.append(f"Data Conversion: {comp_name} (Outputs: {', '.join(output_cols)})")
+                elif comp_type == "OLEDBDestination":
+                    table_name = component.find(".//property[@name='TableName']").text
+                    summary.append(f"SQL Server Destination: {comp_name} (Table: {table_name})")
+
+            for path in root.findall(".//path"):
+                start_id = path.get("startId", "Unknown")
+                end_id = path.get("endId", "Unknown")
+                summary.append(f"Data Flow Path: {start_id} -> {end_id}")
+
+            for log_provider in root.findall(".//DTS:LogProvider", namespaces={"DTS": "www.microsoft.com/SqlServer/Dts"}):
+                log_name = log_provider.get("DTS:ObjectName", "Unnamed Log")
+                log_file = log_provider.get("DTS:ConfigString", "Unknown")
+                events = [event.text.strip() for event in log_provider.findall(".//LogEvent")]
+                summary.append(f"Log Provider: {log_name} (File: {log_file}, Events: {', '.join(events)})")
+
+            combined_summary = "\n".join(summary)[:2000] or "No components found in SSIS package"
+            logger.info("Parsed SSIS summary: %s", combined_summary)
+            return [combined_summary] * question_count
+        except ET.ParseError as e:
+            logger.error("Invalid SSIS package file: %s", str(e))
+            return [f"Invalid SSIS package file: {str(e)}"] * question_count
+
+class SSISEvaluator:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.model = GeminiFlashModel(api_key)
+
+    def evaluate(self, questions: List[str], answer_path: str) -> Dict[str, any]:
+        answers = SSISAnswerParser.parse(answer_path, len(questions))
+        if len(answers) != len(questions):
+            logger.warning("Mismatch: %d questions but %d answers", len(questions), len(answers))
+        return self.model.evaluate([{"question": q, "answer": a} for q, a in zip(questions, answers)])

quantumchecker-0.1.0/QuantumChecker.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: QuantumChecker
+Version: 0.1.0
+Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
+Author-email: Qobiljon <qobiljonkhayrullayev@gmail.com>
+Project-URL: Homepage, https://github.com/yourusername/homework_evaluator
+Project-URL: Repository, https://github.com/yourusername/homework_evaluator
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tenacity>=8.2.3
+Requires-Dist: pdf2image>=1.16.3
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: Pillow>=10.0.0
+Dynamic: license-file
+
+# HomeworkEvaluator
+
+A Python package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS formats.
+
+## Installation
+
+```bash
+pip install homework-evaluator

quantumchecker-0.1.0/QuantumChecker.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+QuantumCheck/__init__.py
+QuantumCheck/main.py
+QuantumCheck/powerbi_evaluator.py
+QuantumCheck/prompts.py
+QuantumCheck/python_evaluator.py
+QuantumCheck/sql_evaluator.py
+QuantumCheck/ssis_evaluator.py
+QuantumChecker.egg-info/PKG-INFO
+QuantumChecker.egg-info/SOURCES.txt
+QuantumChecker.egg-info/dependency_links.txt
+QuantumChecker.egg-info/requires.txt
+QuantumChecker.egg-info/top_level.txt

quantumchecker-0.1.0/QuantumChecker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

quantumchecker-0.1.0/QuantumChecker.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.31.0
+tenacity>=8.2.3
+pdf2image>=1.16.3
+python-dotenv>=1.0.0
+Pillow>=10.0.0

quantumchecker-0.1.0/QuantumChecker.egg-info/top_level.txt

@@ -0,0 +1 @@
+QuantumCheck

quantumchecker-0.1.0/README.md

@@ -0,0 +1,8 @@
+# HomeworkEvaluator
+
+A Python package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS formats.
+
+## Installation
+
+```bash
+pip install homework-evaluator

quantumchecker-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "QuantumChecker"
+version = "0.1.0"
+authors = [
+  { name = "Qobiljon", email = "qobiljonkhayrullayev@gmail.com" },
+]
+description = "A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS."
+readme = "README.md"
+license = { file = "LICENSE.txt" }
+requires-python = ">=3.6"
+dependencies = [
+  "requests>=2.31.0",
+  "tenacity>=8.2.3",
+  "pdf2image>=1.16.3",
+  "python-dotenv>=1.0.0",
+  "Pillow>=10.0.0",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/homework_evaluator"
+Repository = "https://github.com/yourusername/homework_evaluator"

quantumchecker-0.1.0/setup.cfg

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