QuantumChecker 0.3.0__tar.gz → 0.3.2__tar.gz

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuantumChecker
-Version: 0.3.0
+Version: 0.3.2
 Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
 Author: Qobiljon
 Author-email: qobiljonkhayrullayev@gmail.com
@@ -37,13 +37,12 @@ Q1: What is a Python list? Explain with an example.
 Q2: Write an SQL query to select all records from a table named 'students'.
 """
     answer_path = "sample_submissions/student1_answer.py"
-    api_keys = ["your_api_key_1", "your_api_key_2"]
     question_type = "python"
 
     result = await evaluator.evaluate_from_content(
         question_content=question_content,
         answer_path=answer_path,
-        api_keys=api_keys,
+        api_key="your_api_key",
         question_type=question_type
     )
     print(result)

quantumchecker-0.3.2/QuantumCheck/main.py

@@ -0,0 +1,138 @@
+import logging
+import os
+import zipfile
+from datetime import datetime
+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
+import asyncio
+
+_logger_cache = {}
+
+class HomeworkEvaluator:
+    EVALUATOR_REGISTRY = {
+        "python": PythonEvaluator,
+        "sql": SQLEvaluator,
+        "powerbi": PowerBIEvaluator,
+        "ssis": SSISEvaluator
+    }
+
+    EXTENSION_TO_TYPE = {
+        ".py": "python",
+        ".sql": "sql",
+        ".pbit": "powerbi",
+        ".pdf": "powerbi",
+        ".dtsx": "ssis",
+        ".DTSX": "ssis",
+        ".txt": "text",
+        ".md": "text"
+    }
+
+    def __init__(self, log_level: int = logging.INFO):
+        self.log_level = log_level
+        self._lock = asyncio.Lock()
+        self._last_request_time = None
+
+    def _get_logger(self, log_type: str) -> logging.Logger:
+        log_name = f"{log_type}_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}"
+        if log_name not in _logger_cache:
+            logger = logging.getLogger(log_name)
+            logger.setLevel(self.log_level)
+            if not logger.handlers:
+                handler = logging.StreamHandler()
+                handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+                logger.addHandler(handler)
+            _logger_cache[log_name] = logger
+        return _logger_cache[log_name]
+
+    def parse_questions(self, content: str) -> List[str]:
+        logger = self._get_logger("QuantumCheck.main")
+        questions = [q.strip() for q in content.split("\n\n") if q.strip()]
+        if not questions:
+            raise ValueError("No valid questions found in content")
+        return questions
+
+    def _detect_zip_content_type(self, zip_path: str, logger: logging.Logger) -> str:
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            extensions = {os.path.splitext(name)[1].lower() for name in zip_ref.namelist()}
+            file_types = [self.EXTENSION_TO_TYPE.get(ext, "text") for ext in extensions if ext]
+            if "python" in file_types:
+                return "python"
+            elif "sql" in file_types:
+                return "sql"
+            elif "powerbi" in file_types:
+                return "powerbi"
+            elif "ssis" in file_types:
+                return "ssis"
+            else:
+                return "text"
+
+    async def evaluate_from_content(
+        self,
+        question_content: str,
+        answer_path: str,
+        api_key: str,
+        question_type: str
+    ) -> Dict[str, any]:
+        async with self._lock:
+            now = datetime.now()
+            if self._last_request_time:
+                elapsed = (now - self._last_request_time).total_seconds()
+                if elapsed < 5:
+                    await asyncio.sleep(5 - elapsed)
+            self._last_request_time = datetime.now()
+
+            logger = self._get_logger("QuantumCheck.main")
+
+            try:
+                questions = self.parse_questions(question_content)
+            except ValueError as e:
+                return {
+                    "score": 0,
+                    "feedback": f"Error parsing question content: {str(e)}",
+                    "issues": [str(e)],
+                    "recommendations": []
+                }
+
+            answer_path = answer_path.strip()
+            _, ext = os.path.splitext(answer_path)
+            ext = ext.lower()
+
+            if ext == ".zip":
+                logger = self._get_logger("zip")
+                file_type = self._detect_zip_content_type(answer_path, logger)
+            else:
+                file_type = self.EXTENSION_TO_TYPE.get(ext, "text")
+                logger = self._get_logger(file_type)
+
+            eval_type = question_type if question_type in self.EVALUATOR_REGISTRY else file_type
+
+            if not os.path.exists(answer_path):
+                return {
+                    "score": 0,
+                    "feedback": f"Answer file not found: {answer_path}",
+                    "issues": [f"Answer file not found: {answer_path}"],
+                    "recommendations": []
+                }
+
+            evaluator_class = self.EVALUATOR_REGISTRY.get(eval_type, PythonEvaluator)
+            evaluator = evaluator_class(api_key)
+
+            try:
+                evaluation = evaluator.evaluate(questions, answer_path, temp_dir=f"temp_extract_{os.getpid()}")
+                return {
+                    "score": evaluation.get("score", 0),
+                    "feedback": evaluation.get("feedback", "No feedback provided"),
+                    "issues": evaluation.get("issues", []),
+                    "recommendations": evaluation.get("recommendations", [])
+                }
+
+            except Exception as e:
+                return {
+                    "score": 0,
+                    "feedback": f"Evaluation failed: {str(e)}",
+                    "issues": [str(e)],
+                    "recommendations": []
+                }

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/QuantumCheck/powerbi_evaluator.py

@@ -37,7 +37,7 @@ logging.basicConfig(
 
 
 class GeminiFlashModel:
-    def __init__(self, api_key: str, model_name: str = "gemini-2.0-flash"):
+    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.")

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/QuantumCheck/python_evaluator.py

@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 
 class GeminiFlashModel:
-    def __init__(self, api_key: str, model_name: str = "gemini-2.0-flash"):
+    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

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/QuantumCheck/sql_evaluator.py

@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 
 class GeminiFlashModel:
-    def __init__(self, api_key: str, model_name: str = "gemini-2.0-flash"):
+    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

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/QuantumCheck/ssis_evaluator.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 
 
 class GeminiFlashModel:
-    def __init__(self, api_key: str, model_name: str = "gemini-2.0-flash"):
+    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

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/QuantumChecker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuantumChecker
-Version: 0.3.0
+Version: 0.3.2
 Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
 Author: Qobiljon
 Author-email: qobiljonkhayrullayev@gmail.com
@@ -37,13 +37,12 @@ Q1: What is a Python list? Explain with an example.
 Q2: Write an SQL query to select all records from a table named 'students'.
 """
     answer_path = "sample_submissions/student1_answer.py"
-    api_keys = ["your_api_key_1", "your_api_key_2"]
     question_type = "python"
 
     result = await evaluator.evaluate_from_content(
         question_content=question_content,
         answer_path=answer_path,
-        api_keys=api_keys,
+        api_key="your_api_key",
         question_type=question_type
     )
     print(result)

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/QuantumChecker.egg-info/SOURCES.txt

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

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/README.md

@@ -11,13 +11,12 @@ Q1: What is a Python list? Explain with an example.
 Q2: Write an SQL query to select all records from a table named 'students'.
 """
     answer_path = "sample_submissions/student1_answer.py"
-    api_keys = ["your_api_key_1", "your_api_key_2"]
     question_type = "python"
 
     result = await evaluator.evaluate_from_content(
         question_content=question_content,
         answer_path=answer_path,
-        api_keys=api_keys,
+        api_key="your_api_key",
         question_type=question_type
     )
     print(result)

{quantumchecker-0.3.0 → quantumchecker-0.3.2}/setup.py

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

quantumchecker-0.3.2/tests/test.py

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

quantumchecker-0.3.0/QuantumCheck/main.py

@@ -1,230 +0,0 @@
-import logging
-import os
-import zipfile
-from datetime import datetime
-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
-import asyncio
-
-_logger_cache = {}
-
-class HomeworkEvaluator:
-    EVALUATOR_REGISTRY = {
-        "python": PythonEvaluator,
-        "sql": SQLEvaluator,
-        "powerbi": PowerBIEvaluator,
-        "ssis": SSISEvaluator
-    }
-
-    EXTENSION_TO_TYPE = {
-        ".py": "python",
-        ".sql": "sql",
-        ".pbit": "powerbi",
-        ".pdf": "powerbi",
-        ".dtsx": "ssis",
-        ".DTSX": "ssis",
-        ".txt": "text",
-        ".md": "text"
-    }
-
-    API_NAME_MAPPING = {
-        "python": "Google Gemini API",
-        "sql": "Google Gemini API",
-        "powerbi": "Google Gemini API",
-        "ssis": "Google Gemini API",
-        "text": "Google Gemini API"
-    }
-
-    def __init__(self, log_level: int = logging.INFO):
-        self.log_level = log_level
-        self._successful_key_cache = {}
-        self._rate_limit_delay = {}
-        self._invalid_key_cache = set()
-        self._lock = asyncio.Lock()
-        self._last_request_time = None
-
-    def _get_logger(self, log_type: str) -> logging.Logger:
-        log_name = f"{log_type}_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}"
-        if log_name not in _logger_cache:
-            logger = logging.getLogger(log_name)
-            logger.setLevel(self.log_level)
-            if not logger.handlers:
-                handler = logging.StreamHandler()
-                handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
-                logger.addHandler(handler)
-            _logger_cache[log_name] = logger
-        return _logger_cache[log_name]
-
-    def parse_questions(self, content: str) -> List[str]:
-        logger = self._get_logger("QuantumCheck.main")
-        questions = [q.strip() for q in content.split("\n\n") if q.strip()]
-        if not questions:
-            raise ValueError("No valid questions found in content")
-        return questions
-
-    def _detect_zip_content_type(self, zip_path: str, logger: logging.Logger) -> str:
-        with zipfile.ZipFile(zip_path, "r") as zip_ref:
-            extensions = {os.path.splitext(name)[1].lower() for name in zip_ref.namelist()}
-            file_types = [self.EXTENSION_TO_TYPE.get(ext, "text") for ext in extensions if ext]
-            if "python" in file_types:
-                return "python"
-            elif "sql" in file_types:
-                return "sql"
-            elif "powerbi" in file_types:
-                return "powerbi"
-            elif "ssis" in file_types:
-                return "ssis"
-            else:
-                return "text"
-
-    async def evaluate_from_content(
-        self,
-        question_content: str,
-        answer_path: str,
-        api_keys: List[str],
-        question_type: str,
-        retry_count: int = 0
-    ) -> Dict[str, any]:
-        async with self._lock:
-            now = datetime.now()
-            if self._last_request_time:
-                elapsed = (now - self._last_request_time).total_seconds()
-                if elapsed < 30:
-                    await asyncio.sleep(30 - elapsed)
-            self._last_request_time = datetime.now()
-
-            try:
-                questions = self.parse_questions(question_content)
-            except ValueError as e:
-                logger = self._get_logger("QuantumCheck.main")
-                return {
-                    "score": 0,
-                    "feedback": f"Error parsing question content: {str(e)}",
-                    "issues": [str(e)],
-                    "recommendations": [],
-                    "used_api_key_index": None,
-                    "used_api_name": None
-                }
-
-            answer_path = answer_path.strip()
-            _, ext = os.path.splitext(answer_path)
-            ext = ext.lower()
-
-            if ext == ".zip":
-                logger = self._get_logger("zip")
-                file_type = self._detect_zip_content_type(answer_path, logger)
-            else:
-                file_type = self.EXTENSION_TO_TYPE.get(ext, "text")
-                logger = self._get_logger(file_type)
-
-            eval_type = question_type if question_type in self.EVALUATOR_REGISTRY else file_type
-
-            if not os.path.exists(answer_path):
-                return {
-                    "score": 0,
-                    "feedback": f"Answer file not found: {answer_path}",
-                    "issues": [f"Answer file not found: {answer_path}"],
-                    "recommendations": [],
-                    "used_api_key_index": None,
-                    "used_api_name": None
-                }
-
-            evaluator_class = self.EVALUATOR_REGISTRY.get(eval_type, PythonEvaluator)
-            last_error_messages = []
-
-            available_keys = [(i + 1, key) for i, key in enumerate(api_keys) if key not in self._invalid_key_cache]
-
-            cached_key_idx = self._successful_key_cache.get(eval_type)
-            if cached_key_idx is not None and cached_key_idx < len(api_keys):
-                cached_key = api_keys[cached_key_idx]
-                if cached_key not in self._invalid_key_cache:
-                    available_keys.insert(0, (cached_key_idx + 1, cached_key))
-
-            if not available_keys:
-                return {
-                    "score": 0,
-                    "feedback": "No valid API keys available.",
-                    "issues": ["All API keys are invalid or rate-limited."],
-                    "recommendations": [],
-                    "used_api_key_index": None,
-                    "used_api_name": None
-                }
-
-            for idx, key in available_keys:
-                if key in self._rate_limit_delay:
-                    delay_until = self._rate_limit_delay[key]
-                    current_time = datetime.now()
-                    delay_until_time = datetime.fromtimestamp(delay_until)
-                    if current_time < delay_until_time:
-                        continue
-                    else:
-                        del self._rate_limit_delay[key]
-
-                evaluator = evaluator_class(key)
-                api_name = getattr(evaluator, 'get_api_name', lambda: self.API_NAME_MAPPING.get(eval_type, "Unknown API"))()
-
-                try:
-                    evaluation = evaluator.evaluate(questions, answer_path, temp_dir=f"temp_extract_{os.getpid()}_{idx}")
-                    feedback = evaluation.get("feedback", "").lower()
-                    issues = " ".join(evaluation.get("issues", [])).lower()
-
-                    if any(phrase in feedback or phrase in issues for phrase in ["api key not valid", "api_key_invalid"]):
-                        last_error_messages.append(f"API key #{idx} invalid.")
-                        self._invalid_key_cache.add(key)
-                        continue
-
-                    if any(phrase in feedback or phrase in issues for phrase in ["429", "too many requests", "rate limit"]):
-                        last_error_messages.append(f"API key #{idx} rate limited.")
-                        self._rate_limit_delay[key] = datetime.now().timestamp() + 300
-                        continue
-
-                    if any(phrase in feedback or phrase in issues for phrase in ["503", "service unavailable"]):
-                        last_error_messages.append(f"API key #{idx} service unavailable.")
-                        self._rate_limit_delay[key] = datetime.now().timestamp() + 7200
-                        continue
-
-                    if evaluation.get("score", 0) == 0 and "evaluation not returned" in feedback:
-                        last_error_messages.append(f"API key #{idx} returned invalid evaluation.")
-                        continue
-
-                    self._successful_key_cache[eval_type] = idx - 1
-                    return {
-                        "score": evaluation.get("score", 0),
-                        "feedback": evaluation.get("feedback", "No feedback provided"),
-                        "issues": evaluation.get("issues", []),
-                        "recommendations": evaluation.get("recommendations", []),
-                        "used_api_key_index": idx,
-                        "used_api_name": api_name
-                    }
-
-                except Exception as e:
-                    last_error_messages.append(f"Exception with key #{idx}: {str(e)}")
-                    if "429" in str(e) or "rate limit" in str(e).lower():
-                        self._rate_limit_delay[key] = datetime.now().timestamp() + 300
-                    elif "503" in str(e) or "service unavailable" in str(e).lower():
-                        self._rate_limit_delay[key] = datetime.now().timestamp() + 7200
-                    continue
-
-            if retry_count < 3 and self._rate_limit_delay:
-                next_available_ts = min(self._rate_limit_delay.values())
-                wait_time = max(0, next_available_ts - datetime.now().timestamp())
-                await asyncio.sleep(wait_time + 1)
-                return await self.evaluate_from_content(
-                    question_content=question_content,
-                    answer_path=answer_path,
-                    api_keys=api_keys,
-                    question_type=question_type,
-                    retry_count=retry_count + 1
-                )
-
-            return {
-                "score": 0,
-                "feedback": "Evaluation failed with all API keys." if retry_count >= 3 else "All API keys are temporarily unavailable.",
-                "issues": last_error_messages if last_error_messages else ["All API keys failed to evaluate the submission."],
-                "recommendations": [],
-                "used_api_key_index": None,
-                "used_api_name": None
-            }

quantumchecker-0.3.0/tests/test.py

@@ -1,135 +0,0 @@
-import asyncio
-import logging
-import random
-from concurrent.futures import ThreadPoolExecutor
-from typing import List, Dict
-from QuantumCheck import HomeworkEvaluator
-from backoff import on_exception, expo
-from google.api_core.exceptions import TooManyRequests
-
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[
-        logging.FileHandler("evaluation.log", encoding="utf-8"),
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger(__name__)
-
-
-question_sets = {
-    "python_beginner": "Your Python beginner questions content here...",
-    "power_bi": "Your Power BI questions content here...",
-    "sql": "Your SQL questions content here...",
-    "ssis": "Your SSIS questions content here..."
-}
-
-answer_paths = {
-    "python": ["../tests/answer/python1.zip"],
-    "power_bi": ["../tests/answer/real.zip"],
-    "sql": ["../tests/answer/sql3.zip"],
-    "ssis":["../tests/answer/answer.dtsx"]
-}
-
-question_type_mapping = {
-    "python_beginner": "python",
-    "power_bi": "power_bi",
-    "sql": "sql",
-    "ssis": "ssis"
-}
-
-api_keys = []
-
-
-evaluator = HomeworkEvaluator(log_level=logging.INFO)
-
-@on_exception(expo, TooManyRequests, max_tries=5, max_time=300)
-async def evaluate_async(question_text: str, answer_path: str, api_keys: List[str], question_type: str) -> Dict:
-    """Wrap the async evaluate function with exponential backoff for rate limit errors."""
-    try:
-        return await evaluator.evaluate_from_content(
-            question_content=question_text,
-            answer_path=answer_path,
-            api_keys=api_keys,
-            question_type=question_type
-        )
-    except Exception as e:
-        logger.error(f"Evaluation failed: {str(e)}")
-        return {
-            "score": 0,
-            "feedback": f"Evaluation failed: {str(e)}",
-            "issues": [str(e)],
-            "recommendations": [],
-            "used_api_key_index": None,
-            "used_api_name": None
-        }
-
-async def main(num_requests: int = 10, max_workers: int = 6):
-    resource_exhausted_count = 0
-    logger.info(f"Starting evaluation with {num_requests} requests and {max_workers} workers")
-
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        loop = asyncio.get_running_loop()
-        tasks = []
-
-        for i in range(num_requests):
-            question_key = random.choice(list(question_sets.keys()))
-            question_text = question_sets[question_key]
-            question_type = question_type_mapping.get(question_key, "python")
-            answer_path = random.choice(answer_paths.get(question_type, answer_paths["python"]))
-
-            logger.info(f"Scheduling Request #{i + 1} for '{question_key}' with '{answer_path}'")
-            task = loop.create_task(evaluate_async(question_text, answer_path, api_keys, question_type))
-            tasks.append((i + 1, task))
-
-
-        results = []
-        for i, task in tasks:
-            try:
-                result = await task
-                if "resource exhausted" in str(result.get("feedback", "")).lower():
-                    resource_exhausted_count += 1
-                results.append((i, result))
-            except Exception as e:
-                logger.error(f"Request #{i} failed with error: {str(e)}")
-                if "resource exhausted" in str(e).lower():
-                    resource_exhausted_count += 1
-                results.append((i, {
-                    "score": 0,
-                    "feedback": f"Request failed: {str(e)}",
-                    "issues": [str(e)],
-                    "recommendations": [],
-                    "used_api_key_index": None,
-                    "used_api_name": None
-                }))
-
-    logger.info("All evaluations completed")
-
-    for i, result in results:
-        score = result.get("score", 0)
-        feedback = result.get("feedback", "")
-        used_key_index = result.get("used_api_key_index", "N/A")
-        used_api_name = result.get("used_api_name", "N/A")
-
-        feedback_words = feedback.split()
-        partial_feedback = " ".join(feedback_words[:40]) + ("..." if len(feedback_words) > 10 else "")
-
-        if score == 0 and "failed" in feedback.lower():
-            logger.error(f"Request #{i} failed with error: {feedback}")
-            print(f"X Request #{i} failed with error: {feedback}")
-        else:
-            logger.info(f"Request #{i} succeeded: Score = {score}, API Index = {used_key_index}, API Name = {used_api_name}")
-            print(f"O Request #{i} succeeded: Score = {score}, API Index = {used_key_index}, API Name = {used_api_name}")
-            print(f"   Feedback preview: {partial_feedback}\n")
-
-    logger.info(f"Total 'resource exhausted' errors encountered: {resource_exhausted_count}")
-    print(f"Total 'resource exhausted' errors encountered: {resource_exhausted_count}")
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main(num_requests=100, max_workers=20))
-    except Exception as e:
-        logger.error(f"Fatal error in main: {e}")
-        print(f"Fatal error in main: {e}")

quantumchecker-0.3.0/tests/test2.py

@@ -1,31 +0,0 @@
-import asyncio
-from QuantumCheck import HomeworkEvaluator
-
-async def main():
-    evaluator = HomeworkEvaluator()
-
-    question_content = """
-    Q1: Write a Python function that calculates the factorial of a number.
-
-    Q2: What is the difference between a list and a tuple in Python?
-    """
-
-    answer_path = "answer/python1.zip"
-    api_keys = []
-
-    question_type = "python"
-
-    result = await evaluator.evaluate_from_content(
-        question_content=question_content,
-        answer_path=answer_path,
-        api_keys=api_keys,
-        question_type=question_type
-    )
-
-    print("Evaluation Result:")
-    print(result["score"])
-    print(result["feedback"])
-
-
-if __name__ == "__main__":
-    asyncio.run(main())