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

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/stats.py

@@ -0,0 +1,92 @@
+import pathlib
+from typing import Iterable, List, Tuple
+
+from rbx import console
+from rbx.box.cd import (
+    find_all_ancestor_packages,
+    is_contest_package,
+    is_problem_package,
+)
+from rbx.box.contest.contest_package import find_contest, find_contest_package_or_die
+from rbx.box.formatting import get_formatted_memory
+
+
+def find_problem_packages_from_contest(
+    root: pathlib.Path = pathlib.Path(),
+) -> Iterable[pathlib.Path]:
+    contest_path = find_contest(root)
+    contest = find_contest_package_or_die(contest_path)
+    for problem in contest.problems:
+        yield contest_path / problem.get_path()
+
+
+def find_all_reachable_packages(
+    root: pathlib.Path = pathlib.Path(),
+) -> List[pathlib.Path]:
+    packages = find_all_ancestor_packages(root)
+
+    for package in list(packages):
+        if is_contest_package(package):
+            packages.extend(find_problem_packages_from_contest(package))
+    return packages
+
+
+def find_and_group_all_reachable_packages(
+    root: pathlib.Path = pathlib.Path(),
+) -> Tuple[List[pathlib.Path], List[pathlib.Path]]:
+    packages = find_all_reachable_packages(root)
+    contest_packages = set(pkg for pkg in packages if is_contest_package(pkg))
+    problem_packages = set(pkg for pkg in packages if is_problem_package(pkg))
+    return sorted(contest_packages), sorted(problem_packages)
+
+
+def get_dir_size(path: pathlib.Path) -> int:
+    if not path.is_dir():
+        return 0
+    return sum(
+        f.stat().st_size
+        for f in path.glob('**/*')
+        if f.is_file() and not f.is_symlink()
+    )
+
+
+def get_cache_size(root: pathlib.Path = pathlib.Path()) -> int:
+    cache_dir = root / '.box'
+    return get_dir_size(cache_dir)
+
+
+def get_build_size(root: pathlib.Path = pathlib.Path()) -> int:
+    build_dir = root / 'build'
+    return get_dir_size(build_dir)
+
+
+def print_package_stats(root: pathlib.Path = pathlib.Path()) -> int:
+    if is_contest_package(root):
+        console.console.print(f'[status]Contest package[/status]: [item]{root}[/item]')
+    else:
+        console.console.print(f'[status]Problem package[/status]: [item]{root}[/item]')
+
+    cache_size = get_cache_size(root)
+    build_size = get_build_size(root)
+    console.console.print(
+        f'[status]Cache size[/status]: [item]{get_formatted_memory(cache_size)}[/item]'
+    )
+    console.console.print(
+        f'[status]Build size[/status]: [item]{get_formatted_memory(build_size)}[/item]'
+    )
+
+    return cache_size + build_size
+
+
+def print_reachable_package_stats(root: pathlib.Path = pathlib.Path()) -> None:
+    contest_packages, problem_packages = find_and_group_all_reachable_packages(root)
+    total_size = 0
+    for pkg in contest_packages:
+        total_size += print_package_stats(pkg)
+        console.console.print()
+    for pkg in problem_packages:
+        total_size += print_package_stats(pkg)
+        console.console.print()
+    console.console.print(
+        f'[status]Total size[/status]: [item]{get_formatted_memory(total_size)}[/item]'
+    )

rbx/box/tasks.py

@@ -4,7 +4,7 @@ from typing import Optional
 from rbx.box import checkers, 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
+from rbx.box.retries import Retrier, get_retrier_config
 from rbx.box.schema import Solution, Testcase
 from rbx.grading.judge.sandbox import SandboxBase
 from rbx.grading.limits import Limits
@@ -51,6 +51,7 @@ async def run_solution_on_testcase(
     use_retries: bool = True,
     use_timelimit: bool = True,
     capture_pipes: bool = False,
+    nruns: int = 0,
 ) -> Evaluation:
     if interactor_digest is not None:
         return await _run_communication_solution_on_testcase(
@@ -66,6 +67,7 @@ async def run_solution_on_testcase(
             use_retries=use_retries,
             use_timelimit=use_timelimit,
             capture_pipes=capture_pipes,
+            nruns=nruns,
         )
 
     async def run_fn(retry_index: int) -> Evaluation:
@@ -132,7 +134,7 @@ async def run_solution_on_testcase(
     if not use_retries:
         return await run_fn(0)
 
-    retrier = Retrier()
+    retrier = Retrier(get_retrier_config(nruns))
     return await retrier.repeat(run_fn)
 
 
@@ -166,6 +168,7 @@ async def _run_communication_solution_on_testcase(
     use_retries: bool = True,
     use_timelimit: bool = True,
     capture_pipes: bool = False,
+    nruns: int = 0,
 ) -> Evaluation:
     capture_pipes = capture_pipes or state.STATE.debug_logs
 
@@ -291,5 +294,5 @@ async def _run_communication_solution_on_testcase(
     if not use_retries:
         return await run_fn(0)
 
-    retrier = Retrier()
+    retrier = Retrier(get_retrier_config(nruns))
     return await retrier.repeat(run_fn)

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),

rbx/box/tooling/boca/main.py

@@ -0,0 +1,13 @@
+import pathlib
+
+import typer
+
+from rbx import annotations
+from rbx.box.tooling.boca.scrape import scrape_boca
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+
+@app.command('scrape', help='Scrape runs from BOCA.')
+def scrape() -> None:
+    scrape_boca(pathlib.Path())

rbx/box/tooling/boca/scrape.py

@@ -0,0 +1,34 @@
+import pathlib
+from concurrent.futures import ThreadPoolExecutor
+
+from rich.progress import MofNCompleteColumn, Progress, SpinnerColumn
+
+from rbx.box.tooling.boca.scraper import BocaRun, BocaScraper
+
+
+def scrape_boca(into_path: pathlib.Path):
+    scraper = BocaScraper()
+    scraper.login()
+    runs = scraper.list_runs()
+
+    progress = Progress(
+        SpinnerColumn(),
+        *Progress.get_default_columns(),
+        MofNCompleteColumn(),
+        transient=True,
+    )
+    scrape_task = progress.add_task('Scraping runs...', total=len(runs))
+    with progress:
+
+        def work(run: BocaRun):
+            scraper.download_run(
+                run.run_number,
+                run.site_number,
+                pathlib.Path(into_path) / run.problem_shortname,
+                name=f'{run.run_number}-{run.site_number}-{run.outcome.short_name().lower()}',
+            )
+
+            progress.update(scrape_task, advance=1)
+
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            executor.map(work, runs)