rbx.cp 0.5.0__py3-none-any.whl

rbx/main.py

@@ -0,0 +1,122 @@
+# flake8: noqa
+from gevent import monkey
+
+monkey.patch_all()
+
+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

@@ -0,0 +1,105 @@
+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/providers/__init__.py

@@ -0,0 +1,43 @@
+from typing import List
+
+from rbx.providers.codeforces import CodeforcesProvider
+from rbx.providers.provider import ProviderInterface
+from rbx.schema import Problem
+
+ALL_PROVIDERS: List[ProviderInterface] = [
+    CodeforcesProvider(),
+]
+
+
+def is_contest(problems: List[Problem]) -> bool:
+    for provider in ALL_PROVIDERS:
+        handle_all = all(provider.should_handle(problem.url) for problem in problems)
+        if handle_all:
+            return provider.is_contest(problems)
+    return False
+
+
+def should_simplify_contest_problems(problems: List[Problem]) -> bool:
+    if not is_contest(problems):
+        return False
+    for provider in ALL_PROVIDERS:
+        handle_all = all(provider.should_handle(problem.url) for problem in problems)
+        if handle_all:
+            return provider.should_simplify_contest_problems()
+    return False
+
+
+def get_code(problem: Problem, simplify: bool = False) -> str:
+    for provider in ALL_PROVIDERS:
+        if provider.should_handle(problem.url):
+            if simplify:
+                return provider.get_problem_code_within_contest(problem)
+            return provider.get_code(problem)
+    return problem.get_normalized_name()
+
+
+def get_aliases(problem: Problem) -> List[str]:
+    for provider in ALL_PROVIDERS:
+        if provider.should_handle(problem.url):
+            return provider.get_aliases(problem)
+    return []

rbx/providers/codeforces.py

@@ -0,0 +1,73 @@
+import re
+from typing import List, Optional
+
+from rbx.providers.provider import ProviderInterface
+from rbx.schema import Problem
+
+
+def _add_underscores(matches: List[str]) -> List[str]:
+    if len(matches) <= 2:
+        return matches
+    return [f'{x}_' for x in matches[:-2]] + matches[-2:]
+
+
+_PATTERNS = [
+    r'https?://(?:.*\.)?codeforces.(?:com|ml|es)/(?:contest|gym)/(\d+)/problem/([^/]+)',
+    r'https?://(?:.*\.)?codeforces.(?:com|ml|es)/problemset/problem/(\d+)/([^/]+)',
+    (
+        r'https?://(?:.*\.)?codeforces.(?:com|ml|es)/group/([^/]+)/contest/(\d+)/problem/([^/]+)',
+        _add_underscores,
+    ),
+    r'https?://(?:.*\.)?codeforces.(?:com|ml|es)/problemset/(gym)Problem/([^/]+)',
+    r'https?://(?:.*\.)?codeforces.(?:com|ml|es)/problemsets/(acm)sguru/problem/(?:\d+)/([^/]+)',
+    # TODO: add EDU
+]
+
+
+def _compiled_pattern(pattern):
+    if isinstance(pattern, tuple):
+        return (re.compile(pattern[0]), pattern[1])
+    return re.compile(pattern)
+
+
+_COMPILED_PATTERNS = [_compiled_pattern(pattern) for pattern in _PATTERNS]
+
+
+def get_code_tuple(url: str) -> Optional[List[str]]:
+    for pattern_obj in _COMPILED_PATTERNS:
+        if isinstance(pattern_obj, tuple):
+            pattern, extract = pattern_obj
+        else:
+            pattern = pattern_obj
+            extract = lambda x: x  # noqa: E731
+
+        if match := pattern.match(url):
+            return extract(list(match.groups()))
+    return None
+
+
+class CodeforcesProvider(ProviderInterface):
+    def should_handle(self, url: str) -> bool:
+        return 'codeforces.com/' in url
+
+    def should_simplify_contest_problems(self) -> bool:
+        return True
+
+    def get_problem_code_within_contest(self, problem: Problem) -> str:
+        return self.get_aliases(problem)[-1]
+
+    def get_code(self, problem: Problem) -> str:
+        code_tuple = get_code_tuple(problem.url)
+        if not code_tuple:
+            return super().get_code(problem)
+        return ''.join(code_tuple)
+
+    def get_aliases(self, problem: Problem) -> List[str]:
+        code_tuple = get_code_tuple(problem.url)
+        if not code_tuple:
+            return super().get_aliases(problem)
+
+        aliases = []
+        for i in range(len(code_tuple)):
+            aliases.append(''.join(code_tuple[i:]))
+        return aliases

rbx/providers/provider.py

@@ -0,0 +1,26 @@
+import abc
+from typing import List
+
+from rbx.schema import Problem
+
+
+class ProviderInterface(abc.ABC):
+    @abc.abstractmethod
+    def should_handle(self, url: str) -> bool:
+        pass
+
+    def is_contest(self, problems: List[Problem]) -> bool:
+        batches = set(problem.batch.id for problem in problems)
+        return len(batches) == 1
+
+    def should_simplify_contest_problems(self) -> bool:
+        return False
+
+    def get_problem_code_within_contest(self, problem: Problem) -> str:
+        return self.get_code(problem)
+
+    def get_code(self, problem: Problem) -> str:
+        return problem.name
+
+    def get_aliases(self, problem: Problem) -> List[str]:
+        return []

rbx/resources/checkers/boilerplate.cpp

@@ -0,0 +1,20 @@
+#include "testlib.h"
+
+using namespace std;
+
+int main(int argc, char *argv[]) {
+    setName("custom checker");
+    registerTestlibCmd(argc, argv);
+
+    quitf(_wa, "wrong answer");
+    quitf(_pe, "presentation error");
+    quitf(_ok, "ok");
+
+    inf, ouf, ans;
+
+    inf.readInt();
+    inf.readInts(5);
+    inf.readWord();
+    inf.readDouble();
+    inf.readLong();
+}

rbx/resources/default_config.json

@@ -0,0 +1,48 @@
+{
+  "defaultLanguage": "exinc",
+  "editor": "vim",
+  "languages": {
+    "c++17": {
+      "template": "template.cpp",
+      "file": "%{problem-code}.cpp",
+      "preprocess": [
+        "g++ \"%{file}\" -std=c++17 -fdiagnostics-color=always"
+      ],
+      "exec": "./a.out",
+      "artifacts": {
+        "a.out": {
+          "executable": true
+        }
+      },
+      "submitor": "c++17"
+    },
+    "exinc": {
+      "template": "template.cpp",
+      "file": "%{problem-code}.cpp",
+      "submitFile": "%{problem-code}.pre.cpp",
+      "preprocess": [
+        "exinc -i \"%{file}\" -o \"%{submit-file}\" -c"
+      ],
+      "exec": "./a.out",
+      "artifacts": {
+        "a.out": {
+          "executable": true
+        }
+      },
+      "submitor": "c++17"
+    }
+  },
+  "submitor": {
+    "c++17": {
+      "codeforces": {
+        "typeid": 54
+      }
+    }
+  },
+  "credentials": {
+    "codeforces": {
+      "handle": "",
+      "password": ""
+    }
+  }
+}

rbx/resources/envs/default.rbx.yml

@@ -0,0 +1,37 @@
+---
+sandbox: "stupid"
+defaultCompilation:
+  sandbox:
+    maxProcesses: 1000
+    timeLimit: 10000 # 10 seconds
+    wallTimeLimit: 10000 # 10 seconds
+    memoryLimit: 1024 # 1gb
+    preserveEnv: true
+    mirrorDirs:
+      - "/etc"
+      - "/usr"
+defaultExecution:
+  sandbox:
+    # Useful for checkers, validators, etc.
+    timeLimit: 10000 # 10 seconds
+    wallTimeLimit: 10000 # 10 seconds
+    memoryLimit: 1024 # 1gb
+languages:
+  - name: "cpp"
+    readable_name: "C++17"
+    extension: "cpp"
+    compilation:
+      commands:
+        - "g++ -std=c++17 -O2 -o {executable} {compilable}"
+    execution:
+      command: "./{executable}"
+    fileMapping:
+      compilable: "compilable.cpp"
+  - name: "py"
+    readable_name: "Python3"
+    extension: "py"
+    execution:
+      command: "python3 {executable}"
+    fileMapping:
+      executable: "executable.py"
+

rbx/resources/envs/isolate.rbx.yml

@@ -0,0 +1,37 @@
+---
+sandbox: "isolate"
+defaultCompilation:
+  sandbox:
+    maxProcesses: null
+    timeLimit: null # 10 seconds
+    wallTimeLimit: null # 10 seconds
+    memoryLimit: null # 1gb
+    preserveEnv: true
+    mirrorDirs:
+      - "/etc"
+      - "/usr"
+defaultExecution:
+  sandbox:
+    # Useful for checkers, validators, etc.
+    timeLimit: 10000 # 10 seconds
+    wallTimeLimit: 10000 # 10 seconds
+    memoryLimit: 1024 # 1gb
+languages:
+  - name: "cpp"
+    readable_name: "C++17"
+    extension: "cpp"
+    compilation:
+      commands:
+        - "/usr/bin/g++ -std=c++17 -O2 -o {executable} {compilable}"
+    execution:
+      command: "./{executable}"
+    fileMapping:
+      compilable: "compilable.cpp"
+  - name: "py"
+    readable_name: "Python3"
+    extension: "py"
+    execution:
+      command: "/usr/bin/python3 {executable}"
+    fileMapping:
+      executable: "executable.py"
+

rbx/resources/packagers/boca/checker.sh

@@ -0,0 +1,43 @@
+### START OF CHECKER COMPILATION
+CHECKER_PATH="checker.cpp"
+CHECKER_OUT="../checker.exe"
+
+# find compiler
+cc=`which g++`
+[ -x "$cc" ] || cc=/usr/bin/g++
+if [ ! -x "$cc" ]; then
+    echo "$cc not found or it's not executable"
+    exit 47
+fi
+read -r -d '' TestlibContent <<"EOF"
+{{testlib_content}}
+EOF
+  
+read -r -d '' CheckerContent <<"EOF"
+{{checker_content}}
+EOF
+
+printf "%s" "${TestlibContent}" > testlib.h
+printf "%s" "${CheckerContent}" > $CHECKER_PATH
+
+checker_hash=($(md5sum $CHECKER_PATH))
+checker_cache="/tmp/boca-chk-${checker_hash}"
+
+echo "Polygon checker hash: $checker_hash"
+if [ -f "$checker_cache" ]; then
+    echo "Recovering polygon checker from cache: $checker_cache"
+    cp "$checker_cache" $CHECKER_OUT -f
+else
+    echo "Compiling polygon checker: $CHECKER_PATH"
+    $cc {{stdcpp}} -static -O2 -lm $CHECKER_PATH -o $CHECKER_OUT
+    
+    if [ $? -ne 0 ]; then
+        echo "Checker could not be compiled"
+        exit 47
+    fi
+
+    cp $CHECKER_OUT "$checker_cache" -f
+fi
+
+chmod 0755 $CHECKER_OUT
+### END OF CHECKER COMPILATION

rbx/resources/packagers/boca/compare

@@ -0,0 +1,53 @@
+#!/bin/bash
+# ////////////////////////////////////////////////////////////////////////////////
+# //BOCA Online Contest Administrator
+# //    Copyright (C) 2003-2012 by BOCA Development Team (bocasystem@gmail.com)
+# //
+# //    This program is free software: you can redistribute it and/or modify
+# //    it under the terms of the GNU General Public License as published by
+# //    the Free Software Foundation, either version 3 of the License, or
+# //    (at your option) any later version.
+# //
+# //    This program is distributed in the hope that it will be useful,
+# //    but WITHOUT ANY WARRANTY; without even the implied warranty of
+# //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# //    GNU General Public License for more details.
+# //    You should have received a copy of the GNU General Public License
+# //    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# ////////////////////////////////////////////////////////////////////////////////
+# // Last modified 21/jul/2012 by cassio@ime.usp.br
+#
+# This script receives:
+# $1 team_output
+# $2 sol_output
+# $3 problem_input (might be used by some specific checkers, here it is not)
+#
+# BOCA reads the last line of the standard output
+# and pass it to judges
+#
+if [ ! -r "$1" -o ! -r "$2" ]; then
+  echo "Parameter problem"
+  exit 43
+fi
+
+# Next lines of this script just compares team_output and sol_output,
+# although it is possible to change them to more complex evaluations.
+output=`../checker.exe $3 $1 $2 2>&1 >/dev/null`
+EC=$?
+
+echo "checker exitcode = $EC"
+echo "$output"
+
+if [ $EC -eq 0 ]; then
+  echo "checker found no differences"
+  exit 4
+elif [ $EC -eq 1 ]; then
+  echo "checker found differences"
+  exit 6
+elif [ $EC -eq 2 ]; then
+  echo "checker failed"
+  exit 5
+elif [ $EC -ne 3 ]; then
+  echo "unkown compare error $EC"
+  exit 43
+fi