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

rbx/box/packaging/polygon/upload.py

@@ -10,8 +10,8 @@ import typer
 from rbx import console
 from rbx.box import header, package
 from rbx.box.generators import get_all_built_testcases
+from rbx.box.lang import code_to_langs, is_valid_lang_code
 from rbx.box.packaging.polygon import polygon_api as api
-from rbx.box.packaging.polygon.packager import code_to_langs, is_valid_lang_code
 from rbx.box.schema import CodeItem, ExpectedOutcome, Solution, TaskType, Testcase
 from rbx.box.statements.build_statements import get_relative_assets
 from rbx.box.statements.builders import (
@@ -20,7 +20,11 @@ from rbx.box.statements.builders import (
     render_jinja_blocks,
 )
 from rbx.box.statements.schema import Statement, StatementType
-from rbx.box.testcase_utils import get_alternate_interaction_texts, parse_interaction
+from rbx.box.testcase_utils import (
+    TestcaseInteractionParsingError,
+    get_alternate_interaction_texts,
+    parse_interaction,
+)
 
 _API_URL = 'https://polygon.codeforces.com/api'
 
@@ -163,17 +167,23 @@ def _get_test_params_for_statement(
 
     pio_path = testcase.outputPath.with_suffix('.pio')
     if pio_path.is_file():
-        interaction = parse_interaction(pio_path)
-        res['test_input_for_statements'], res['test_output_for_statements'] = (
-            get_alternate_interaction_texts(interaction)
-        )
-    else:
-        pin_path = testcase.outputPath.with_suffix('.pin')
-        if pin_path.is_file():
-            res['test_input_for_statements'] = pin_path.read_text()
-        pout_path = testcase.outputPath.with_suffix('.pout')
-        if pout_path.is_file():
-            res['test_output_for_statements'] = pout_path.read_text()
+        try:
+            interaction = parse_interaction(pio_path)
+        except TestcaseInteractionParsingError:
+            pass
+        else:
+            res['test_input_for_statements'], res['test_output_for_statements'] = (
+                get_alternate_interaction_texts(interaction)
+            )
+            return res
+
+    # .pio does not exist or is not parseable, fallback to .pin and .pout.
+    pin_path = testcase.outputPath.with_suffix('.pin')
+    if pin_path.is_file():
+        res['test_input_for_statements'] = pin_path.read_text()
+    pout_path = testcase.outputPath.with_suffix('.pout')
+    if pout_path.is_file():
+        res['test_output_for_statements'] = pout_path.read_text()
     return res
 
 
@@ -229,7 +239,7 @@ def _upload_solutions(problem: api.Problem):
 
 def _get_statement_for_language(language: str) -> Optional[Statement]:
     pkg = package.find_problem_package_or_die()
-    for statement in pkg.statements:
+    for statement in pkg.expanded_statements:
         if statement.language == language:
             return statement
     return None
@@ -290,11 +300,15 @@ def _upload_statement(problem: api.Problem, preserve_language: bool = False):
     pkg = package.find_problem_package_or_die()
 
     languages = set()
-    for statement in pkg.statements:
+    for statement in pkg.expanded_statements:
         if not is_valid_lang_code(statement.language):
             continue
         languages.add(statement.language)
-    for language in languages:
+
+    uploaded_languages = set()
+
+    # Prioritize English statements.
+    for language in ['en'] + list(languages):
         statement = _get_statement_for_language(language)
         if statement is None:
             continue
@@ -304,6 +318,10 @@ def _upload_statement(problem: api.Problem, preserve_language: bool = False):
         console.console.print(
             f'Uploading statement for language [item]{language}[/item] (polygon language: [item]{statement_lang}[/item])...'
         )
+        uploaded_language = statement_lang if preserve_language else 'english'
+        if uploaded_language in uploaded_languages:
+            continue
+        uploaded_languages.add(uploaded_language)
         if not preserve_language and statement_lang != 'english':
             console.console.print(
                 '[warning]By default, Polygon statements are uploaded in English.\n'
@@ -322,7 +340,7 @@ def _upload_statement(problem: api.Problem, preserve_language: bool = False):
             notes=_get_notes_with_explanations(blocks) or '',
         )
         problem.save_statement(
-            lang=statement_lang if preserve_language else 'english',
+            lang=uploaded_language,
             problem_statement=polygon_statement,
         )
 

rbx/box/remote.py

@@ -52,14 +52,14 @@ class BocaExpander(Expander):
         return [str(self.get_boca_path(run_number, site_number)) + '.*']
 
     def expand(self, path: pathlib.Path) -> Optional[pathlib.Path]:
-        from rbx.box.packaging.boca import upload as boca_upload
+        from rbx.box.tooling.boca import scraper as boca_upload
 
         match = self.get_match(str(path))
         if match is None:
             return None
         run_number, site_number = match
 
-        boca_uploader = boca_upload.get_boca_uploader()
+        boca_uploader = boca_upload.get_boca_scraper()
         boca_uploader.login()
         sol_path = boca_uploader.download_run(
             run_number, site_number, self.get_boca_folder()

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: