rbx.cp 0.5.52__py3-none-any.whl → 0.5.54__py3-none-any.whl

rbx/box/checkers.py

@@ -226,6 +226,10 @@ def _check_sanitizer_warnings(run_log: Optional[RunLog]) -> bool:
     return run_log.warnings
 
 
+def _is_testlib_eof(stderr: str) -> bool:
+    return 'wrong output format Unexpected end of file' in stderr
+
+
 async def check(
     checker_digest: str,
     run_log: Optional[RunLog],
@@ -283,15 +287,21 @@ async def check_communication(
     # interactor exited before it. Thus, check the interactor, as it might have
     # returned a checker verdict.
     #
-    # Also, do the same if the solution returned a non-zero exit code. Checker verdict
-    # should usually supersede a solution's RTE verdict.
+    # Also, treat the case where the solution has a non-zero exit code similarly.
+    # This is aligned with what Polygon/Codeforces does: for some languages, we don't
+    # get a SIGPIPE. Instead, we get a non-zero exit code which we can't distinguish
+    # from a normal RTE. Thus, we decide that we should prioritize the interactor verdict
+    # over the solution's exit code in these cases.
     if (
         interactor_run_log is not None
         and run_log is not None
         and (
             run_log.exitcode == -signal.SIGPIPE
             or run_log.exitstatus == SandboxBase.EXIT_TERMINATED
-            or run_log.exitstatus == SandboxBase.EXIT_NONZERO_RETURN
+            or (
+                run_log.exitstatus == SandboxBase.EXIT_NONZERO_RETURN
+                and not _is_testlib_eof(interactor_stderr.read_text())
+            )
         )
     ):
         result = _check_interactor()

rbx/box/dump_schemas.py

@@ -0,0 +1,18 @@
+import pathlib
+
+import mkdocs_gen_files
+
+from rbx.box.contest.schema import Contest
+from rbx.box.environment import Environment
+from rbx.box.package import Package
+from rbx.box.presets.lock_schema import PresetLock
+from rbx.box.presets.schema import Preset
+from rbx.box.statements.schema import Statement
+from rbx.utils import dump_schema_str
+
+models = [Package, Environment, Contest, Preset, PresetLock, Statement]
+
+for model in models:
+    path = pathlib.Path('schemas') / f'{model.__name__}.json'
+    with mkdocs_gen_files.open(str(path), 'w') as f:
+        f.write(dump_schema_str(model))

rbx/box/packaging/polygon/upload.py

@@ -250,6 +250,24 @@ def _get_statement_blocks(statement: Statement) -> StatementBlocks:
         )
 
 
+def _get_explanations(explanations: Dict[int, str]) -> str:
+    entries = []
+    for i in sorted(explanations):
+        explanation = explanations[i]
+        entries.append(f'\\textbf{{Explanation for example {i + 1}}}\n\n{explanation}')
+    return '\n\n'.join(entries)
+
+
+def _get_notes_with_explanations(blocks: StatementBlocks) -> Optional[str]:
+    notes = blocks.blocks.get('notes')
+    explanations = blocks.explanations
+    if notes is None and not explanations:
+        return None
+    if notes is None:
+        return _get_explanations(blocks.explanations)
+    return notes + '\n\n' + _get_explanations(blocks.explanations)
+
+
 def _upload_statement_resources(problem: api.Problem, statement: Statement):
     assets = get_relative_assets(statement.path, statement.assets)
     for asset, relative_asset in assets:
@@ -293,7 +311,7 @@ def _upload_statement(problem: api.Problem):
             input=blocks.blocks.get('input'),
             output=blocks.blocks.get('output'),
             interaction=blocks.blocks.get('interaction'),
-            notes=blocks.blocks.get('notes'),
+            notes=_get_notes_with_explanations(blocks),
         )
         problem.save_statement(
             lang=code_to_langs([language])[0], problem_statement=polygon_statement
@@ -311,8 +329,8 @@ async def upload_problem(name: str):
     name = _normalize_problem_name(name)
     problem = _find_or_create_problem(name)
     _update_problem_info(problem)
-    _update_checker(problem)
     _update_rbx_header(problem)
+    _update_checker(problem)
 
     if (
         pkg.type == TaskType.COMMUNICATION

rbx/grading/processing_context.py

@@ -1,3 +1,4 @@
+import asyncio
 import contextlib
 import os
 import signal
@@ -5,22 +6,26 @@ import threading
 from typing import Optional, Set
 
 _processing_context_pids: Optional[Set[int]] = None
+_terminate_all_on_error = False
 _lock = threading.Lock()
 
 # Creating a processing context is not thread-safe, but adding to it is.
 
 
 @contextlib.contextmanager
-def new_processing_context():
-    global _processing_context_pids
+def new_processing_context(terminate_all_on_error: bool = False):
+    global _processing_context_pids, _terminate_all_on_error
     with _lock:
         old_processing_context_pids = _processing_context_pids
+        _old_terminate_all_on_error = _terminate_all_on_error
         _processing_context_pids = set()
+        _terminate_all_on_error = terminate_all_on_error
     try:
         yield
     finally:
         with _lock:
             _processing_context_pids = old_processing_context_pids
+            _terminate_all_on_error = _old_terminate_all_on_error
 
 
 def get_processing_context() -> Set[int]:
@@ -36,7 +41,8 @@ def add_to_processing_context(pid: int):
         _processing_context_pids.add(pid)
 
 
-def terminate_all_processes_in_context():
+def terminate_all_processes_in_context(clear: bool = True):
+    global _processing_context_pids
     with _lock:
         if _processing_context_pids is None:
             return
@@ -45,4 +51,37 @@ def terminate_all_processes_in_context():
                 os.kill(pid, signal.SIGTERM)
             except OSError:
                 pass
-        _processing_context_pids.clear()
+        if clear:
+            _processing_context_pids.clear()
+
+
+async def wait_all_processes_in_context(wait_for: int):
+    global _processing_context_pids, _terminate_all_on_error
+    wait_pids = set()
+    while len(get_processing_context()) < wait_for:
+        await asyncio.sleep(0.01)
+
+    with _lock:
+        if _processing_context_pids is None:
+            return
+        wait_pids.update(_processing_context_pids)
+
+    wait_lock = threading.Lock()
+    finished_pids = []
+
+    def process(pid: int, returncode: int):
+        with wait_lock:
+            finished_pids.append(pid)
+        if returncode != 0 and _terminate_all_on_error:
+            terminate_all_processes_in_context()
+
+    def wait_all_processes():
+        while len(finished_pids) < len(wait_pids):
+            try:
+                pid, status = os.wait()
+            except ChildProcessError:
+                return
+            if pid in wait_pids:
+                process(pid, os.waitstatus_to_exitcode(status))
+
+    await asyncio.to_thread(wait_all_processes)

rbx/grading/steps.py

@@ -193,6 +193,11 @@ class RunLogMetadata(BaseModel):
     retryIndex: Optional[int] = None
 
 
+class ProcessingContextLog(BaseModel):
+    pid: int = -1
+    exitindex: int = -1
+
+
 class RunLog(BaseModel):
     exitcode: int = 0
     exitstatus: str = SandboxBase.EXIT_SANDBOX_ERROR
@@ -330,14 +335,29 @@ def _expand_part(part: str, sandbox: SandboxBase) -> List[str]:
     return [part]
 
 
+def _get_java_memory_limits(sandbox: SandboxBase) -> Tuple[int, int]:
+    max_memory = sandbox.params.address_space
+    if max_memory is None:
+        max_memory = 2048
+    return max_memory, min(512, int(max_memory * 0.9))
+
+
 def _split_and_expand(command: str, sandbox: SandboxBase) -> List[str]:
     res = []
-    parts = shlex.split(command.format(memory=sandbox.params.address_space or 2048))
+    max_mem, init_mem = _get_java_memory_limits(sandbox)
+    parts = shlex.split(command.format(memory=max_mem, initialMemory=init_mem))
     for part in parts:
         res.extend(_expand_part(part, sandbox))
     return res
 
 
+def get_exe_from_command(command: str) -> str:
+    cmds = shlex.split(command)
+    if not cmds:
+        return command
+    return cmds[0]
+
+
 def _is_c_command(exe_command: str) -> bool:
     return 'gcc' in exe_command or 'clang' in exe_command
 
@@ -351,15 +371,26 @@ def is_cxx_command(exe_command: str) -> bool:
 
 
 def is_cxx_sanitizer_command(command: str) -> bool:
-    cmds = shlex.split(command)
-    if not cmds:
+    exe = get_exe_from_command(command)
+    if not exe:
         return False
-    exe = cmds[0]
     if not is_cxx_command(exe):
         return False
     return 'fsanitize' in command
 
 
+def is_java_command(exe_command: str) -> bool:
+    return 'javac' in exe_command or 'java' in exe_command
+
+
+def is_kotlin_command(exe_command: str) -> bool:
+    return 'kotlinc' in exe_command or 'kotlin' in exe_command
+
+
+def is_java_like_command(exe_command: str) -> bool:
+    return is_java_command(exe_command) or is_kotlin_command(exe_command)
+
+
 @functools.cache
 def _complain_about_clang() -> None:
     console.print(
@@ -539,6 +570,10 @@ def compile(
         stderr_file = pathlib.PosixPath(f'compile-{i}.stderr')
         sandbox.params.set_stdall(stdout=stdout_file, stderr=stderr_file)
 
+        # Remove memory constraints for Java.
+        if is_java_like_command(get_exe_from_command(command)):
+            sandbox.params.address_space = None
+
         if bits_artifact is not None and _is_cpp_command(cmd[0]):
             # Include from sandbox directory to import bits/stdc++.h.
             cmd.append('-I.')
@@ -604,6 +639,10 @@ async def run(
     cmd = _split_and_expand(command, sandbox)
     sandbox.set_params(params)
 
+    # Remove memory constraints for Java.
+    if is_java_like_command(get_exe_from_command(command)):
+        sandbox.params.address_space = None
+
     if not await asyncio.to_thread(sandbox.execute_without_std, cmd):
         console.print(
             '[error]Sandbox crashed while processing command:[/error]',
@@ -614,7 +653,7 @@ async def run(
         return None
 
     if sandbox.get_exit_code() != 0 and kill_on_processing_context_exit:
-        processing_context.terminate_all_processes_in_context()
+        processing_context.terminate_all_processes_in_context(clear=False)
 
     if not _process_output_artifacts(artifacts, sandbox):
         return None
@@ -657,22 +696,27 @@ async def run_coordinated(
     interactor: CoordinatedRunParams,
     solution: CoordinatedRunParams,
 ) -> Tuple[Optional[RunLog], Optional[RunLog]]:
-    with processing_context.new_processing_context():
+    with processing_context.new_processing_context(terminate_all_on_error=True):
+        # Schedule both runs to execute immediately.
         runs = tuple(
-            run(
-                params.command,
-                params.params,
-                params.sandbox,
-                params.artifacts,
-                params.metadata,
-                kill_on_processing_context_exit=True,
+            asyncio.create_task(
+                run(
+                    params.command,
+                    params.params,
+                    params.sandbox,
+                    params.artifacts,
+                    params.metadata,
+                    kill_on_processing_context_exit=True,
+                )
             )
             for params in [interactor, solution]
         )
-        return typing.cast(
+        await processing_context.wait_all_processes_in_context(wait_for=2)
+        logs = typing.cast(
             Tuple[Optional[RunLog], Optional[RunLog]],
             tuple(await asyncio.gather(*runs)),
         )
+        return logs
 
 
 def _normalize_checked_words(s: str) -> Tuple[str, ...]:

rbx/utils.py

@@ -57,21 +57,32 @@ def get_app_path() -> pathlib.Path:
     return pathlib.Path(app_dir)
 
 
-def ensure_schema(model: Type[BaseModel]) -> pathlib.Path:
-    path = get_app_path() / 'schemas' / f'{model.__name__}.json'
+def dump_schema_str(model: Type[BaseModel]) -> str:
+    return json.dumps(model.model_json_schema(), indent=4)
+
+
+def dump_schema(model: Type[BaseModel], path: pathlib.Path):
     path.parent.mkdir(parents=True, exist_ok=True)
-    schema = json.dumps(model.model_json_schema(), indent=4)
+    schema = dump_schema_str(model)
     path.write_text(schema)
+
+
+def ensure_schema(model: Type[BaseModel]) -> pathlib.Path:
+    path = get_app_path() / 'schemas' / f'{model.__name__}.json'
+    dump_schema(model, path)
     return path.resolve()
 
 
 def model_json(model: BaseModel) -> str:
-    ensure_schema(model.__class__)
     return model.model_dump_json(indent=4, exclude_unset=True, exclude_none=True)
 
 
+def uploaded_schema_path(model: Type[BaseModel]) -> str:
+    return f'https://rsalesc.github.io/rbx/schemas/{model.__name__}.json'
+
+
 def model_to_yaml(model: BaseModel) -> str:
-    path = ensure_schema(model.__class__)
+    path = uploaded_schema_path(model.__class__)
     return f'# yaml-language-server: $schema={path}\n\n' + yaml.dump(
         model.model_dump(mode='json', exclude_unset=True, exclude_none=True),
         sort_keys=False,
@@ -80,7 +91,6 @@ def model_to_yaml(model: BaseModel) -> str:
 
 
 def model_from_yaml(model: Type[T], s: str) -> T:
-    ensure_schema(model)
     return model(**yaml.safe_load(s))
 
 

{rbx_cp-0.5.52.dist-info → rbx_cp-0.5.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.5.52
+Version: 0.5.54
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9,<4.0
@@ -21,6 +21,7 @@ Requires-Dist: latexbuild (>=0.2.2,<0.3.0)
 Requires-Dist: mechanize (>=0.4.10,<0.5.0)
 Requires-Dist: more-itertools (>=10.5.0,<11.0.0)
 Requires-Dist: nest-asyncio (>=1.6.0,<2.0.0)
+Requires-Dist: psutil (>=7.0.0,<8.0.0)
 Requires-Dist: pydantic (==2.8.2)
 Requires-Dist: pydantic-xml[lxml] (>=2.11.0,<3.0.0)
 Requires-Dist: pyte (>=0.8.2,<0.9.0)

{rbx_cp-0.5.52.dist-info → rbx_cp-0.5.54.dist-info}/RECORD

@@ -4,7 +4,7 @@ rbx/autoenum.py,sha256=cusv8ClXRlDVvhZ8eDrtYcL_2peXlHugAey_ht8roXk,12025
 rbx/box/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rbx/box/builder.py,sha256=MDm2qqmhedAbhn3rWP6cDwbBsGhV6sz_2sg1zLkPDw0,3613
 rbx/box/cd.py,sha256=9a_SOnzoJBXxxffp4Wbf3UKXIwKuN3Hvj7K6SocALwE,1194
-rbx/box/checkers.py,sha256=eb4tqtVUJYlme_Vkj2TGkUABM7EMS0P1EswhMYjN7BI,11459
+rbx/box/checkers.py,sha256=5Pj6a8y5YCVY3KvV7B_WLo30uDmIhnEgxE6_KKZqzvY,11923
 rbx/box/cli.py,sha256=GPoGDgmaV1lXL9puXhUbZUIEU0lOMvdH1kD4TGCXkCo,26738
 rbx/box/code.py,sha256=hmA2EoGOr13AYzicHNsnU2SkFW-44l7kOdu8QRwTJlI,18848
 rbx/box/compile.py,sha256=OJLthDQ921w9vyoE6Gk1Df54i5RwtRJ2YG-8XEfefcs,2489
@@ -19,6 +19,7 @@ rbx/box/contest/statements.py,sha256=Or8gFb6P_oViGdeiVgepXsvd_W84mA7LRaVmiAXWWSg
 rbx/box/creation.py,sha256=Evz7K6JoarD-4JJQsZsgoxU9FgCF9Z7-LfuroG4Cqls,2444
 rbx/box/deferred.py,sha256=II3X9e87JCOZtmspnHh-n4PFqh-FsH_oc0XJHZ9ZYVQ,691
 rbx/box/download.py,sha256=DxAiAk4lDYWEz1C9UTvZzHTq6hgm4fxGezApm2IkCTM,2601
+rbx/box/dump_schemas.py,sha256=3j5t47_vJmXj0BCczxDX6ByOcsfolGEDNCBXlPpk86w,593
 rbx/box/environment.py,sha256=fZnNQCdpG3xzKne0FY7gkuaopy6fdYvVFAXeHmC1ZOo,11498
 rbx/box/extensions.py,sha256=Von8kIeXvNFTkGlMRMTvL2HIHPwlkuiMswr-ydbGV1w,519
 rbx/box/formatting.py,sha256=3phFRHzqVXj4Ok1yDhCq6Clbw6KlqwJNpMhs--oTWFI,405
@@ -39,7 +40,7 @@ rbx/box/packaging/packager.py,sha256=da2haC1L9cG30myneMrRIAdGubtid0Xmy38BHKPCZZ4
 rbx/box/packaging/polygon/packager.py,sha256=GfZ-Dc2TDKkb3QNnfOy8yxldho2L401Ao06oWg--Gcs,11714
 rbx/box/packaging/polygon/polygon_api.py,sha256=mPKEqiwANJ1nr-JhOgzGMaDhnbljsAgzzPHW6kkf7R4,41016
 rbx/box/packaging/polygon/test.py,sha256=bgEju5PwudgyfwxXJagm8fM6CJVlWM6l_-2q1V-oKaQ,3069
-rbx/box/packaging/polygon/upload.py,sha256=2WyEXlfprLUDbq-9AMB5hXOQVvvmsT1-stO60MHrEo0,11182
+rbx/box/packaging/polygon/upload.py,sha256=woaqf2vcWmvCyBXtAesBUOaMcVUns3hkuzXqzcgAjyo,11826
 rbx/box/packaging/polygon/xml_schema.py,sha256=ZgcLyvxggMUccbTNdzflue5G-FTN2_ZmOGGF7FD0Y5A,2851
 rbx/box/presets/__init__.py,sha256=BwmjBw8wF8yiZFjCYBjMk-HGMZaRwhlfszbWAj3B0vw,18689
 rbx/box/presets/fetch.py,sha256=F-BCOlvEBEyDqtOhiDuGPn4EDtA4Bwm-fqHJ7zZGlW8,1975
@@ -97,8 +98,8 @@ rbx/grading/judge/sandboxes/timeit.py,sha256=jQonQhaVI93diYQsJYXwS77IO1t5iZVKJtm
 rbx/grading/judge/storage.py,sha256=3vv0HvtenbUZBH33CB5ZzX66ppL22G6munBaAA9BgwQ,9418
 rbx/grading/judge/test.py,sha256=ll0Iw7zyOpGdKPD_PGH7dvUkb4stQLu-ikbQnqJvuAc,944
 rbx/grading/judge/testiso.py,sha256=v14DtkWiZFJ9AKMzrb0_vZKPWDt8jz8iIw1Z2O-Advk,1397
-rbx/grading/processing_context.py,sha256=2fxa610WzXGvICDVWkPCG721w-1tXDVT7w_KtSnD0OM,1213
-rbx/grading/steps.py,sha256=RpA6HjQ4NaZLMryyFFGBW53QojLoD9VH5yjuZMycWds,25752
+rbx/grading/processing_context.py,sha256=EOxsRTKB_JEgcKNodDWPIYaBramANU-6QnDkqdF8tEk,2556
+rbx/grading/steps.py,sha256=VscFO-fnKtSspdB1Cnu18l8feaREbsh0MNkexJ6obOc,27163
 rbx/grading/steps_with_caching.py,sha256=nez2YwgauGXKRjhk6tQxTDGQ-HEk7KfZOeAPhsxi5iw,3150
 rbx/grading/steps_with_caching_run_test.py,sha256=mh4DRInrOGhnQFWD1SlcjDm_HvcSDFTDMSpAlG-Q5SI,15570
 rbx/grading_utils.py,sha256=lL2KtSkOsMElqrRoApQTbFcqVOeHVWUDTMCa3IsLpC4,4484
@@ -191,9 +192,9 @@ rbx/test.py,sha256=tZyTrXDK8MLR-1TyCRxiOiNz-PhlXVpshfUGphakkT4,11830
 rbx/testcase.py,sha256=yKOq3CAJZ1YTmInvnoIs0u1iJnRj_X85XiWbLI-p9d8,1951
 rbx/testcase_rendering.py,sha256=nfmv6dSEqd4aR3TsaODwkKGK6AXty_DDKtWf_ejiQpI,2084
 rbx/testing_utils.py,sha256=x_PqD8Zd2PkN91NxVHUnSTs044-1WK5KKtttKQBXpFs,2083
-rbx/utils.py,sha256=6e1eXRzNE-52D0UVtqclePxqR4Haiqt8qWCrSVjnGuE,4585
-rbx_cp-0.5.52.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-rbx_cp-0.5.52.dist-info/METADATA,sha256=zA9fGYWC651-X-bxyI87ll66EM9GqMSn7FF28UIcAkE,3348
-rbx_cp-0.5.52.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-rbx_cp-0.5.52.dist-info/entry_points.txt,sha256=qBTLBOeifT1F00LWaEewRRE_jQPgvH7BUdJfZ-dYsFU,57
-rbx_cp-0.5.52.dist-info/RECORD,,
+rbx/utils.py,sha256=SfR844_i0ebRDMkmS_w1YdZiWPc6h2RGADygewlWRbA,4845
+rbx_cp-0.5.54.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+rbx_cp-0.5.54.dist-info/METADATA,sha256=Ki-VbHPb5TES3dtzJ_muEqjIuzJRACCQ5MIhdIGG0G4,3387
+rbx_cp-0.5.54.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+rbx_cp-0.5.54.dist-info/entry_points.txt,sha256=qBTLBOeifT1F00LWaEewRRE_jQPgvH7BUdJfZ-dYsFU,57
+rbx_cp-0.5.54.dist-info/RECORD,,