rbx.cp 0.5.0__py3-none-any.whl

rbx/submitors/codeforces.py

@@ -0,0 +1,120 @@
+import pathlib
+from typing import Any
+
+import mechanize
+
+from rbx.console import console
+from rbx.schema import Problem
+from rbx.submitors.submitor import Submitor
+
+_SUBMITOR_KEY = 'codeforces'
+
+
+class Session:
+    def __init__(self):
+        self.br = mechanize.Browser()
+        self.br.set_handle_robots(False)
+        self.br.addheaders = [  # type: ignore
+            (
+                'User-agent',
+                'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1',
+            )
+        ]
+
+    def select_form_by_id(self, id, forms):
+        for form in forms:
+            if form.attrs.get('id') == id:
+                return form
+        return None
+
+    def select_form_by_class(self, cl, forms):
+        for form in forms:
+            if form.attrs.get('class') == cl:
+                return form
+        return None
+
+    def login(self, handle, password):
+        response = self.br.open('http://codeforces.com/enter')
+        if response is None:
+            raise Exception('Response was not received')
+        if not response.geturl().endswith('enter'):
+            return
+        form = self.select_form_by_id('enterForm', self.br.forms())
+        if form is None:
+            raise Exception('Login form was not found')
+
+        form['handleOrEmail'] = handle
+        form['password'] = password
+        self.br.form = form
+        response = self.br.submit()
+        if response is None:
+            raise Exception('Response was not received')
+        if response.geturl().endswith('enter'):
+            raise Exception(
+                'Login attempt was not successful. Check your credentials or your internet connection'
+            )
+
+    def submit_from_contest(self, url: str, file: pathlib.Path, typeid: int):
+        filename = str(file.resolve())
+        self.br.open(url)
+        form = self.select_form_by_class('submit-form', self.br.forms())
+        if form is None:
+            raise Exception('You are not logged in or problem does not exist')
+
+        form['programTypeId'] = [str(typeid)]
+        form.add_file(file.open(), 'plain/text', filename)
+        self.br.form = form
+        self.br.submit()
+
+    def submit(self, url: str, file: pathlib.Path, typeid: int):
+        filename = str(file.resolve())
+        response = self.br.open(url)
+        if response is None:
+            raise Exception('Response was not received')
+        if response.geturl().endswith('attachments'):
+            self.submit_from_contest(url.replace('/problem/', '/submit/'), file, typeid)
+            return
+        form = self.select_form_by_class('submitForm', self.br.forms())
+        if form is None:
+            raise Exception('You are not logged in or problem does not exist')
+
+        form['programTypeId'] = [str(typeid)]
+        form.add_file(file.open(), 'plain/text', filename)
+        self.br.form = form
+        self.br.submit()
+
+
+class CodeforcesSubmitor(Submitor):
+    def key(self) -> str:
+        return _SUBMITOR_KEY
+
+    def should_handle(self, problem: Problem) -> bool:
+        return 'codeforces.com/' in problem.url
+
+    def submit(
+        self,
+        file: pathlib.Path,
+        problem: Problem,
+        submitor_config: Any,
+        credentials: Any,
+    ) -> bool:
+        typeid = submitor_config['typeid']
+        handle = credentials['handle']
+        password = credentials['password']
+
+        session = Session()
+        console.print(
+            f'Trying to login with handle [item]{handle}[/item] in Codeforces.'
+        )
+        try:
+            session.login(handle, password)
+        except Exception as e:
+            console.print(f'[error]Failed to log in: {str(e)}[/error]')
+            return False
+        console.print('[italic]Possibly[/italic] logged in!')
+        try:
+            session.submit(problem.url, file, typeid)
+        except Exception as e:
+            console.print(f'[error]Failed to submit: {str(e)}[/error]')
+            return False
+        return True

rbx/submitors/submitor.py

@@ -0,0 +1,25 @@
+import abc
+import pathlib
+from typing import Any
+
+from rbx.schema import Problem
+
+
+class Submitor(abc.ABC):
+    @abc.abstractmethod
+    def key(self) -> str:
+        pass
+
+    @abc.abstractmethod
+    def should_handle(self, problem: Problem) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def submit(
+        self,
+        file: pathlib.Path,
+        problem: Problem,
+        submitor_config: Any,
+        credentials: Any,
+    ) -> bool:
+        pass

rbx/test.py

@@ -0,0 +1,347 @@
+import atexit
+import pathlib
+import tempfile
+from typing import Dict, List, Optional
+
+from rich.columns import Columns
+from rich.panel import Panel
+from rich.progress import MofNCompleteColumn, Progress, SpinnerColumn
+from rich.text import Text
+
+from rbx import annotations, config, grading_utils, metadata, testcase_rendering
+from rbx.config import Language, get_config
+from rbx.console import console, multiline_prompt
+from rbx.grading import steps
+from rbx.grading.judge.sandbox import SandboxBase
+from rbx.grading.judge.sandboxes import stupid_sandbox
+from rbx.schema import DumpedProblem, Problem
+
+
+def get_testcase_index(path: pathlib.Path) -> int:
+    return int(path.stem.split('.')[-1])
+
+
+def get_testcases_io(
+    problem: DumpedProblem, root: pathlib.Path = pathlib.Path()
+) -> List[steps.TestcaseIO]:
+    testcases_per_index: Dict[int, steps.TestcaseIO] = {}
+    for input_file in root.glob(f'{problem.code}.*.in'):
+        try:
+            index = get_testcase_index(input_file)
+        except ValueError:
+            continue
+        testcases_per_index[index] = steps.TestcaseIO(index=index, input=input_file)
+
+    for output_file in root.glob(f'{problem.code}.*.out'):
+        index = get_testcase_index(output_file)
+        try:
+            index = get_testcase_index(output_file)
+        except ValueError:
+            continue
+        if index in testcases_per_index:
+            testcases_per_index[index].output = output_file
+            continue
+        testcases_per_index[index] = steps.TestcaseIO(index=index, output=output_file)
+
+    return sorted(testcases_per_index.values(), key=lambda x: x.index)
+
+
+def _run_testcases(
+    problem: Problem,
+    lang: Language,
+    lang_name: Optional[str],
+    sandbox: SandboxBase,
+    testcases: List[steps.TestcaseIO],
+    persist_root: pathlib.Path = pathlib.Path(),
+) -> Dict[int, Optional[steps.TestcaseLog]]:
+    logs: Dict[int, Optional[steps.TestcaseLog]] = {}
+
+    # Ensure persist dir exists.
+    persist_root.mkdir(parents=True, exist_ok=True)
+
+    progress = Progress(
+        SpinnerColumn(),
+        *Progress.get_default_columns(),
+        MofNCompleteColumn(),
+        transient=True,
+    )
+    with progress:
+        for testcase in progress.track(testcases, description='Running testcases...'):
+            params = grading_utils.build_run_sandbox_params(
+                problem, testcase.input is not None
+            )
+            artifacts = grading_utils.build_run_grading_artifacts(
+                testcase, persist_root
+            )
+            run_log = steps.run(
+                lang.exec,
+                params,
+                sandbox,
+                artifacts,
+                metadata=steps.RunLogMetadata(language=lang_name),
+            )
+            if not run_log:
+                logs[testcase.index] = None
+                continue
+            logs[testcase.index] = steps.TestcaseLog(
+                **run_log.__dict__,
+                stdout_absolute_path=persist_root / f'stdout-{testcase.index}.txt',
+                stderr_absolute_path=persist_root / f'stderr-{testcase.index}.txt',
+            )
+
+    return logs
+
+
+def _evaluate_testcases(
+    problem: DumpedProblem,
+    sandbox: SandboxBase,
+    testcases: List[steps.TestcaseIO],
+    testcase_logs: Dict[int, Optional[steps.TestcaseLog]],
+    persist_root: pathlib.Path = pathlib.Path(),
+) -> List[steps.Evaluation]:
+    evaluations = []
+    artifacts = grading_utils.build_checker_run_grading_artifacts(
+        problem,
+        persist_root,
+    )
+    for testcase in testcases:
+        if testcase.index not in testcase_logs:
+            continue
+
+        log = testcase_logs[testcase.index]
+        evaluations.append(
+            steps.evaluate(
+                sandbox,
+                testcase,
+                log,
+                artifacts,
+                should_use_python_checker=not problem.checker,
+            )
+        )
+
+    return evaluations
+
+
+def _pretty_print_output_on_panel(file: Optional[pathlib.Path], title: str) -> Panel:
+    if not file:
+        return Panel('[error]No file to read from.[/error]', title=title, expand=False)
+    return Panel(
+        testcase_rendering.render_from_file(file),
+        title=title,
+        expand=False,
+    )
+
+
+def _pretty_print_side_by_side(result: steps.Evaluation):
+    if not result.testcase.output:
+        return _pretty_print_output_on_panel(result.log.stdout_absolute_path, 'Output')
+    return Columns(
+        [
+            _pretty_print_output_on_panel(result.testcase.output, 'Expected'),
+            _pretty_print_output_on_panel(result.log.stdout_absolute_path, 'Actual'),
+        ],
+        equal=True,
+        expand=False,
+    )
+
+
+def _get_outcome_style(outcome: steps.Outcome) -> str:
+    if outcome == steps.Outcome.ACCEPTED:
+        return 'success'
+    if outcome == steps.Outcome.JUDGE_FAILED or outcome == steps.Outcome.INTERNAL_ERROR:
+        return 'warning'
+    return 'error'
+
+
+def _pretty_print_outcome_panel(
+    problem: DumpedProblem, eval: steps.Evaluation
+) -> Panel:
+    result: steps.CheckerResult = eval.result
+    is_tle = result.outcome == steps.Outcome.TIME_LIMIT_EXCEEDED or (
+        problem.timeLimit and eval.log.time * 1000 > problem.timeLimit
+    )
+
+    text = Text()
+    text.append('Outcome: ')
+    text.append(
+        result.outcome.value,
+        style=_get_outcome_style(result.outcome),
+    )
+    text.append(' ' * 4)
+    text.append('Time: ')
+    text.append(f'{eval.log.time:.2f}s', style='error' if is_tle else 'item')
+    text.append('\n')
+    if eval.testcase.input:
+        text.append(f'Input path: {eval.testcase.input.absolute()}')
+        text.append('\n')
+    if eval.testcase.output:
+        text.append(f'Expected path: {eval.testcase.output.absolute()}')
+        text.append('\n')
+    text.append(f'Answer path: {eval.log.stdout_absolute_path}')
+    return Panel(
+        text,
+        title=f'[bold]Testcase [item]#{eval.testcase.index}[/item]',
+        expand=False,
+    )
+
+
+def _pretty_print_evaluation_result(
+    problem: DumpedProblem,
+    eval: steps.Evaluation,
+    interactive: bool = False,
+):
+    console.print(_pretty_print_outcome_panel(problem, eval))
+    if eval.result.outcome != steps.Outcome.ACCEPTED:
+        if interactive:
+            console.print(
+                _pretty_print_output_on_panel(eval.log.stdout_absolute_path, 'Output')
+            )
+        else:
+            console.print(_pretty_print_side_by_side(eval))
+        if eval.result.message:
+            console.print(
+                f'[error]Checker message:[/error] {eval.result.message.strip()}'
+            )
+    console.print()
+
+
+def pretty_print_summary(
+    problem: DumpedProblem,
+    lang: Language,
+    evals: List[steps.Evaluation],
+    root: pathlib.Path = pathlib.Path(),
+):
+    submission_file = root / lang.get_submit_file(problem.code)
+    passed = sum(1 for eval in evals if eval.result.outcome == steps.Outcome.ACCEPTED)
+    total = len(evals)
+    console.print(f'Summary for problem [item]{problem.pretty_name()}[/item]:')
+
+    # Test summary.
+    text = Text()
+    text.append('Passed tests: ')
+    text.append(f'{passed}/{total}', style='success' if passed == total else 'error')
+    console.print(text)
+
+    console.print(f'Submission file: {submission_file.absolute()}')
+
+
+def pretty_print_evaluation_results(
+    problem: DumpedProblem,
+    evals: List[steps.Evaluation],
+    interactive: bool = False,
+):
+    for eval in evals:
+        _pretty_print_evaluation_result(problem, eval, interactive=interactive)
+
+
+def main(
+    problem: annotations.Problem,
+    language: annotations.LanguageWithDefault = None,
+    keep_sandbox: bool = False,
+    interactive: bool = False,
+    index: Optional[annotations.TestcaseIndex] = None,
+):
+    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
+
+    if interactive:
+        testcases = []
+        while True:
+            console.print(
+                f'Providing IO for testcase [item]#{len(testcases)}[/item]...'
+            )
+            input = multiline_prompt('Testcase input')
+            if not input.strip():
+                break
+            output = multiline_prompt('Testcase output')
+            input_path = pathlib.Path(tempfile.mktemp())
+            output_path = pathlib.Path(tempfile.mktemp())
+            input_path.write_text(input)
+            output_path.write_text(output)
+            testcases.append(
+                steps.TestcaseIO(
+                    index=len(testcases), input=input_path, output=output_path
+                )
+            )
+    else:
+        testcases = get_testcases_io(dumped_problem)
+
+    if index is not None:
+        testcases = [tc for tc in testcases if tc.index == index]
+
+    if not testcases:
+        console.print(
+            f'[error]No testcases found for the problem [item]{dumped_problem.pretty_name()}[/item].[/error]'
+        )
+        return
+
+    box = stupid_sandbox.StupidSandbox()
+    atexit.register(lambda: box.cleanup(delete=not keep_sandbox))
+    persist_root = config.get_empty_app_persist_path()
+
+    with console.status(
+        f'Preprocessing code for problem [item]{dumped_problem.pretty_name()}[/item] in language [item]{language or get_config().defaultLanguage}[/item]...'
+    ):
+        if lang.preprocess:
+            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
+
+    with console.status(
+        f'Compiling checker for problem [item]{dumped_problem.pretty_name()}[/item]...'
+    ):
+        command = '/usr/bin/g++ -std=c++17 -o checker checker.cpp'
+        artifacts = grading_utils.build_checker_compile_grading_artifacts(
+            dumped_problem, persist_root
+        )
+        if dumped_problem.checker and not steps.compile(
+            [command], grading_utils.build_preprocess_sandbox_params(), box, artifacts
+        ):
+            console.print(
+                f'[error]Failed to compile checker for problem [item]{dumped_problem.pretty_name()}[/item].[/error]'
+            )
+            return
+
+    testcase_logs = _run_testcases(
+        dumped_problem, lang, language, box, testcases, persist_root
+    )
+
+    if not testcase_logs:
+        console.print(
+            f'[error]Failed to run testcases for problem [item]{dumped_problem.pretty_name()}[/item]. Sandbox probably crashed.[/error]'
+        )
+        return
+
+    with console.status(
+        f'Evaluating testcases for problem [item]{dumped_problem.pretty_name()}[/item]...'
+    ):
+        evals = _evaluate_testcases(
+            dumped_problem, box, testcases, testcase_logs, persist_root
+        )
+    if not evals:
+        console.print(
+            f'[error]Failed to evaluate testcases for problem [item]{dumped_problem.pretty_name()}[/item].[/error]'
+        )
+        return
+    pretty_print_evaluation_results(dumped_problem, evals, interactive=interactive)
+    pretty_print_summary(dumped_problem, lang, evals)

rbx/testcase.py

@@ -0,0 +1,70 @@
+import pathlib
+
+import typer
+
+from rbx import annotations, hydration, metadata
+from rbx.console import console, multiline_prompt
+from rbx.schema import Testcase
+
+app = typer.Typer()
+
+
+@app.command()
+def hydrate(problem: annotations.ProblemOption = None):
+    """
+    Populate all samples of a problem (or of all problems in the folder).
+    """
+    hydration.main(problem=problem)
+
+
+@app.command('add, a')
+def add(problem: annotations.Problem):
+    """
+    Add a testcase to 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
+
+    input = multiline_prompt('Testcase input')
+    output = multiline_prompt('Testcase output')
+
+    hydration.add_testcase(
+        pathlib.Path(), dumped_problem, Testcase(input=input, output=output)
+    )
+
+
+@app.command('delete, d')
+def delete(
+    problem: annotations.Problem,
+    i: annotations.TestcaseIndex,
+):
+    """
+    Remove the i-th testcase from a problem.
+    """
+    if i is None:
+        console.print(f'[error]Index [item]{i}[/item] is invalid.[/error]')
+        return
+    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
+
+    hydration.remove_testcase(pathlib.Path(), dumped_problem, i)
+
+
+@app.command('edit, e')
+def edit(problem: annotations.Problem, i: annotations.TestcaseIndex):
+    """
+    Edit the testcases of a problem.
+    """
+    if i is None:
+        console.print(f'[error]Index [item]{i}[/item] is invalid.[/error]')
+        return
+    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
+
+    hydration.edit_testcase(pathlib.Path(), dumped_problem, i)

rbx/testcase_rendering.py

@@ -0,0 +1,79 @@
+import dataclasses
+import pathlib
+import string
+from typing import List, Tuple
+
+from rich.text import Text
+
+
+@dataclasses.dataclass
+class TruncatedOutput:
+    truncate: bool = False
+    lines: List[Tuple[int, str]] = dataclasses.field(default_factory=list)
+
+
+def split_and_truncate_in_lines(
+    s: str, max_line_length: int = 64, max_lines: int = 30
+) -> TruncatedOutput:
+    lines: List[Tuple[int, str]] = []
+    current_line = []
+    current_line_idx = 1
+
+    def end_line(wrap: bool = False):
+        nonlocal current_line, current_line_idx
+        lines.append((current_line_idx, ''.join(current_line)))
+        current_line = []
+        if not wrap:
+            current_line_idx += 1
+
+    printable = set(string.printable)
+    truncate = False
+    for c in s:
+        if c == '\n':
+            end_line()
+            continue
+        if c not in printable:
+            # TODO: handle better
+            continue
+        if len(current_line) >= max_line_length:
+            end_line(wrap=True)
+        if current_line_idx > max_lines:
+            truncate = True
+            break
+        current_line.append(c)
+
+    if current_line:
+        end_line()
+
+    return TruncatedOutput(truncate=truncate, lines=lines)
+
+
+def _largest_line_number_length(lines: List[Tuple[int, str]]) -> int:
+    return max([len(str(line[0])) for line in lines] + [1])
+
+
+def render(s: str):
+    truncated = split_and_truncate_in_lines(s)
+    number_len = _largest_line_number_length(truncated.lines)
+
+    text = Text()
+
+    last_number = 0
+    for line in truncated.lines:
+        number, content = line
+        number_str = '' if last_number == number else str(number)
+        text.append(f'{number_str:>{number_len}}', style='lnumber')
+        text.append(' ' * 3)
+        text.append(content)
+        text.append('\n')
+
+        last_number = number
+    if truncated.truncate:
+        text.append(f"{'':>{number_len}}", style='lnumber')
+        text.append(' ' * 3)
+        text.append('... (truncated)')
+    return text
+
+
+def render_from_file(file: pathlib.Path):
+    return render(file.read_text())

rbx/testdata/box1/gen1.cpp

@@ -0,0 +1,7 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int32_t main() {
+  cout << "123" << endl;
+}

rbx/testdata/box1/gen2.cpp

@@ -0,0 +1,9 @@
+#include "testlib.h"
+
+using namespace std;
+
+int main(int argc, char *argv[]) {
+    registerGen(argc, argv, 1);
+
+    println(opt<int>(1));
+}

rbx/testdata/box1/genScript.py

@@ -0,0 +1,2 @@
+print('gen2 25')
+print('gen2 1000000000')

rbx/testdata/box1/hard-tle.sol.cpp

@@ -0,0 +1,26 @@
+#include <bits/stdc++.h>
+#include <ctime>
+
+using namespace std;
+
+void busy_loop() {
+  double wait = 5.0;
+  int start = clock();
+  int end = clock();
+  while (((double) (end - start)) / CLOCKS_PER_SEC < wait)
+  {
+    end = clock();
+  }
+}
+
+int32_t main() {
+    ios::sync_with_stdio(false);
+    cin.tie(0);
+
+    int n; cin >> n;
+
+    busy_loop();
+
+    cout << "hard" << endl;
+    return 0;
+}