rbx.cp 0.5.0__py3-none-any.whl

rbx/box/stressing/finder_parser.py

@@ -0,0 +1,359 @@
+import dataclasses
+import pathlib
+import typing
+from enum import Enum
+from typing import Callable, List, Optional
+
+import lark
+import typer
+
+from rbx import console
+from rbx.box import package
+from rbx.box.schema import CodeItem, ExpectedOutcome
+from rbx.grading.steps import CheckerResult, Outcome, RunLog
+
+LARK_GRAMMAR = r"""
+// A bunch of words
+start: disjunction
+
+disjunction: conjunction | disjunction _OR conjunction
+
+conjunction: _atom | conjunction _AND _atom
+
+_atom: statement | "(" disjunction ")" | negation
+negation: _NOT "(" disjunction ")"
+
+statement: solution matcher outcome checking?
+
+solution: _filename | WILDCARD
+outcome: CNAME
+checking: "ON"i (checking_mode? checker | ":nil")
+checking_mode: MODE ":"
+MODE: "2" | "3"
+checker: _filename | WILDCARD
+
+// Operators
+matcher: MATCHES | NOT_MATCHES
+
+MATCHES: "~"
+NOT_MATCHES: "!~"
+_OR: "||"
+_AND: "&&"
+_NOT: "!"
+WILDCARD: "$"
+
+// File name
+_filename: FILENAME | "\"" FILENAME "\""
+FILENAME: /[\/A-Za-z0-9\-_\.]/+
+
+%import common.CNAME
+%ignore " "
+"""
+
+LARK_PARSER = lark.Lark(LARK_GRAMMAR)
+
+
+class CheckingMode(Enum):
+    THREE_WAY = 0
+    TWO_WAY = 1
+
+
+@dataclasses.dataclass(frozen=True)
+class FinderChecker:
+    path: str
+    mode: CheckingMode
+
+
+@dataclasses.dataclass(frozen=True)
+class FinderCall:
+    solution: str
+    expected_outcome: ExpectedOutcome
+    checker: Optional[FinderChecker]
+
+
+@dataclasses.dataclass(frozen=True)
+class FinderSolutionResult:
+    output_path: pathlib.Path
+    stderr_path: Optional[pathlib.Path] = None
+    run_log: Optional[RunLog] = None
+
+
+@dataclasses.dataclass(frozen=True)
+class FinderResult:
+    solution: str
+    outcome: Outcome
+    checker: Optional[FinderChecker]
+    truth_value: bool
+
+    # Auxiliary information.
+    solution_result: Optional[FinderSolutionResult] = None
+    checker_result: Optional[CheckerResult] = None
+
+
+@dataclasses.dataclass(frozen=True)
+class FinderOutcome:
+    truth_value: bool
+    results: List[FinderResult]
+
+
+def or_outcome(a: FinderOutcome, b: FinderOutcome) -> FinderOutcome:
+    return FinderOutcome(
+        truth_value=a.truth_value or b.truth_value, results=a.results + b.results
+    )
+
+
+def and_outcome(a: FinderOutcome, b: FinderOutcome) -> FinderOutcome:
+    return FinderOutcome(
+        truth_value=a.truth_value and b.truth_value, results=a.results + b.results
+    )
+
+
+def get_checking_mode_from_string(mode: Optional[str]) -> CheckingMode:
+    if not mode:
+        return CheckingMode.THREE_WAY
+    if mode == '2':
+        return CheckingMode.TWO_WAY
+    return CheckingMode.THREE_WAY
+
+
+def _get_main_checker() -> Optional[str]:
+    pkg = package.find_problem_package_or_die()
+    if not pkg.checker:
+        return None
+    return str(pkg.checker.path)
+
+
+def _get_main_solution() -> Optional[str]:
+    sol = package.get_main_solution()
+    if sol is None:
+        return None
+    return str(sol.path)
+
+
+def _get_default_checker_for_finder() -> Optional[FinderChecker]:
+    main_checker = _get_main_checker()
+    if main_checker is None:
+        return None
+    return FinderChecker(path=main_checker, mode=CheckingMode.THREE_WAY)
+
+
+def _get_solution_from_token(token: lark.Token) -> str:
+    path = str(token)
+    if path == '$':
+        main_path = _get_main_solution()
+        assert main_path is not None
+        return main_path
+    return path
+
+
+def _get_checker_from_token(token: lark.Token) -> str:
+    path = str(token)
+    if path == '$':
+        main_path = _get_main_checker()
+        assert main_path is not None
+        return main_path
+    return path
+
+
+def _get_statement_checker(statement: lark.ParseTree) -> Optional[FinderChecker]:
+    checking_nodes = list(statement.find_data('checking'))
+    if not checking_nodes:
+        return _get_default_checker_for_finder()
+    (checking,) = checking_nodes
+
+    if not checking.children:
+        # Checking is nil
+        return None
+
+    if len(checking.children) == 1:
+        checker = typing.cast(lark.ParseTree, checking.children[0])
+        return FinderChecker(
+            path=_get_checker_from_token(typing.cast(lark.Token, checker.children[0])),
+            mode=CheckingMode.THREE_WAY,
+        )
+
+    mode = typing.cast(lark.ParseTree, checking.children[0])
+    checker = typing.cast(lark.ParseTree, checking.children[1])
+
+    return FinderChecker(
+        path=_get_checker_from_token(typing.cast(lark.Token, checker.children[0])),
+        mode=get_checking_mode_from_string(
+            typing.cast(lark.Token, mode.children[0]).value
+        ),
+    )
+
+
+def get_all_solutions(tree: lark.ParseTree) -> List[str]:
+    solution_nodes = tree.find_data('solution')
+    res = set(
+        [
+            _get_solution_from_token(typing.cast(lark.Token, node.children[0]))
+            for node in solution_nodes
+        ]
+    )
+
+    if needs_expected_output(tree):
+        main_solution = package.get_main_solution()
+        assert main_solution is not None
+        res.add(str(main_solution.path))
+    return list(res)
+
+
+def get_all_solution_items(tree: lark.ParseTree) -> List[CodeItem]:
+    solution_names = get_all_solutions(tree)
+    res = []
+
+    for solution_name in solution_names:
+        found_solution = package.get_solution_or_nil(solution_name)
+        if found_solution is None:
+            res.append(
+                CodeItem(
+                    path=pathlib.Path(solution_name),
+                    language=None,
+                    compilationFiles=None,
+                )
+            )
+            continue
+        res.append(found_solution)
+
+    main_solution = package.get_main_solution()
+    if main_solution is None:
+        return res
+
+    for i, sol in enumerate(res):
+        if main_solution.path == sol.path:
+            res[i], res[0] = res[0], res[i]
+    return res
+
+
+def _get_all_finder_checkers(tree: lark.ParseTree) -> List[FinderChecker]:
+    statement_nodes = tree.find_data('statement')
+    res = []
+
+    for statement_node in statement_nodes:
+        finder_checker = _get_statement_checker(statement_node)
+        if finder_checker is not None:
+            res.append(finder_checker)
+
+    return res
+
+
+def get_all_checkers(tree: lark.ParseTree) -> List[str]:
+    return [finder_checker.path for finder_checker in _get_all_finder_checkers(tree)]
+
+
+def get_all_checker_items(tree: lark.ParseTree) -> List[CodeItem]:
+    checker_names = get_all_checkers(tree)
+    res = []
+
+    for checker_name in checker_names:
+        main_checker = package.get_checker()
+        if str(main_checker.path) == checker_name:
+            res.append(main_checker)
+            continue
+        res.append(
+            CodeItem(
+                path=pathlib.Path(checker_name),
+                language=None,
+                compilationFiles=None,
+            )
+        )
+    return res
+
+
+def needs_expected_output(tree: lark.ParseTree) -> bool:
+    finder_checkers = _get_all_finder_checkers(tree)
+    for finder_checker in finder_checkers:
+        if finder_checker.mode == CheckingMode.THREE_WAY:
+            return True
+    return False
+
+
+def validate(tree: lark.ParseTree):
+    if needs_expected_output(tree):
+        if package.get_main_solution() is None:
+            console.console.print(
+                '[error]Finder expression requires three-way checking, but problem has no main solution.[/error]'
+            )
+            console.console.print(
+                'Either provide an ACCEPTED solution at your problem.rbx.yml, or use two-way checking in your finder expression by providing the `2:` parameter before the checker name.'
+            )
+            raise typer.Exit(1)
+
+    all_checkers = get_all_checkers(tree)
+    for checker in all_checkers:
+        if not pathlib.Path(checker).is_file():
+            console.console.print(
+                f'[error]Finder expression references non-existing checker [item]{checker}[/item].[/error]'
+            )
+            raise typer.Exit(1)
+
+    all_solutions = get_all_solutions(tree)
+    for solution in all_solutions:
+        if not pathlib.Path(solution).is_file():
+            console.console.print(
+                f'[error]Finder expression references non-existing solution [item]{solution}[/item].[/error]'
+            )
+            raise typer.Exit(1)
+
+
+@lark.v_args(inline=True)
+class FinderTreeRunner(lark.Transformer):
+    outcome = ExpectedOutcome
+
+    def __init__(
+        self,
+        runner: Callable[[FinderCall], FinderResult],
+    ):
+        self.run_fn = runner
+
+    def solution(self, token: lark.Token) -> str:
+        return _get_solution_from_token(token)
+
+    def matcher(self, op: lark.Token) -> bool:
+        return op.value == '~'
+
+    @lark.v_args(inline=False, tree=True)
+    def statement(
+        self,
+        tree: lark.ParseTree,
+    ) -> FinderOutcome:
+        solution = typing.cast(str, tree.children[0])
+        is_positive = typing.cast(bool, tree.children[1])
+        expected_outcome = typing.cast(ExpectedOutcome, tree.children[2])
+
+        checker: Optional[FinderChecker] = _get_statement_checker(tree)
+
+        call = FinderCall(solution, expected_outcome=expected_outcome, checker=checker)
+        result = self.run_fn(call)
+        truth_value = result.truth_value
+        if not is_positive:
+            truth_value = not truth_value
+
+        return FinderOutcome(truth_value=truth_value, results=[result])
+
+    def negation(self, value: FinderOutcome) -> FinderOutcome:
+        return dataclasses.replace(value, truth_value=not value.truth_value)
+
+    @lark.v_args(inline=False)
+    def conjunction(self, values: List[FinderOutcome]) -> FinderOutcome:
+        res = FinderOutcome(truth_value=True, results=[])
+        for value in values:
+            res = and_outcome(res, value)
+        return res
+
+    @lark.v_args(inline=False)
+    def disjunction(self, values: List[FinderOutcome]) -> FinderOutcome:
+        res = FinderOutcome(truth_value=False, results=[])
+        for value in values:
+            res = or_outcome(res, value)
+        return res
+
+    def start(self, value: FinderOutcome) -> FinderOutcome:
+        return value
+
+
+def parse(expression: str) -> lark.ParseTree:
+    tree = LARK_PARSER.parse(expression)
+    validate(tree)
+    return tree

rbx/box/stressing/generator_parser.py

@@ -0,0 +1,258 @@
+# flake8: noqa
+from typing import Any, Optional, Union
+import typing
+
+import random
+import lark
+
+LARK_GRAMMAR = r"""
+start: args
+
+// A bunch of args
+args: (arg (_WS arg)*)?
+
+// Argument shlex
+arg: _block | random_hex
+
+// Blocks
+_block: (TEXT | _ticked | _expr)+
+
+// Expression
+_expr: var | range | select
+
+// Ticked
+_ticked: "`" _expr "`"
+
+// Variables
+var: "<" CNAME ">"
+
+// Select
+select: "(" select_value ("|" select_value)* ")"
+select_value: _block
+
+// Ranges
+range: "[" range_value ".." range_value "]"
+range_value: range | var | int | float | char
+int: SIGNED_INT
+float: SIGNED_FLOAT
+char: "'" /./ "'"
+
+// Random hex
+random_hex.1: "@"
+
+// Rest, strings, etc
+TEXT: (/[^ \t\f\r\n\[\]\(\)\<\>\|\`]/ | ESCAPED_STRING)+
+
+// Whitespace
+_WS: WS
+
+%import common.WS
+%import common.CNAME
+%import common.SIGNED_INT
+%import common.SIGNED_FLOAT
+%import common.ESCAPED_STRING
+"""
+
+LARK_PARSER = lark.Lark(LARK_GRAMMAR)
+
+Primitive = Union[int, float, str]
+
+
+class GeneratorParsingError(Exception):
+    pass
+
+
+class RandomInt:
+    def __init__(self, min: int, max: int):
+        self.min = min
+        self.max = max
+
+    def get(self) -> int:
+        if self.max < self.min:
+            raise GeneratorParsingError(
+                f'Found int range with invalid bounds [{self.min}..{self.max}].'
+            )
+        return random.randint(self.min, self.max)
+
+
+class RandomChar:
+    def __init__(self, min: str, max: str):
+        self.min = min
+        self.max = max
+
+    def get(self) -> str:
+        if len(self.min) != 1 or len(self.max) != 1:
+            raise GeneratorParsingError(
+                f"Found char range with invalid bounds ['{self.min}'..'{self.max}']"
+            )
+        mn = ord(self.min)
+        mx = ord(self.max)
+        if mx < mn:
+            raise GeneratorParsingError(
+                f"Found char range with invalid bounds ['{self.min}'..'{self.max}']"
+            )
+        return chr(random.randint(mn, mx))
+
+
+class RandomHex:
+    len: int
+
+    def __init__(self, len: int = 8):
+        self.len = len
+
+    def get(self) -> str:
+        return ''.join(random.choice('0123456789abcdef') for _ in range(self.len))
+
+
+def parse(args: str) -> lark.ParseTree:
+    tree = LARK_PARSER.parse(args)
+    (args_root,) = tree.find_data('args')
+    return args_root
+
+
+def _var_as_str(var: Any) -> str:
+    if isinstance(var, float):
+        return f'{var:.6f}'
+    return str(var)
+
+
+def _down(node: lark.ParseTree) -> Union[lark.Token, lark.ParseTree]:
+    return node.children[0]
+
+
+def _down_tree(node: lark.ParseTree) -> lark.ParseTree:
+    downed = _down(node)
+    return typing.cast(lark.ParseTree, downed)
+
+
+def _down_token(node: lark.ParseTree) -> lark.Token:
+    downed = _down(node)
+    return typing.cast(lark.Token, downed)
+
+
+def _is_primitive(x: Primitive) -> bool:
+    return isinstance(x, (int, float, str))
+
+
+def _get_casting_type(a: Primitive, b: Primitive) -> Optional[str]:
+    if isinstance(a, int) and isinstance(b, int):
+        return 'int'
+    if isinstance(a, float) or isinstance(b, float):
+        if isinstance(a, (int, float)) or isinstance(b, (int, float)):
+            return 'float'
+    if isinstance(a, str) and isinstance(b, str):
+        return 'char'
+    return None
+
+
+class Generator:
+    def __init__(self, vars):
+        self.vars = vars
+
+    def handle_var(self, expr: lark.ParseTree) -> Any:
+        name = typing.cast(lark.Token, _down(expr))
+        if name.value not in self.vars:
+            raise GeneratorParsingError(
+                f'Error parsing generator expression: variable {name.value} is not defined'
+            )
+        value = self.vars[name.value]
+        if not _is_primitive(value):
+            raise GeneratorParsingError(
+                f'Variable {name.value} has type {type(value)}, which is not supported by the Generator expression parser.'
+            )
+        return value
+
+    def handle_range_value(self, range_value: lark.ParseTree) -> Primitive:
+        tp = _down_tree(range_value)
+        if tp.data == 'int':
+            return int(_down_token(tp).value)
+        if tp.data == 'float':
+            return float(_down_token(tp).value)
+        if tp.data == 'char':
+            return str(_down_token(tp).value)
+        if tp.data == 'var':
+            return self.handle_var(tp)
+        return self.handle_range(tp)
+
+    def handle_range(self, range: lark.ParseTree) -> Primitive:
+        value_a, value_b = range.children[:2]
+
+        item_a = self.handle_range_value(typing.cast(lark.ParseTree, value_a))
+        item_b = self.handle_range_value(typing.cast(lark.ParseTree, value_b))
+
+        casting_type = _get_casting_type(item_a, item_b)
+        if casting_type is None:
+            raise GeneratorParsingError(
+                f'Types in range are uncompatible: {type(item_a)} != {type(item_b)}'
+            )
+
+        if casting_type == 'int':
+            return RandomInt(int(item_a), int(item_b)).get()
+        if casting_type == 'float':
+            return random.uniform(float(item_a), float(item_b))
+        if casting_type == 'char':
+            return RandomChar(str(item_a), str(item_b)).get()
+
+        raise GeneratorParsingError(
+            f'Types in range are not supported: {type(item_a)}, {type(item_b)}'
+        )
+
+    def handle_select_value(self, select_value: lark.ParseTree) -> str:
+        items = []
+        for item in select_value.children:
+            items.append(self.handle_block(item))
+        return ''.join(items)
+
+    def handle_select(self, select: lark.ParseTree) -> str:
+        options = []
+        for select_value in select.children:
+            options.append(
+                self.handle_select_value(typing.cast(lark.ParseTree, select_value))
+            )
+        return options[RandomInt(0, len(options) - 1).get()]
+
+    def handle_expr(self, expr: lark.ParseTree) -> str:
+        if expr.data == 'var':
+            return _var_as_str(self.handle_var(expr))
+        if expr.data == 'range':
+            return _var_as_str(self.handle_range(expr))
+        if expr.data == 'select':
+            return self.handle_select(expr)
+        raise GeneratorParsingError(
+            f'Internal error: found invalid AST node in Generator parsing, {expr.data}'
+        )
+
+    def handle_block(self, block: Union[lark.ParseTree, lark.Token]) -> str:
+        if isinstance(block, lark.Token):
+            return block.value
+
+        return self.handle_expr(block)
+
+    def generate_arg(self, arg: lark.ParseTree) -> str:
+        items = []
+        for arg_item in arg.children:
+            if hasattr(arg_item, 'data'):
+                data_item = typing.cast(lark.ParseTree, arg_item)
+                if data_item.data == 'random_hex':
+                    items.append(RandomHex().get())
+                    continue
+            items.append(self.handle_block(arg_item))
+        return ''.join(items)
+
+    def generate(self, args: lark.ParseTree) -> str:
+        args_list = []
+
+        for arg in args.children:
+            args_list.append(self.generate_arg(typing.cast(lark.ParseTree, arg)))
+
+        return ' '.join(args_list)
+
+
+if __name__ == '__main__':
+    tree = parse(
+        """--MAX_N="allow me" --int=[1..<MAX_N>] --float=[1.0..<MAX_N>] --char=['a'..'a'] --selection="(a|b|(c|<MAX_N>))" --select=("a"|"b"|"c") @ --r2=[1..[8..15]]"""
+    )
+    print(tree)
+
+    generator = Generator({'MAX_N': 10})
+    print(generator.generate(tree))

rbx/box/testcases.py

@@ -0,0 +1,54 @@
+import pathlib
+import shutil
+from typing import List
+
+import typer
+from pydantic import BaseModel
+
+from rbx import console
+from rbx.box import package
+from rbx.box.package import get_build_testgroup_path, get_build_tests_path
+from rbx.box.schema import Testcase, TestcaseGroup
+
+
+class TestcaseData(BaseModel):
+    input: str
+    output: str
+
+
+def find_built_testcases(group: TestcaseGroup) -> List[Testcase]:
+    inputs = find_built_testcase_inputs(group)
+
+    testcases = []
+    for input in inputs:
+        output = input.with_suffix('.out')
+        testcases.append(Testcase(inputPath=input, outputPath=output))
+    return testcases
+
+
+def find_built_testcase_inputs(group: TestcaseGroup) -> List[pathlib.Path]:
+    testgroup_path = get_build_testgroup_path(group.name)
+    if not testgroup_path.is_dir():
+        console.console.print(
+            f'Testgroup {group.name} is not generated in build folder'
+        )
+        raise typer.Exit(1)
+
+    return sorted(testgroup_path.glob('*.in'))
+
+
+def clear_built_testcases():
+    shutil.rmtree(str(get_build_tests_path()), ignore_errors=True)
+
+
+def get_samples() -> List[Testcase]:
+    tcs = find_built_testcases(package.get_testgroup('samples'))
+    return [
+        Testcase(
+            inputPath=tc.inputPath.resolve(),
+            outputPath=tc.outputPath.resolve()
+            if tc.outputPath is not None and tc.outputPath.is_file()
+            else None,
+        )
+        for tc in tcs
+    ]