rbx.cp 0.13.2__py3-none-any.whl → 0.13.4__py3-none-any.whl

rbx/box/conftest.py

@@ -1,42 +0,0 @@
-import os
-import pathlib
-import shutil
-from collections.abc import Iterator
-
-import pytest
-
-from rbx import testing_utils
-from rbx.box import package
-
-
-@pytest.fixture
-def pkg_cleandir(cleandir: pathlib.Path) -> Iterator[pathlib.Path]:
-    old_temp_dir = package.TEMP_DIR
-    package.TEMP_DIR = cleandir
-
-    pkgdir = cleandir / 'pkg'
-    pkgdir.mkdir(exist_ok=True, parents=True)
-    lwd = pathlib.Path.cwd()
-    os.chdir(str(pkgdir))
-    try:
-        yield pkgdir.absolute()
-    finally:
-        os.chdir(str(lwd))
-        package.TEMP_DIR = old_temp_dir
-
-
-@pytest.fixture
-def pkg_from_testdata(
-    request, testdata_path: pathlib.Path, pkg_cleandir: pathlib.Path
-) -> Iterator[pathlib.Path]:
-    marker = request.node.get_closest_marker('test_pkg')
-    if marker is None:
-        raise ValueError('test_pkg marker not found')
-    testdata = testdata_path / marker.args[0]
-    shutil.copytree(str(testdata), str(pkg_cleandir), dirs_exist_ok=True)
-    yield pkg_cleandir
-
-
-@pytest.fixture(autouse=True)
-def clear_cache():
-    testing_utils.clear_all_functools_cache()

rbx/box/generators_test.py

@@ -1,67 +0,0 @@
-import pathlib
-
-import pytest
-
-from rbx.box import package
-from rbx.box.generators import (
-    generate_outputs_for_testcases,
-    generate_testcases,
-)
-from rbx.box.testcase_extractors import extract_generation_testcases_from_groups
-from rbx.testing_utils import print_directory_tree
-
-
-@pytest.mark.test_pkg('box1')
-async def test_generator_works(pkg_from_testdata: pathlib.Path):
-    await generate_testcases()
-    entries = [
-        entry.group_entry for entry in await extract_generation_testcases_from_groups()
-    ]
-    await generate_outputs_for_testcases(entries)
-
-    # Debug when fail.
-    print_directory_tree(pkg_from_testdata)
-
-    assert (
-        package.get_build_testgroup_path('gen1') / '0-000.in'
-    ).read_text() == '777\n'
-    assert (
-        package.get_build_testgroup_path('gen1') / '1-gen-000.in'
-    ).read_text() == '123\n'
-    assert (
-        package.get_build_testgroup_path('gen1') / '1-gen-001.in'
-    ).read_text() == '424242\n'
-    assert (
-        package.get_build_testgroup_path('gen1') / '2-genScript-000.in'
-    ).read_text() == '25\n'
-
-
-@pytest.mark.test_pkg('box1')
-async def test_generator_cache_works(
-    pkg_from_testdata: pathlib.Path,
-):
-    # Run the first time.
-    await generate_testcases()
-    assert (
-        package.get_build_testgroup_path('gen1') / '1-gen-000.in'
-    ).read_text() == '123\n'
-    assert (
-        package.get_build_testgroup_path('gen1') / '1-gen-001.in'
-    ).read_text() == '424242\n'
-
-    # Change the generator `gen1`, but keep `gen2` as is.
-    gen_path = pkg_from_testdata / 'gen1.cpp'
-    gen_path.write_text(gen_path.read_text().replace('123', '4567'))
-
-    # Run the second time.
-    await generate_testcases()
-
-    # Debug when fail.
-    print_directory_tree(pkg_from_testdata)
-
-    assert (
-        package.get_build_testgroup_path('gen1') / '1-gen-000.in'
-    ).read_text() == '4567\n'
-    assert (
-        package.get_build_testgroup_path('gen1') / '1-gen-001.in'
-    ).read_text() == '424242\n'

rbx/box/lazy_importing_test.py

@@ -1,25 +0,0 @@
-import subprocess
-import sys
-from pathlib import Path
-
-LAZY_MODULES = {
-    'gitpython',
-    'questionary',
-    'fastapi',
-    'requests',
-    'pydantic_xml',
-    'rbx.box.packaging.polygon.packager',
-    'rbx.box.stresses',
-}
-
-
-def test_rich_not_imported_unnecessary():
-    file_path = Path(__file__).parent / 'lazy_importing_main.py'
-    result = subprocess.run(
-        [sys.executable, '-m', 'coverage', 'run', str(file_path)],
-        capture_output=True,
-        encoding='utf-8',
-    )
-    modules = result.stdout.splitlines()
-    modules = [module for module in modules if module in LAZY_MODULES]
-    assert not modules

rbx/box/solutions_test.py

@@ -1,47 +0,0 @@
-import pathlib
-
-import pytest
-
-from rbx.box.environment import VerificationLevel
-from rbx.box.generators import (
-    generate_outputs_for_testcases,
-    generate_testcases,
-)
-from rbx.box.solutions import (
-    convert_list_of_solution_evaluations_to_dict,
-    run_solutions,
-)
-from rbx.box.testcase_extractors import extract_generation_testcases_from_groups
-from rbx.grading.steps import Outcome
-
-
-@pytest.mark.test_pkg('box1')
-async def test_solutions(pkg_from_testdata: pathlib.Path):
-    await generate_testcases()
-    entries = [
-        entry.group_entry for entry in await extract_generation_testcases_from_groups()
-    ]
-    await generate_outputs_for_testcases(entries)
-
-    result = run_solutions(verification=VerificationLevel.FULL)
-    res = await convert_list_of_solution_evaluations_to_dict(
-        result.skeleton, result.items
-    )
-
-    # First solution should pass all tests.
-    assert all(chk.result.outcome == Outcome.ACCEPTED for chk in res[0]['gen1'])
-    # 25 test should be WA for the second solution.
-    assert res[1]['gen1'][3].result.outcome == Outcome.WRONG_ANSWER
-    # Runtime error for third solution.
-    assert all(chk.result.outcome == Outcome.RUNTIME_ERROR for chk in res[2]['gen1'])
-    # 1e9 test should be TLE for the fourth solution (soft TLE)
-    assert res[3]['gen1'][4].result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-    # no TLE outcome should be WA (soft TLE)
-    assert res[4]['gen1'][4].result.no_tle_outcome == Outcome.WRONG_ANSWER
-    # hard TLE
-    assert res[5]['gen1'][4].result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-    assert res[5]['gen1'][4].result.no_tle_outcome is None
-    # OLE
-    assert all(
-        chk.result.outcome == Outcome.OUTPUT_LIMIT_EXCEEDED for chk in res[6]['gen1']
-    )

rbx/box/validators_test.py

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

rbx/checker.py

@@ -1,128 +0,0 @@
-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

@@ -1,197 +0,0 @@
-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)

rbx/conftest.py

@@ -1,38 +0,0 @@
-import os
-import pathlib
-import shutil
-import tempfile
-from collections.abc import Iterator
-
-import pytest
-
-from rbx.testing_utils import get_testdata_path
-
-
-@pytest.fixture
-def testdata_path() -> pathlib.Path:
-    return get_testdata_path()
-
-
-@pytest.fixture
-def cleandir() -> Iterator[pathlib.Path]:
-    with tempfile.TemporaryDirectory() as newpath:
-        abspath = pathlib.Path(newpath).absolute()
-        old_cwd = pathlib.Path.cwd()
-        os.chdir(newpath)
-        try:
-            yield abspath
-        finally:
-            os.chdir(str(old_cwd))
-
-
-@pytest.fixture
-def cleandir_with_testdata(
-    request, testdata_path: pathlib.Path, cleandir: pathlib.Path
-) -> Iterator[pathlib.Path]:
-    marker = request.node.get_closest_marker('test_pkg')
-    if marker is None:
-        raise ValueError('test_pkg marker not found')
-    testdata = testdata_path / marker.args[0]
-    shutil.copytree(str(testdata), str(cleandir), dirs_exist_ok=True)
-    yield cleandir

rbx/create.py

@@ -1,37 +0,0 @@
-import pathlib
-
-from rbx import annotations
-from rbx.clone import create_problem_structure
-from rbx.config import get_config
-from rbx.console import console
-from rbx.schema import Batch, Problem
-
-
-def main(
-    name: str,
-    lang: annotations.Language,
-    timelimit: annotations.Timelimit = 1000,
-    memorylimit: annotations.Memorylimit = 256,
-    multitest: annotations.Multitest = False,
-):
-    language = get_config().get_language(lang)
-    if language is None:
-        console.print(
-            f'[error]Language {lang or get_config().defaultLanguage} not found in config. Please check your configuration.[/error]'
-        )
-        return
-
-    problem = Problem(
-        name=name,
-        timeLimit=timelimit,
-        memoryLimit=memorylimit,
-        testType='multiNumber' if multitest else 'single',
-        batch=Batch.create(),
-    )
-    create_problem_structure(
-        pathlib.Path(),
-        problem,
-        language,
-        status=None,
-        verbose=True,
-    )

rbx/edit.py

@@ -1,24 +0,0 @@
-import pathlib
-from typing import Optional
-
-from rbx import annotations, console, metadata
-from rbx.config import get_config, open_editor
-
-
-def main(problem: str, language: Optional[annotations.LanguageWithDefault] = None):
-    lang = get_config().get_language(language)
-    if lang is None:
-        console.console.print(
-            f'[error]Language {language or get_config().defaultLanguage} not found in config. Please check your configuration.[/error]'
-        )
-        return
-
-    dumped_problem = metadata.find_problem_by_anything(problem)
-    if not dumped_problem:
-        console.console.print(
-            f'[error]Problem with identifier {problem} not found.[/error]'
-        )
-        return
-
-    filename = lang.get_file(dumped_problem.code)
-    open_editor(pathlib.Path(filename))

rbx/grading/conftest.py

@@ -1,33 +0,0 @@
-import pathlib
-from collections.abc import Iterator
-
-import pytest
-
-from rbx.grading.caching import DependencyCache
-from rbx.grading.judge.cacher import FileCacher
-from rbx.grading.judge.sandbox import SandboxBase
-from rbx.grading.judge.sandboxes.stupid_sandbox import StupidSandbox
-from rbx.grading.judge.storage import FilesystemStorage, Storage
-
-
-@pytest.fixture
-def storage(request, cleandir: pathlib.Path) -> Iterator[Storage]:
-    storage_path = cleandir / '.box' / '.storage'
-    yield FilesystemStorage(storage_path)
-
-
-@pytest.fixture
-def file_cacher(request, storage: Storage) -> Iterator[FileCacher]:
-    yield FileCacher(storage)
-
-
-@pytest.fixture
-def sandbox(request, file_cacher: FileCacher) -> Iterator[SandboxBase]:
-    yield StupidSandbox(file_cacher=file_cacher)
-
-
-@pytest.fixture
-def dependency_cache(
-    request, cleandir: pathlib.Path, file_cacher: FileCacher
-) -> Iterator[DependencyCache]:
-    yield DependencyCache(cleandir / '.box', file_cacher)