rbx.cp 0.5.73__py3-none-any.whl → 0.6.0__py3-none-any.whl

rbx/box/schema.py

@@ -2,30 +2,21 @@ from __future__ import annotations
 
 import os
 import pathlib
-from typing import Dict, List, Optional, Union
+import re
+from typing import Annotated, Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+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 FNameField, NameField
+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 NameField(**kwargs):
-    return Field(
-        pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]*$', min_length=3, max_length=32, **kwargs
-    )
-
-
-def FNameField(**kwargs):
-    return Field(
-        pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]*$', min_length=3, max_length=128, **kwargs
-    )
-
-
 def _check_oneof(model_obj: BaseModel, fields: List[str]):
     has = []
     for field in fields:
@@ -56,6 +47,44 @@ def expand_var(value: Primitive) -> Primitive:
     )
 
 
+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
+
+
+def _represents_float(s: str) -> bool:
+    return re.match(r'[-+]?\d+\.\d+$', s.strip()) is not None
+
+
+def _represents_bool(s: str) -> bool:
+    return s.lower().strip() in ['true', 'false', 'True', 'False']
+
+
+def convert_to_primitive(value: Any) -> Primitive:
+    if _represents_int(value):
+        return int(value)
+    if _represents_float(value):
+        return float(value)
+    if _represents_bool(value):
+        return value.lower().strip() == 'true'
+    return str(value)
+
+
+def expand_any_vars(vars: Dict[str, Any]) -> Dict[str, Primitive]:
+    converted_vars = {key: convert_to_primitive(value) for key, value in vars.items()}
+    return expand_vars(converted_vars)
+
+
+def is_unique_by_name(statements: List['Statement']) -> List['Statement']:
+    names = {st.name for st in statements}
+    if len(names) != len(statements):
+        raise ValueError('Statement names must be unique.')
+    return statements
+
+
 class ExpectedOutcome(AutoEnum):
     ANY = alias('any')  # type: ignore
     """Expected outcome for any outcome."""
@@ -459,9 +488,10 @@ that is correct and used as reference -- and should have the `accepted` outcome.
         default=[], description='Stress tests for the problem.'
     )
 
-    statements: List[Statement] = Field(
-        default=[], description='Statements for the problem.'
-    )
+    statements: Annotated[
+        List[Statement],
+        AfterValidator(is_unique_by_name),
+    ] = Field(default=[], description='Statements for the problem.')
 
     # Vars to be re-used across the package.
     #   - It will be passed as --key=value arguments to the validator.
@@ -475,9 +505,13 @@ that is correct and used as reference -- and should have the `accepted` outcome.
         description='Unit tests for components of this problem.',
     )
 
+    @property
+    def expanded_statements(self) -> List[Statement]:
+        return expand_statements(self.statements)
+
     @property
     def expanded_vars(self) -> Dict[str, Primitive]:
-        return {key: expand_var(value) for key, value in self.vars.items()}
+        return expand_vars(self.vars)
 
     def timelimit_for_language(self, language: Optional[str]) -> int:
         res = self.timeLimit
@@ -525,3 +559,19 @@ that is correct and used as reference -- and should have the `accepted` outcome.
                     {'i': i + 1},
                 )
         return self
+
+    @model_validator(mode='after')
+    def check_checker_and_interactor_for_task_type(self):
+        if self.type == TaskType.BATCH:
+            if self.interactor is not None:
+                raise PydanticCustomError(
+                    'INTERACTOR_NOT_ALLOWED',
+                    'Interactor is not allowed for batch problems. Change the task type to COMMUNICATION.',
+                )
+        if self.type == TaskType.COMMUNICATION:
+            if self.checker is not None:
+                raise PydanticCustomError(
+                    'CHECKER_NOT_ALLOWED',
+                    'Checkers should not be specified for communication problems.',
+                )
+        return self

rbx/box/solutions.py

@@ -48,6 +48,7 @@ from rbx.box.tasks import (
 from rbx.box.testcase_extractors import extract_generation_testcases
 from rbx.box.testcase_utils import (
     TestcaseEntry,
+    TestcaseInteractionParsingError,
     find_built_testcases,
     parse_interaction,
     print_interaction,
@@ -374,7 +375,11 @@ def print_best_output(output_files: List[pathlib.Path], empty_warning: bool = Fa
         if not output_file.is_file():
             continue
         if output_file.suffix == '.pio':
-            print_interaction(parse_interaction(output_file))
+            try:
+                print_interaction(parse_interaction(output_file))
+            except TestcaseInteractionParsingError:
+                # Ignore parsing errors and proceed to next file.
+                continue
         else:
             console.console.print(output_file.read_text())
         return

rbx/box/statements/build_statements.py

@@ -1,7 +1,7 @@
 import pathlib
 import tempfile
 import typing
-from typing import Annotated, Dict, List, Optional, Tuple
+from typing import Annotated, Any, Dict, List, Optional, Tuple
 
 import syncer
 import typer
@@ -9,7 +9,7 @@ import typer
 from rbx import annotations, console
 from rbx.box import environment, naming, package
 from rbx.box.formatting import href
-from rbx.box.schema import Package
+from rbx.box.schema import Package, expand_any_vars
 from rbx.box.statements.builders import (
     BUILDER_LIST,
     PROBLEM_BUILDER_LIST,
@@ -217,7 +217,7 @@ def build_statement_bytes(
     overridden_params: Optional[Dict[ConversionType, ConversionStep]] = None,
     overridden_assets: Optional[List[Tuple[pathlib.Path, pathlib.Path]]] = None,
     use_samples: bool = True,
-    is_editorial: bool = False,
+    custom_vars: Optional[Dict[str, Any]] = None,
 ) -> Tuple[bytes, StatementType]:
     overridden_params = overridden_params or {}
     overridden_assets = overridden_assets or []
@@ -258,10 +258,11 @@ def build_statement_bytes(
             output = bdr.build(
                 input=last_content,
                 context=StatementBuilderContext(
+                    lang=statement.language,
                     languages=get_environment_languages_for_statement(),
                     params=params,
                     root=pathlib.Path(td),
-                    editorial=is_editorial,
+                    custom_vars=custom_vars,
                 ),
                 item=StatementBuilderProblem(
                     package=pkg,
@@ -284,24 +285,23 @@ def build_statement(
     pkg: Package,
     output_type: Optional[StatementType] = None,
     use_samples: bool = True,
-    is_editorial: bool = False,
+    custom_vars: Optional[Dict[str, Any]] = None,
 ) -> pathlib.Path:
     last_content, last_output = build_statement_bytes(
         statement,
         pkg,
         output_type=output_type,
         use_samples=use_samples,
-        is_editorial=is_editorial,
+        custom_vars=custom_vars,
         short_name=naming.get_problem_shortname(),
     )
-    statement_path = (
-        package.get_build_path()
-        / f'{statement.path.stem}{last_output.get_file_suffix()}'
+    statement_path = (package.get_build_path() / statement.name).with_suffix(
+        last_output.get_file_suffix()
     )
     statement_path.parent.mkdir(parents=True, exist_ok=True)
     statement_path.write_bytes(last_content)
     console.console.print(
-        f'Statement built successfully for language '
+        f'Statement [item]{statement.name}[/item] built successfully for language '
         f'[item]{statement.language}[/item] at '
         f'{href(statement_path)}'
     )
@@ -313,13 +313,18 @@ def build_statement(
 @syncer.sync
 async def build(
     verification: environment.VerificationParam,
+    names: Annotated[
+        Optional[List[str]],
+        typer.Argument(
+            help='Names of statements to build.',
+        ),
+    ] = None,
     languages: Annotated[
         Optional[List[str]],
         typer.Option(
-            default_factory=list,
             help='Languages to build statements for. If not specified, build statements for all available languages.',
         ),
-    ],
+    ] = None,
     output: Annotated[
         Optional[StatementType],
         typer.Option(
@@ -331,9 +336,14 @@ async def build(
         bool,
         typer.Option(help='Whether to build the statement with samples or not.'),
     ] = True,
-    editorial: Annotated[
-        bool, typer.Option(help='Whether to add editorial blocks to the statements.')
-    ] = False,
+    vars: Annotated[
+        Optional[List[str]],
+        typer.Option(
+            '-v',
+            '--vars',
+            help='Variables to be used in the statements.',
+        ),
+    ] = None,
 ):
     # At most run the validators, only in samples.
     if samples:
@@ -350,24 +360,31 @@ async def build(
             raise typer.Exit(1)
 
     pkg = package.find_problem_package_or_die()
-    candidate_languages = languages
-    if not candidate_languages:
-        candidate_languages = sorted(set([st.language for st in pkg.statements]))
+    candidate_languages = set(languages or [])
+    candidate_names = set(names or [])
 
-    for language in candidate_languages:
-        candidates_for_lang = [st for st in pkg.statements if st.language == language]
-        if not candidates_for_lang:
-            console.console.print(
-                f'[error]No statement found for language [item]{language}[/item].[/error]',
-            )
-            raise typer.Exit(1)
+    def should_process(st: Statement) -> bool:
+        if candidate_languages and st.language not in candidate_languages:
+            return False
+        if candidate_names and st.name not in candidate_names:
+            return False
+        return True
+
+    valid_statements = [st for st in pkg.expanded_statements if should_process(st)]
+
+    if not valid_statements:
+        console.console.print(
+            '[error]No statement found according to the specified criteria.[/error]',
+        )
+        raise typer.Exit(1)
 
+    for statement in valid_statements:
         build_statement(
-            candidates_for_lang[0],
+            statement,
             pkg,
             output_type=output,
             use_samples=samples,
-            is_editorial=editorial,
+            custom_vars=expand_any_vars(annotations.parse_dictionary_items(vars)),
         )
 
 

rbx/box/statements/builders.py

@@ -25,7 +25,11 @@ from rbx.box.statements.schema import (
     TexToPDF,
     rbxToTeX,
 )
-from rbx.box.testcase_utils import TestcaseInteraction, parse_interaction
+from rbx.box.testcase_utils import (
+    TestcaseInteraction,
+    TestcaseInteractionParsingError,
+    parse_interaction,
+)
 
 
 @dataclasses.dataclass
@@ -37,20 +41,22 @@ class StatementCodeLanguage:
 
 @dataclasses.dataclass
 class StatementBuilderContext:
+    lang: str
     languages: List[StatementCodeLanguage]
     params: ConversionStep
     root: pathlib.Path
-    editorial: bool
+    custom_vars: Optional[Dict[str, Any]] = None
     vars: Optional[Dict[str, Primitive]] = None
 
     def build_jinja_kwargs(self) -> Dict[str, Any]:
         res = {
+            'lang': self.lang,
             'languages': self.languages,
             'keyed_languages': {lang.id: lang for lang in self.languages},
-            'is_editorial': self.editorial,
         }
-        if self.vars is not None:
-            res['vars'] = self.vars
+        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
 
 
@@ -82,7 +88,13 @@ class StatementSample(BaseModel):
 
         interaction = None
         if pio_path.is_file():
-            interaction = parse_interaction(pio_path)
+            try:
+                interaction = parse_interaction(pio_path)
+            except TestcaseInteractionParsingError as e:
+                console.console.print(
+                    f'Error parsing interactive sample: [error]{e}[/error]'
+                )
+                raise typer.Exit(1) from e
 
         return StatementSample(
             inputPath=input_path,
@@ -325,10 +337,6 @@ class rbxTeXBuilder(StatementBuilder):
         )
         blocks = statement_blocks.blocks
 
-        # Remove editorial block when not editorial.
-        if not context.editorial and 'editorial' in blocks:
-            del blocks['editorial']
-
         problem_kwargs = problem.build_jinja_kwargs()
         problem_kwargs['problem']['blocks'] = blocks
         if statement_blocks.explanations is not None:

rbx/box/statements/expander.py

@@ -0,0 +1,49 @@
+import collections
+from typing import Any, List, TypeVar
+
+from rbx.box.fields import merge_pydantic_models
+
+TypeVarT = TypeVar('TypeVarT', bound=Any)
+
+
+def expand_statements(statements: List[TypeVarT]) -> List[TypeVarT]:
+    deg = collections.defaultdict(int)
+    dependencies = collections.defaultdict(list)
+    for statement in statements:
+        if statement.extends is not None:
+            deg[statement.name] += 1
+            dependencies[statement.extends].append(statement.name)
+
+    # Topological sort.
+    #   - We need to expand statements in the order of dependencies.
+    #   - This is a simple topological sort.
+    #   - If there are multiple statements with indegree 0, we choose the first one.
+    st_per_name = {}
+    expanded = {}
+    st = []
+    for statement in statements:
+        st_per_name[statement.name] = statement
+        if deg[statement.name] == 0:
+            st.append(statement)
+
+    while st:
+        statement = st.pop()
+        expanded_statement = statement.model_copy()
+        if statement.extends is not None:
+            expanded_statement = merge_pydantic_models(
+                expanded[statement.extends], statement
+            )
+
+        expanded[statement.name] = expanded_statement
+
+        for dep_name in dependencies[statement.name]:
+            deg[dep_name] -= 1
+            if deg[dep_name] == 0:
+                st.append(st_per_name[dep_name])
+
+    if len(expanded) != len(statements):
+        raise ValueError(
+            f'Failed to expand statements: only {len(expanded)} out of {len(statements)} were expanded. This means there is a cycle introduced by the `extends` field.'
+        )
+
+    return [expanded[statement.name] for statement in statements]

rbx/box/statements/latex_jinja.py

@@ -6,9 +6,10 @@ with Latex.
 import pathlib
 import re
 import typing
-from typing import Dict, Tuple, Union
+from typing import Any, Dict, Tuple, Union
 
 import jinja2
+import jinja2.runtime
 import typer
 
 from rbx import console
@@ -131,11 +132,56 @@ def path_stem(path: pathlib.Path) -> str:
     return path.stem
 
 
+@jinja2.pass_context
+def test_var_truthy(ctx: jinja2.runtime.Context, value: Any):
+    if isinstance(value, jinja2.Undefined):
+        return False
+    if value is None:
+        return False
+    return bool(value)
+
+
+@jinja2.pass_context
+def test_var_falsy(ctx: jinja2.runtime.Context, value: Any):
+    return not test_var_truthy(ctx, value)
+
+
+@jinja2.pass_context
+def test_var_null(ctx: jinja2.runtime.Context, value: Any):
+    if isinstance(value, jinja2.Undefined):
+        return True
+    if value is None:
+        return True
+    return False
+
+
+@jinja2.pass_context
+def test_var_nonnull(ctx: jinja2.runtime.Context, value: Any):
+    return not test_var_null(ctx, value)
+
+
 ######################################################################
 # Declare module functions
 ######################################################################
 
 
+class StrictChainableUndefined(jinja2.StrictUndefined):
+    def __getattr__(self, name: str) -> 'StrictChainableUndefined':
+        # Raise AttributeError on requests for names that appear to be unimplemented
+        # dunder methods to avoid confusing Python with truthy non-method objects that
+        # do not implement the protocol being probed for. e.g., copy.copy(Undefined())
+        # fails spectacularly if getattr(Undefined(), '__setstate__') returns an
+        # Undefined object instead of raising AttributeError to signal that it does not
+        # support that style of object initialization.
+        if name[:2] == '__' and name[-2:] == '__':
+            raise AttributeError(name)
+
+        return self
+
+    def __getitem__(self, _name: str) -> 'StrictChainableUndefined':  # type: ignore[override]
+        return self
+
+
 class JinjaDictWrapper(dict):
     def __init__(self, *args, key='dict object', **kwargs):
         super().__init__(*args, **kwargs)
@@ -145,7 +191,9 @@ class JinjaDictWrapper(dict):
         try:
             return super().__getitem__(key)
         except KeyError:
-            return jinja2.StrictUndefined(hint=f'"{key}" was not found in "{self.key}"')
+            return StrictChainableUndefined(
+                hint=f'"{key}" was not found in "{self.key}"'
+            )
 
 
 def add_builtin_filters(j2_env: jinja2.Environment):
@@ -155,6 +203,13 @@ def add_builtin_filters(j2_env: jinja2.Environment):
     j2_env.filters['stem'] = path_stem
 
 
+def add_builtin_tests(j2_env: jinja2.Environment):
+    j2_env.tests['truthy'] = test_var_truthy
+    j2_env.tests['falsy'] = test_var_falsy
+    j2_env.tests['null'] = test_var_null
+    j2_env.tests['nonnull'] = test_var_nonnull
+
+
 def render_latex_template(path_templates, template_filename, template_vars=None) -> str:
     """Render a latex template, filling in its template variables
 
@@ -168,9 +223,10 @@ def render_latex_template(path_templates, template_filename, template_vars=None)
     j2_env = jinja2.Environment(
         loader=jinja2.FileSystemLoader(path_templates),
         **J2_ARGS,
-        undefined=jinja2.StrictUndefined,
+        undefined=StrictChainableUndefined,
     )
     add_builtin_filters(j2_env)
+    add_builtin_tests(j2_env)
     template = j2_env.get_template(template_filename)
     try:
         return template.render(**var_dict)  # type: ignore
@@ -198,9 +254,10 @@ def render_latex_template_blocks(
     j2_env = jinja2.Environment(
         loader=jinja2.FileSystemLoader(path_templates),
         **J2_ARGS,
-        undefined=jinja2.StrictUndefined,
+        undefined=StrictChainableUndefined,
     )
     add_builtin_filters(j2_env)
+    add_builtin_tests(j2_env)
     template = j2_env.get_template(template_filename)
     ctx = template.new_context(var_dict)  # type: ignore
     try:

rbx/box/statements/schema.py

@@ -2,11 +2,24 @@ from __future__ import annotations
 
 import pathlib
 from enum import Enum
-from typing import List, Literal, Union
+from typing import Annotated, List, Literal, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import AfterValidator, BaseModel, ConfigDict, Field
 
 from rbx.autoenum import AutoEnum, alias
+from rbx.box.fields import FNameField
+from rbx.box.lang import is_valid_lang_code
+
+
+def validate_statement_language(lang: str):
+    if not is_valid_lang_code(lang) or not lang.islower():
+        raise ValueError(
+            f'Invalid statement language: {lang}. Language must be a valid lowercase ISO 639-1 code.'
+        )
+    return lang
+
+
+StatementLanguage = Annotated[str, AfterValidator(validate_statement_language)]
 
 
 ### Conversion types
@@ -95,13 +108,28 @@ class StatementType(AutoEnum):
 class Statement(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
+    name: str = FNameField(description='Name of this statement.')
+
+    extends: Optional[str] = FNameField(
+        default=None,
+        description='Name of the statement that this statement extends.',
+    )
+
+    language: StatementLanguage = Field(
+        default='en', description='Language code of this statement (ISO 639-1).'
+    )
+
     title: str = Field(
-        description='Name of the problem, as it appears in the statement.'
+        default='', description='Name of the problem, as it appears in the statement.'
     )
 
-    path: pathlib.Path = Field(description='Path to the input statement file.')
+    path: pathlib.Path = Field(
+        default_factory=pathlib.Path, description='Path to the input statement file.'
+    )
 
-    type: StatementType = Field(description='Type of the input statement file.')
+    type: StatementType = Field(
+        default=StatementType.rbxTeX, description='Type of the input statement file.'
+    )
 
     steps: List[ConversionStep] = Field(
         default=[],
@@ -134,7 +162,3 @@ 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`.
 """,
     )
-
-    language: str = Field(
-        default='en', description='Language this is statement is written in.'
-    )

rbx/box/testcase_utils.py

@@ -160,6 +160,10 @@ def fill_output_for_defined_testcase(testcase: Testcase) -> Testcase:
     return res
 
 
+class TestcaseInteractionParsingError(Exception):
+    pass
+
+
 def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
     entries = []
     with file.open('r') as f:
@@ -167,53 +171,21 @@ def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
             interactor_prefix = f.readline().strip()
             solution_prefix = f.readline().strip()
         except Exception:
-            console.console.print(
-                f'[error]Failed to read interaction file [item]{file}[/item]. Expected the first two lines to be the interactor and solution prefixes.[/error]'
-            )
-            raise typer.Exit(1) from None
-
-        # Crop file.
-        rest = f.read()
-        start = 0
-
-        def _find_next_prefix(start: int) -> Optional[Tuple[int, int]]:
-            interactor_idx = rest.find(interactor_prefix, start)
-            solution_idx = rest.find(solution_prefix, start)
-            if interactor_idx == -1 and solution_idx == -1:
-                return None
-            if interactor_idx == -1:
-                return (solution_idx, solution_idx + len(solution_prefix))
-            if solution_idx == -1:
-                return (interactor_idx, interactor_idx + len(interactor_prefix))
-            if interactor_idx < solution_idx:
-                return (interactor_idx, interactor_idx + len(interactor_prefix))
-            return (solution_idx, solution_idx + len(solution_prefix))
-
-        def _find_next_block() -> Optional[Tuple[int, Tuple[int, int]]]:
-            prefix = _find_next_prefix(start)
-            if prefix is None:
-                return None
-            prefix_start, prefix_end = prefix
-            prefix = rest[prefix_start:prefix_end]
-            pipe = 1 if prefix == solution_prefix else 0
-
-            nxt = _find_next_prefix(prefix_end)
-            if nxt is None:
-                return (pipe, (prefix_end, len(rest)))
-            nxt_start, _ = nxt
-            return (pipe, (prefix_end, nxt_start))
-
-        # TODO: optimize
-        blocks = 0
-        MAX_BLOCKS = 1024
-        while blocks < MAX_BLOCKS:
-            block = _find_next_block()
-            if block is None:
-                break
-            pipe, (st, nd) = block
-            entries.append(TestcaseInteractionEntry(data=rest[st:nd], pipe=pipe))
-            start = nd
-            blocks += 1
+            raise TestcaseInteractionParsingError(
+                f'Failed to read interaction file {file}. Expected the first two lines to be the interactor and solution prefixes.'
+            ) from None
+
+        while line := f.readline().strip():
+            if line.startswith(interactor_prefix):
+                stripped = line[len(interactor_prefix) :].strip()
+                entries.append(TestcaseInteractionEntry(data=stripped, pipe=0))
+            elif line.startswith(solution_prefix):
+                stripped = line[len(solution_prefix) :].strip()
+                entries.append(TestcaseInteractionEntry(data=stripped, pipe=1))
+            else:
+                raise TestcaseInteractionParsingError(
+                    f'Invalid line in interaction file {file}. Expected the line to start with the interactor or solution prefix ({interactor_prefix} or {solution_prefix}).'
+                ) from None
 
     return TestcaseInteraction(
         prefixes=(interactor_prefix, solution_prefix),