rbx.cp 0.13.5__tar.gz → 0.13.6__tar.gz

{rbx_cp-0.13.5 → rbx_cp-0.13.6}/PKG-INFO

@@ -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 → rbx_cp-0.13.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.13.5"
+version = "0.13.6"
 description = ""
 packages = [
   {include = "rbx"}

{rbx_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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_cp-0.13.5 → rbx_cp-0.13.6}/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))