Spaces:
Running
Running
| """ | |
| Python Code Evaluator — SE-Group1 | |
| COS60011 Technology Design Project | |
| """ | |
| # --------------------------------------------------------------------------- | |
| # IMPORTS (all at top) | |
| # --------------------------------------------------------------------------- | |
| import os | |
| import re | |
| import ast | |
| import time | |
| from collections import deque | |
| from dotenv import load_dotenv | |
| import gradio as gr | |
| from google import genai | |
| load_dotenv() | |
| # --------------------------------------------------------------------------- | |
| # MODULE 3 — Pre-processing Module | |
| # --------------------------------------------------------------------------- | |
| def pre_processing(description, code): | |
| build_prompt = f""" | |
| #ROLE | |
| You are a Python code reviewer. Your goal is to determine if the provided Python code strictly complies with the requirements mentioned by the user. | |
| #CONTEXT | |
| Developers may create code that does not entirely meet the specified requirements. You will examine the relationship between a natural-language description and a Python code sample and create a structured evaluation report. | |
| #INPUT DATA | |
| Description: {description} | |
| Code: ```python | |
| {code} | |
| ``` | |
| #TASK | |
| 1. Carefully read the requirements description. | |
| 2. Examine each line of the Python code. | |
| 3. Determine whether the code fulfils ALL requirements stated in the description. | |
| 4. Estimate the accuracy in percentages to assess how accurately the code matches the description. | |
| 5. List specific requirements that are either absent or incorrectly applied. | |
| 6. Base your evaluation solely on static code analysis and logical reasoning. | |
| #CONSTRAINTS | |
| 1. Do not execute the code. | |
| 2. The output must be in the specified format. | |
| 3. The output should be clear and concise. | |
| #OUTPUT FORMAT (to be strictly followed without any changes) | |
| Result: either "Pass" or "Fail" (Pass if the code is functional and matches the description, Fail if it has bugs or doesn't match). | |
| Accuracy: an integer from 0 to 100 representing how well the code matches the description and is bug-free. | |
| Review: a short prose explanation of the result (e.g. "Code correctly handles all described requirements including edge cases."). | |
| Issues: The value should be a single string containing a numbered list. For each item, include the severity (Error, Warning, or Info) followed by a dash and description of the issue (e.g. "Missing type hints on function signature"). List each issue on a new line starting with a number. Use newline characters (\n) to separate each line. | |
| ... | |
| """ | |
| return prompt | |
| # --------------------------------------------------------------------------- | |
| # MODULE 4 — Generation Module | |
| # --------------------------------------------------------------------------- | |
| MODEL_ID = "gemma-4-31b-it" | |
| GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY") | |
| def generate_response(prompt: str) -> str: | |
| if not GOOGLE_API_KEY: | |
| return ( | |
| "⚠️ Error: API Key not found! " | |
| "Please configure GOOGLE_API_KEY in Settings → Variables and secrets." | |
| ) | |
| try: | |
| client = genai.Client(api_key=GOOGLE_API_KEY) | |
| response = client.models.generate_content(model=MODEL_ID, contents=prompt) | |
| return response.text | |
| except Exception as e: | |
| return f"❌ An error occurred during generation: {str(e)}" | |
| # --------------------------------------------------------------------------- | |
| # MODULE 5 — Output Module | |
| # --------------------------------------------------------------------------- | |
| def parse_output(raw: str) -> dict: | |
| if "<start_of_turn>model" in raw: | |
| raw = raw.split("<start_of_turn>model")[-1] | |
| result_match = re.search(r"RESULT:\s*(PASS|FAIL)", raw, re.IGNORECASE) | |
| accuracy_match = re.search(r"ACCURACY:\s*(\d{1,3})%?", raw, re.IGNORECASE) | |
| summary_match = re.search(r"SUMMARY:\s*(.+)", raw, re.IGNORECASE) | |
| issues_match = re.search(r"ISSUES:\s*([\s\S]+)", raw, re.IGNORECASE) | |
| result = result_match.group(1).upper() if result_match else "UNKNOWN" | |
| accuracy = int(accuracy_match.group(1)) if accuracy_match else -1 | |
| summary = summary_match.group(1).strip() if summary_match else "Could not extract summary." | |
| if issues_match: | |
| raw_issues = issues_match.group(1).strip() | |
| issues = [ | |
| line.lstrip("-•* ").strip() | |
| for line in raw_issues.splitlines() | |
| if line.strip() and line.strip() not in ("-", "•") | |
| ] | |
| else: | |
| issues = ["Could not extract issues from model response."] | |
| return { | |
| "result": result, | |
| "accuracy": accuracy, | |
| "summary": summary, | |
| "issues": issues, | |
| "raw": raw.strip(), | |
| } | |
| def format_for_display(parsed: dict) -> tuple[str, str, str]: | |
| emoji = "✅" if parsed["result"] == "PASS" else ("❌" if parsed["result"] == "FAIL" else "⚠️") | |
| verdict = f"{emoji} {parsed['result']}" | |
| acc_str = f"{parsed['accuracy']}%" if parsed["accuracy"] >= 0 else "N/A" | |
| metrics = f"Accuracy: {acc_str}\n\nSummary: {parsed['summary']}" | |
| issues_text = "\n".join(f"• {issue}" for issue in parsed["issues"]) | |
| return verdict, metrics, issues_text | |
| # --------------------------------------------------------------------------- | |
| # MODULE 2 — Validation & Flow Management Module | |
| # --------------------------------------------------------------------------- | |
| MIN_DESCRIPTION_CHARS = 20 | |
| MAX_DESCRIPTION_CHARS = 3000 | |
| MIN_CODE_CHARS = 10 | |
| MAX_CODE_CHARS = 8000 | |
| MAX_CODE_LINES = 300 | |
| FORBIDDEN_PATTERNS = [ | |
| r"ignore (all |previous |above )?instructions", | |
| r"disregard (all |previous |above )?instructions", | |
| r"you are now", | |
| r"act as (a |an )?", | |
| r"<\s*(script|iframe|object|embed)", | |
| r"system\s*prompt", | |
| r"jailbreak", | |
| ] | |
| PYTHON_KEYWORDS = { | |
| "def", "class", "import", "from", "return", "if", "else", "elif", | |
| "for", "while", "try", "except", "with", "lambda", "yield", "pass", | |
| "raise", "assert", "in", "not", "and", "or", "True", "False", "None", | |
| "print", "len", "range", "self", | |
| } | |
| class RateLimiter: | |
| def __init__(self, max_calls: int = 5, window_seconds: int = 60): | |
| self.max_calls = max_calls | |
| self.window_seconds = window_seconds | |
| self._timestamps: deque = deque() | |
| def is_allowed(self) -> tuple[bool, str]: | |
| now = time.time() | |
| while self._timestamps and now - self._timestamps[0] > self.window_seconds: | |
| self._timestamps.popleft() | |
| if len(self._timestamps) >= self.max_calls: | |
| wait = int(self.window_seconds - (now - self._timestamps[0])) + 1 | |
| return False, ( | |
| f"⏳ Rate limit reached — {self.max_calls} requests in " | |
| f"{self.window_seconds}s. Please wait ~{wait}s and try again." | |
| ) | |
| self._timestamps.append(now) | |
| return True, "" | |
| _rate_limiter = RateLimiter(max_calls=5, window_seconds=60) | |
| def _check_forbidden(text: str) -> str | None: | |
| lower = text.lower() | |
| for pattern in FORBIDDEN_PATTERNS: | |
| if re.search(pattern, lower): | |
| return ( | |
| "Input contains disallowed content. " | |
| "Please remove prompt-injection or HTML patterns and try again." | |
| ) | |
| return None | |
| def _looks_like_python(code: str) -> tuple[bool, str]: | |
| tokens = set(re.findall(r"[A-Za-z_]\w*", code)) | |
| if not tokens.intersection(PYTHON_KEYWORDS): | |
| return False, ( | |
| "🐍 The code doesn't appear to be Python — no recognisable Python " | |
| "keywords found (e.g. def, class, import, return). " | |
| "Please submit Python code only." | |
| ) | |
| try: | |
| ast.parse(code) | |
| except SyntaxError as exc: | |
| line_hint = f" (line {exc.lineno})" if exc.lineno else "" | |
| return False, ( | |
| f"🐍 Python syntax error{line_hint}: {exc.msg}. " | |
| "Please fix the syntax error before evaluating." | |
| ) | |
| return True, "" | |
| def validate_inputs(description: str, code: str) -> list[str]: | |
| errors: list[str] = [] | |
| if not description or not description.strip(): | |
| errors.append("📋 Requirements description is required.") | |
| if not code or not code.strip(): | |
| errors.append("🐍 Python code is required.") | |
| if errors: | |
| return errors | |
| desc, code_ = description.strip(), code.strip() | |
| if len(desc) < MIN_DESCRIPTION_CHARS: | |
| errors.append(f"📋 Description too short ({len(desc)} chars) — minimum is {MIN_DESCRIPTION_CHARS} characters.") | |
| if len(code_) < MIN_CODE_CHARS: | |
| errors.append(f"🐍 Code too short ({len(code_)} chars) — minimum is {MIN_CODE_CHARS} characters.") | |
| if len(desc) > MAX_DESCRIPTION_CHARS: | |
| errors.append(f"📋 Description too long ({len(desc):,} chars) — max is {MAX_DESCRIPTION_CHARS:,} characters.") | |
| if len(code_) > MAX_CODE_CHARS: | |
| errors.append(f"🐍 Code too long ({len(code_):,} chars) — max is {MAX_CODE_CHARS:,} characters.") | |
| if len(code_.splitlines()) > MAX_CODE_LINES: | |
| errors.append(f"🐍 Code has too many lines ({len(code_.splitlines())}) — max is {MAX_CODE_LINES} lines.") | |
| if err := _check_forbidden(desc): | |
| errors.append(f"📋 {err}") | |
| if err := _check_forbidden(code_): | |
| errors.append(f"🐍 {err}") | |
| if not errors: | |
| is_python, py_error = _looks_like_python(code_) | |
| if not is_python: | |
| errors.append(py_error) | |
| if not errors: | |
| allowed, rate_msg = _rate_limiter.is_allowed() | |
| if not allowed: | |
| errors.append(rate_msg) | |
| return errors | |
| def validate_and_evaluate(description: str, code: str): | |
| errors = validate_inputs(description, code) | |
| if errors: | |
| return "", "", "", "\n".join(f"{i+1}. {e}" for i, e in enumerate(errors)) | |
| if not GOOGLE_API_KEY: | |
| return "", "", "", "❌ GOOGLE_API_KEY secret not set in Space Settings." | |
| prompt = build_prompt(description, code) | |
| try: | |
| raw_output = generate_response(prompt) | |
| except Exception as exc: | |
| return "", "", "", f"❌ Model error: {exc}" | |
| parsed = parse_output(raw_output) | |
| verdict, metrics, issues = format_for_display(parsed) | |
| return verdict, metrics, issues, "" | |
| # --------------------------------------------------------------------------- | |
| # MODULE 1 — UI Module | |
| # --------------------------------------------------------------------------- | |
| CUSTOM_CSS = """ | |
| @import url('https://fonts.googleapis.com/css2?family=Space+Mono:wght@400;700&family=DM+Sans:ital,wght@0,300;0,400;0,500;0,600;1,400&display=swap'); | |
| *, *::before, *::after { box-sizing: border-box; } | |
| body, .gradio-container { | |
| font-family: 'DM Sans', sans-serif !important; | |
| background: #0D0F14 !important; | |
| color: #E8EAF0 !important; | |
| } | |
| .gradio-container { | |
| max-width: 1140px !important; | |
| margin: 0 auto !important; | |
| padding: 32px 24px !important; | |
| } | |
| .eval-header { | |
| display: flex; | |
| align-items: center; | |
| gap: 16px; | |
| padding: 0 0 28px; | |
| border-bottom: 1px solid #2E3140; | |
| margin-bottom: 28px; | |
| } | |
| .eval-header .logo { | |
| width: 44px; height: 44px; | |
| border-radius: 10px; | |
| background: linear-gradient(135deg, #534AB7 0%, #1D9E75 100%); | |
| display: flex; align-items: center; justify-content: center; | |
| flex-shrink: 0; | |
| font-size: 22px; line-height: 1; | |
| } | |
| .eval-header h1 { | |
| font-size: 20px !important; | |
| font-weight: 600 !important; | |
| letter-spacing: -0.3px !important; | |
| color: #E8EAF0 !important; | |
| margin: 0 !important; | |
| } | |
| .eval-header .model-badge { | |
| margin-left: auto; | |
| font-family: 'Space Mono', monospace; | |
| font-size: 10px; | |
| background: #1E2028; | |
| border: 1px solid #3A3E52; | |
| color: #6A6E80; | |
| padding: 4px 10px; | |
| border-radius: 4px; | |
| letter-spacing: 1.5px; | |
| white-space: nowrap; | |
| } | |
| .gradio-textbox textarea, | |
| .gradio-code textarea, | |
| .gradio-textbox input { | |
| background: #161820 !important; | |
| border: 1px solid #2E3140 !important; | |
| border-radius: 10px !important; | |
| color: #E8EAF0 !important; | |
| font-family: 'DM Sans', sans-serif !important; | |
| font-size: 13.5px !important; | |
| line-height: 1.7 !important; | |
| padding: 14px 16px !important; | |
| transition: border-color 0.15s !important; | |
| resize: vertical !important; | |
| } | |
| .gradio-textbox textarea:focus, | |
| .gradio-code textarea:focus { | |
| border-color: #534AB7 !important; | |
| outline: none !important; | |
| box-shadow: 0 0 0 3px rgba(83, 74, 183, 0.15) !important; | |
| } | |
| .gradio-textbox textarea::placeholder { | |
| color: #4A4E60 !important; | |
| } | |
| #code-input textarea { | |
| font-family: 'Space Mono', monospace !important; | |
| font-size: 12.5px !important; | |
| line-height: 1.65 !important; | |
| } | |
| .gradio-textbox label span, | |
| .gradio-code label span { | |
| font-family: 'DM Sans', sans-serif !important; | |
| font-size: 13px !important; | |
| font-weight: 700 !important; | |
| color: #E8EAF0 !important; | |
| text-transform: uppercase !important; | |
| letter-spacing: 0.8px !important; | |
| } | |
| #eval-btn { | |
| background: #534AB7 !important; | |
| border: none !important; | |
| color: #fff !important; | |
| font-family: 'DM Sans', sans-serif !important; | |
| font-size: 14px !important; | |
| font-weight: 500 !important; | |
| padding: 12px 32px !important; | |
| border-radius: 8px !important; | |
| cursor: pointer !important; | |
| transition: background 0.15s, transform 0.1s !important; | |
| letter-spacing: -0.1px !important; | |
| } | |
| #eval-btn:hover { background: #7F77DD !important; transform: translateY(-1px) !important; } | |
| #eval-btn:active { transform: translateY(0) !important; } | |
| #clear-btn { | |
| background: transparent !important; | |
| border: 1px solid #3A3E52 !important; | |
| color: #9DA0B0 !important; | |
| font-family: 'DM Sans', sans-serif !important; | |
| font-size: 13px !important; | |
| padding: 12px 20px !important; | |
| border-radius: 8px !important; | |
| cursor: pointer !important; | |
| transition: border-color 0.15s, color 0.15s !important; | |
| } | |
| #clear-btn:hover { border-color: #7F77DD !important; color: #E8EAF0 !important; } | |
| .results-heading { | |
| font-size: 11px !important; | |
| font-weight: 500 !important; | |
| color: #6A6E80 !important; | |
| text-transform: uppercase !important; | |
| letter-spacing: 1px !important; | |
| padding: 0 0 16px !important; | |
| border-bottom: 1px solid #2E3140 !important; | |
| margin-bottom: 20px !important; | |
| } | |
| #verdict-out textarea { | |
| background: #161820 !important; border: 1px solid #2E3140 !important; | |
| border-radius: 10px !important; font-family: 'Space Mono', monospace !important; | |
| font-size: 26px !important; font-weight: 700 !important; | |
| text-align: center !important; padding: 20px !important; | |
| color: #E8EAF0 !important; cursor: default !important; | |
| } | |
| #accuracy-out textarea { | |
| background: #161820 !important; border: 1px solid #2E3140 !important; | |
| border-radius: 10px !important; font-family: 'Space Mono', monospace !important; | |
| font-size: 26px !important; font-weight: 700 !important; | |
| text-align: center !important; padding: 20px !important; | |
| color: #E8EAF0 !important; cursor: default !important; | |
| } | |
| #summary-out textarea { | |
| background: #161820 !important; border: 1px solid #2E3140 !important; | |
| border-radius: 10px !important; font-family: 'DM Sans', sans-serif !important; | |
| font-size: 13.5px !important; line-height: 1.7 !important; | |
| padding: 16px !important; color: #C0C3D0 !important; cursor: default !important; | |
| } | |
| #issues-out textarea { | |
| background: #161820 !important; border: 1px solid #2E3140 !important; | |
| border-radius: 10px !important; font-family: 'DM Sans', sans-serif !important; | |
| font-size: 13.5px !important; line-height: 1.8 !important; | |
| padding: 16px !important; color: #C0C3D0 !important; | |
| cursor: default !important; min-height: 120px !important; | |
| } | |
| #error-out textarea { | |
| background: #1A0E0E !important; border: 1px solid #5a2020 !important; | |
| border-radius: 10px !important; font-family: 'DM Sans', sans-serif !important; | |
| font-size: 13.5px !important; padding: 14px 16px !important; | |
| color: #F0997B !important; cursor: default !important; | |
| } | |
| .divider { height: 1px; background: #2E3140; margin: 20px 0; } | |
| footer { display: none !important; } | |
| ::-webkit-scrollbar { width: 6px; height: 6px; } | |
| ::-webkit-scrollbar-track { background: transparent; } | |
| ::-webkit-scrollbar-thumb { background: #3A3E52; border-radius: 3px; } | |
| ::-webkit-scrollbar-thumb:hover { background: #534AB7; } | |
| """ | |
| HEADER_HTML = """ | |
| <div class="eval-header"> | |
| <div class="logo">🔍</div> | |
| <div><h1>Python Code Evaluator</h1></div> | |
| <div class="model-badge">GEMMA-4 · 31B-IT</div> | |
| </div> | |
| """ | |
| RESULTS_HEADING_HTML = """ | |
| <div class="divider"></div> | |
| <div class="results-heading">⬡ Evaluation Results</div> | |
| """ | |
| INPUT_HINT_HTML = """ | |
| <div style="font-size:12px;color:#4A4E60;margin-top:-4px;padding-bottom:4px;"> | |
| Tip — paste your description and code above, then click | |
| <strong style="color:#7F77DD">Evaluate</strong>. | |
| </div> | |
| """ | |
| def build_ui(evaluate_fn): | |
| def _split_metrics(metrics_str: str): | |
| acc, summary = "", "" | |
| if not metrics_str: | |
| return acc, summary | |
| for line in metrics_str.splitlines(): | |
| if line.startswith("Accuracy:"): | |
| acc = line.replace("Accuracy:", "").strip() | |
| elif line.startswith("Summary:"): | |
| summary = line.replace("Summary:", "").strip() | |
| return acc, summary | |
| def _ui_evaluate(description: str, code: str): | |
| verdict, metrics, issues, error = evaluate_fn(description, code) | |
| accuracy, summary = _split_metrics(metrics) | |
| if "PASS" in verdict.upper(): | |
| verdict_display = "✅ PASS" | |
| elif "FAIL" in verdict.upper(): | |
| verdict_display = "❌ FAIL" | |
| else: | |
| verdict_display = verdict or "" | |
| return verdict_display, accuracy, summary, issues, error | |
| with gr.Blocks(css=CUSTOM_CSS, title="Python Code Evaluator") as demo: | |
| gr.HTML(HEADER_HTML) | |
| with gr.Row(equal_height=True): | |
| description_input = gr.Textbox( | |
| label="Requirements Description", | |
| placeholder=( | |
| "Describe what the Python code is supposed to do…\n\n" | |
| "Example: Write a function that accepts a list of integers " | |
| "and returns the sum of all even numbers." | |
| ), | |
| lines=10, max_lines=20, elem_id="desc-input", | |
| ) | |
| code_input = gr.Textbox( | |
| label="Python Code", | |
| placeholder="# Paste your Python code here…\n\ndef example(data):\n pass\n", | |
| lines=10, max_lines=30, elem_id="code-input", | |
| ) | |
| gr.HTML(INPUT_HINT_HTML) | |
| with gr.Row(): | |
| eval_btn = gr.Button("Evaluate", variant="primary", elem_id="eval-btn", scale=0) | |
| clear_btn = gr.Button("Clear", variant="secondary", elem_id="clear-btn", scale=0) | |
| gr.HTML(RESULTS_HEADING_HTML) | |
| with gr.Row(equal_height=True): | |
| verdict_out = gr.Textbox(label="Verdict", interactive=False, elem_id="verdict-out", scale=1) | |
| accuracy_out = gr.Textbox(label="Accuracy", interactive=False, elem_id="accuracy-out", scale=1) | |
| summary_out = gr.Textbox(label="Summary", interactive=False, elem_id="summary-out", scale=2, lines=3) | |
| issues_out = gr.Textbox(label="Issues Detected", interactive=False, lines=5, elem_id="issues-out") | |
| error_out = gr.Textbox(label="Status / Errors", interactive=False, visible=True, elem_id="error-out") | |
| gr.HTML(""" | |
| <div style="text-align:right;font-size:11px;color:#4A4E60;margin-top:8px;"> | |
| Press <kbd style="background:#1E2028;border:1px solid #3A3E52;border-radius:4px; | |
| padding:2px 6px;font-family:'Space Mono',monospace;font-size:10px;color:#9DA0B0;"> | |
| Ctrl+Enter</kbd> to evaluate | |
| </div> | |
| """) | |
| outputs = [verdict_out, accuracy_out, summary_out, issues_out, error_out] | |
| eval_btn.click(fn=_ui_evaluate, inputs=[description_input, code_input], outputs=outputs) | |
| description_input.submit(fn=_ui_evaluate, inputs=[description_input, code_input], outputs=outputs) | |
| code_input.submit(fn=_ui_evaluate, inputs=[description_input, code_input], outputs=outputs) | |
| def _clear(): | |
| return "", "", "", "", "", "" | |
| clear_btn.click( | |
| fn=_clear, inputs=[], | |
| outputs=[description_input, code_input, | |
| verdict_out, accuracy_out, summary_out, issues_out], | |
| ) | |
| return demo | |
| # --------------------------------------------------------------------------- | |
| # ENTRY POINT | |
| # --------------------------------------------------------------------------- | |
| if __name__ == "__main__": | |
| app = build_ui(validate_and_evaluate) | |
| app.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True) |