rbx.cp 0.13.7__py3-none-any.whl → 0.14.0__py3-none-any.whl

rbx/box/statements/latex_jinja.py

@@ -6,10 +6,11 @@ with Latex.
 import pathlib
 import re
 import typing
-from typing import Any, Dict, Tuple, Union
+from typing import Any, Dict, Optional, Tuple, Union
 
 import jinja2
 import jinja2.runtime
+import rich.pretty
 import typer
 
 from rbx import console
@@ -188,17 +189,62 @@ class StrictChainableUndefined(jinja2.StrictUndefined):
         return self
 
 
+class VarWrapperUndefinedError(jinja2.UndefinedError):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def vars(self) -> Dict[str, Any]:
+        return {}
+
+
 class JinjaDictWrapper(dict):
-    def __init__(self, *args, key='dict object', **kwargs):
+    def __init__(
+        self,
+        *args,
+        key='dict object',
+        prefix='',
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
         self.key = key
-
-    def __getitem__(self, key):
+        self.prefix = prefix
+        self.ancestor_d: Optional[Dict[str, Any]] = None
+
+        slf = self
+
+        class _AccessError(VarWrapperUndefinedError):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+
+            def vars(self) -> Dict[str, Any]:
+                return slf.ancestor_d or slf
+
+        self.exc = _AccessError
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any], wrapper_key: str) -> 'JinjaDictWrapper':
+        res = cls(key=wrapper_key)
+        for key, value in d.items():
+            splits = key.split('.')
+            prefix = ''
+            acc = res
+            for split in splits[:-1]:
+                prefix = f'{prefix}.{split}'.strip('.')
+                if split not in acc or not isinstance(acc[split], dict):
+                    acc[split] = JinjaDictWrapper(key=wrapper_key, prefix=prefix)
+                    acc[split].ancestor_d = res
+                acc = acc[split]
+            acc[splits[-1]] = value
+        return res
+
+    def __getitem__(self, key: str) -> Any:
         try:
             return super().__getitem__(key)
         except KeyError:
+            final_key = f'{self.prefix}.{key}'.strip('.')
             return StrictChainableUndefined(
-                hint=f'"{key}" was not found in "{self.key}"'
+                hint=f'"{final_key}" was not found in "{self.key}"',
+                exc=self.exc,
             )
 
 
@@ -216,6 +262,22 @@ def add_builtin_tests(j2_env: jinja2.Environment):
     j2_env.tests['nonnull'] = test_var_nonnull
 
 
+def _handle_rendering_undefined(
+    err: jinja2.UndefinedError,
+) -> str:
+    console.console.print('[error]Error while rendering Jinja2 template:', end=' ')
+    console.console.print(err)
+    console.console.print(
+        '[warning]This usually happens when accessing an undefined variable.[/warning]'
+    )
+    if isinstance(err, VarWrapperUndefinedError):
+        vars = err.vars()
+        if vars:
+            console.console.print('[warning]Defined variables are[/warning] ', end='')
+            console.console.print(rich.pretty.Pretty(vars))
+    raise typer.Abort() from err
+
+
 def render_latex_template(path_templates, template_filename, template_vars=None) -> str:
     """Render a latex template, filling in its template variables
 
@@ -237,12 +299,8 @@ def render_latex_template(path_templates, template_filename, template_vars=None)
     try:
         return template.render(**var_dict)  # type: ignore
     except jinja2.UndefinedError as err:
-        console.console.print('[error]Error while rendering Jinja2 template:', end=' ')
-        console.console.print(err)
-        console.console.print(
-            '[warning]This usually happens when accessing an undefined variable.[/warning]'
-        )
-        raise typer.Abort() from err
+        _handle_rendering_undefined(err)
+        raise
 
 
 def render_latex_template_blocks(
@@ -269,12 +327,8 @@ def render_latex_template_blocks(
     try:
         return {key: ''.join(value(ctx)) for key, value in template.blocks.items()}
     except jinja2.UndefinedError as err:
-        console.console.print('[error]Error while rendering Jinja2 template:', end=' ')
-        console.console.print(err)
-        console.console.print(
-            '[warning]This usually happens when accessing an undefined variable.[/warning]'
-        )
-        raise typer.Abort() from err
+        _handle_rendering_undefined(err)
+        raise
 
 
 def render_markdown_template_blocks(
@@ -301,9 +355,5 @@ def render_markdown_template_blocks(
     try:
         return {key: ''.join(value(ctx)) for key, value in template.blocks.items()}
     except jinja2.UndefinedError as err:
-        console.console.print('[error]Error while rendering Jinja2 template:', end=' ')
-        console.console.print(err)
-        console.console.print(
-            '[warning]This usually happens when accessing an undefined variable.[/warning]'
-        )
-        raise typer.Abort() from err
+        _handle_rendering_undefined(err)
+        raise

rbx/box/statements/schema.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import pathlib
 from enum import Enum
-from typing import Annotated, Dict, List, Literal, Optional, Union
+from typing import Annotated, List, Literal, Optional, Union
 
 from pydantic import AfterValidator, BaseModel, ConfigDict, Field
 
 from rbx.autoenum import AutoEnum, alias
-from rbx.box.fields import FNameField, Primitive, expand_var
+from rbx.box.fields import FNameField, RecVars, Vars, expand_vars
 from rbx.box.lang import is_valid_lang_code
 
 
@@ -144,9 +144,8 @@ class Statement(BaseModel):
         default=StatementType.rbxTeX, description='Type of the input statement file.'
     )
 
-    steps: List[ConversionStep] = Field(
+    steps: List[Annotated[ConversionStep, Field(discriminator='type')]] = Field(
         default=[],
-        discriminator='type',
         description="""
 Describes a sequence of conversion steps that should be applied to the statement file.
 
@@ -156,9 +155,8 @@ certain conversion steps to happen.
 """,
     )
 
-    configure: List[ConversionStep] = Field(
+    configure: List[Annotated[ConversionStep, Field(discriminator='type')]] = Field(
         default=[],
-        discriminator='type',
         description="""
 Configure how certain conversion steps should happen when applied to the statement file.
 
@@ -176,11 +174,11 @@ their relativeness. Can be glob pattern as well, such as `imgs/*.png`.
 """,
     )
 
-    vars: Dict[str, Primitive] = Field(
+    vars: RecVars = 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()}
+    def expanded_vars(self) -> Vars:
+        return expand_vars(self.vars)

rbx/box/stressing/generator_parser.py

@@ -24,7 +24,7 @@ _expr: var | range | select
 _ticked: "`" _expr "`"
 
 // Variables
-var: "<" CNAME ">"
+var: "<" RECNAME ">"
 
 // Select
 select: "(" select_value ("|" select_value)* ")"
@@ -46,6 +46,8 @@ TEXT: (/[^ \t\f\r\n\[\]\(\)\<\>\|\`]/ | ESCAPED_STRING)+
 // Whitespace
 _WS: WS
 
+RECNAME: /[a-zA-Z0-9_]/+ /(\.[a-zA-Z0-9_])/*
+
 %import common.WS
 %import common.CNAME
 %import common.SIGNED_INT

rbx/box/tasks.py

@@ -1,7 +1,7 @@
 import pathlib
 from typing import Optional
 
-from rbx.box import checkers, package, state
+from rbx.box import checkers, limits_info, package, state
 from rbx.box.code import CommunicationItem, run_communication, run_item
 from rbx.box.environment import EnvironmentSandbox, ExecutionConfig, VerificationLevel
 from rbx.box.retries import Retrier, get_retrier_config
@@ -27,16 +27,16 @@ def get_limits_for_language(
     timelimit_override: Optional[int],
     use_timelimit: bool = True,
 ) -> Limits:
-    pkg = package.find_problem_package_or_die()
-    time = timelimit_override or pkg.timelimit_for_language(lang)
-    isDoubleTL = verification.value >= VerificationLevel.FULL.value
-    memory = pkg.memorylimit_for_language(lang)
-    return Limits(
-        time=time if use_timelimit and time > 0 else None,
-        memory=memory,
-        output=pkg.outputLimit,
-        isDoubleTL=isDoubleTL,
+    limits = limits_info.get_limits(
+        lang,
+        profile=limits_info.get_active_profile() or 'local',
+        verification=verification,
     )
+    if timelimit_override is not None:
+        limits.time = timelimit_override
+    if limits.time is not None and (not use_timelimit or limits.time <= 0):
+        limits.time = None
+    return limits
 
 
 async def run_solution_on_testcase(

rbx/box/testcase_extractors.py

@@ -115,6 +115,7 @@ class GenerationTestcaseEntry(BaseModel):
     metadata: GenerationMetadata
     validator: Optional[CodeItem] = None
     extra_validators: List[CodeItem] = []
+    model_solution: Optional[CodeItem] = None
 
 
 class TestcaseVisitor(abc.ABC):
@@ -151,6 +152,7 @@ async def run_testcase_visitor(visitor: TestcaseVisitor):
         prefix: List[str],
         validator: Optional[CodeItem] = None,
         extra_validators: Optional[List[CodeItem]] = None,
+        model_solution: Optional[CodeItem] = None,
     ):
         extra_validators = extra_validators or []
 
@@ -192,6 +194,7 @@ async def run_testcase_visitor(visitor: TestcaseVisitor):
                     ),
                     validator=validator,
                     extra_validators=extra_validators,
+                    model_solution=model_solution,
                 )
             )
             i += 1
@@ -215,6 +218,7 @@ async def run_testcase_visitor(visitor: TestcaseVisitor):
                         ),
                         validator=validator,
                         extra_validators=extra_validators,
+                        model_solution=model_solution,
                     )
                 )
                 i += 1
@@ -231,6 +235,7 @@ async def run_testcase_visitor(visitor: TestcaseVisitor):
                     ),
                     validator=validator,
                     extra_validators=extra_validators,
+                    model_solution=model_solution,
                 )
             )
             i += 1
@@ -259,6 +264,7 @@ async def run_testcase_visitor(visitor: TestcaseVisitor):
                         ),
                         validator=validator,
                         extra_validators=extra_validators,
+                        model_solution=model_solution,
                     )
                 )
                 i += 1
@@ -278,6 +284,7 @@ async def run_testcase_visitor(visitor: TestcaseVisitor):
             [group.name],
             validator=group_validator,
             extra_validators=extra_validators,
+            model_solution=group.model_solution,
         )
 
         for i, subgroup in enumerate(group.subgroups):
@@ -287,6 +294,7 @@ async def run_testcase_visitor(visitor: TestcaseVisitor):
                 [group.name, subgroup.name],
                 validator=group_validator,
                 extra_validators=extra_validators + subgroup.extraValidators,
+                model_solution=group.model_solution,
             )
 
 

rbx/box/testcase_utils.py

@@ -181,10 +181,10 @@ def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
 
         while line := f.readline().strip():
             if line.startswith(interactor_prefix):
-                stripped = line[len(interactor_prefix) :].strip()
+                stripped = line[len(interactor_prefix) :].rstrip()
                 entries.append(TestcaseInteractionEntry(data=stripped, pipe=0))
             elif line.startswith(solution_prefix):
-                stripped = line[len(solution_prefix) :].strip()
+                stripped = line[len(solution_prefix) :].rstrip()
                 entries.append(TestcaseInteractionEntry(data=stripped, pipe=1))
             else:
                 raise TestcaseInteractionParsingError(
@@ -204,11 +204,11 @@ def get_alternate_interaction_texts(
     solution_entries = []
     for entry in interaction.entries:
         if entry.pipe == 1:
-            solution_entries.append(entry.data)
-            interactor_entries.extend(['\n'] * entry.data.count('\n'))
+            solution_entries.append(entry.data + '\n')
+            interactor_entries.extend(['\n'] * (entry.data.count('\n') + 1))
         else:
-            interactor_entries.append(entry.data)
-            solution_entries.extend(['\n'] * entry.data.count('\n'))
+            interactor_entries.append(entry.data + '\n')
+            solution_entries.extend(['\n'] * (entry.data.count('\n') + 1))
     return ''.join(interactor_entries), ''.join(solution_entries)
 
 
@@ -219,4 +219,4 @@ def print_interaction(interaction: TestcaseInteraction):
             text.stylize('status')
         else:
             text.stylize('info')
-        console.console.print(text, end='')
+        console.console.print(text)

rbx/box/testing/testing_preset.py

@@ -1,7 +1,7 @@
 import pathlib
 
 from rbx import utils
-from rbx.box.presets.schema import Preset
+from rbx.box.presets.schema import Preset, TrackedAsset, Tracking
 from rbx.box.testing.testing_shared import PathOrStr, TestingShared
 
 
@@ -16,13 +16,19 @@ class TestingPreset(TestingShared):
             self.yml_path.touch()
             self.yml_path.write_text(
                 utils.model_to_yaml(
-                    Preset(uri='rsalesc/test-preset', env=pathlib.Path('env.rbx.yml'))
+                    Preset(
+                        name='test-preset',
+                        uri='rsalesc/test-preset',
+                        env=pathlib.Path('env.rbx.yml'),
+                        tracking=Tracking(),  # Explicitly include tracking
+                    )
                 )
             )
             self.add_from_resources(
                 pathlib.Path('env.rbx.yml'), pathlib.Path('presets/default/env.rbx.yml')
             )
 
+    @property
     def yml_path(self) -> pathlib.Path:
         return self.root / 'preset.rbx.yml'
 
@@ -34,3 +40,124 @@ class TestingPreset(TestingShared):
 
     def save(self):
         self.yml_path.write_text(utils.model_to_yaml(self.yml))
+        self._yml = None
+
+    def set_name(self, name: str):
+        """Set the preset name."""
+        self.yml.name = name
+        self.save()
+
+    def set_uri(self, uri: str):
+        """Set the preset URI."""
+        self.yml.uri = uri
+        self.save()
+
+    def set_env(self, env_path: PathOrStr):
+        """Set the environment file path."""
+        self.yml.env = pathlib.Path(env_path)
+        self.save()
+
+    def set_problem_path(self, path: PathOrStr):
+        """Set the problem package path."""
+        self.yml.problem = pathlib.Path(path)
+        self.save()
+
+    def set_contest_path(self, path: PathOrStr):
+        """Set the contest package path."""
+        self.yml.contest = pathlib.Path(path)
+        self.save()
+
+    def add_problem_tracked_asset(self, path: PathOrStr, symlink: bool = False):
+        """Add a tracked asset to the problem tracking list."""
+        # Create a new tracking object with the updated problem list
+        current_tracking = self.yml.tracking
+        new_problem_list = current_tracking.problem + [
+            TrackedAsset(path=pathlib.Path(path), symlink=symlink)
+        ]
+        self.yml.tracking = Tracking(
+            problem=new_problem_list, contest=current_tracking.contest
+        )
+        self.save()
+
+    def add_contest_tracked_asset(self, path: PathOrStr, symlink: bool = False):
+        """Add a tracked asset to the contest tracking list."""
+        # Create a new tracking object with the updated contest list
+        current_tracking = self.yml.tracking
+        new_contest_list = current_tracking.contest + [
+            TrackedAsset(path=pathlib.Path(path), symlink=symlink)
+        ]
+        self.yml.tracking = Tracking(
+            problem=current_tracking.problem, contest=new_contest_list
+        )
+        self.save()
+
+    def create_problem_package(self):
+        """Create a basic problem package structure."""
+        if self.yml.problem:
+            problem_dir = self.root / self.yml.problem
+            problem_dir.mkdir(parents=True, exist_ok=True)
+
+            # Create a basic problem.rbx.yml
+            problem_yml = problem_dir / 'problem.rbx.yml'
+            if not problem_yml.exists():
+                problem_yml.write_text("""---
+name: "test-problem"
+timeLimit: 1000
+memoryLimit: 256
+""")
+
+    def create_contest_package(self):
+        """Create a basic contest package structure."""
+        if self.yml.contest:
+            contest_dir = self.root / self.yml.contest
+            contest_dir.mkdir(parents=True, exist_ok=True)
+
+            # Create a basic contest.rbx.yml
+            contest_yml = contest_dir / 'contest.rbx.yml'
+            if not contest_yml.exists():
+                contest_yml.write_text("""---
+name: "Test Contest"
+duration: 180
+""")
+
+    def create_symlink(self, link_path: PathOrStr, target_path: PathOrStr):
+        """Create a symlink from link_path to target_path relative to the preset root."""
+        link = self.root / link_path
+        target = pathlib.Path(target_path)
+
+        # Ensure parent directory exists
+        link.parent.mkdir(parents=True, exist_ok=True)
+
+        # Remove existing file/symlink if present
+        if link.exists() or link.is_symlink():
+            link.unlink()
+
+        # Create symlink
+        link.symlink_to(target)
+
+    def verify_file_exists(self, path: PathOrStr) -> bool:
+        """Verify that a file exists in the preset."""
+        return (self.root / path).exists()
+
+    def verify_symlink(self, path: PathOrStr, expected_target: PathOrStr) -> bool:
+        """Verify that a symlink exists and points to the expected target."""
+        link = self.root / path
+        if not link.is_symlink():
+            return False
+        return link.readlink() == pathlib.Path(expected_target)
+
+    def get_file_content(self, path: PathOrStr) -> str:
+        """Get the content of a file in the preset."""
+        return (self.root / path).read_text()
+
+    def get_problem_dir(self) -> pathlib.Path:
+        """Get the problem package directory."""
+        if not self.yml.problem:
+            raise ValueError('No problem package defined in preset')
+        return self.root / self.yml.problem
+
+    def get_contest_dir(self) -> pathlib.Path:
+        """Get the contest package directory."""
+        if not self.yml.contest:
+            raise ValueError('No contest package defined in preset')
+        return self.root / self.yml.contest

rbx/box/testing/testing_shared.py

@@ -28,7 +28,9 @@ class TestingShared:
             os.chdir(self._old_cwd)
         self.cleanup()
 
-    def path(self, path: PathOrStr) -> pathlib.Path:
+    def path(self, path: Optional[PathOrStr] = None) -> pathlib.Path:
+        if path is None:
+            return self.root
         return self.root / path
 
     def abspath(self, path: PathOrStr) -> pathlib.Path: