rbx.cp 0.5.0__py3-none-any.whl

rbx/box/validators.py

@@ -0,0 +1,245 @@
+import pathlib
+import shlex
+from typing import Dict, List, Optional, Set, Tuple
+
+from pydantic import BaseModel
+
+from rbx import console
+from rbx.box import package
+from rbx.box.code import compile_item, run_item
+from rbx.box.schema import CodeItem, Primitive
+from rbx.box.testcases import find_built_testcase_inputs
+from rbx.grading.steps import (
+    DigestHolder,
+    DigestOrDest,
+    DigestOrSource,
+    GradingFileOutput,
+)
+from rbx.utils import StatusProgress
+
+HitBounds = Dict[str, Tuple[bool, bool]]
+
+
+class TestcaseValidationInfo(BaseModel):
+    group: str
+    path: pathlib.Path
+    ok: bool
+    hit_bounds: HitBounds
+    message: Optional[str] = None
+
+
+def _compile_validator(validator: CodeItem) -> str:
+    try:
+        digest = compile_item(validator)
+    except:
+        console.console.print(
+            f'[error]Failed compiling validator [item]{validator.path}[/item].[/error]'
+        )
+        raise
+    return digest
+
+
+def _bounds_or(lhs: Tuple[bool, bool], rhs: Tuple[bool, bool]) -> Tuple[bool, bool]:
+    return (lhs[0] or rhs[0], lhs[1] or rhs[1])
+
+
+def _process_bounds(log: str) -> HitBounds:
+    bounds: HitBounds = {}
+    for line in log.splitlines():
+        items = line.split(':')
+        if len(items) != 2:
+            continue
+        k, v = items
+        v = v.strip()
+
+        hit = ('min-value-hit' in v, 'max-value-hit' in v)
+        if k not in bounds:
+            bounds[k] = hit
+            continue
+        bounds[k] = _bounds_or(bounds[k], hit)
+    return bounds
+
+
+def _merge_hit_bounds(hit_bounds: List[HitBounds]) -> HitBounds:
+    res: HitBounds = {}
+    for hb in hit_bounds:
+        for k, hit in hb.items():
+            if k not in res:
+                res[k] = hit
+                continue
+            res[k] = _bounds_or(res[k], hit)
+    return res
+
+
+def _has_group_specific_validator() -> bool:
+    pkg = package.find_problem_package_or_die()
+
+    return any(group.validator is not None for group in pkg.testcases)
+
+
+def _validate_testcase(
+    testcase: pathlib.Path,
+    validator: CodeItem,
+    validator_digest: str,
+    vars: Optional[Dict[str, Primitive]] = None,
+) -> Tuple[bool, Optional[str], HitBounds]:
+    vars = vars or {}
+    for var in vars:
+        assert (
+            var.isidentifier()
+        ), f'Variable {var} should be a valid Python identifier.'
+    # TODO: check if needs to do some escaping
+    var_args = [f'--{k}={v}' for k, v in vars.items()]
+    var_args.extend(['--testOverviewLogFileName', 'validator.log'])
+
+    message_digest = DigestHolder()
+    log_digest = DigestHolder()
+    run_log = run_item(
+        validator,
+        DigestOrSource.create(validator_digest),
+        stdin=DigestOrSource.create(testcase),
+        stderr=DigestOrDest.create(message_digest),
+        outputs=[
+            GradingFileOutput(
+                src=pathlib.Path('validator.log'),
+                digest=log_digest,
+                optional=True,
+            )
+        ],
+        extra_args=shlex.join(var_args) if var_args else None,
+    )
+    log_overview = ''
+    if log_digest.value is not None:
+        log_overview = package.get_digest_as_string(log_digest.value or '')
+    message = package.get_digest_as_string(message_digest.value or '')
+    return (
+        run_log is not None and run_log.exitcode == 0,
+        message,
+        _process_bounds(log_overview or ''),
+    )
+
+
+def validate_test(
+    testcase: pathlib.Path,
+    validator: CodeItem,
+    validator_digest: str,
+) -> Tuple[bool, Optional[str], HitBounds]:
+    pkg = package.find_problem_package_or_die()
+    return _validate_testcase(
+        testcase, validator, validator_digest, vars=pkg.expanded_vars
+    )
+
+
+def compile_main_validator() -> Optional[Tuple[CodeItem, str]]:
+    pkg = package.find_problem_package_or_die()
+    if pkg.validator is None:
+        return None
+
+    return pkg.validator, _compile_validator(pkg.validator)
+
+
+def compile_validators(
+    progress: Optional[StatusProgress] = None,
+) -> Dict[str, str]:
+    pkg = package.find_problem_package_or_die()
+
+    group_to_compiled_digest = {}
+
+    for group in pkg.testcases:
+        validator = group.validator or pkg.validator
+        if validator is None:
+            continue
+        if progress:
+            progress.update(
+                f'Compiling validator for group [item]{group.name}[/item]...'
+            )
+        group_to_compiled_digest[group.name] = _compile_validator(validator)
+
+    return group_to_compiled_digest
+
+
+def validate_testcases(
+    progress: Optional[StatusProgress] = None,
+    groups: Optional[Set[str]] = None,
+) -> List[TestcaseValidationInfo]:
+    def step():
+        if progress is not None:
+            progress.step()
+
+    pkg = package.find_problem_package_or_die()
+
+    group_to_compiled_digest = compile_validators(progress)
+
+    validation_info = []
+
+    for group in pkg.testcases:
+        validator = group.validator or pkg.validator
+        if validator is None:
+            continue
+        if group.name not in group_to_compiled_digest:
+            continue
+        if groups is not None and group.name not in groups:
+            continue
+        compiled_digest = group_to_compiled_digest[group.name]
+
+        testcases = find_built_testcase_inputs(group)
+
+        for testcase in testcases:
+            ok, message, hit_bounds = validate_test(
+                testcase, validator, compiled_digest
+            )
+            validation_info.append(
+                TestcaseValidationInfo(
+                    group=group.name,
+                    path=testcase,
+                    ok=ok,
+                    hit_bounds=hit_bounds,
+                    message=message,
+                )
+            )
+            step()
+
+    return validation_info
+
+
+def print_validation_report(infos: List[TestcaseValidationInfo]):
+    console.console.rule('Validation report', style='status')
+    hit_bounds_per_group: Dict[str, HitBounds] = {}
+    for info in infos:
+        if not info.ok:
+            console.console.print(
+                f'[error]Testcase [item]{info.path}[/item] failed verification:[/error]\n{info.message}'
+            )
+            continue
+
+        if info.group not in hit_bounds_per_group:
+            hit_bounds_per_group[info.group] = {}
+        hit_bounds_per_group[info.group] = _merge_hit_bounds(
+            [hit_bounds_per_group[info.group], info.hit_bounds]
+        )
+
+    if not _has_group_specific_validator():
+        hit_bounds_per_group = {None: _merge_hit_bounds(hit_bounds_per_group.values())}
+
+    for group, hit_bounds in hit_bounds_per_group.items():
+        if group == 'samples':
+            # Skip samples.
+            continue
+        if group is None:
+            console.console.print('Hit bounds:')
+        else:
+            console.console.print(f'Group [item]{group}[/item] hit bounds:')
+
+        for k, v in hit_bounds.items():
+            if all(v):
+                continue
+
+            if not v[0]:
+                console.console.print(
+                    f'  - {k}: [warning]min-value not hit[/warning]',
+                )
+            if not v[1]:
+                console.console.print(
+                    f'  - {k}: [warning]max-value not hit[/warning]',
+                )
+        console.console.print()

rbx/box/validators_test.py

@@ -0,0 +1,15 @@
+import pathlib
+
+import pytest
+
+from rbx.box.generators import generate_testcases
+from rbx.box.validators import validate_testcases
+
+
+@pytest.mark.test_pkg('box1')
+def test_validators(pkg_from_testdata: pathlib.Path):
+    generate_testcases()
+    validation_infos = validate_testcases()
+
+    for info in validation_infos:
+        assert info.ok

rbx/checker.py

@@ -0,0 +1,128 @@
+import pathlib
+from typing import Optional
+
+import typer
+from typing_extensions import Annotated
+
+from rbx import annotations, config, metadata, utils
+from rbx.config import get_builtin_checker, get_testlib
+from rbx.console import console
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command('add, a')
+def add(
+    problem: annotations.Problem,
+    template: Annotated[
+        Optional[str],
+        typer.Option(
+            '--template', '-t', help='Checker that should be used as template.'
+        ),
+    ] = None,
+):
+    """
+    Add a new checker for the problem.
+    """
+    dumped_problem = metadata.find_problem_by_anything(problem)
+    if dumped_problem is None:
+        console.print(f'[error]Problem [item]{problem}[/item] not found.[/error]')
+        return
+
+    template_path = get_builtin_checker(template or 'boilerplate.cpp')
+
+    if not template_path.is_file():
+        console.print(f'[error]Template file {template} not found.[/error]')
+        return
+
+    testlib_path = get_testlib()
+    if not testlib_path.is_file():
+        console.print('[error]Testlib file not found.[/error]')
+        return
+
+    checker_name = f'{dumped_problem.code}.checker.cpp'
+    checker_path = pathlib.Path() / checker_name
+
+    # Create both files.
+    checker_path.write_text(template_path.read_text())
+    (checker_path.parent / 'testlib.h').write_text(testlib_path.read_text())
+
+    # Set checker.
+    problem_to_dump = dumped_problem.model_copy()
+    problem_to_dump.checker = checker_name
+    problem_path = metadata.find_problem_path_by_code(dumped_problem.code)
+    if not problem_path:
+        raise typer.Exit(1)
+    problem_path.write_text(utils.model_json(problem_to_dump))
+    console.print(
+        f'Checker [item]{checker_name}[/item] added to problem [item]{dumped_problem.pretty_name()}[/item].'
+    )
+
+
+@app.command('set, s')
+def set(problem: annotations.Problem, checker: annotations.Checker):
+    """
+    Set a checker for the problem.
+    """
+    dumped_problem = metadata.find_problem_by_anything(problem)
+    if dumped_problem is None:
+        console.print(f'[error]Problem [item]{problem}[/item] not found.[/error]')
+        return
+
+    problem_to_dump = dumped_problem.model_copy()
+    problem_to_dump.checker = checker
+    problem_path = metadata.find_problem_path_by_code(dumped_problem.code)
+    if not problem_path:
+        raise typer.Exit(1)
+    problem_path.write_text(utils.model_json(problem_to_dump))
+    console.print(
+        f'Checker [item]{checker}[/item] will be used for problem [item]{dumped_problem.pretty_name()}[/item].'
+    )
+
+
+@app.command('unset, u')
+def unset(problem: annotations.Problem):
+    """
+    Use the default checker for a problem.
+    """
+    dumped_problem = metadata.find_problem_by_anything(problem)
+    if dumped_problem is None:
+        console.print(f'[error]Problem [item]{problem}[/item] not found.[/error]')
+        return
+
+    problem_to_dump = dumped_problem.model_copy()
+    problem_to_dump.checker = None
+    problem_path = metadata.find_problem_path_by_code(dumped_problem.code)
+    if not problem_path:
+        raise typer.Exit(1)
+    problem_path.write_text(utils.model_json(problem_to_dump))
+    console.print(
+        f'Default checker will be used for problem [item]{dumped_problem.pretty_name()}[/item].'
+    )
+
+
+@app.command('edit, e')
+def edit(problem: annotations.Problem):
+    """
+    Edit the checker for a problem.
+    """
+    dumped_problem = metadata.find_problem_by_anything(problem)
+    if dumped_problem is None:
+        console.print(f'[error]Problem [item]{problem}[/item] not found.[/error]')
+        return
+
+    checker = dumped_problem.checker
+    if checker is None:
+        console.print(
+            f'[error]No checker set for problem [item]{dumped_problem.pretty_name()}[/item].[/error]'
+        )
+        return
+
+    checker_path = pathlib.Path() / checker
+    if not checker_path.is_file():
+        console.print(
+            f'[error]Checker [item]{checker}[/item] not found in the problems folder. You cannot edit a builtin checker.[/error]'
+        )
+        return
+
+    config.open_editor(checker_path)

rbx/clone.py

@@ -0,0 +1,197 @@
+import logging
+import pathlib
+import threading
+import time
+from typing import List, Optional
+
+import fastapi
+import jinja2
+import rich
+import rich.prompt
+import rich.status
+import uvicorn
+
+from rbx import hydration, metadata, providers, utils
+from rbx.config import Language, get_config
+from rbx.console import console
+from rbx.schema import DumpedProblem, Problem
+
+
+def clear_loggers():
+    for logger_name in [
+        'uvicorn',
+        'uvicorn.access',
+        'uvicorn.asgi',
+    ]:
+        logging.getLogger(logger_name).handlers.clear()
+        logging.getLogger(logger_name).propagate = False
+
+
+def create_problem_structure(
+    root: pathlib.Path,
+    problem: Problem,
+    lang: Language,
+    status: Optional[rich.status.Status],
+    should_simplify: bool = False,
+    verbose: bool = False,
+) -> Optional[DumpedProblem]:
+    # Create directory structure.
+    root.parent.mkdir(parents=True, exist_ok=True)
+
+    problem_to_dump = DumpedProblem.from_problem(
+        problem,
+        code=providers.get_code(problem, simplify=should_simplify),
+        aliases=providers.get_aliases(problem),
+    )
+
+    if verbose:
+        console.print(
+            f'Creating problem structure for [item]{problem_to_dump.pretty_name()}[/item]...'
+        )
+
+    code_path = root / lang.get_file(problem_to_dump.code)
+    json_path = root / f'{problem_to_dump.code}.rbx.json'
+
+    existing_problem = metadata.find_problem_by_code(problem_to_dump.code, root)
+    if existing_problem:
+        console.print(
+            f'[error]Problem with identifier [item]{problem_to_dump.code}[/item] already exists in this folder.[/error]'
+        )
+        if not utils.confirm_on_status(
+            status, 'Do you want to overwrite it?', default=False
+        ):
+            console.print(
+                f'Skipping problem [item]{problem_to_dump.pretty_name()}[/item].'
+            )
+            return None
+
+    json_path.write_text(utils.model_json(problem_to_dump))
+    code = jinja2.Template(lang.get_template()).render(**problem_to_dump.get_vars())
+    code_path.write_text(code)
+
+    if verbose:
+        console.print(
+            f'Problem structure for [item]{problem_to_dump.pretty_name()}[/item] created successfully.'
+        )
+    return problem_to_dump
+
+
+def process_problems(
+    problems: List[Problem], lang: Language, status: rich.status.Status
+):
+    console.print(
+        f'Creating problem structure for [item]{len(problems)}[/item] problems...'
+    )
+
+    should_simplify = False
+    if providers.should_simplify_contest_problems(problems):
+        console.print('Detected the parsed problems are from a contest.')
+        if utils.confirm_on_status(
+            status,
+            'Do you want to identify these problems by their letters?',
+            default=True,
+        ):
+            should_simplify = True
+
+    root = pathlib.Path()
+    dumped_problems = []
+    for problem in problems:
+        dumped_problem = create_problem_structure(
+            root, problem, lang, status, should_simplify=should_simplify
+        )
+        if dumped_problem:
+            dumped_problems.append(dumped_problem)
+    console.print(f'Hydrating [item]{len(dumped_problems)}[/item] problems...')
+    for problem in dumped_problems:
+        hydration.hydrate_problem(root, problem)
+
+
+def main(lang: Optional[str] = None):
+    if get_config().get_language(lang) is None:
+        console.print(
+            f'[error]Language {lang or get_config().defaultLanguage} not found in config. Please check your configuration.[/error]'
+        )
+        return
+
+    app = fastapi.FastAPI()
+
+    async def shutdown():
+        server.should_exit = True
+
+    batch_to_left_lock = threading.Lock()
+    batch_to_left = {}
+    ignored = set()
+    saved_status = None
+    problems_to_process = []
+
+    def process_batch_item(problem: Problem):
+        batch_to_left_lock.acquire()
+        if problem.batch.id in ignored:
+            batch_to_left_lock.release()
+            return True
+        if problem.batch.id not in batch_to_left:
+            if len(batch_to_left) > 0:
+                console.print(
+                    f'[error]Ignoring extra batch [item]{problem.batch.id}[/item] since other batch is being parsed.[/error]'
+                )
+                ignored.add(problem.batch.id)
+                batch_to_left_lock.release()
+                return True
+            if problem.batch.size > 1 and saved_status:
+                saved_status.update(
+                    f'[rbx]rbx[/rbx] is parsing problems from group [item]{problem.group}[/item]'
+                )
+            elif saved_status:
+                saved_status.update('[rbx]rbx[/rbx] is parsing problems...')
+            console.print(
+                f'Started parsing batch [item]{problem.batch.id}[/item] with size [item]{problem.batch.size}[/item].'
+            )
+            batch_to_left[problem.batch.id] = problem.batch.size
+        console.print(f'Parsing problem [item]{problem.name}[/item]...')
+        problems_to_process.append(problem)
+        finished = False
+        if batch_to_left[problem.batch.id] == 1:
+            finished = True
+            if problem.batch.size > 1:
+                console.print(
+                    f'[status][rbx]rbx[/rbx] parsed all problems from group [item]{problem.group}[/item].[/status]'
+                )
+            else:
+                console.print(
+                    f'[status][rbx]rbx[/rbx] parsed problem from [item]{problem.url}[/item].[/status]'
+                )
+        else:
+            batch_to_left[problem.batch.id] -= 1
+        batch_to_left_lock.release()
+        return not finished
+
+    clock = None
+
+    @app.post('/')
+    async def parse(problem: Problem, background_tasks: fastapi.BackgroundTasks):
+        nonlocal clock
+        if clock is None:
+            clock = time.monotonic()
+        if not process_batch_item(problem):
+            duration = time.monotonic() - clock
+            console.print(
+                f'Parsed all problems in [item]{duration:.2f}[/item] seconds.'
+            )
+            background_tasks.add_task(shutdown)
+        return {}
+
+    config = uvicorn.Config(app, port=1327)
+    server = uvicorn.Server(config=config)
+    clear_loggers()
+    with console.status('Waiting for Competitive Companion request...') as status:
+        saved_status = status
+        server.run()
+
+    with console.status('Processing parsed problems...') as status:
+        language = get_config().get_language(lang)
+        if not language:
+            console.print(
+                f'[error]Language {lang or get_config().defaultLanguage} not found in config. Please check your configuration.[/error]'
+            )
+            return
+        process_problems(problems_to_process, language, status)