import asyncio
from openjudge.graders.code import SyntaxCheckGrader, CodeStyleGrader
from openjudge.runner.grading_runner import GradingRunner

async def main():
    # For code quality evaluation without test cases
    runner = GradingRunner(grader_configs={
        "syntax": SyntaxCheckGrader(),
        "style": CodeStyleGrader(),
    })

    code_response = '''
    ```python
    def fibonacci(n):
        if n <= 1:
            return n
        return fibonacci(n-1) + fibonacci(n-2)
    ```
    '''

    results = await runner.arun([{"response": code_response}])

    print(f"Syntax Score: {results['syntax'][0].score}")
    print(f"Style Score: {results['style'][0].score}")

asyncio.run(main())

import asyncio
from openjudge.graders.code import CodeExecutionGrader
from openjudge.runner.grading_runner import GradingRunner

async def main():
    # CodeExecutionGrader is used with datasets containing test cases
    # Typical usage in benchmark evaluation contexts (HumanEval, APPS, etc.)
    grader = CodeExecutionGrader(continuous=True, timeout=10)
    runner = GradingRunner(grader_configs={"execution": grader})

    # Dataset format from benchmarks
    # Each sample should include test cases in the expected format
    dataset = [
        {
            "response": "def add(a, b):\n    return a + b",
            # Test cases are typically pre-loaded from benchmark datasets
        }
    ]

    results = await runner.arun(dataset)
    print(f"Execution Score: {results['execution'][0].score}")

asyncio.run(main())

import asyncio
from openjudge.graders.code import SyntaxCheckGrader

async def main():
    grader = SyntaxCheckGrader()

    response = '''
    Here's a function:
    ```python
    def greet(name):
        return f"Hello, {name}!"
    ```
    '''

    result = await grader.aevaluate(response=response)
    print(f"Score: {result.score}")   # 1.0
    print(f"Reason: {result.reason}") # Syntax check: 1/1 blocks valid, 0 errors

asyncio.run(main())

import asyncio
from openjudge.graders.code import SyntaxCheckGrader

async def main():
    grader = SyntaxCheckGrader()

    # Missing colon after function definition
    invalid_response = '''
    ```python
    def greet(name)
        return f"Hello, {name}!"
    ```
    '''

    result = await grader.aevaluate(response=invalid_response)
    print(f"Score: {result.score}")   # -0.5
    print(f"Errors: {result.metadata['syntax_errors']}")

asyncio.run(main())

import asyncio
from openjudge.graders.code import CodeStyleGrader

async def main():
    grader = CodeStyleGrader()

    # Proper snake_case naming and consistent indentation
    good_code = '''
    ```python
    def calculate_sum(numbers):
        total = 0
        for num in numbers:
            total += num
        return total
    ```
    '''

    result = await grader.aevaluate(response=good_code)
    print(f"Score: {result.score}")   # 1.0
    print(f"Reason: {result.reason}")

asyncio.run(main())

import asyncio
from openjudge.graders.code import CodeStyleGrader

async def main():
    grader = CodeStyleGrader()

    # Incorrect PascalCase naming (should be snake_case)
    poor_code = '''
    ```python
    def CalculateSum(Numbers):
        Total = 0
        for Num in Numbers:
            Total += Num
        return Total
    ```
    '''

    result = await grader.aevaluate(response=poor_code)
    print(f"Score: {result.score}")   # Lower score
    print(f"Details: {result.metadata['details']}")

asyncio.run(main())

import asyncio
from openjudge.graders.math import MathExpressionVerifyGrader

async def main():
    grader = MathExpressionVerifyGrader()

    # Simple numeric comparison
    result = await grader.aevaluate(
        response="4",
        reference_response="2+2"
    )
    print(f"Score: {result.score}")   # 1.0
    print(f"Reason: {result.reason}") # Expressions are equivalent

asyncio.run(main())

import asyncio
from openjudge.graders.math import MathExpressionVerifyGrader

async def main():
    grader = MathExpressionVerifyGrader()

    # LaTeX notation comparison
    result = await grader.aevaluate(
        response=r"\frac{1}{2}",
        reference_response="0.5"
    )
    print(f"Score: {result.score}")   # 1.0
    print(f"Reason: {result.reason}")

asyncio.run(main())

import asyncio
from openjudge.graders.math import MathExpressionVerifyGrader

async def main():
    grader = MathExpressionVerifyGrader()

    # Non-equivalent values
    result = await grader.aevaluate(
        response="5",
        reference_response="3"
    )
    print(f"Score: {result.score}")   # 0.0
    print(f"Reason: {result.reason}") # Expressions are not equivalent

asyncio.run(main())