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

rbx/box/header.py

@@ -49,7 +49,7 @@ def _get_string_var_block() -> str:
     return _get_var_block(_get_vars_of_type(str, _string_repr))
 
 
-def _check_int_bounds(x: int) -> None:
+def check_int_bounds(x: int) -> None:
     if x >= 2**64:
         raise ValueError(
             f'Some variable you defined (value: {x}) is too large to fit in a C++ 64-bit integer (signed or unsigned)'
@@ -63,11 +63,19 @@ def _check_int_bounds(x: int) -> None:
 def _get_int_var_block() -> str:
     def _transform(x: Primitive) -> str:
         if isinstance(x, bool):
-            return str(int(x))
-        _check_int_bounds(int(x))
+            return f'static_cast<int64_t>({int(x)})'
+        check_int_bounds(int(x))
         return f'static_cast<int64_t>({x})'
 
-    return _get_var_block(_get_vars_of_type(int, _transform))
+    # Get both int and bool variables for the int block
+    pkg = package.find_problem_package_or_die()
+    vars = pkg.expanded_vars
+    int_vars = {
+        name: _transform(value)
+        for name, value in vars.items()
+        if isinstance(value, (int, bool))
+    }
+    return _get_var_block(int_vars)
 
 
 def _get_float_var_block() -> str:
@@ -81,11 +89,9 @@ def _get_bool_var_block() -> str:
 def _get_vars_of_type(t: Type, transform: Callable[[Primitive], str]) -> Dict[str, str]:
     pkg = package.find_problem_package_or_die()
     vars = pkg.expanded_vars
-
-    def is_valid(value: Primitive) -> bool:
-        return isinstance(value, t)
-
-    return {name: transform(value) for name, value in vars.items() if is_valid(value)}
+    return {
+        name: transform(value) for name, value in vars.items() if isinstance(value, t)
+    }
 
 
 def _get_var_block(mappings: Dict[str, str]) -> str:

rbx/box/testing/testing_package.py

@@ -3,9 +3,10 @@ from dataclasses import dataclass
 from typing import Dict, List, Optional
 
 from rbx import console, utils
-from rbx.box import presets
+from rbx.box import package, presets
 from rbx.box.fields import Primitive
 from rbx.box.schema import (
+    CheckerTest,
     CodeItem,
     ExpectedOutcome,
     Generator,
@@ -14,6 +15,8 @@ from rbx.box.schema import (
     Solution,
     TaskType,
     TestcaseGroup,
+    ValidatorOutcome,
+    ValidatorTest,
 )
 from rbx.box.testing.testing_preset import TestingPreset
 from rbx.box.testing.testing_shared import PathOrStr, TestingShared
@@ -79,6 +82,9 @@ class TestingPackage(TestingShared):
 
     def save(self):
         self.yml_path.write_text(utils.model_to_yaml(self.yml))
+        # Clear internal cache and package cache to ensure the updated package is loaded fresh
+        self._yml = None
+        package.clear_package_cache()
 
     def set_type(self, type: TaskType):
         self.yml.type = type
@@ -244,3 +250,59 @@ class TestingPackage(TestingShared):
         if interactor_pipes_path.exists():
             contents.interactor_pipes = interactor_pipes_path.read_text()
         return contents
+
+    def add_validator_unit_test(
+        self,
+        glob: str,
+        outcome: ValidatorOutcome = ValidatorOutcome.VALID,
+        validator: Optional[PathOrStr] = None,
+        files: Optional[Dict[str, str]] = None,
+    ):
+        """Add a unit test for the validator.
+
+        Args:
+            glob: Glob pattern for input files
+            outcome: Expected validation outcome
+            validator: Optional validator to use (if not main validator)
+            files: Optional dict of {filename: content} to create test files
+        """
+        if files:
+            for filename, content in files.items():
+                self.add_file(filename).write_text(content)
+
+        validator_test = ValidatorTest(
+            glob=glob,
+            outcome=outcome,
+            validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+        )
+
+        # Explicitly set the unitTests field to mark it as dirty
+        unit_tests = self.yml.unitTests
+        unit_tests.validator = unit_tests.validator + [validator_test]
+        self.yml.unitTests = unit_tests
+        self.save()
+
+    def add_checker_unit_test(
+        self,
+        glob: str,
+        outcome: ExpectedOutcome = ExpectedOutcome.ACCEPTED,
+        files: Optional[Dict[str, str]] = None,
+    ):
+        """Add a unit test for the checker.
+
+        Args:
+            glob: Glob pattern for test files
+            outcome: Expected checker outcome
+            files: Optional dict of {filename: content} to create test files
+        """
+        if files:
+            for filename, content in files.items():
+                self.add_file(filename).write_text(content)
+
+        checker_test = CheckerTest(glob=glob, outcome=outcome)
+
+        # Explicitly set the unitTests field to mark it as dirty
+        unit_tests = self.yml.unitTests
+        unit_tests.checker = unit_tests.checker + [checker_test]
+        self.yml.unitTests = unit_tests
+        self.save()

rbx/box/unit.py

@@ -41,7 +41,7 @@ class CheckerTestEntry(BaseModel):
         return ', '.join(res)
 
 
-def _extract_validator_test_entries(
+def extract_validator_test_entries(
     tests: List[ValidatorTest],
 ) -> List[ValidatorTestEntry]:
     res: List[ValidatorTestEntry] = []
@@ -57,7 +57,7 @@ def _extract_validator_test_entries(
     return sorted(res, key=lambda x: x.input.name)
 
 
-def _extract_checker_test_entries(tests: List[CheckerTest]) -> List[CheckerTestEntry]:
+def extract_checker_test_entries(tests: List[CheckerTest]) -> List[CheckerTestEntry]:
     res: List[CheckerTestEntry] = []
     seen: Set[pathlib.Path] = set()
     for test in tests:
@@ -94,7 +94,7 @@ def _get_validator_for_test(test: ValidatorTestEntry) -> Optional[CodeItem]:
 async def run_validator_unit_tests(progress: StatusProgress):
     pkg = package.find_problem_package_or_die()
 
-    entries = _extract_validator_test_entries(pkg.unitTests.validator)
+    entries = extract_validator_test_entries(pkg.unitTests.validator)
 
     vals: List[CodeItem] = []
     for test in entries:
@@ -158,7 +158,7 @@ async def run_checker_unit_tests(progress: StatusProgress):
 
     console.console.rule('Checker tests', style='info')
 
-    entries = _extract_checker_test_entries(pkg.unitTests.checker)
+    entries = extract_checker_test_entries(pkg.unitTests.checker)
     if not entries:
         console.console.print('No checker unit tests found.')
         return

rbx/grading/caching.py

@@ -371,7 +371,7 @@ class DependencyCache:
         self.transient_db = SqliteDict(str(tmp_dir / '.cache_db'), autocommit=True)
         atexit.register(lambda: self.db.close())
         atexit.register(lambda: self.transient_db.close())
-        atexit.register(lambda: shutil.rmtree(tmp_dir))
+        atexit.register(lambda: shutil.rmtree(tmp_dir, ignore_errors=True))
 
     def _cache_name(self) -> str:
         return str(self.root / '.cache_db')

rbx/grading/judge/cacher.py

@@ -73,7 +73,9 @@ class FileCacher:
             self.file_dir = pathlib.Path(tempfile.mkdtemp())
             # Delete this directory on exit since it has a random name and
             # won't be used again.
-            atexit.register(lambda: shutil.rmtree(str(self.file_dir)))
+            atexit.register(
+                lambda: shutil.rmtree(str(self.file_dir), ignore_errors=True)
+            )
         else:
             assert folder is not None
             self.file_dir = folder / 'fs-cache-shared'
@@ -84,7 +86,7 @@ class FileCacher:
         self.temp_dir = pathlib.Path(
             tempfile.mkdtemp(dir=self.file_dir, prefix='_temp')
         )
-        atexit.register(lambda: shutil.rmtree(str(self.temp_dir)))
+        atexit.register(lambda: shutil.rmtree(str(self.temp_dir), ignore_errors=True))
         # Just to make sure it was created.
 
     def is_shared(self) -> bool:
@@ -526,7 +528,7 @@ class FileCacher:
         """
         if self.is_shared():
             raise Exception('You may not destroy a shared cache.')
-        shutil.rmtree(str(self.file_dir))
+        shutil.rmtree(str(self.file_dir), ignore_errors=True)
 
     def list(self) -> List[storage.FileWithMetadata]:
         """List the files available in the storage.

rbx/grading/judge/program.py

@@ -94,12 +94,40 @@ def get_preexec_fn(params: ProgramParams):
 
 
 def get_memory_usage(ru: resource.struct_rusage) -> int:
+    """Get memory usage in bytes from resource usage statistics.
+
+    Returns the total memory usage (RSS + shared memory segments) in bytes.
+
+    Platform differences in ru.ru_maxrss:
+    - macOS/Darwin: ru.ru_maxrss is in bytes
+    - Linux: ru.ru_maxrss is in kilobytes
+
+    This function normalizes the result to always return bytes.
+
+    Args:
+        ru: Resource usage statistics from os.wait4() or similar
+
+    Returns:
+        int: Total memory usage in bytes
+    """
     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
+        # On macOS, ru.ru_maxrss is already in bytes
+        return ru.ru_maxrss + ru.ru_ixrss * 1024
+    # On Linux, ru.ru_maxrss is in kilobytes, so convert to bytes
+    return (ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss) * 1024
 
 
 def get_cpu_time(ru: resource.struct_rusage) -> float:
+    """Get CPU time in seconds from resource usage statistics.
+
+    Returns the total CPU time (user + system) in seconds.
+
+    Args:
+        ru: Resource usage statistics from os.wait4() or similar
+
+    Returns:
+        float: Total CPU time in seconds
+    """
     return ru.ru_utime + ru.ru_stime
 
 
@@ -239,6 +267,10 @@ class Program:
         ):
             program_codes.append(ProgramCode.WT)
             program_codes.append(ProgramCode.TO)
+        # Memory limit checking: Two ways a process can exceed memory limits:
+        # 1. Runtime monitoring (_handle_alarm) kills the process during execution
+        # 2. Post-execution check using ru.ru_maxrss detects peak memory usage exceeded limit
+        # Both memory_used (from ru.ru_maxrss) and memory_limit (converted to bytes) are in bytes
         if (
             self.params.memory_limit is not None
             and memory_used > self.params.memory_limit * 1024 * 1024

rbx/grading/judge/sandbox.py

@@ -1,6 +1,5 @@
 import abc
 import asyncio
-import collections
 import dataclasses
 import io
 import json
@@ -146,12 +145,6 @@ class SandboxParams(pydantic.BaseModel):
     reverse_io: bool = False
     pgid: Optional[int] = None
 
-    # For timeit
-    timeit_dups: Dict[str, List[pathlib.Path]] = dataclasses.field(
-        default_factory=lambda: collections.defaultdict(list)
-    )
-    timeit_prefix: Optional[str] = None
-
     def get_cacheable_params(self) -> Dict[str, Any]:
         return self.model_dump(mode='json', exclude_unset=True, exclude_none=True)
 

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -5,6 +5,7 @@ import logging
 import os
 import pathlib
 import shutil
+import signal
 import subprocess
 import sys
 import tempfile
@@ -313,7 +314,9 @@ class StupidSandbox(SandboxBase):
                 if should_tee:
                     assert interactor_tee.pipes.output is not None
                     interactor_tee.pipes.output.close()
-                # TODO: kill in case of WA
+
+                if idx == 0 and program_result.exitcode != 0:
+                    os.killpg(group_id, signal.SIGKILL)
             elif pid == program.pid:
                 program_result = program.process_exit(status, ru)
                 results[0] = self._get_sandbox_log(program_result, params)

rbx/grading/judge/storage.py

@@ -277,8 +277,14 @@ class FilesystemStorage(Storage):
             return None
 
         # Create a temporary file in the same directory
+        # Use only the basename for the suffix to avoid issues with subdirectories
+        filename_basename = pathlib.Path(filename).name
         temp_file = tempfile.NamedTemporaryFile(
-            'wb', delete=False, prefix='.tmp.', suffix=filename, dir=self.path
+            'wb',
+            delete=False,
+            prefix='.tmp.',
+            suffix=f'.{filename_basename}',
+            dir=self.path,
         )
         metadata: Dict[str, Optional[BaseModel]] = {'compression': None}
         if self.compress or grading_context.should_compress():

rbx/grading/steps.py

@@ -595,7 +595,7 @@ def _maybe_complain_about_sanitization(command: str) -> None:
         raise typer.Exit(1)
 
 
-def _check_for_sanitizer_warnings_in_line(line: str) -> bool:
+def check_for_sanitizer_warnings_in_line(line: str) -> bool:
     line = line.lower()
     return 'runtime error:' in line or '==error' in line
 
@@ -608,7 +608,7 @@ def _check_for_sanitizer_warnings(
     if not sandbox.file_exists(stderr_file):
         return False
     with sandbox.get_file(stderr_file) as f:
-        return any(_check_for_sanitizer_warnings_in_line(line.decode()) for line in f)
+        return any(check_for_sanitizer_warnings_in_line(line.decode()) for line in f)
 
 
 _WARNING_RE = re.compile(r'([^:]+):\d+:\d+:[ ]+warning:.*')

rbx/utils.py

@@ -103,14 +103,62 @@ 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:
+def model_to_yaml(model: BaseModel, **kwargs) -> str:
+    """Convert model to YAML string with proper boolean handling.
+
+    This function works around Pydantic's issue where Union[str, int, float, bool]
+    fields convert booleans to floats when using mode='json'.
+    """
+    # Use regular dump to preserve boolean types
+    data = model.model_dump(exclude_unset=True, exclude_none=True)
+
+    # Ensure the result is JSON-serializable by converting any non-JSON types
+    json_safe_data = _ensure_json_serializable(data)
+
+    # Add schema path comment and convert to YAML
     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,
-        allow_unicode=True,
+    schema_comment = f'# yaml-language-server: $schema={path}\n\n'
+
+    yaml_content = yaml.safe_dump(
+        json_safe_data, sort_keys=False, allow_unicode=True, **kwargs
     )
 
+    return schema_comment + yaml_content
+
+
+def _ensure_json_serializable(obj):
+    """Recursively ensure an object is JSON-serializable while preserving booleans."""
+    from datetime import date, datetime
+    from enum import Enum
+    from pathlib import Path
+    from uuid import UUID
+
+    from rbx.autoenum import AutoEnum
+
+    if isinstance(obj, dict):
+        return {k: _ensure_json_serializable(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_ensure_json_serializable(item) for item in obj]
+    elif isinstance(obj, tuple):
+        return [_ensure_json_serializable(item) for item in obj]
+    elif isinstance(obj, set):
+        return [_ensure_json_serializable(item) for item in obj]
+    elif isinstance(obj, AutoEnum):
+        return str(obj)
+    elif isinstance(obj, Enum):
+        return obj.value
+    elif isinstance(obj, (str, int, float, bool)) or obj is None:
+        return obj
+    elif isinstance(obj, (datetime, date)):
+        return obj.isoformat()
+    elif isinstance(obj, UUID):
+        return str(obj)
+    elif isinstance(obj, Path):
+        return str(obj)
+    else:
+        # For any other type, try to convert to string
+        return str(obj)
+
 
 def model_from_yaml(model: Type[T], s: str) -> T:
     return model(**yaml.safe_load(s))

{rbx_cp-0.13.5.dist-info → rbx_cp-0.13.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.13.5
+Version: 0.13.6
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9.1,<4.0.0

{rbx_cp-0.13.5.dist-info → rbx_cp-0.13.6.dist-info}/RECORD

@@ -26,7 +26,7 @@ rbx/box/formatting.py,sha256=i3vXHpo_L_VpVPxOe4wHlai1WhlDJlfxUexS9DC0Szg,1249
 rbx/box/generators.py,sha256=Q7xZ0BQVrh4eTwiYgxdpaHJqqZT4_X_YPl-uReZz5tw,16880
 rbx/box/git_utils.py,sha256=VlUgzuHOCnrjjiJQnDB32qDHbHw_zkwgA7wm4bloibc,750
 rbx/box/global_package.py,sha256=YfFGw2vxFspF2v3phBEeBCrLe1sfbANrctGqii3I2X4,2106
-rbx/box/header.py,sha256=68Sd7cnooULXVb2KCWc4Wrt8YrAP4hpOfZbry4A-fp0,2828
+rbx/box/header.py,sha256=OZJD2J0fdIiYyiEAwQ3x3M8TwM1v1J9nhIjnPVz4Zy8,3029
 rbx/box/lang.py,sha256=CSD-yxFUC3LWdGpv4IVFOLdgONc_JbsI45BEN3bjaFw,888
 rbx/box/lazy_importing_main.py,sha256=6Z8As7qVFFT619xHH9Xt8VCH57NjC4aDxfAgkWiUwT8,116
 rbx/box/linting.py,sha256=wRE0hKCduTBHZYBFmmis_d9AMTsDu0Q-AjByCeTnkrY,3187
@@ -79,7 +79,7 @@ rbx/box/testcase_utils.py,sha256=HoDr_RxWpfviLd2oTj_m2wg1e4XaY9LD-QBqx_QjDI0,689
 rbx/box/testcases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rbx/box/testcases/main.py,sha256=_I7h_obRcpNLRQ6dDJDIE5NAvTyn5nBOhdsBhRA_PvU,5442
 rbx/box/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rbx/box/testing/testing_package.py,sha256=kEQn22CwyYK_KbeY6eEG_FeVdQ_Is61Xb1QNdqNYmjY,7947
+rbx/box/testing/testing_package.py,sha256=kzvSbL_4fkjD2l3hfYapyOezLHhhySi9sp4u92MoycY,10121
 rbx/box/testing/testing_preset.py,sha256=7TxfL4fT9JetRMRkQ3Iko99N5gzfKz8_lPM0rkkQx_k,1135
 rbx/box/testing/testing_shared.py,sha256=rX7w5VrCzf4l9zYhq3eFW1iHaWDLU-Xkn5oCjnAavhA,2558
 rbx/box/tooling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -113,29 +113,26 @@ rbx/box/ui/widgets/interaction_box.py,sha256=mJoQjHegxkIL00OgiCULmV0_w-2ZcwsQEa-
 rbx/box/ui/widgets/rich_log_box.py,sha256=mF565c_Y3RYUZ_GJEFj5Eb86SFjsib31wE5qu1K0UBM,91
 rbx/box/ui/widgets/test_output_box.py,sha256=ws7Oa2E8ZABM6Q4ZtL2UQiq59sJzKYPe-STrqhZJI8M,3871
 rbx/box/ui/widgets/two_sided_test_output_box.py,sha256=L-ORiDwd6CP5DFpavrKGBaX0ZHkSoQqbJrGZ4BdFUWc,2289
-rbx/box/unit.py,sha256=oIXbQDidrt-DlDjhM1C-WW2jBr7xjsZrRBO6YXP3sJo,7891
+rbx/box/unit.py,sha256=B1GOt537hOh-E0KAhB7AAgTpcu9UbA8n3JLNlX-2tRg,7887
 rbx/box/validators.py,sha256=z34cUMkuSlCPWnaCqaHqegCxuvmfhAvWlsqSeaduL6s,10580
 rbx/config.py,sha256=Tj0NHSf13fXxbNpif5C4qnaL1k3S-G87OnzuykEAcNQ,8463
 rbx/console.py,sha256=X8EJy68OROgh6ao3ZcUjZm5Y56VFMzen58ywAuQ7pAU,990
 rbx/grading/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rbx/grading/caching.py,sha256=p9ZTz9Y1ZdkcPTIjPH8hEK_LHFtLMWY5z5YIVCkhi3k,16931
+rbx/grading/caching.py,sha256=hasSs10PV4J_3e6b3xc7BDCnUNzT9uwrDZcZ_h_hL1I,16951
 rbx/grading/debug_context.py,sha256=kuAXEI8yRG8xfhS9WKKIRh9X0e5JUD8zvl_cpczJTC8,699
 rbx/grading/grading_context.py,sha256=TaRyLwPkkxvspQIFUFk8Ok0T8EST2pHMMNoVDx9lbFU,3416
 rbx/grading/judge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rbx/grading/judge/cacher.py,sha256=wtRnVE_Es9xcqIgrhn6WzUoB90aihUuKaFyuVsusngg,20323
+rbx/grading/judge/cacher.py,sha256=QiVa74gFUuN4pyw_0hT3qg4oMF0frc1Iu56svpRUa9k,20413
 rbx/grading/judge/digester.py,sha256=gtOIe_iL4PEWA7OKelW1gjSI-nBvbOpDPJGV8VQyjSg,912
-rbx/grading/judge/program.py,sha256=ejjmnAN2evN9FiPsmEUrsDeOvM4uccB_0oyJVaUzWQw,8465
-rbx/grading/judge/sandbox.py,sha256=STsDJH-PEhSJ9hGvwxApHDX7jCAa797FV7hZQBmFOSo,21537
+rbx/grading/judge/program.py,sha256=ttT7X_uLls4ARIbid0MnSteo8Eti1fRw73FL_Ej6S_o,9683
+rbx/grading/judge/sandbox.py,sha256=mcqJscMPhMfjKhxKFkwIP-I4bnQHHMWeBcXiWHGVS-k,21324
 rbx/grading/judge/sandboxes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rbx/grading/judge/sandboxes/stupid_sandbox.py,sha256=Q3UyFiwMpJ36tlU_oesNJ3lTzL4iNVmcWlazA0Yq4r4,11368
+rbx/grading/judge/sandboxes/stupid_sandbox.py,sha256=-fSYt0WNf04rrakhxdrunYlmwO2uM2Pf1HmUX8qfxrI,11458
 rbx/grading/judge/sandboxes/tee.py,sha256=fLulB8fV7k5cO-ikRgURpsETrvr6LoUSjGxFM3GZs5U,672
-rbx/grading/judge/sandboxes/timeit.py,sha256=V4Nu7YAU85jJp2_MtUbh4g8Fx5Wf3hax-4_UTNCorEs,11355
-rbx/grading/judge/storage.py,sha256=T1r3g8NKzF6IpW2K2gCJSBz81NBAQ_j_0cwq58gqZFA,14373
-rbx/grading/judge/test.py,sha256=ll0Iw7zyOpGdKPD_PGH7dvUkb4stQLu-ikbQnqJvuAc,944
+rbx/grading/judge/storage.py,sha256=A88O81-vzv8vMBGrO9gtFk8iB5fTD7ObpO8mvNH4OmA,14576
 rbx/grading/limits.py,sha256=ev312UTOo8S4-3AAVibQdXZclWCxS96CdbZxqW4y1kE,770
-rbx/grading/processing_context.py,sha256=Jg9kNnkH3hi2hiE6Gh23QwS89r9Zj230NMl1CUEHSfo,1866
 rbx/grading/profiling.py,sha256=OEdtoAzjYjLfi-QI5Ke7tLZzJeqvGpMB2utQBNuH3E4,3369
-rbx/grading/steps.py,sha256=PLnuORN-11W9ARSLOrZ0Di30Pl9oSKVfRUGLQoCfeow,26606
+rbx/grading/steps.py,sha256=MkeWH3VfTcwBkKW8Jn5q32ttdJKw0m0_4Cl5rZiL5WI,26604
 rbx/grading/steps_with_caching.py,sha256=RWHtmlEfszKnKM9ADrfbCUZbxZSTD-BiHV3XSiGW8WY,4797
 rbx/providers/__init__.py,sha256=gHXg1BTiXJ_0Z_HoVTZrqhi5IIZ57Dhy0pt7K2ETbA4,1378
 rbx/providers/codeforces.py,sha256=HWQN3Zb9UfXgCfwcNMEk6m1HoXQ-UE2odVfZoPukyCg,2294
@@ -221,9 +218,9 @@ rbx/submitors/__init__.py,sha256=sVcRNnuKMZatmpGkQURaEVHK-MfU2U0nH4nOatuqywE,620
 rbx/submitors/codeforces.py,sha256=s8c7sXfm5k76SKMC8g0Y93-RRf8wY2uWbBtA8ODD5eM,4030
 rbx/submitors/submitor.py,sha256=8q-Hbdahxt30ciT_R9j_xF6lEPUh9IcfAUnzjQjbvHU,457
 rbx/testing_utils.py,sha256=965vlkQpUW8cEqjB6S2g_C_avL5fn503mJPbqjY_zt4,2317
-rbx/utils.py,sha256=8f53t5AdonCi20Xxm3hjBZ8fdg9hNpt0-xUhSTfE7u4,6929
-rbx_cp-0.13.5.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-rbx_cp-0.13.5.dist-info/METADATA,sha256=lKzIg6at_3DbPTYFqMgkGU2FOsrnRTzojlgvS6x6aXk,4659
-rbx_cp-0.13.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-rbx_cp-0.13.5.dist-info/entry_points.txt,sha256=qBTLBOeifT1F00LWaEewRRE_jQPgvH7BUdJfZ-dYsFU,57
-rbx_cp-0.13.5.dist-info/RECORD,,
+rbx/utils.py,sha256=xDqmry5rpqRGPFrx3ipNGBt2WxWDAD5LwU7jvgibXkk,8630
+rbx_cp-0.13.6.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+rbx_cp-0.13.6.dist-info/METADATA,sha256=YRfhn0e29x1tf9DRjJbTE2kL19oQN3gx7Cz1evofaUg,4659
+rbx_cp-0.13.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+rbx_cp-0.13.6.dist-info/entry_points.txt,sha256=qBTLBOeifT1F00LWaEewRRE_jQPgvH7BUdJfZ-dYsFU,57
+rbx_cp-0.13.6.dist-info/RECORD,,

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/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)