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

rbx/box/header.py

@@ -1,11 +1,12 @@
 import functools
 import importlib
 import importlib.resources
+import json
 import pathlib
 from typing import Callable, Dict, Type
 
 from rbx.box import package
-from rbx.box.schema import Primitive
+from rbx.box.fields import Primitive
 
 
 @functools.cache
@@ -40,12 +41,33 @@ def _preprocess_header(header: str) -> str:
     )
 
 
+def _string_repr(s):
+    return json.dumps(s)
+
+
 def _get_string_var_block() -> str:
-    return _get_var_block(_get_vars_of_type(str, lambda x: f'{x:!r}'))
+    return _get_var_block(_get_vars_of_type(str, _string_repr))
+
+
+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)'
+        )
+    if x < -(2**63):
+        raise ValueError(
+            f'Some variable you defined (value: {x}) is too small to fit in a C++ 64-bit signed integer (int64_t)'
+        )
 
 
 def _get_int_var_block() -> str:
-    return _get_var_block(_get_vars_of_type(int, lambda x: str(x)))
+    def _transform(x: Primitive) -> str:
+        if isinstance(x, bool):
+            return str(int(x))
+        _check_int_bounds(int(x))
+        return f'static_cast<int64_t>({x})'
+
+    return _get_var_block(_get_vars_of_type(int, _transform))
 
 
 def _get_float_var_block() -> str:
@@ -56,16 +78,14 @@ def _get_bool_var_block() -> str:
     return _get_var_block(_get_vars_of_type(bool, lambda x: 'true' if x else 'false'))
 
 
-def _get_vars_of_type(
-    type: Type, transform: Callable[[Primitive], str]
-) -> Dict[str, 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
-    return {
-        name: transform(value)
-        for name, value in vars.items()
-        if isinstance(value, type)
-    }
+
+    def is_valid(value: Primitive) -> bool:
+        return isinstance(value, t)
+
+    return {name: transform(value) for name, value in vars.items() if is_valid(value)}
 
 
 def _get_var_block(mappings: Dict[str, str]) -> str:

rbx/box/package.py

@@ -1,8 +1,6 @@
 import atexit
 import functools
-import os
 import pathlib
-import shutil
 import sys
 from typing import Dict, List, Optional, Tuple
 
@@ -181,8 +179,10 @@ def get_file_cacher(root: pathlib.Path = pathlib.Path()) -> FileCacher:
 
 @functools.cache
 def get_digest_as_string(
-    digest: str, root: pathlib.Path = pathlib.Path()
+    digest: Optional[str], root: pathlib.Path = pathlib.Path()
 ) -> Optional[str]:
+    if not digest:
+        return None
     cacher = get_file_cacher(root)
     try:
         content = cacher.get_file_content(digest)
@@ -453,18 +453,6 @@ def get_empty_sentinel_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path
     return path
 
 
-@functools.cache
-def get_fifos(root: pathlib.Path = pathlib.Path()) -> Tuple[pathlib.Path, pathlib.Path]:
-    path = get_shared_dir(root) / '.fifos'
-    shutil.rmtree(path, ignore_errors=True)
-    path.mkdir(parents=True, exist_ok=True)
-    fifo_in = path / 'fifo.in'
-    fifo_out = path / 'fifo.out'
-    os.mkfifo(fifo_in)
-    os.mkfifo(fifo_out)
-    return fifo_in, fifo_out
-
-
 @functools.cache
 def get_merged_capture_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     path = get_shared_dir(root) / '.merged_capture'

rbx/box/presets/__init__.py

@@ -339,9 +339,9 @@ def _copy_preset_file(
 
     # The symlink points somewhere inside the preset folder, fix the symlink.
     dst_absolute_path = utils.abspath(dst)
-    fixed_target_relative_path = target_absolute_path.relative_to(
+    fixed_target_relative_path = utils.relpath(
+        target_absolute_path,
         dst_absolute_path.parent,
-        walk_up=True,
     )
     dst.symlink_to(fixed_target_relative_path)
 

rbx/box/schema.py

@@ -3,19 +3,17 @@ from __future__ import annotations
 import os
 import pathlib
 import re
-from typing import Annotated, Any, Dict, List, Optional, Union
+from typing import Annotated, Any, Dict, List, Optional
 
 from pydantic import AfterValidator, BaseModel, ConfigDict, Field, model_validator
 from pydantic_core import PydanticCustomError
 
 from rbx.autoenum import AutoEnum, alias
-from rbx.box.fields import NameField
+from rbx.box.fields import NameField, Primitive, expand_vars
 from rbx.box.statements.expander import expand_statements
 from rbx.box.statements.schema import Statement
 from rbx.grading.steps import Outcome
 
-Primitive = Union[str, int, float, bool]
-
 
 def _check_oneof(model_obj: BaseModel, fields: List[str]):
     has = []
@@ -30,27 +28,6 @@ def _check_oneof(model_obj: BaseModel, fields: List[str]):
     )
 
 
-def expand_var(value: Primitive) -> Primitive:
-    if not isinstance(value, str):
-        return value
-    if value.startswith('\\'):
-        return value[1:]
-    if not value.startswith('py`') or not value.endswith('`'):
-        return value
-    res = eval(value[3:-1])
-    for supported_type in [str, int, float, bool]:
-        if isinstance(res, supported_type):
-            return res
-
-    raise TypeError(
-        f'Variable with backticks should evaluate to a primitive Python type: {value}'
-    )
-
-
-def expand_vars(vars: Dict[str, Primitive]) -> Dict[str, Primitive]:
-    return {key: expand_var(value) for key, value in vars.items()}
-
-
 def _represents_int(s: str) -> bool:
     return re.match(r'[-+]?\d+$', s.strip()) is not None
 
@@ -245,6 +222,8 @@ Whether this interactor is a legacy interactor and needs a checker to be specifi
 
 
 class Testcase(BaseModel):
+    __test__ = False
+
     model_config = ConfigDict(extra='forbid')
 
     inputPath: pathlib.Path = Field(description="""The path of the input file.""")

rbx/box/setter_config.py

@@ -66,6 +66,13 @@ class CachingConfig(BaseModel):
     )
 
 
+class JudgingConfig(BaseModel):
+    check_stack: bool = Field(
+        default=True,
+        description='Whether to check the stack size before running code.',
+    )
+
+
 class SetterConfig(BaseModel):
     sanitizers: SanitizersConfig = Field(
         default_factory=SanitizersConfig,  # type: ignore
@@ -93,6 +100,10 @@ class SetterConfig(BaseModel):
         default_factory=CachingConfig,  # type: ignore
         description='Configuration for caching.',
     )
+    judging: JudgingConfig = Field(
+        default_factory=JudgingConfig,  # type: ignore
+        description='Configuration for judging.',
+    )
 
     def substitute_command(self, command: str, sanitized: bool = False) -> str:
         exe = shlex.split(command)[0]

rbx/box/solutions.py

@@ -922,6 +922,12 @@ def get_worst_outcome(evals: List[Evaluation]) -> Outcome:
     return Outcome.worst_outcome(eval.result.outcome for eval in evals)
 
 
+def get_truncated_message(message: str, max_length: int = 100) -> str:
+    if len(message) > max_length:
+        return message[:max_length] + '... (truncated)'
+    return message
+
+
 class SolutionOutcomeReport(BaseModel):
     solution: Solution
     evals: List[Evaluation]
@@ -971,9 +977,8 @@ class SolutionOutcomeReport(BaseModel):
         if print_message and self.message is not None:
             tc, msg = self.message
             if msg:
-                if len(msg) > 100:
-                    msg = msg[:100] + '... (truncated)'
-                res += f'\nMessage for {tc}: {msg}'
+                msg = get_truncated_message(msg)
+                res += f'\nMessage for {utils.escape_markup(str(tc))}: {utils.escape_markup(msg)}'
         return res
 
 
@@ -1471,7 +1476,10 @@ async def print_run_report(
                     console.print(f' ({time}, {memory})', end='')
                     checker_msg = eval.result.message
                     if checker_msg:
-                        console.print(f': [i]{checker_msg}[/i]', end='')
+                        checker_msg = get_truncated_message(checker_msg, 150)
+                        console.print(
+                            f': [i]{utils.escape_markup(checker_msg)}[/i]', end=''
+                        )
                 else:
                     console.print(f'{i}/', end='')
                     console.print(get_testcase_markup_verdict(eval), end='')

rbx/box/statements/build_statements.py

@@ -262,7 +262,6 @@ def build_statement_bytes(
                     languages=get_environment_languages_for_statement(),
                     params=params,
                     root=pathlib.Path(td),
-                    custom_vars=custom_vars,
                 ),
                 item=StatementBuilderProblem(
                     package=pkg,
@@ -271,6 +270,11 @@ def build_statement_bytes(
                         get_samples() if use_samples else []
                     ),
                     short_name=short_name,
+                    vars={
+                        **pkg.expanded_vars,
+                        **statement.expanded_vars,
+                        **(custom_vars or {}),
+                    },
                 ),
                 verbose=False,
             )

rbx/box/statements/builders.py

@@ -11,7 +11,8 @@ import typer
 from pydantic import BaseModel
 
 from rbx import console, utils
-from rbx.box.schema import Package, Primitive, Testcase
+from rbx.box.fields import Primitive
+from rbx.box.schema import Package, Testcase
 from rbx.box.statements.latex_jinja import (
     JinjaDictWrapper,
     render_latex_template,
@@ -48,8 +49,6 @@ class StatementBuilderContext:
     languages: List[StatementCodeLanguage]
     params: ConversionStep
     root: pathlib.Path
-    custom_vars: Optional[Dict[str, Any]] = None
-    vars: Optional[Dict[str, Primitive]] = None
 
     def build_jinja_kwargs(self) -> Dict[str, Any]:
         res = {
@@ -57,9 +56,6 @@ class StatementBuilderContext:
             'languages': self.languages,
             'keyed_languages': {lang.id: lang for lang in self.languages},
         }
-        if self.vars is not None or self.custom_vars is not None:
-            res['vars'] = self.vars or {}
-            res['vars'].update(self.custom_vars or {})
         return res
 
 
@@ -125,12 +121,14 @@ class StatementBuilderProblem(StatementBuilderItem):
     # Will only be filled by contests.
     io_path: Optional[pathlib.Path] = None
 
+    vars: Optional[Dict[str, Primitive]] = None
+
     def build_inner_jinja_kwargs(self) -> Dict[str, Any]:
         kwargs = {
             'package': self.package,
             'statement': self.statement,
             'samples': self.samples,
-            'vars': JinjaDictWrapper(self.package.expanded_vars, key='vars'),
+            'vars': JinjaDictWrapper(self.vars or {}, key='vars'),
             'title': self.statement.title or self.package.name,
         }
         if self.short_name is not None:
@@ -152,6 +150,7 @@ class StatementBuilderContest(StatementBuilderItem):
     location: Optional[str] = None
     date: Optional[str] = None
     problems: List[StatementBuilderProblem] = dataclasses.field(default_factory=list)
+    vars: Optional[Dict[str, Primitive]] = None
 
     def build_inner_jinja_kwargs(self) -> Dict[str, Any]:
         res = {'title': self.title}
@@ -167,6 +166,7 @@ class StatementBuilderContest(StatementBuilderItem):
             'problems': [
                 problem.build_inner_jinja_kwargs() for problem in self.problems
             ],
+            'vars': JinjaDictWrapper(self.vars or {}, key='vars'),
         }
         return res
 

rbx/box/statements/schema.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import pathlib
 from enum import Enum
-from typing import Annotated, List, Literal, Optional, Union
+from typing import Annotated, Dict, List, Literal, Optional, Union
 
 from pydantic import AfterValidator, BaseModel, ConfigDict, Field
 
 from rbx.autoenum import AutoEnum, alias
-from rbx.box.fields import FNameField
+from rbx.box.fields import FNameField, Primitive, expand_var
 from rbx.box.lang import is_valid_lang_code
 
 
@@ -175,3 +175,12 @@ 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`.
 """,
     )
+
+    vars: Dict[str, Primitive] = Field(
+        default={},
+        description='Variables to be used in the statement.',
+    )
+
+    @property
+    def expanded_vars(self) -> Dict[str, Primitive]:
+        return {key: expand_var(value) for key, value in self.vars.items()}

rbx/box/tasks.py

@@ -51,7 +51,7 @@ async def run_solution_on_testcase(
     timelimit_override: Optional[int] = None,
     use_retries: bool = True,
     use_timelimit: bool = True,
-    capture_pipes: bool = False,
+    capture_pipes: Optional[bool] = None,
     nruns: int = 0,
     filestem: Optional[str] = None,
     is_stress: bool = False,
@@ -175,12 +175,13 @@ async def _run_communication_solution_on_testcase(
     timelimit_override: Optional[int] = None,
     use_retries: bool = True,
     use_timelimit: bool = True,
-    capture_pipes: bool = False,
+    capture_pipes: Optional[bool] = None,
     nruns: int = 0,
     filestem: Optional[str] = None,
     is_stress: bool = False,
 ) -> Evaluation:
-    capture_pipes = capture_pipes or state.STATE.debug_logs
+    if capture_pipes is None:
+        capture_pipes = state.STATE.debug_logs
 
     async def run_fn(retry_index: int) -> Evaluation:
         actual_sandbox = package.get_singleton_sandbox()
@@ -243,6 +244,7 @@ async def _run_communication_solution_on_testcase(
             capture=DigestOrDest.create(interactor_capture_path)
             if interactor_capture_path
             else None,
+            file_prefix='interactor',
         )
         solution_capture_path = (
             output_path.with_suffix('.pout') if capture_pipes else None
@@ -255,6 +257,7 @@ async def _run_communication_solution_on_testcase(
             capture=DigestOrDest.create(solution_capture_path)
             if solution_capture_path
             else None,
+            file_prefix='solution',
         )
 
         merged_capture_path = output_path.with_suffix('.pio') if capture_pipes else None
@@ -262,7 +265,9 @@ async def _run_communication_solution_on_testcase(
             interactor=interactor_item,
             solution=solution_item,
             retry_index=retry_index,
-            merged_capture=merged_capture_path,
+            merged_capture=DigestOrDest.create(merged_capture_path)
+            if merged_capture_path
+            else None,
         )
 
         checker_result = await checkers.check_communication(

rbx/box/testcase_utils.py

@@ -14,6 +14,8 @@ from rbx.box.schema import Testcase, TestcaseGroup
 
 
 class TestcaseEntry(BaseModel):
+    __test__ = False
+
     group: str
     index: int
 

rbx/box/testing/testing_package.py

@@ -0,0 +1,246 @@
+import pathlib
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from rbx import console, utils
+from rbx.box import presets
+from rbx.box.fields import Primitive
+from rbx.box.schema import (
+    CodeItem,
+    ExpectedOutcome,
+    Generator,
+    Interactor,
+    Package,
+    Solution,
+    TaskType,
+    TestcaseGroup,
+)
+from rbx.box.testing.testing_preset import TestingPreset
+from rbx.box.testing.testing_shared import PathOrStr, TestingShared
+from rbx.grading.steps import Evaluation
+from rbx.testing_utils import print_directory_tree
+
+
+@dataclass
+class TestcaseArtifacts:
+    output: Optional[str] = None
+    log: Optional[Evaluation] = None
+    interactor_input: Optional[str] = None
+    interactor_output: Optional[str] = None
+    interactor_pipes: Optional[str] = None
+
+
+class TestingPackage(TestingShared):
+    def __init__(self, root: PathOrStr):
+        super().__init__(root)
+        self._yml = None
+
+        self.initialize()
+        self.preset = self.initialize_preset()
+
+    @property
+    def yml_path(self) -> pathlib.Path:
+        return self.root / 'problem.rbx.yml'
+
+    def initialize(self):
+        if not self.yml_path.exists():
+            self.yml_path.parent.mkdir(parents=True, exist_ok=True)
+            self.yml_path.touch()
+            self.yml_path.write_text(
+                utils.model_to_yaml(
+                    Package(name='test-problem', timeLimit=1000, memoryLimit=256)
+                )
+            )
+
+    def initialize_preset(self) -> TestingPreset:
+        preset = presets.get_active_preset_or_null(self.root)
+        if preset is None:
+            preset_path = self.root / '.local.rbx'
+            preset_path.mkdir(parents=True, exist_ok=True)
+        else:
+            preset_path = presets.get_active_preset_path(self.root)
+        return TestingPreset(preset_path)
+
+    def print_tree(self):
+        print_directory_tree(self.root)
+
+    def print_yml(self):
+        console.console.print(self.yml_path.read_text(), highlight=True)
+
+    def print_debug(self):
+        self.print_yml()
+        self.print_tree()
+
+    @property
+    def yml(self) -> Package:
+        if self._yml is None:
+            self._yml = utils.model_from_yaml(Package, self.yml_path.read_text())
+        return self._yml
+
+    def save(self):
+        self.yml_path.write_text(utils.model_to_yaml(self.yml))
+
+    def set_type(self, type: TaskType):
+        self.yml.type = type
+        self.save()
+
+    def add_solution(
+        self,
+        path: PathOrStr,
+        outcome: ExpectedOutcome,
+        language: Optional[str] = None,
+    ):
+        self.yml.solutions = self.yml.solutions + [
+            Solution(path=pathlib.Path(path), language=language, outcome=outcome)
+        ]
+        self.save()
+        return self.add_file(path)
+
+    def add_generator(
+        self,
+        path: PathOrStr,
+        language: Optional[str] = None,
+        alias: Optional[str] = None,
+        src: Optional[PathOrStr] = None,
+    ):
+        if alias is not None:
+            self.yml.generators = self.yml.generators + [
+                Generator(path=pathlib.Path(path), language=language, name=alias)
+            ]
+        self.save()
+        return self.add_file(path, src=src)
+
+    def set_validator(
+        self,
+        path: PathOrStr,
+        language: Optional[str] = None,
+        src: Optional[PathOrStr] = None,
+    ):
+        self.yml.validator = CodeItem(path=pathlib.Path(path), language=language)
+        self.save()
+        return self.add_file(path, src=src)
+
+    def set_checker(
+        self,
+        path: PathOrStr,
+        language: Optional[str] = None,
+        src: Optional[PathOrStr] = None,
+    ):
+        self.yml.checker = CodeItem(path=pathlib.Path(path), language=language)
+        self.save()
+        return self.add_file(path, src=src)
+
+    def set_interactor(
+        self,
+        path: PathOrStr,
+        language: Optional[str] = None,
+        src: Optional[PathOrStr] = None,
+    ):
+        self.yml.interactor = Interactor(path=pathlib.Path(path), language=language)
+        self.save()
+        return self.add_file(path, src=src)
+
+    def set_var(self, name: str, value: Primitive):
+        self.yml.vars[name] = value
+        self.save()
+
+    def set_vars(self, vars: Dict[str, Primitive]):
+        self.yml.vars = vars
+        self.save()
+
+    def add_testplan(self, name: str, src: Optional[PathOrStr] = None):
+        path = self.add_file(pathlib.Path('testplan') / f'{name}.txt', src)
+        return path
+
+    def add_testscript(self, name: str, src: Optional[PathOrStr] = None):
+        path = self.add_file(pathlib.Path('testplan') / f'{name}.py', src)
+        return path
+
+    def add_testgroup_from_glob(
+        self,
+        name: str,
+        glob: str,
+        validator: Optional[PathOrStr] = None,
+        extra_validators: Optional[List[PathOrStr]] = None,
+    ):
+        self.yml.testcases = self.yml.testcases + [
+            TestcaseGroup(
+                name=name,
+                testcaseGlob=glob,
+                validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+                extraValidators=[
+                    CodeItem(path=pathlib.Path(v)) for v in extra_validators
+                ]
+                if extra_validators
+                else [],
+            )
+        ]
+        self.save()
+
+    def add_testgroup_from_plan(
+        self,
+        name: str,
+        plan: str,
+        validator: Optional[PathOrStr] = None,
+        extra_validators: Optional[List[PathOrStr]] = None,
+    ):
+        plan_path = self.add_testplan(name)
+        plan_path.write_text(plan)
+        self.yml.testcases = self.yml.testcases + [
+            TestcaseGroup(
+                name=name,
+                generatorScript=CodeItem(path=plan_path),
+                validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+                extraValidators=[
+                    CodeItem(path=pathlib.Path(v)) for v in extra_validators
+                ]
+                if extra_validators
+                else [],
+            )
+        ]
+        self.save()
+
+    def add_testgroup_from_script(
+        self,
+        name: str,
+        script: str,
+        validator: Optional[PathOrStr] = None,
+        extra_validators: Optional[List[PathOrStr]] = None,
+    ):
+        script_path = self.add_testscript(name)
+        script_path.write_text(script)
+        self.yml.testcases = self.yml.testcases + [
+            TestcaseGroup(
+                name=name,
+                generatorScript=CodeItem(path=script_path),
+                validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+                extraValidators=[
+                    CodeItem(path=pathlib.Path(v)) for v in extra_validators
+                ]
+                if extra_validators
+                else [],
+            )
+        ]
+        self.save()
+
+    def get_build_testgroup_path(self, name: str) -> pathlib.Path:
+        return self.root / 'build' / 'tests' / name
+
+    def get_testcase_contents(self, path: pathlib.Path) -> TestcaseArtifacts:
+        contents = TestcaseArtifacts()
+        output_path = path.with_suffix('.out')
+        if output_path.exists():
+            contents.output = output_path.read_text()
+        log_path = path.with_suffix('.log')
+        if log_path.exists():
+            contents.log = Evaluation.model_validate_json(log_path.read_text())
+        interactor_input_path = path.with_suffix('.pin')
+        if interactor_input_path.exists():
+            contents.interactor_input = interactor_input_path.read_text()
+        interactor_output_path = path.with_suffix('.pout')
+        if interactor_output_path.exists():
+            contents.interactor_output = interactor_output_path.read_text()
+        interactor_pipes_path = path.with_suffix('.pio')
+        if interactor_pipes_path.exists():
+            contents.interactor_pipes = interactor_pipes_path.read_text()
+        return contents