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

rbx/grading_utils.py

@@ -1,148 +0,0 @@
-import pathlib
-from pathlib import PosixPath
-from typing import List
-
-from rbx import config
-from rbx.config import Artifact, Language, format_vars
-from rbx.grading import steps
-from rbx.grading.judge.sandbox import MERGE_STDERR, SandboxParams
-from rbx.grading.steps import (
-    GradingArtifacts,
-    GradingFileInput,
-    GradingFileOutput,
-    TestcaseIO,
-)
-from rbx.schema import DumpedProblem, Problem
-
-
-def build_formatted_command(
-    command: str, problem: DumpedProblem, lang: Language
-) -> str:
-    return format_vars(
-        command,
-        **problem.get_vars(),
-        file=lang.get_file(problem.code),
-        submit_file=lang.get_submit_file(problem.code),
-    )
-
-
-def build_preprocess_commands(problem: DumpedProblem, lang: Language) -> List[str]:
-    return [
-        build_formatted_command(cmd, problem, lang) for cmd in (lang.preprocess or [])
-    ]
-
-
-def build_preprocess_sandbox_params() -> SandboxParams:
-    params = SandboxParams(
-        max_processes=None,
-        preserve_env=True,
-    )
-    params.add_mapped_directory(pathlib.Path('/usr'))
-    params.add_mapped_directory(pathlib.Path('/etc'))
-    return params
-
-
-def build_compile_grading_artifacts(
-    problem: DumpedProblem, lang: Language
-) -> GradingArtifacts:
-    res = GradingArtifacts(root=PosixPath('.'))
-    file = lang.get_file(problem.code)
-    submit_file = lang.get_submit_file(problem.code)
-    # Copy input file.
-    res.inputs.append(GradingFileInput(src=PosixPath(file), dest=PosixPath(file)))
-    # Copy output file.
-    if lang.has_submit_file():
-        res.outputs.append(
-            GradingFileOutput(
-                src=PosixPath(submit_file),
-                dest=PosixPath(submit_file),
-            )
-        )
-    # Copy other artifacts.
-    for artifact_name, artifact_cfg in lang.artifacts.items():
-        artifact_cfg = artifact_cfg or Artifact()
-        artifact_path = format_vars(
-            artifact_name, **problem.get_vars(), file=file, submit_file=submit_file
-        )
-        res.outputs.append(
-            GradingFileOutput(
-                src=PosixPath(artifact_path),
-                dest=PosixPath(artifact_cfg.filename or artifact_path),
-                optional=artifact_cfg.optional,
-                executable=artifact_cfg.executable,
-            )
-        )
-
-    return res
-
-
-def build_run_sandbox_params(problem: Problem, has_input: bool) -> SandboxParams:
-    params = SandboxParams()
-    params.timeout = problem.timeLimit * 2
-    params.wallclock_timeout = problem.timeLimit * 5
-    params.address_space = problem.memoryLimit or 1024  # 1 GB
-    params.set_stdall(
-        stdin=PosixPath('stdin.txt') if has_input else None,
-        stdout=PosixPath('stdout.txt'),
-        stderr=MERGE_STDERR,
-    )
-    return params
-
-
-def build_run_grading_artifacts(
-    testcase: TestcaseIO, persist_root: pathlib.Path
-) -> GradingArtifacts:
-    res = GradingArtifacts(root=PosixPath('.'))
-    res.inputs.append(
-        GradingFileInput(
-            src=testcase.input,
-            dest=PosixPath('stdin.txt'),
-        )
-    )
-    res.outputs.append(
-        GradingFileOutput(
-            src=PosixPath('stdout.txt'),
-            dest=persist_root / f'stdout-{testcase.index}.txt',
-            maxlen=steps.MAX_STDOUT_LEN,
-        )
-    )
-    return res
-
-
-def build_checker_compile_grading_artifacts(
-    problem: DumpedProblem, persist_root: pathlib.Path
-) -> GradingArtifacts:
-    res = GradingArtifacts(root=PosixPath('.'))
-    if not problem.checker:
-        return res
-
-    checker_path = PosixPath(problem.checker)
-    if not checker_path.is_file():
-        checker_path = config.get_builtin_checker(problem.checker)
-    if not checker_path:
-        return res
-
-    res.inputs.append(GradingFileInput(src=checker_path, dest=PosixPath('checker.cpp')))
-    testlib = config.get_testlib()
-    if testlib.is_file():
-        res.inputs.append(GradingFileInput(src=testlib, dest=PosixPath('testlib.h')))
-    res.outputs.append(
-        GradingFileOutput(
-            src=PosixPath('checker'), dest=persist_root / 'checker', executable=True
-        )
-    )
-    return res
-
-
-def build_checker_run_grading_artifacts(
-    problem: DumpedProblem, persist_root: pathlib.Path
-) -> GradingArtifacts:
-    res = GradingArtifacts(root=PosixPath('.'))
-    if not problem.checker:
-        return res
-    res.inputs.append(
-        GradingFileInput(
-            src=persist_root / 'checker', dest=PosixPath('checker'), executable=True
-        )
-    )
-    return res

rbx/hydration.py

@@ -1,101 +0,0 @@
-import pathlib
-from typing import List, Optional, Tuple
-
-from rbx import config, hydration, metadata
-from rbx.console import console
-from rbx.schema import DumpedProblem, Testcase
-from rbx.test import get_testcases_io
-
-
-def get_testcase_paths(
-    root: pathlib.Path, problem: DumpedProblem, i: int
-) -> Tuple[pathlib.Path, pathlib.Path]:
-    return (root / f'{problem.code}.{i}.in', root / f'{problem.code}.{i}.out')
-
-
-def hydrate_problem(root: pathlib.Path, problem: DumpedProblem):
-    for i, testcase in enumerate(problem.tests or []):
-        in_path, out_path = get_testcase_paths(root, problem, i)
-        in_path.write_text(testcase.input)
-        out_path.write_text(testcase.output)
-
-
-def add_testcase(root: pathlib.Path, problem: DumpedProblem, testcase: Testcase):
-    problem_path = metadata.find_problem_path_by_code(problem.code, root)
-    if not problem_path or not problem_path.is_file():
-        console.print(
-            f'[error]Problem [item]{problem.pretty_name()}[/item] not found.[/error]'
-        )
-        return
-
-    # Pick next number.
-    i = max([tc.index for tc in get_testcases_io(problem, root)] + [-1]) + 1
-    in_path, out_path = get_testcase_paths(root, problem, i)
-    in_path.write_text(testcase.input)
-    out_path.write_text(testcase.output)
-
-    console.print(
-        f'Added testcase [item]{i}[/item] to problem [item]{problem.pretty_name()}[/item].'
-    )
-
-
-def remove_testcase(root: pathlib.Path, problem: DumpedProblem, i: int):
-    problem_path = metadata.find_problem_path_by_code(problem.code, root)
-    if not problem_path or not problem_path.is_file():
-        console.print(
-            f'[error]Problem [item]{problem.pretty_name()}[/item] not found.[/error]'
-        )
-        return
-
-    testcases = get_testcases_io(problem, root)
-    testcases = [testcase for testcase in testcases if testcase.index == i]
-    if not testcases:
-        console.print(
-            f'[error]Testcase [item]{i}[/item] not found in problem [item]{problem.pretty_name()}[/item].[/error]'
-        )
-        return
-    if testcases[0].input:
-        testcases[0].input.unlink(missing_ok=True)
-    if testcases[0].output:
-        testcases[0].output.unlink(missing_ok=True)
-
-    console.print(
-        f'Removed testcase [item]{i}[/item] from problem [item]{problem.pretty_name()}[/item].'
-    )
-
-
-def edit_testcase(root: pathlib.Path, problem: DumpedProblem, i: int):
-    problem_path = metadata.find_problem_path_by_code(problem.code, root)
-    if not problem_path or not problem_path.is_file():
-        console.print(
-            f'[error]Problem [item]{problem.pretty_name()}[/item] not found.[/error]'
-        )
-        return
-
-    testcases = get_testcases_io(problem, root)
-    testcases = [testcase for testcase in testcases if testcase.index == i]
-    if not testcases:
-        console.print(
-            f'[error]Testcase [item]{i}[/item] not found in problem [item]{problem.pretty_name()}[/item].[/error]'
-        )
-        return
-
-    paths: List[Optional[pathlib.Path]] = [testcases[0].input, testcases[0].output]
-    config.open_editor(*[path for path in paths if path is not None and path.is_file()])
-
-
-def main(problem: Optional[str] = None):
-    problems_to_hydrate = []
-    if not problem:
-        problems_to_hydrate = metadata.find_problems()
-    else:
-        dumped_problem = metadata.find_problem_by_anything(problem)
-        problems_to_hydrate.append(dumped_problem)
-
-    root = pathlib.Path()
-
-    for dumped_problem in problems_to_hydrate:
-        console.print(
-            f'Hydrating problem [item]{dumped_problem.pretty_name()}[/item]...'
-        )
-        hydration.hydrate_problem(root, dumped_problem)

rbx/main.py

@@ -1,118 +0,0 @@
-# flake8: noqa
-import typer
-from typing_extensions import Annotated
-
-from rbx import annotations, checker, config, testcase
-from rbx import clone as clone_pkg
-from rbx import create as create_pkg
-from rbx import edit as edit_pkg
-from rbx import run as run_pkg
-from rbx import submit as submit_pkg
-from rbx import test as test_pkg
-from rbx.box import main
-
-app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
-app.add_typer(main.app, name='box', cls=annotations.AliasGroup)
-app.add_typer(
-    config.app,
-    name='config, cfg',
-    cls=annotations.AliasGroup,
-    help='Manage the configuration of the tool.',
-)
-app.add_typer(
-    testcase.app,
-    name='testcase, tc',
-    cls=annotations.AliasGroup,
-    help='Commands to manage the testcases of a problem.',
-)
-app.add_typer(
-    checker.app,
-    name='checker, check',
-    cls=annotations.AliasGroup,
-    help='Commands to manage the checker of a problem.',
-)
-
-
-@app.command('clone, c')
-def clone(lang: annotations.Language):
-    """
-    Clones by waiting for a set of problems to be sent through Competitive Companion.
-    """
-    clone_pkg.main(lang=lang)
-
-
-@app.command('new, n')
-def new(
-    name: str,
-    language: annotations.Language,
-    timelimit: annotations.Timelimit = 1000,
-    memorylimit: annotations.Memorylimit = 256,
-    multitest: annotations.Multitest = False,
-):
-    """
-    Create a new problem from scratch.
-    """
-    create_pkg.main(name, language, timelimit, memorylimit, multitest)
-
-
-@app.command('edit, e')
-def edit(
-    problem: annotations.Problem, language: annotations.LanguageWithDefault = None
-):
-    """
-    Edit the code of a problem using the provided language.
-    """
-    edit_pkg.main(problem, language)
-
-
-@app.command('test, t')
-def test(
-    problem: annotations.Problem,
-    language: annotations.LanguageWithDefault = None,
-    keep_sandbox: bool = False,
-    index: annotations.TestcaseIndex = None,
-    interactive: Annotated[bool, typer.Option('--interactive', '--int')] = False,
-):
-    """
-    Test a problem using the provided language.
-    """
-    test_pkg.main(
-        problem,
-        language,
-        keep_sandbox=keep_sandbox,
-        index=index,
-        interactive=interactive,
-    )
-
-
-@app.command('run, r')
-def run(
-    problem: annotations.Problem,
-    language: annotations.LanguageWithDefault = None,
-    keep_sandbox: bool = False,
-):
-    """
-    Run a problem using the provided language.
-    """
-    run_pkg.main(
-        problem,
-        language,
-        keep_sandbox=keep_sandbox,
-    )
-
-
-@app.command('submit, s')
-def submit(
-    problem: annotations.Problem,
-    language: annotations.LanguageWithDefault = None,
-    keep_sandbox: bool = False,
-):
-    """
-    Submit a problem using the provided language.
-    """
-    submit_pkg.main(problem, language, keep_sandbox=keep_sandbox)
-
-
-@app.callback()
-def callback():
-    pass

rbx/metadata.py

@@ -1,105 +0,0 @@
-import pathlib
-from typing import List, Optional, Tuple
-
-from rbx.schema import DumpedProblem
-
-
-def _normalize_alias(alias: str) -> str:
-    return alias.lower()
-
-
-def _find_alias(alias: str, haystack: List[str]) -> Optional[int]:
-    normalized_alias = _normalize_alias(alias)
-    for i, candidate in enumerate(haystack):
-        if _normalize_alias(candidate) == normalized_alias:
-            return i
-    return None
-
-
-def _get_best_alias_from_candidates(
-    alias: str, candidates: List[Tuple[pathlib.Path, DumpedProblem]]
-) -> Optional[Tuple[pathlib.Path, DumpedProblem]]:
-    best_priority = 1e9
-    best_candidates = []
-    for path, problem in candidates:
-        index = _find_alias(alias, problem.aliases)
-        if index is None:
-            continue
-        if index < best_priority:
-            best_priority = index
-            best_candidates = [(path, problem)]
-        elif index == best_priority:
-            best_candidates.append((path, problem))
-
-    if len(best_candidates) != 1:
-        # TODO
-        return None
-
-    return best_candidates[0]
-
-
-def find_problem_path_by_code(
-    code: str, root: Optional[pathlib.Path] = None
-) -> Optional[pathlib.Path]:
-    if not root:
-        root = pathlib.Path()
-
-    metadata_path = root / f'{code}.rbx.json'
-    if not metadata_path.is_file():
-        return None
-    return metadata_path
-
-
-def find_problem_path_by_alias(
-    alias: str, root: Optional[pathlib.Path] = None
-) -> Optional[pathlib.Path]:
-    if not root:
-        root = pathlib.Path()
-
-    candidates: List[Tuple[pathlib.Path, DumpedProblem]] = []
-    for metadata_path in root.glob('*.rbx.json'):
-        problem = DumpedProblem.model_validate_json(metadata_path.read_text())
-        if _find_alias(alias, problem.aliases) is not None:
-            candidates.append((metadata_path, problem))
-
-    picked_candidate = _get_best_alias_from_candidates(alias, candidates)
-    if not picked_candidate:
-        return None
-    return picked_candidate[0]
-
-
-def find_problem_by_alias(
-    alias: str, root: Optional[pathlib.Path] = None
-) -> Optional[DumpedProblem]:
-    metadata_path = find_problem_path_by_alias(alias, root)
-    if not metadata_path:
-        return None
-    return DumpedProblem.model_validate_json(metadata_path.read_text())
-
-
-def find_problem_by_code(
-    code: str, root: Optional[pathlib.Path] = None
-) -> Optional[DumpedProblem]:
-    metadata_path = find_problem_path_by_code(code, root)
-    if not metadata_path:
-        return None
-    return DumpedProblem.model_validate_json(metadata_path.read_text())
-
-
-def find_problem_by_anything(
-    anything: str, root: Optional[pathlib.Path] = None
-) -> Optional[DumpedProblem]:
-    problem = find_problem_by_code(anything, root)
-    if problem:
-        return problem
-    return find_problem_by_alias(anything, root)
-
-
-def find_problems(root: Optional[pathlib.Path] = None) -> List[DumpedProblem]:
-    if not root:
-        root = pathlib.Path()
-
-    problems = []
-    for metadata_path in root.glob('*.rbx.json'):
-        problems.append(DumpedProblem.model_validate_json(metadata_path.read_text()))
-    return problems

rbx/run.py

@@ -1,45 +0,0 @@
-import atexit
-import os
-import shlex
-
-from rbx import annotations, grading_utils, metadata
-from rbx.config import get_config
-from rbx.console import stderr_console
-from rbx.grading import steps
-from rbx.grading.judge.sandboxes import stupid_sandbox
-
-
-def main(
-    problem: annotations.Problem,
-    language: annotations.LanguageWithDefault = None,
-    keep_sandbox: bool = False,
-):
-    dumped_problem = metadata.find_problem_by_anything(problem)
-    if not dumped_problem:
-        stderr_console.print(
-            f'[error]Problem with identifier [item]{problem}[/item] not found.[/error]'
-        )
-        return
-
-    lang = get_config().get_language(language)
-    if not lang:
-        stderr_console.print(
-            f'[error]Language {language or get_config().defaultLanguage} not found in config. Please check your configuration.[/error]'
-        )
-        return
-
-    box = stupid_sandbox.StupidSandbox()
-    atexit.register(lambda: box.cleanup(delete=not keep_sandbox))
-
-    preprocess_cmds = grading_utils.build_preprocess_commands(dumped_problem, lang)
-    sandbox_params = grading_utils.build_preprocess_sandbox_params()
-    artifacts = grading_utils.build_compile_grading_artifacts(dumped_problem, lang)
-
-    if not steps.compile(preprocess_cmds, sandbox_params, box, artifacts):
-        stderr_console.print(
-            f'[error]Failed to preprocess problem [item]{dumped_problem.pretty_name()}[/item].[/error]'
-        )
-        return
-
-    cmd = shlex.split(lang.exec)
-    os.execv(cmd[0], cmd)

rbx/schema.py

@@ -1,64 +0,0 @@
-import uuid
-from typing import Dict, List, Optional
-
-from pydantic import BaseModel
-
-from rbx import utils
-
-
-class Testcase(BaseModel):
-    input: str
-    output: str
-
-
-class Batch(BaseModel):
-    id: str
-    size: int
-
-    @staticmethod
-    def create():
-        return Batch(id=str(uuid.uuid4()), size=1)
-
-
-class Problem(BaseModel):
-    name: str
-    group: str = ''
-    url: str = ''
-    interactive: bool = False
-    memoryLimit: int
-    timeLimit: int
-    tests: List[Testcase] = []
-    testType: str = 'single'
-    batch: Batch
-
-    def get_code(self):
-        return self.get_normalized_name()
-
-    def get_normalized_name(self) -> str:
-        return utils.normalize_with_underscores(self.name)
-
-
-class DumpedProblem(Problem):
-    code: str
-    aliases: List[str]
-    checker: Optional[str] = None
-
-    @staticmethod
-    def from_problem(problem: Problem, **kwargs) -> 'DumpedProblem':
-        return DumpedProblem(**problem.model_dump(), **kwargs)
-
-    def pretty_name(self) -> str:
-        if self.name == self.code:
-            return self.name
-        return f'{self.name} ({self.code})'
-
-    def get_vars(self) -> Dict[str, str]:
-        return {
-            'problem_name': self.name,
-            'problem_code': self.code,
-            'problem_url': self.url,
-            'problem_contest': self.group,
-            'problem_time_limit': f'{self.timeLimit}ms',
-            'problem_memory_limit': f'{self.memoryLimit}MB',
-            'problem_test_type': self.testType,
-        }

rbx/submit.py

@@ -1,61 +0,0 @@
-import atexit
-from pathlib import PosixPath
-from typing import Optional
-
-from rbx import annotations, grading_utils, metadata, submitors, utils
-from rbx.config import get_config
-from rbx.console import console
-from rbx.grading import steps
-from rbx.grading.judge.sandboxes import stupid_sandbox
-
-
-def main(
-    problem: annotations.Problem,
-    language: Optional[annotations.LanguageWithDefault] = None,
-    keep_sandbox: bool = False,
-):
-    dumped_problem = metadata.find_problem_by_anything(problem)
-    if not dumped_problem:
-        console.print(
-            f'[error]Problem with identifier [item]{problem}[/item] not found.[/error]'
-        )
-        return
-
-    lang = get_config().get_language(language)
-    if not lang:
-        console.print(
-            f'[error]Language {language or get_config().defaultLanguage} not found in config. Please check your configuration.[/error]'
-        )
-        return
-
-    box = stupid_sandbox.StupidSandbox()
-    atexit.register(lambda: box.cleanup(delete=not keep_sandbox))
-
-    with console.status(
-        f'Preprocessing problem [item]{dumped_problem.pretty_name()}[/item]...'
-    ):
-        preprocess_cmds = grading_utils.build_preprocess_commands(dumped_problem, lang)
-        sandbox_params = grading_utils.build_preprocess_sandbox_params()
-        artifacts = grading_utils.build_compile_grading_artifacts(dumped_problem, lang)
-        if not steps.compile(preprocess_cmds, sandbox_params, box, artifacts):
-            console.print(
-                f'[error]Failed to preprocess problem [item]{dumped_problem.pretty_name()}[/item].[/error]'
-            )
-            return
-
-    submit_file = PosixPath(lang.get_submit_file(dumped_problem.code))
-    console.print(
-        f'Problem to be submitted: [item]{dumped_problem.pretty_name()}[/item]'
-    )
-    console.print(f'Submission file: {submit_file.absolute()}')
-
-    if not utils.confirm_on_status(
-        None, 'Do you want to submit this problem?', default=False
-    ):
-        console.print('Skipping submission.')
-        return
-
-    if submitors.handle_submit(submit_file, dumped_problem, lang):
-        console.print('[green]Submission successful.[/green]')
-    else:
-        console.print('[error]Submission failed.[/error]')