rbx.cp 0.5.72__py3-none-any.whl → 0.6.0__py3-none-any.whl

rbx/box/statements/schema.py

@@ -2,11 +2,24 @@ from __future__ import annotations
 
 import pathlib
 from enum import Enum
-from typing import List, Literal, Union
+from typing import Annotated, List, Literal, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import AfterValidator, BaseModel, ConfigDict, Field
 
 from rbx.autoenum import AutoEnum, alias
+from rbx.box.fields import FNameField
+from rbx.box.lang import is_valid_lang_code
+
+
+def validate_statement_language(lang: str):
+    if not is_valid_lang_code(lang) or not lang.islower():
+        raise ValueError(
+            f'Invalid statement language: {lang}. Language must be a valid lowercase ISO 639-1 code.'
+        )
+    return lang
+
+
+StatementLanguage = Annotated[str, AfterValidator(validate_statement_language)]
 
 
 ### Conversion types
@@ -95,13 +108,28 @@ class StatementType(AutoEnum):
 class Statement(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
+    name: str = FNameField(description='Name of this statement.')
+
+    extends: Optional[str] = FNameField(
+        default=None,
+        description='Name of the statement that this statement extends.',
+    )
+
+    language: StatementLanguage = Field(
+        default='en', description='Language code of this statement (ISO 639-1).'
+    )
+
     title: str = Field(
-        description='Name of the problem, as it appears in the statement.'
+        default='', description='Name of the problem, as it appears in the statement.'
     )
 
-    path: pathlib.Path = Field(description='Path to the input statement file.')
+    path: pathlib.Path = Field(
+        default_factory=pathlib.Path, description='Path to the input statement file.'
+    )
 
-    type: StatementType = Field(description='Type of the input statement file.')
+    type: StatementType = Field(
+        default=StatementType.rbxTeX, description='Type of the input statement file.'
+    )
 
     steps: List[ConversionStep] = Field(
         default=[],
@@ -134,7 +162,3 @@ the statement. Files will be included in the same folder as the statement file,
 their relativeness. Can be glob pattern as well, such as `imgs/*.png`.
 """,
     )
-
-    language: str = Field(
-        default='en', description='Language this is statement is written in.'
-    )

rbx/box/testcase_utils.py

@@ -160,6 +160,10 @@ def fill_output_for_defined_testcase(testcase: Testcase) -> Testcase:
     return res
 
 
+class TestcaseInteractionParsingError(Exception):
+    pass
+
+
 def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
     entries = []
     with file.open('r') as f:
@@ -167,53 +171,21 @@ def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
             interactor_prefix = f.readline().strip()
             solution_prefix = f.readline().strip()
         except Exception:
-            console.console.print(
-                f'[error]Failed to read interaction file [item]{file}[/item]. Expected the first two lines to be the interactor and solution prefixes.[/error]'
-            )
-            raise typer.Exit(1) from None
-
-        # Crop file.
-        rest = f.read()
-        start = 0
-
-        def _find_next_prefix(start: int) -> Optional[Tuple[int, int]]:
-            interactor_idx = rest.find(interactor_prefix, start)
-            solution_idx = rest.find(solution_prefix, start)
-            if interactor_idx == -1 and solution_idx == -1:
-                return None
-            if interactor_idx == -1:
-                return (solution_idx, solution_idx + len(solution_prefix))
-            if solution_idx == -1:
-                return (interactor_idx, interactor_idx + len(interactor_prefix))
-            if interactor_idx < solution_idx:
-                return (interactor_idx, interactor_idx + len(interactor_prefix))
-            return (solution_idx, solution_idx + len(solution_prefix))
-
-        def _find_next_block() -> Optional[Tuple[int, Tuple[int, int]]]:
-            prefix = _find_next_prefix(start)
-            if prefix is None:
-                return None
-            prefix_start, prefix_end = prefix
-            prefix = rest[prefix_start:prefix_end]
-            pipe = 1 if prefix == solution_prefix else 0
-
-            nxt = _find_next_prefix(prefix_end)
-            if nxt is None:
-                return (pipe, (prefix_end, len(rest)))
-            nxt_start, _ = nxt
-            return (pipe, (prefix_end, nxt_start))
-
-        # TODO: optimize
-        blocks = 0
-        MAX_BLOCKS = 1024
-        while blocks < MAX_BLOCKS:
-            block = _find_next_block()
-            if block is None:
-                break
-            pipe, (st, nd) = block
-            entries.append(TestcaseInteractionEntry(data=rest[st:nd], pipe=pipe))
-            start = nd
-            blocks += 1
+            raise TestcaseInteractionParsingError(
+                f'Failed to read interaction file {file}. Expected the first two lines to be the interactor and solution prefixes.'
+            ) from None
+
+        while line := f.readline().strip():
+            if line.startswith(interactor_prefix):
+                stripped = line[len(interactor_prefix) :].strip()
+                entries.append(TestcaseInteractionEntry(data=stripped, pipe=0))
+            elif line.startswith(solution_prefix):
+                stripped = line[len(solution_prefix) :].strip()
+                entries.append(TestcaseInteractionEntry(data=stripped, pipe=1))
+            else:
+                raise TestcaseInteractionParsingError(
+                    f'Invalid line in interaction file {file}. Expected the line to start with the interactor or solution prefix ({interactor_prefix} or {solution_prefix}).'
+                ) from None
 
     return TestcaseInteraction(
         prefixes=(interactor_prefix, solution_prefix),

rbx/box/tooling/boca/main.py

@@ -0,0 +1,13 @@
+import pathlib
+
+import typer
+
+from rbx import annotations
+from rbx.box.tooling.boca.scrape import scrape_boca
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+
+@app.command('scrape', help='Scrape runs from BOCA.')
+def scrape() -> None:
+    scrape_boca(pathlib.Path())

rbx/box/tooling/boca/scrape.py

@@ -0,0 +1,34 @@
+import pathlib
+from concurrent.futures import ThreadPoolExecutor
+
+from rich.progress import MofNCompleteColumn, Progress, SpinnerColumn
+
+from rbx.box.tooling.boca.scraper import BocaRun, BocaScraper
+
+
+def scrape_boca(into_path: pathlib.Path):
+    scraper = BocaScraper()
+    scraper.login()
+    runs = scraper.list_runs()
+
+    progress = Progress(
+        SpinnerColumn(),
+        *Progress.get_default_columns(),
+        MofNCompleteColumn(),
+        transient=True,
+    )
+    scrape_task = progress.add_task('Scraping runs...', total=len(runs))
+    with progress:
+
+        def work(run: BocaRun):
+            scraper.download_run(
+                run.run_number,
+                run.site_number,
+                pathlib.Path(into_path) / run.problem_shortname,
+                name=f'{run.run_number}-{run.site_number}-{run.outcome.short_name().lower()}',
+            )
+
+            progress.update(scrape_task, advance=1)
+
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            executor.map(work, runs)

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/screens/run_explorer.py

@@ -46,7 +46,7 @@ class RunExplorerScreen(Screen):
             if pkg.type == TaskType.COMMUNICATION:
                 tips.display = True
                 tips.write(
-                    'This is an interactive problem.\nYou can use the [bold blue]rbx -d run[/bold blue] command to capture the interaction between the processes and see them here.'
+                    'This is an interactive problem.\nYou can use the [bold blue]rbx --capture run[/bold blue] command to capture the interaction between the processes and see them here.'
                 )
             yield tips
 

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,21 @@ logger = logging.getLogger(__name__)
 MERGE_STDERR = pathlib.PosixPath('/dev/stdout')
 
 
+# Thread-safe version of asyncio.Event.
+class Event_ts(asyncio.Event):
+    def get_loop(self):
+        if self._loop is None:
+            return asyncio.get_event_loop()
+        else:
+            return self._loop
+
+    def set(self):
+        self.get_loop().call_soon_threadsafe(super().set)
+
+    def clear(self):
+        self.get_loop().call_soon_threadsafe(super().clear)
+
+
 def wait_without_std(
     procs: List[subprocess.Popen], actually_pipe_to_stdout: bool = False
 ) -> List[int]:
@@ -116,6 +131,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 +245,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 +346,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 +740,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,