rbx.cp 0.5.0__py3-none-any.whl

rbx/box/statements/latex_jinja.py

@@ -0,0 +1,214 @@
+"""This module provides a template-rendering function for Jinja2
+that overrides Jinja2 defaults to make it work more seamlessly
+with Latex.
+"""
+
+import pathlib
+import re
+import typing
+from typing import Dict, Tuple, Union
+
+import jinja2
+import typer
+
+from rbx import console
+
+######################################################################
+# J2_ARGS
+#   Constant was borrowed from Marc Brinkmann's
+#   latex repository (mbr/latex on github)
+######################################################################
+J2_ARGS = {
+    'block_start_string': r'\BLOCK{',
+    'block_end_string': '}',
+    'variable_start_string': r'\VAR{',
+    'variable_end_string': '}',
+    'comment_start_string': r'\#{',
+    'comment_end_string': '}',
+    'line_statement_prefix': '%-',
+    'line_comment_prefix': '%#',
+    'trim_blocks': True,
+    'autoescape': False,
+}
+
+######################################################################
+# Latex escape regex constants
+######################################################################
+
+# Organize all latex escape characters in one list
+# (EXCEPT FOR ( "\" ), which is handled separately)
+# escaping those which are special characters in
+# PERL regular expressions
+ESCAPE_CHARS = [
+    r'\&',
+    '%',
+    r'\$',
+    '#',
+    '_',
+    r'\{',
+    r'\}',
+    '~',
+    r'\^',
+]
+
+# For each latex escape character, create a regular expression
+# that matches all of the following criteria
+# 1) one or two characters
+# 2) if two characters, the first character is NOT a backslash ( "\" )
+# 3) if two characters, the second, if one, the first character
+#       is one of the latex escape characters
+REGEX_ESCAPE_CHARS = [
+    (re.compile(r'(?<!\\)' + i), r'\\' + i.replace('\\', '')) for i in ESCAPE_CHARS
+]
+
+# Place escape characters in [] for "match any character" regex
+ESCAPE_CHARS_OR = r'[{}\\]'.format(''.join(ESCAPE_CHARS))
+
+# For the back slash, create a regular expression
+# that matches all of the following criteria
+# 1) one, two, or three characters
+# 2) the first character is not a backslash
+# 3) the second character is a backslash
+# 4) the third character is none of the ESCAPE_CHARS,
+#       and is also not a backslash
+REGEX_BACKSLASH = re.compile(r'(?<!\\)\\(?!{})'.format(ESCAPE_CHARS_OR))
+
+
+######################################################################
+# Declare module functions
+######################################################################
+def escape_latex_str_if_str(value):
+    """Escape a latex string"""
+    if not isinstance(value, str):
+        return value
+    for regex, replace_text in REGEX_ESCAPE_CHARS:
+        value = re.sub(regex, replace_text, value)
+    value = re.sub(REGEX_BACKSLASH, r'\\textbackslash{}', value)
+    return value
+
+
+def _process_zeroes(value: int) -> Tuple[int, int, int]:
+    cnt = 0
+
+    acc = value
+    while acc >= 10:
+        acc //= 10
+        cnt += 1
+    return acc, cnt, value - acc * 10**cnt
+
+
+def scientific_notation(
+    value: Union[int, jinja2.Undefined], zeroes: int = 2
+) -> Union[str, jinja2.Undefined]:
+    if jinja2.is_undefined(value):
+        return typing.cast(jinja2.Undefined, value)
+    assert isinstance(value, int)
+    assert zeroes >= 1
+    if value == 0:
+        return '0'
+    if value < 0:
+        return f'-{scientific_notation(-value, zeroes=zeroes)}'
+
+    mult, exp, rest = _process_zeroes(value)
+    if exp < zeroes:
+        return str(value)
+    res = '10' if exp == 1 else f'10^{exp}'
+    if rest > 0 and len(str(rest)) + 1 >= len(str(value)):
+        # Should not convert numbers like 532 to 5*10^2 + 32.
+        return str(value)
+    if mult > 1:
+        res = f'{mult} \\times {res}'
+    if rest > 0:
+        res = f'{res} + {rest}'
+    return res
+
+
+def path_parent(path: pathlib.Path) -> pathlib.Path:
+    return path.parent
+
+
+def path_stem(path: pathlib.Path) -> str:
+    return path.stem
+
+
+######################################################################
+# Declare module functions
+######################################################################
+
+
+class JinjaDictWrapper(dict):
+    def __init__(self, *args, key='dict object', **kwargs):
+        super().__init__(*args, **kwargs)
+        self.key = key
+
+    def __getitem__(self, key):
+        try:
+            return super().__getitem__(key)
+        except KeyError:
+            return jinja2.StrictUndefined(hint=f'"{key}" was not found in "{self.key}"')
+
+
+def add_builtin_filters(j2_env: jinja2.Environment):
+    j2_env.filters['escape'] = escape_latex_str_if_str
+    j2_env.filters['sci'] = scientific_notation
+    j2_env.filters['parent'] = path_parent
+    j2_env.filters['stem'] = path_stem
+
+
+def render_latex_template(path_templates, template_filename, template_vars=None) -> str:
+    """Render a latex template, filling in its template variables
+
+    :param path_templates: the path to the template directory
+    :param template_filename: the name, rooted at the path_template_directory,
+        of the desired template for rendering
+    :param template_vars: dictionary of key:val for jinja2 variables
+        defaults to None for case when no values need to be passed
+    """
+    var_dict = template_vars if template_vars else {}
+    j2_env = jinja2.Environment(
+        loader=jinja2.FileSystemLoader(path_templates),
+        **J2_ARGS,
+        undefined=jinja2.StrictUndefined,
+    )
+    add_builtin_filters(j2_env)
+    template = j2_env.get_template(template_filename)
+    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
+
+
+def render_latex_template_blocks(
+    path_templates, template_filename, template_vars=None
+) -> Dict[str, str]:
+    """Render a latex template, filling in its template variables
+
+    :param path_templates: the path to the template directory
+    :param template_filename: the name, rooted at the path_template_directory,
+        of the desired template for rendering
+    :param template_vars: dictionary of key:val for jinja2 variables
+        defaults to None for case when no values need to be passed
+    """
+    var_dict = template_vars if template_vars else {}
+    j2_env = jinja2.Environment(
+        loader=jinja2.FileSystemLoader(path_templates),
+        **J2_ARGS,
+        undefined=jinja2.StrictUndefined,
+    )
+    add_builtin_filters(j2_env)
+    template = j2_env.get_template(template_filename)
+    ctx = template.new_context(var_dict)  # type: ignore
+    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

rbx/box/statements/schema.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import pathlib
+from enum import Enum
+from typing import List, Literal, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from rbx.autoenum import AutoEnum, alias
+
+
+### Conversion types
+class ConversionType(str, Enum):
+    rbxToTex = 'rbx-tex'
+    """Conversion from rbxTeX to LaTeX."""
+
+    TexToPDF = 'tex2pdf'
+    """Conversion from LaTeX to PDF using pdfLaTeX."""
+
+    JinjaTeX = 'jinja-tex'
+    """Conversion from LaTeX with Jinja2 expressions to LaTeX."""
+
+    def __repr__(self):
+        return str.__repr__(self.value)
+
+
+### Conversion nodes.
+class rbxToTeX(BaseModel):
+    """Configures the conversion between rbxTeX and LaTeX."""
+
+    type: Literal[ConversionType.rbxToTex]
+
+    template: pathlib.Path = Field(
+        default=pathlib.Path('template.rbx.tex'),
+        description='Path to the template that should be used to render the rbx-tex blocks.',
+    )
+
+
+class TexToPDF(BaseModel):
+    """Configures the conversion between LaTeX and PDF using pdfLaTeX."""
+
+    type: Literal[ConversionType.TexToPDF]
+
+
+class JinjaTeX(BaseModel):
+    type: Literal[ConversionType.JinjaTeX]
+
+
+### Joiner types.
+class JoinerType(str, Enum):
+    TexToPDF = 'tex2pdf'
+    """Join contest tex and problem texs to PDF using pdfLaTeX."""
+
+    def __repr__(self):
+        return str.__repr__(self.value)
+
+
+### Joiner nodes.
+class JoinTexToPDF(BaseModel):
+    """Configures the joining of contest and problem texes to PDF."""
+
+    type: Literal[JoinerType.TexToPDF]
+
+
+ConversionStep = Union[TexToPDF, JinjaTeX, rbxToTeX]
+Joiner = JoinTexToPDF
+
+
+### Statement types
+class StatementType(AutoEnum):
+    rbxTeX = alias('rbx-tex', 'rbx-tex', 'rbx')  # type: ignore
+    """Statement written in rbxTeX format."""
+
+    TeX = alias('tex')
+    """Statement written in pure LaTeX format."""
+
+    JinjaTeX = alias('jinja-tex')
+    """Statement written in LaTeX format with Jinja2 expressions."""
+
+    PDF = alias('pdf')
+    """Statement is a PDF."""
+
+    def get_file_suffix(self) -> str:
+        if self == StatementType.TeX:
+            return '.tex'
+        if self == StatementType.rbxTeX:
+            return '.rbx.tex'
+        if self == StatementType.JinjaTeX:
+            return '.jinja.tex'
+        if self == StatementType.PDF:
+            return '.pdf'
+        raise ValueError(f'Unknown statement type: {self}')
+
+
+class Statement(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+
+    title: str = Field(
+        description='Name of the problem, as it appears in the statement.'
+    )
+
+    path: pathlib.Path = Field(description='Path to the input statement file.')
+
+    type: StatementType = Field(description='Type of the input statement file.')
+
+    steps: List[ConversionStep] = Field(
+        [],
+        discriminator='type',
+        description="""
+Describes a sequence of conversion steps that should be applied to the statement file.
+
+Usually, it is not necessary to specify these, as they can be inferred from the
+input statement type and the output statement type, but you can use this to force
+certain conversion steps to happen.
+""",
+    )
+
+    configure: List[ConversionStep] = Field(
+        [],
+        discriminator='type',
+        description="""
+Configure how certain conversion steps should happen when applied to the statement file.
+
+Different from the `steps` field, this does not force the steps to happen, but rather only
+configure them in case they are applied.
+""",
+    )
+
+    assets: List[str] = Field(
+        [],
+        description="""
+Assets relative to the package directory that should be included while building
+the statement. Files will be included in the same folder as the statement file, preserving
+their relativeness. Can be glob pattern as well, such as `imgs/*.png`.
+""",
+    )
+
+    language: str = Field('en', description='Language this is statement is written in.')

rbx/box/stresses.py

@@ -0,0 +1,292 @@
+import dataclasses
+import functools
+import time
+from shutil import rmtree
+from typing import List, Optional
+
+import typer
+from pydantic import BaseModel
+
+from rbx import console
+from rbx.box import checkers, package, validators
+from rbx.box.code import compile_item, run_item
+from rbx.box.generators import generate_standalone
+from rbx.box.schema import CodeItem, GeneratorCall, Stress, Testcase
+from rbx.box.solutions import compile_solutions, get_outcome_style_verdict
+from rbx.box.stressing import finder_parser
+from rbx.grading.steps import (
+    DigestOrDest,
+    DigestOrSource,
+    Outcome,
+)
+from rbx.utils import StatusProgress
+
+
+class StressFinding(BaseModel):
+    generator: GeneratorCall
+
+
+class StressReport(BaseModel):
+    findings: List[StressFinding] = []
+    executed: int = 0
+
+
+def _compile_finder(finder: CodeItem) -> str:
+    try:
+        digest = compile_item(finder)
+    except Exception as e:
+        console.console.print(
+            f'[error]Failed compiling checker [item]{finder.path}[/item].[/error]'
+        )
+        raise typer.Exit(1) from e
+    return digest
+
+
+def run_stress(
+    name: str,
+    timeoutInSeconds: int,
+    finder: Optional[str] = None,
+    args: Optional[str] = None,
+    findingsLimit: int = 1,
+    verbose: bool = False,
+    progress: Optional[StatusProgress] = None,
+) -> StressReport:
+    if finder:
+        stress = Stress(
+            name=f'{name}',
+            generator=GeneratorCall(name=name, args=args or ''),
+            finder=finder,
+        )
+    else:
+        stress = package.get_stress(name)
+
+    call = stress.generator
+    generator = package.get_generator(call.name)
+
+    try:
+        generator_digest = compile_item(generator)
+    except:
+        console.console.print(
+            f'[error]Failed compiling generator [item]{generator.name}[/item].[/error]'
+        )
+        raise
+
+    # Finder expression parser
+    parsed_finder = finder_parser.parse(stress.finder)
+
+    solutions = finder_parser.get_all_solution_items(parsed_finder)
+    finders = finder_parser.get_all_checker_items(parsed_finder)
+    needs_expected_output = finder_parser.needs_expected_output(parsed_finder)
+
+    solution_indices = {str(solution.path): i for i, solution in enumerate(solutions)}
+    solutions_digest = compile_solutions(
+        tracked_solutions=set(str(solution.path) for solution in solutions)
+    )
+    if progress:
+        progress.update('Compiling finders...')
+    finders_digest = {str(finder.path): _compile_finder(finder) for finder in finders}
+
+    compiled_validator = validators.compile_main_validator()
+
+    # Erase old stress directory
+    runs_dir = package.get_problem_runs_dir()
+    stress_dir = runs_dir / '.stress'
+    rmtree(str(stress_dir), ignore_errors=True)
+    stress_dir.mkdir(parents=True, exist_ok=True)
+    empty_path = runs_dir / '.stress' / '.empty'
+    empty_path.write_text('')
+
+    startTime = time.monotonic()
+
+    executed = 0
+    findings = []
+
+    while len(findings) < findingsLimit:
+        if time.monotonic() - startTime > timeoutInSeconds:
+            break
+
+        if progress:
+            seconds = timeoutInSeconds - int(time.monotonic() - startTime)
+            progress.update(
+                f'Stress testing: found [item]{len(findings)}[/item] tests, '
+                f'executed [item]{executed}[/item], '
+                f'[item]{seconds}[/item] second(s) remaining...'
+            )
+
+        input_path = runs_dir / '.stress' / 'input'
+        input_path.parent.mkdir(parents=True, exist_ok=True)
+
+        expanded_generator_call = generate_standalone(
+            stress.generator,
+            input_path,
+            generator_digest=generator_digest,
+            validator_digest=compiled_validator[1]
+            if compiled_validator is not None
+            else None,
+        )
+
+        @functools.cache
+        def run_solution_fn(
+            solution: str,
+            input_path=input_path,
+        ) -> finder_parser.FinderSolutionResult:
+            index = solution_indices[solution]
+            sol = solutions[index]
+            output_path = input_path.with_stem(f'{index}').with_suffix('.out')
+            stderr_path = output_path.with_suffix('.err')
+
+            run_log = run_item(
+                sol,
+                DigestOrSource.create(solutions_digest[sol.path]),
+                stdin=DigestOrSource.create(input_path),
+                stdout=DigestOrDest.create(output_path),
+                stderr=DigestOrDest.create(stderr_path),
+            )
+
+            return finder_parser.FinderSolutionResult(
+                output_path=output_path,
+                stderr_path=stderr_path,
+                run_log=run_log,
+            )
+
+        # Get main solution output.
+        expected_output_path = empty_path
+        if needs_expected_output:
+            main_result = run_solution_fn(str(solutions[0].path))
+            main_checker_result = checkers.check_with_no_output(main_result.run_log)
+            if main_checker_result.outcome != Outcome.ACCEPTED:
+                console.console.print(
+                    '[error]Error while generating main solution output.[/error]'
+                )
+                console.console.print(f'Input written at [item]{input_path}[/item].')
+                console.console.print(
+                    f'Output written at [item]{main_result.output_path}[/item].'
+                )
+                console.console.print(
+                    f'Stderr written at [item]{main_result.stderr_path}[/item].'
+                )
+                console.console.print()
+                console.console.print(
+                    "[warning]If you don't want reference outputs to be generated for the tests, you should "
+                    "use the two-way modifier in your finder expression (':2')."
+                )
+                raise typer.Exit(1)
+            expected_output_path = main_result.output_path
+
+        @functools.cache
+        def run_solution_and_checker_fn(
+            solution: str,
+            checker: Optional[finder_parser.FinderChecker],
+            input_path=input_path,
+            expected_output_path=expected_output_path,
+        ) -> finder_parser.FinderResult:
+            solution_result = run_solution_fn(solution)
+
+            if checker is None:
+                checker_result = checkers.check_with_no_output(solution_result.run_log)
+            else:
+                checker_digest = finders_digest[checker.path]
+                checker_result = checkers.check(
+                    checker_digest,
+                    solution_result.run_log,
+                    Testcase(inputPath=input_path, outputPath=expected_output_path),
+                    program_output=solution_result.output_path,
+                )
+            return finder_parser.FinderResult(
+                solution=solution,
+                outcome=checker_result.outcome,
+                checker=checker,
+                truth_value=True,
+                solution_result=solution_result,
+                checker_result=checker_result,
+            )
+
+        def run_fn(
+            call: finder_parser.FinderCall,
+        ) -> finder_parser.FinderResult:
+            finder_result = run_solution_and_checker_fn(call.solution, call.checker)
+            truth_value = call.expected_outcome.match(finder_result.outcome)
+            return dataclasses.replace(finder_result, truth_value=truth_value)
+
+        runner = finder_parser.FinderTreeRunner(runner=run_fn)
+        finder_outcome: finder_parser.FinderOutcome = runner.transform(parsed_finder)
+
+        internal_error_results = [
+            result
+            for result in finder_outcome.results
+            if result.outcome == Outcome.INTERNAL_ERROR
+        ]
+
+        if internal_error_results:
+            console.console.print(
+                f'[error]Checkers failed during stress test [item]{name}[/item] with args [info]{expanded_generator_call.name} {expanded_generator_call.args}[/info].[/error]'
+            )
+            for internal_error_result in internal_error_results:
+                assert internal_error_result.checker is not None
+                assert internal_error_result.checker_result is not None
+                internal_error_checker_name = internal_error_result.checker.path
+                console.console.print(
+                    f'[warning]Checker [item]{internal_error_checker_name}[/item] failed with message:'
+                )
+                console.console.print(internal_error_result.checker_result.message)
+            raise typer.Exit(1)
+
+        if not finder_outcome.truth_value:
+            continue
+
+        findings_dir = stress_dir / 'findings'
+        findings_dir.mkdir(parents=True, exist_ok=True)
+        finding_index = len(findings)
+
+        finding_path = findings_dir / f'{finding_index}.in'
+        finding_path.write_bytes(input_path.read_bytes())
+
+        if progress:
+            console.console.print(
+                f'[error]FINDING[/error] Generator args are "[status]{expanded_generator_call.name} {expanded_generator_call.args}[/status]"'
+            )
+            seen_finder_results = set()
+            for finder_result in finder_outcome.results:
+                style = get_outcome_style_verdict(finder_result.outcome)
+                finder_result_key = (finder_result.solution, finder_result.checker)
+                if finder_result_key in seen_finder_results:
+                    continue
+                seen_finder_results.add(finder_result_key)
+                finder_result_report_line = f'{finder_result.solution} = [{style}]{finder_result.outcome.name}[/{style}]'
+                if finder_result.checker is not None:
+                    finder_result_report_line += (
+                        f' [item]ON[/item] {finder_result.checker.path}'
+                    )
+                console.console.print(finder_result_report_line)
+
+        findings.append(
+            StressFinding(
+                generator=expanded_generator_call,
+            )
+        )
+
+        # Be cooperative.
+        executed += 1
+        time.sleep(0.001)
+
+    return StressReport(findings=findings, executed=executed)
+
+
+def print_stress_report(report: StressReport):
+    console.console.rule('Stress test report', style='status')
+    console.console.print(f'Executed [item]{report.executed}[/item] tests.')
+    if not report.findings:
+        console.console.print('No stress test findings.')
+        return
+    console.console.print(f'Found [item]{len(report.findings)}[/item] testcases.')
+
+    findings_dir = package.get_problem_runs_dir() / '.stress' / 'findings'
+    console.console.print(f'Findings: {findings_dir.resolve()}')
+    console.console.print()
+
+    for i, finding in enumerate(report.findings):
+        console.console.print(f'[error]Finding {i + 1}[/error]')
+        console.console.print(
+            f'Generator: [status]{finding.generator.name} {finding.generator.args}[/status]'
+        )
+        console.console.print()