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

rbx/grading/judge/sandboxes/timeit.py

@@ -1,358 +0,0 @@
-import dataclasses
-import os
-import pathlib
-import resource
-import signal
-import stat
-import sys
-import threading
-from time import monotonic
-from typing import Any, Dict, List, Optional, Set, Union
-
-
-@dataclasses.dataclass
-class Options:
-    output_file: str
-    argv: List[str]
-    chdir: Optional[str] = None
-    stdin_file: Optional[str] = None
-    stdout_file: Optional[str] = None
-    stderr_file: Optional[str] = None
-    time_limit: Optional[float] = None
-    wall_time_limit: Optional[float] = None  # seconds
-    memory_limit: Optional[int] = None  # kb, but passed in args as mb
-    fs_limit: Optional[int] = None  # kb
-    files_to_open: List[int] = dataclasses.field(default_factory=list)
-    file_duplicates: Dict[int, List[str]] = dataclasses.field(default_factory=dict)
-    prefixed: Set[str] = dataclasses.field(default_factory=set)
-    prefix: str = ''
-    process_group: Optional[int] = None
-
-
-def exit_with(code: int):
-    sys.exit(code)
-
-
-def get_tee_command(files: List[str]) -> str:
-    path = (
-        os.path.join(os.path.dirname(os.path.realpath(__file__)), 'tee.py')
-        + ' '
-        + ' '.join(files)
-    )
-    return sys.executable + ' ' + path
-
-
-valid_modes = ['a', 'w']
-
-
-@dataclasses.dataclass
-class Tee:
-    file: Any
-    prefix: Union[str, bytes] = ''
-
-
-def create_tee(files, mode, buffer_size=4096, prefix=''):
-    """Get a file object that will mirror writes across multiple files objs
-
-    Options:
-        files     A list of files and/or file objects. All strings will be
-                  treated as file paths and opened for writing. Everything
-                  else is assumed to be a file-like object that implements
-                  both the write() and flush() methods.
-
-        mode      Which mode to use when opening new files. Valid values
-                  are 'a' (append) and 'w' (overwrite).
-
-        buffer_size
-                Control the size of the buffer between writes to the
-                resulting file object and the list of files.
-    """
-    if mode not in valid_modes:
-        raise IOError(
-            'Only valid modes to create_tee() are: %s' % ', '.join(valid_modes)
-        )
-
-    tee_list = []
-    for file in files:
-        if isinstance(file, Tee):
-            tee_list.append(file)
-        else:
-            tee_list.append(Tee(file))
-    for tee in tee_list:
-        if isinstance(tee.file, str):
-            tee.file = open(tee.file, f'{mode}b')
-        if isinstance(tee.prefix, str):
-            tee.prefix = tee.prefix.encode()
-
-    pipe_read, pipe_write = os.pipe()
-    pid = os.fork()
-    if pid == 0:
-        # Child -- Read bytes from the pipe and write them to the specified
-        #          files.
-        try:
-            # Close parent's end of the pipe
-            os.close(pipe_write)
-
-            new = True
-            while bytes := os.read(pipe_read, 1):
-                for tee in tee_list:
-                    if tee.prefix and new:
-                        tee.file.write(tee.prefix)
-                    tee.file.write(bytes)
-                    tee.file.flush()
-                    # TODO maybe add in fsync() here if the fileno() method
-                    # exists on file
-                new = bytes == b'\n'
-        except Exception:
-            pass
-        finally:
-            os._exit(255)
-    else:
-        # Parent -- Return a file object wrapper around the pipe to the
-        #           child.
-        # Preserve line buffering (buffering=1).
-        return os.fdopen(pipe_write, 'w', buffering=1, closefd=False)
-
-
-def parse_opts() -> Options:
-    options = Options(output_file=sys.argv[1], argv=[])
-    options.files_to_open = []
-    num_opts = 0
-    while num_opts + 2 < len(sys.argv) and sys.argv[num_opts + 2].startswith('-'):
-        # Process option
-        opt = sys.argv[num_opts + 2]
-        if opt.startswith('-t'):
-            options.time_limit = float(opt[2:])
-        elif opt.startswith('-w'):
-            options.wall_time_limit = float(opt[2:])
-        elif opt.startswith('-m'):
-            options.memory_limit = int(opt[2:]) * 1024
-        elif opt.startswith('-i'):
-            options.stdin_file = opt[2:]
-            options.files_to_open.append(0)
-        elif opt.startswith('-o'):
-            options.stdout_file = opt[2:]
-            options.files_to_open.append(1)
-        elif opt.startswith('-e'):
-            options.stderr_file = opt[2:]
-            options.files_to_open.append(2)
-        elif opt.startswith('-d') or opt.startswith('-D'):
-            is_prefixed = opt.startswith('-D')
-            possibilities = [None, 'o', 'e']
-            index = possibilities.index(opt[2])
-            if index not in options.file_duplicates:
-                options.file_duplicates[index] = []
-            options.file_duplicates[index].append(opt[3:])
-            if is_prefixed:
-                options.prefixed.add(opt[3:])
-        elif opt.startswith('-c'):
-            options.chdir = opt[2:]
-        elif opt.startswith('-f'):
-            options.fs_limit = int(opt[2:])
-        elif opt.startswith('-P'):
-            options.prefix = opt[2:]
-        elif opt.startswith('-g'):
-            options.process_group = int(opt[2:])
-        else:
-            raise Exception(f'Invalid option {opt}')
-        num_opts += 1
-    options.argv = sys.argv[num_opts + 2 :]
-    return options
-
-
-def get_memory_usage(ru: resource.struct_rusage) -> int:
-    if sys.platform == 'darwin':
-        return ru.ru_maxrss // 1024 + ru.ru_ixrss
-    return ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss
-
-
-def get_cpu_time(ru: resource.struct_rusage) -> float:
-    return ru.ru_utime + ru.ru_stime
-
-
-def _get_file_size(filename: Optional[str]) -> int:
-    if filename is None:
-        return 0
-    path = pathlib.Path(filename)
-    if not path.is_file():
-        return 0
-    return path.stat().st_size
-
-
-def get_file_sizes(options: Options):
-    return _get_file_size(options.stdout_file) + _get_file_size(options.stderr_file)
-
-
-def set_rlimits(options: Options):
-    if options.time_limit is not None:
-        time_limit_in_ms = int(options.time_limit * 1000)
-        rlimit_cpu = int((time_limit_in_ms + 999) // 1000)
-        resource.setrlimit(resource.RLIMIT_CPU, (rlimit_cpu, rlimit_cpu + 1))
-    if options.fs_limit is not None:
-        fs_limit = options.fs_limit * 1024  # in bytes
-        resource.setrlimit(resource.RLIMIT_FSIZE, (fs_limit + 1, fs_limit * 2))
-
-
-def redirect_fds(options: Options):
-    files = [options.stdin_file, options.stdout_file, options.stderr_file]
-
-    for i in options.files_to_open:
-        file = files[i]
-        if file is None:
-            continue
-        open_args = [
-            os.O_WRONLY | os.O_TRUNC | os.O_CREAT,
-            stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR,
-        ]
-        if i == 0:
-            # stdin
-            open_args = [os.O_RDONLY]
-        if i in options.file_duplicates:
-            dups = [
-                Tee(f, prefix=options.prefix if f in options.prefixed else '')
-                for f in options.file_duplicates[i]
-            ]
-            tee = create_tee(dups + [file], 'a', prefix=options.prefix)
-            fd = tee.fileno()
-        else:
-            fd = os.open(
-                file,
-                *open_args,
-            )
-        os.dup2(fd, i)
-        os.close(fd)
-
-
-def wait_and_finish(
-    pid: int,
-    options: Options,
-    start_time: float,
-    status_holder: Set[str],
-    alarm_msg: Optional[List[Optional[str]]] = None,
-):
-    _, exitstatus, ru = os.wait4(pid, 0)
-    wall_time = monotonic() - start_time
-    cpu_time = get_cpu_time(ru)
-    memory_used = get_memory_usage(ru)
-    file_sizes = get_file_sizes(options)
-
-    entries = []
-    exitcode = os.waitstatus_to_exitcode(exitstatus)
-    entries.append(f'exit-code: {exitcode}')
-    if exitcode < 0:
-        entries.append(f'exit-sig: {-exitcode}')
-
-    status = status_holder
-    if exitcode > 0:
-        status.add('RE')
-    if exitcode < 0:
-        status.add('SG')
-    if options.time_limit is not None and (
-        cpu_time > options.time_limit or -exitcode == 24
-    ):
-        status.add('TO')
-        cpu_time = max(cpu_time, options.time_limit)
-    if options.wall_time_limit is not None and wall_time > options.wall_time_limit:
-        status.add('WT')
-        status.add('TO')
-    if options.memory_limit is not None and memory_used > options.memory_limit:
-        status.add('ML')
-    if options.fs_limit is not None and file_sizes > options.fs_limit * 1024:
-        status.add('OL')
-
-    if status:
-        status_str = ','.join(status)
-        entries.append(f'status: {status_str}')
-
-    if alarm_msg:
-        alarm_str = ','.join(msg for msg in alarm_msg if msg is not None)
-        if alarm_str:
-            entries.append(f'alarm-msg: {alarm_str}')
-
-    entries.append(f'time: {cpu_time:.3f}')
-    entries.append(f'time-wall: {wall_time:.3f}')
-    entries.append(f'mem: {memory_used}')
-    entries.append(f'file: {file_sizes}')
-    entries.append(f'pid: {pid}')
-
-    output_file = pathlib.Path(sys.argv[1])
-    output_file.parent.mkdir(parents=True, exist_ok=True)
-    output_file.write_text('\n'.join(entries) + '\n')
-
-
-def main():
-    options = parse_opts()
-
-    if options.process_group is not None:
-        os.setpgid(0, options.process_group)
-
-    start_time = monotonic()
-    sub_pid = os.fork()
-    if sub_pid == 0:
-        if options.chdir is not None:
-            os.chdir(options.chdir)
-        set_rlimits(options)
-        redirect_fds(options)
-        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
-        os.execvp(options.argv[0], options.argv)
-
-    alarm_msg: List[Optional[str]] = [None]
-    status_holder: Set[str] = set()
-
-    stop_wall_handler = threading.Event()
-    stop_alarm_handler = threading.Event()
-
-    def handle_wall():
-        if stop_wall_handler.wait(options.wall_time_limit):
-            return
-        stop_alarm_handler.set()
-        nonlocal alarm_msg
-        alarm_msg[0] = 'wall timelimit'
-        os.kill(sub_pid, 9)
-
-    def handle_alarm():
-        if stop_alarm_handler.wait(0.3):
-            return
-        nonlocal alarm_msg
-        ru = resource.getrusage(resource.RUSAGE_CHILDREN)
-        if options.time_limit is not None:
-            cpu_time = get_cpu_time(ru)
-            if cpu_time > options.time_limit:
-                alarm_msg[0] = 'timelimit'
-                os.kill(sub_pid, 9)
-                return
-        if options.memory_limit is not None:
-            memory_used = get_memory_usage(ru)
-            if memory_used > options.memory_limit:
-                alarm_msg[0] = 'memorylimit'
-                os.kill(sub_pid, 9)
-                return
-
-        stop_alarm_handler.clear()
-        handle_alarm()
-
-    alarm_handler = threading.Thread(target=handle_alarm, daemon=True)
-    wall_handler = threading.Thread(target=handle_wall, daemon=True)
-    alarm_handler.start()
-    wall_handler.start()
-
-    def handle_sub_term(*args, **kwargs):
-        nonlocal status_holder
-        status_holder.add('TE')
-        os.kill(sub_pid, 9)
-
-    signal.signal(signal.SIGTERM, handle_sub_term)
-
-    wait_and_finish(sub_pid, options, start_time, status_holder, alarm_msg=alarm_msg)
-
-    # Process finished, stop the handlers.
-    stop_wall_handler.set()
-    stop_alarm_handler.set()
-
-    # Exit gracefully.
-    sys.exit(0)
-
-
-if __name__ == '__main__':
-    main()
-# type: ignore

rbx/grading/judge/test.py

@@ -1,38 +0,0 @@
-import atexit
-import pathlib
-
-from rich.console import Console
-
-from rbx.grading.judge import cacher, storage
-from rbx.grading.judge.sandboxes import stupid_sandbox
-
-console = Console()
-
-
-def main():
-    fs = storage.FilesystemStorage(pathlib.PosixPath('/tmp/rbx-storage'))
-    cache = cacher.FileCacher(fs)
-
-    python_file = cache.put_file_text("print('hello')")
-
-    sandbox = stupid_sandbox.StupidSandbox(cache)
-    atexit.register(sandbox.cleanup)
-    sandbox.create_file_from_storage(pathlib.PosixPath('run.py'), python_file)
-
-    sandbox.params.stdout_file = pathlib.PosixPath('run.out')
-
-    sandbox.execute_without_std(['ls'])
-    try:
-        sandbox.hydrate_logs()
-    except Exception:
-        console.print_exception()
-
-    print(sandbox.get_human_exit_description())
-    print(sandbox.get_stats())
-    print(sandbox.log)
-
-    print(sandbox.get_file_to_string(pathlib.PosixPath('run.out')))
-
-
-if __name__ == '__main__':
-    main()

rbx/grading/judge/testiso.py

@@ -1,54 +0,0 @@
-import atexit
-import pathlib
-
-from rich.console import Console
-
-from rbx import grading_utils
-from rbx.grading.judge import cacher, storage
-from rbx.grading.judge.sandboxes.isolate import IsolateSandbox
-
-console = Console()
-
-
-def main():
-    fs = storage.FilesystemStorage(pathlib.PosixPath('/tmp/rbx-storage'))
-    cache = cacher.FileCacher(fs)
-
-    python_file = cache.put_file_text(
-        """
-#include <bits/stdc++.h>
- 
-int main() {
-    std::cout << "Hello, World!" << std::endl;
-    return 0;                                      
-}
-"""
-    )
-
-    sandbox = IsolateSandbox(
-        cache, params=grading_utils.build_preprocess_sandbox_params(), debug=True
-    )
-    atexit.register(sandbox.cleanup)
-    sandbox.create_file_from_storage(pathlib.PosixPath('run.cpp'), python_file)
-
-    sandbox.params.stdout_file = pathlib.PosixPath('run.out')
-    sandbox.params.stderr_file = pathlib.PosixPath('run.err')
-
-    sandbox.execute_without_std(
-        ['/usr/bin/g++', '-std=c++17', '-o', 'executable', 'run.cpp'],
-    )
-    try:
-        sandbox.hydrate_logs()
-    except Exception:
-        console.print_exception()
-
-    print(sandbox.log)
-    print(sandbox.get_human_exit_description())
-    print(sandbox.get_stats())
-
-    print(sandbox.get_file_to_string(pathlib.PosixPath('run.out')))
-    print(sandbox.get_file_to_string(pathlib.PosixPath('run.err')))
-
-
-if __name__ == '__main__':
-    main()

rbx/grading/processing_context.py

@@ -1,71 +0,0 @@
-import contextlib
-import os
-import signal
-import subprocess
-from typing import List, Optional
-
-from rbx.grading.judge.sandbox import SandboxBase
-
-
-@contextlib.contextmanager
-def new_process_group():
-    p = subprocess.Popen(['/bin/bash', '-c', 'exec sleep infinity'])
-    try:
-        yield p.pid
-    finally:
-        p.terminate()
-        p.wait()
-
-
-def should_use_group(sandboxes: List[SandboxBase]) -> bool:
-    if not sandboxes:
-        return False
-    uses_pgid = all(sandbox.use_pgid() for sandbox in sandboxes)
-    all_pgids = set(
-        sandbox.params.pgid for sandbox in sandboxes if sandbox.params.pgid is not None
-    )
-    return uses_pgid and len(all_pgids) == 1
-
-
-async def _fetch_pids(sandboxes: List[SandboxBase]) -> List[int]:
-    return [await sandbox.get_pid() for sandbox in sandboxes]
-
-
-def _find_sandbox_idx(pids: List[int], pid: int) -> Optional[int]:
-    try:
-        return pids.index(pid)
-    except ValueError:
-        return None
-
-
-async def _wait_for_group(sandboxes: List[SandboxBase]) -> List[int]:
-    pgid = [
-        sandbox.params.pgid for sandbox in sandboxes if sandbox.params.pgid is not None
-    ][0]
-    assert pgid is not None
-
-    sandbox_pids = await _fetch_pids(sandboxes)
-
-    finished = []
-    while len(finished) < len(sandboxes):
-        try:
-            pid, status = os.waitpid(-pgid, 0)
-        except ChildProcessError:
-            break
-
-        if os.waitstatus_to_exitcode(status) != 0:
-            os.kill(pgid, signal.SIGKILL)
-
-        sandbox_idx = _find_sandbox_idx(sandbox_pids, pid)
-        if sandbox_idx is not None:
-            finished.append(sandbox_idx)
-            continue
-
-    return finished
-
-
-async def wait_all(sandboxes: List[SandboxBase]):
-    if not should_use_group(sandboxes):
-        raise RuntimeError('Sandboxes are not using a process group')
-
-    await _wait_for_group(sandboxes)

rbx/resources/envs/isolate.rbx.yml

@@ -1,36 +0,0 @@
----
-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"
-    readableName: "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"
-    readableName: "Python3"
-    extension: "py"
-    execution:
-      command: "/usr/bin/python3 {executable}"
-    fileMapping:
-      executable: "executable.py"

rbx/resources/presets/default/problem/sols/slow.cpp

@@ -1,15 +0,0 @@
-#include <bits/stdc++.h>
-
-using namespace std;
-
-int32_t main() {
-  int64_t a, b;
-  cin >> a >> b;
-
-  int64_t i;
-  // Unncessarily slow.
-  for (int k = 0; k < 10; k++)
-    for (i = 0; i < a + b; i++) {}
-    
-  cout << i << endl;
-}