rbx.cp 0.5.73__py3-none-any.whl → 0.6.1__py3-none-any.whl

rbx/box/{packaging/boca/upload.py → tooling/boca/scraper.py}

@@ -6,15 +6,17 @@ import pathlib
 import re
 import shutil
 import typing
-from typing import Any, NoReturn, Optional, Tuple
+from typing import Any, List, NoReturn, Optional, Tuple
 
 import dateparser
 import mechanize
 import typer
 from bs4 import BeautifulSoup
+from pydantic import BaseModel
 
 from rbx import console
 from rbx.box import naming
+from rbx.grading.steps import Outcome
 
 ALERT_REGEX = re.compile(r'\<script[^\>]*\>\s*alert\(\'([^\']+)\'\);?\s*\<\/script\>')
 UPLOAD_LOG_REGEX = re.compile(r'Problem (\d+) \([^\)]+\) updated')
@@ -32,7 +34,30 @@ def _parse_env_var(var: str, override: Optional[str]) -> str:
     return value
 
 
-class BocaUploader:
+def _parse_answer_as_outcome(answer: str) -> Optional[Outcome]:
+    answer = answer.lower()
+    if 'yes' in answer:
+        return Outcome.ACCEPTED
+    if 'wrong answer' in answer:
+        return Outcome.WRONG_ANSWER
+    if 'time limit exceeded' in answer:
+        return Outcome.TIME_LIMIT_EXCEEDED
+    if 'runtime error' in answer:
+        return Outcome.RUNTIME_ERROR
+    return None
+
+
+class BocaRun(BaseModel):
+    run_number: int
+    site_number: int
+    problem_shortname: str
+    outcome: Outcome
+    time: int
+
+    user: Optional[str] = None
+
+
+class BocaScraper:
     def __init__(
         self,
         base_url: Optional[str] = None,
@@ -256,7 +281,49 @@ class BocaUploader:
             )
             raise typer.Exit(1)
 
-    def download_run(self, run_number: int, site_number: int, into_dir: pathlib.Path):
+    def list_runs(self) -> List[BocaRun]:
+        _, html = self.open(
+            f'{self.base_url}/admin/run.php',
+            error_msg='Error while listing runs in BOCA',
+        )
+
+        soup = BeautifulSoup(html, 'html.parser')
+        rows = soup.select('form[name="form1"] table tr')
+
+        runs: List[BocaRun] = []
+        for row in rows[1:]:
+            cells = row.select('td')
+
+            run_number = cells[0].text.strip()
+            site_number = cells[1].text.strip()
+            shortname = cells[4].text.strip()
+            answer = cells[-1].text.strip()
+            time = int(cells[3].text.strip())
+            user = cells[2].text.strip()
+
+            outcome = _parse_answer_as_outcome(answer)
+            if outcome is None:
+                continue
+            runs.append(
+                BocaRun(
+                    run_number=run_number,
+                    site_number=site_number,
+                    problem_shortname=shortname,
+                    outcome=outcome,
+                    time=time,
+                    user=user,
+                )
+            )
+
+        return runs
+
+    def download_run(
+        self,
+        run_number: int,
+        site_number: int,
+        into_dir: pathlib.Path,
+        name: Optional[str] = None,
+    ):
         url = f'{self.base_url}/admin/runedit.php?runnumber={run_number}&runsitenumber={site_number}'
         _, html = self.open(
             url,
@@ -277,7 +344,8 @@ class BocaUploader:
             if link_col is None:
                 continue
             href = str(link_col.attrs['href'])
-            filename = pathlib.Path(link_col.text.strip())
+            if filename is None:
+                filename = pathlib.Path(link_col.text.strip())
             break
 
         if href is None or filename is None:
@@ -289,16 +357,17 @@ class BocaUploader:
         tmp_file, _ = self.br.retrieve(link.absolute_url)
         if tmp_file is None:
             self.raw_error('Error while downloading run:\nDownloaded file is None.')
-        final_path = into_dir / filename.with_stem(f'{run_number}-{site_number}')
+        filename = filename.with_stem(name or f'{run_number}-{site_number}')
+        final_path = into_dir / filename
         final_path.parent.mkdir(parents=True, exist_ok=True)
         shutil.move(tmp_file, final_path)
         return final_path
 
 
 @functools.lru_cache
-def get_boca_uploader(
+def get_boca_scraper(
     base_url: Optional[str] = None,
     username: Optional[str] = None,
     password: Optional[str] = None,
-) -> BocaUploader:
-    return BocaUploader(base_url, username, password)
+) -> BocaScraper:
+    return BocaScraper(base_url, username, password)

rbx/box/tooling/main.py

@@ -0,0 +1,8 @@
+import typer
+
+from rbx import annotations
+from rbx.box.tooling.boca import main as boca_main
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+app.add_typer(boca_main.app, name='boca')

rbx/box/ui/utils/run_ui.py

@@ -52,7 +52,7 @@ def get_solution_markup(
 
     evals = get_solution_evals_or_null(skeleton, solution)
     report = solutions.get_solution_outcome_report(
-        solution, evals or [], skeleton.verification, subset=False
+        solution, skeleton, evals or [], skeleton.verification, subset=False
     )
     if evals is None:
         return header + '\n' + report.get_verdict_markup(incomplete=True)

rbx/box/ui/widgets/interaction_box.py

@@ -28,13 +28,31 @@ class InteractionBox(RichLogBox):
         self.auto_scroll = False
         self.can_focus = False
 
+    def _show_raw_text(self, path: pathlib.Path):
+        path_str = str(path.relative_to(pathlib.Path.cwd()))
+        self.write(
+            rich.text.Text(
+                'Showing raw interaction file because the interaction text is not parseable.\n'
+                'This might usually happen when the processes do not communicate properly.\n',
+                style='red',
+            )
+        )
+        self.write(rich.text.Text(path.read_text()))
+        self.border_subtitle = f'{path_str} (raw file)'
+
     @work(exclusive=True)
     async def _load_file(self, path: pathlib.Path):
         self.clear()
         path_str = str(path.relative_to(pathlib.Path.cwd()))
         self.border_subtitle = f'{path_str} (loading...)'
 
-        interaction = await asyncio.to_thread(testcase_utils.parse_interaction, path)
+        try:
+            interaction = await asyncio.to_thread(
+                testcase_utils.parse_interaction, path
+            )
+        except testcase_utils.TestcaseInteractionParsingError:
+            self._show_raw_text(path)
+            return
 
         for entry in interaction.entries:
             if entry.pipe == 0:

rbx/grading/caching.py

@@ -7,10 +7,13 @@ from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel
 
+from rbx import console
 from rbx.grading.judge.digester import digest_cooperatively
 from rbx.grading.judge.storage import Storage, copyfileobj
 from rbx.grading.steps import DigestHolder, GradingArtifacts, GradingLogsHolder
 
+VERBOSE = False
+
 
 class CacheInput(BaseModel):
     """
@@ -157,12 +160,21 @@ def _build_cache_input(
         artifacts.model_copy(deep=True) for artifacts in artifact_list
     ]
     for artifacts in cloned_artifact_list:
+        # Clear logs from cache input, since they are not
+        # part of the cache key.
+        artifacts.logs = None
+
         for output in artifacts.outputs:
             if output.hash:
                 # Cleanup dest field from hash artifacts
                 # since they only their digest value should
                 # be tracked by cache.
                 output.dest = None
+
+            if output.digest is not None:
+                # Cleanup output digest value from cache input,
+                # since it is not part of the cache key.
+                output.digest.value = None
     return CacheInput(
         commands=commands, artifacts=cloned_artifact_list, extra_params=extra_params
     )
@@ -237,7 +249,11 @@ class DependencyCacheBlock:
             artifact_list=self.artifact_list,
             extra_params=self.extra_params,
         )
+        if VERBOSE:
+            console.console.log(f'Cache input is: {input}')
         self._key = _build_cache_key(input)
+        if VERBOSE:
+            console.console.log(f'Cache key is: {self._key}')
         found = self.cache.find_in_cache(
             self.commands, self.artifact_list, self.extra_params, key=self._key
         )
@@ -349,8 +365,8 @@ class DependencyCache:
         extra_params: Dict[str, Any],
         key: Optional[str] = None,
     ):
-        input = CacheInput(
-            commands=commands, artifacts=artifact_list, extra_params=extra_params
+        input = _build_cache_input(
+            commands=commands, artifact_list=artifact_list, extra_params=extra_params
         )
         key = key or _build_cache_key(input)
 

rbx/grading/judge/sandbox.py

@@ -1,4 +1,5 @@
 import abc
+import asyncio
 import collections
 import dataclasses
 import io
@@ -15,7 +16,6 @@ from typing import IO, Any, Dict, List, Optional
 
 import pydantic
 
-from rbx.grading import processing_context
 from rbx.grading.judge import cacher, storage
 
 logger = logging.getLogger(__name__)
@@ -23,6 +23,33 @@ logger = logging.getLogger(__name__)
 MERGE_STDERR = pathlib.PosixPath('/dev/stdout')
 
 
+# Thread-safe version of asyncio.Event.
+class Event_ts(asyncio.Event):
+    def __init__(self):
+        super().__init__()
+        self._inherited_loop = asyncio.get_event_loop()
+
+    def get_loop(self):
+        if self._inherited_loop is None:
+            return None
+        if self._inherited_loop.is_closed():
+            return None
+        return self._inherited_loop
+
+    def set_loop(self, loop):
+        self._inherited_loop = loop
+
+    def set(self):
+        loop = self.get_loop()
+        if loop is not None:
+            loop.call_soon_threadsafe(super().set)
+
+    def clear(self):
+        loop = self.get_loop()
+        if loop is not None:
+            loop.call_soon_threadsafe(super().clear)
+
+
 def wait_without_std(
     procs: List[subprocess.Popen], actually_pipe_to_stdout: bool = False
 ) -> List[int]:
@@ -116,6 +143,7 @@ class SandboxParams(pydantic.BaseModel):
     wallclock_timeout: Optional[int] = None  # ms
     extra_timeout: Optional[int] = None  # ms
     reverse_io: bool = False
+    pgid: Optional[int] = None
 
     # For timeit
     timeit_dups: Dict[str, List[pathlib.Path]] = dataclasses.field(
@@ -229,6 +257,7 @@ class SandboxBase(abc.ABC):
 
         self.params = params or SandboxParams()
         self.pid = None
+        self.pid_event = Event_ts()
 
         # Set common environment variables.
         # Specifically needed by Python, that searches the home for
@@ -329,18 +358,35 @@ class SandboxBase(abc.ABC):
         pass
 
     def set_pid(self, pid: int):
-        processing_context.add_to_processing_context(pid)
+        """Set the PID of the sandboxed process.
+
+        pid (int): the PID of the sandboxed process.
+
+        """
         self.pid = pid
+        self.pid_event.set()
 
-    def get_pid(self) -> Optional[int]:
+    async def get_pid(self) -> int:
         """Return the PID of the sandboxed process.
 
-        return (int|None): the PID of the sandboxed process, or None if
-            the sandboxed process is not running.
+        Blocks until the PID is set.
+
+        return (int): the PID of the sandboxed process.
 
         """
+        await self.pid_event.wait()
+        assert self.pid is not None
         return self.pid
 
+    def clear_pid(self):
+        """Clear the PID of the sandboxed process."""
+        self.pid_event.clear()
+        self.pid = None
+
+    def use_pgid(self) -> bool:
+        """Whether the sandbox supports process groups."""
+        return False
+
     @abc.abstractmethod
     def get_detailed_logs(self) -> str:
         """Return the detailed logs of the sandbox.
@@ -706,6 +752,15 @@ class SandboxBase(abc.ABC):
         """
         pass
 
+    def reset(self):
+        """Reset the sandbox.
+
+        To be called at the beginning of the execution.
+
+        """
+        self.cleanup(delete=True)
+        self.initialize()
+
     @abc.abstractmethod
     def cleanup(self, delete: bool = False):
         """Cleanup the sandbox.

rbx/grading/judge/sandboxes/isolate.py

@@ -599,6 +599,7 @@ class IsolateSandbox(SandboxBase):
         return (bool|Popen): return True if the sandbox didn't report
             errors (caused by the sandbox itself), False otherwise.
         """
+        self.clear_pid()
         popen = self._popen(
             command,
             stdin=subprocess.PIPE,

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -51,23 +51,22 @@ class StupidSandbox(SandboxBase):
         SandboxBase.__init__(self, file_cacher, name, temp_dir, params)
 
         # Make box directory
+        self.initialize()
+
+    def initialize(self):
         self._path = pathlib.Path(
             tempfile.mkdtemp(dir=str(self.temp_dir), prefix='rbx-%s-' % (self.name))
         )
-        self.initialize()
-
         self.exec_num = -1
         self.log = None
         self.returncode = None
+        self._path.mkdir(parents=True, exist_ok=True)
 
         logger.debug("Sandbox in `%s' created, using stupid box.", self._path)
 
         # Box parameters
         self.chdir = self._path
 
-    def initialize(self):
-        self._path.mkdir(parents=True, exist_ok=True)
-
     def get_timeit_executable(self) -> pathlib.Path:
         with importlib.resources.as_file(
             importlib.resources.files('rbx')
@@ -94,6 +93,8 @@ class StupidSandbox(SandboxBase):
             args.append(f'-f{self.params.fsize}')
         if self.chdir:
             args.append(f'-c{self.chdir}')
+        if self.use_pgid() and self.params.pgid is not None:
+            args.append(f'-g{self.params.pgid}')
 
         file_args = []
         if self.params.stdin_file:
@@ -148,6 +149,9 @@ class StupidSandbox(SandboxBase):
     def use_soft_timeout(self) -> bool:
         return True
 
+    def use_pgid(self) -> bool:
+        return True
+
     def get_memory_used(self) -> Optional[int]:
         """Return the memory used by the sandbox.
 
@@ -305,6 +309,8 @@ class StupidSandbox(SandboxBase):
             + self.get_timeit_args()
             + command
         )
+
+        self.clear_pid()
         with subprocess.Popen(
             real_command,
             stdin=subprocess.PIPE,

rbx/grading/judge/sandboxes/timeit.py

@@ -5,6 +5,7 @@ import resource
 import signal
 import stat
 import sys
+import threading
 from time import monotonic
 from typing import Any, Dict, List, Optional, Set, Union
 
@@ -25,6 +26,7 @@ class Options:
     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):
@@ -91,17 +93,16 @@ def create_tee(files, mode, buffer_size=4096, prefix=''):
             # Close parent's end of the pipe
             os.close(pipe_write)
 
-            bytes = os.read(pipe_read, buffer_size)
-            while bytes:
+            new = True
+            while bytes := os.read(pipe_read, 1):
                 for tee in tee_list:
-                    if tee.prefix:
+                    if tee.prefix and new:
                         tee.file.write(tee.prefix)
                     tee.file.write(bytes)
                     tee.file.flush()
+                    new = bytes == b'\n'
                     # TODO maybe add in fsync() here if the fileno() method
                     # exists on file
-
-                bytes = os.read(pipe_read, buffer_size)
         except Exception:
             pass
         finally:
@@ -150,6 +151,8 @@ def parse_opts() -> Options:
             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
@@ -270,6 +273,7 @@ def wait_and_finish(
     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)
@@ -279,6 +283,9 @@ def wait_and_finish(
 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:
@@ -292,13 +299,21 @@ def main():
     alarm_msg: List[Optional[str]] = [None]
     status_holder: Set[str] = set()
 
-    def handle_alarm(*args, **kwargs):
+    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
-        wall_time = monotonic() - start_time
-        if options.wall_time_limit is not None and wall_time > options.wall_time_limit:
-            alarm_msg[0] = 'wall timelimit'
-            os.kill(sub_pid, 9)
+        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)
@@ -313,20 +328,26 @@ def main():
                 os.kill(sub_pid, 9)
                 return
 
-        signal.setitimer(signal.ITIMER_REAL, 0.3)
+        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.setitimer(signal.ITIMER_REAL, 0.3)
-    signal.signal(signal.SIGALRM, handle_alarm)
     signal.signal(signal.SIGTERM, handle_sub_term)
 
     wait_and_finish(sub_pid, options, start_time, status_holder, alarm_msg=alarm_msg)
-    # Cancel alarm before exiting to avoid surprises.
-    signal.setitimer(signal.ITIMER_REAL, 0)
+
+    # Process finished, stop the handlers.
+    stop_wall_handler.set()
+    stop_alarm_handler.set()
 
     # Exit gracefully.
     sys.exit(0)