rbx.cp 0.5.49__py3-none-any.whl → 0.5.51__py3-none-any.whl

rbx/box/packaging/polygon/upload.py

@@ -0,0 +1,336 @@
+import os
+import pathlib
+import tempfile
+from typing import Any, Dict, Optional
+
+import rich
+import rich.progress
+import typer
+
+from rbx import console
+from rbx.box import header, package
+from rbx.box.generators import get_all_built_testcases
+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 (
+    StatementBlocks,
+    StatementBuilderProblem,
+    render_jinja_blocks,
+)
+from rbx.box.statements.schema import Statement, StatementType
+from rbx.box.testcase_utils import get_alternate_interaction_texts, parse_interaction
+
+_API_URL = 'https://polygon.codeforces.com/api'
+
+POLY = api.Polygon(
+    _API_URL,
+    os.environ.get('POLYGON_API_KEY', '').strip(),
+    os.environ.get('POLYGON_API_SECRET', '').strip(),
+)
+
+
+def _get_source_type(code: CodeItem):
+    return None
+
+
+def _get_solution_tag(solution: Solution, is_first: bool = False) -> api.SolutionTag:
+    if solution.outcome == ExpectedOutcome.ACCEPTED:
+        return api.SolutionTag.OK if not is_first else api.SolutionTag.MA
+    if solution.outcome == ExpectedOutcome.ACCEPTED_OR_TLE:
+        return api.SolutionTag.TO
+    if solution.outcome == ExpectedOutcome.WRONG_ANSWER:
+        return api.SolutionTag.WA
+    if solution.outcome == ExpectedOutcome.TIME_LIMIT_EXCEEDED:
+        return api.SolutionTag.TL
+    if solution.outcome == ExpectedOutcome.MEMORY_LIMIT_EXCEEDED:
+        return api.SolutionTag.ML
+    if solution.outcome == ExpectedOutcome.RUNTIME_ERROR:
+        return api.SolutionTag.RE
+    return api.SolutionTag.RJ
+
+
+def _find_or_create_problem(problem_name: str) -> api.Problem:
+    results = POLY.problems_list(name=problem_name)
+    for result in results:
+        if result.name == problem_name:
+            console.console.print(
+                f'Found already existing problem [item]{problem_name}[/item].'
+            )
+            return result
+    console.console.print(f'Creating new problem [item]{problem_name}[/item].')
+    return POLY.problem_create(problem_name)
+
+
+def _update_problem_info(problem: api.Problem):
+    pkg = package.find_problem_package_or_die()
+
+    problem.update_info(
+        api.ProblemInfo(
+            interactive=pkg.type == TaskType.COMMUNICATION,
+            time_limit=pkg.timeLimit,
+            memory_limit=pkg.memoryLimit,
+        )
+    )
+
+
+def _get_checker_name() -> str:
+    checker = package.get_checker()
+    return checker.path.with_stem('checker').name
+
+
+def _get_interactor_name() -> str:
+    interactor = package.get_interactor()
+    return interactor.path.with_stem('interactor').name
+
+
+def _get_validator_name() -> str:
+    validator = package.get_validator()
+    return validator.path.with_stem('validator').name
+
+
+def _update_rbx_header(problem: api.Problem):
+    console.console.print('Uploading rbx.h...')
+    rbx_header = header.get_header()
+    problem.save_file(
+        type=api.FileType.RESOURCE,
+        name='rbx.h',
+        file=rbx_header.read_bytes(),
+        source_type=None,
+    )
+
+
+def _update_checker(problem: api.Problem):
+    console.console.print('Uploading checker...')
+    checker = package.get_checker()
+    problem.save_file(
+        type=api.FileType.SOURCE,
+        name=_get_checker_name(),
+        file=checker.path.read_bytes(),
+        source_type=_get_source_type(checker),
+    )
+
+    problem.set_checker(_get_checker_name())
+
+
+def _update_interactor(problem: api.Problem):
+    console.console.print('Uploading interactor...')
+    interactor = package.get_interactor()
+    problem.save_file(
+        type=api.FileType.SOURCE,
+        name=_get_interactor_name(),
+        file=interactor.path.read_bytes(),
+        source_type=_get_source_type(interactor),
+    )
+
+    problem.set_interactor(_get_interactor_name())
+
+
+def _upload_validator(problem: api.Problem):
+    console.console.print('Uploading validator...')
+    validator = package.get_validator()
+    problem.save_file(
+        type=api.FileType.SOURCE,
+        name=_get_validator_name(),
+        file=validator.path.read_bytes(),
+        source_type=_get_source_type(validator),
+    )
+
+    problem.set_validator(_get_validator_name())
+
+
+def _save_skip_coinciding_testcases(problem: api.Problem, *args, **kwargs) -> bool:
+    try:
+        problem.save_test(*args, **kwargs)
+    except api.PolygonRequestFailedException as e:
+        if 'test coincides with' in e.comment.lower():
+            return False
+        raise
+    return True
+
+
+def _get_test_params_for_statement(
+    testcase: Testcase, is_sample: bool
+) -> Dict[str, Any]:
+    if not is_sample:
+        return {}
+    res: Dict[str, Any] = {'test_use_in_statements': True}
+    if testcase.outputPath is not None:
+        res['test_output_for_statements'] = testcase.outputPath.read_text()
+    else:
+        return res
+
+    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()
+    return res
+
+
+def _upload_testcases(problem: api.Problem):
+    pkg = package.find_problem_package_or_die()
+    testcases = get_all_built_testcases()
+    i = 0
+
+    with rich.progress.Progress(speed_estimate_period=5) as progress:
+        total_len = 0
+        for group in pkg.testcases:
+            total_len += len(testcases[group.name])
+        task_id = progress.add_task('Uploading testcases...', total=total_len)
+        for group in pkg.testcases:
+            for testcase in testcases[group.name]:
+                is_sample = group.name == 'samples'
+                saved = _save_skip_coinciding_testcases(
+                    problem,
+                    testset='tests',
+                    test_index=i + 1,
+                    test_input=testcase.inputPath.read_text(),
+                    **_get_test_params_for_statement(testcase, is_sample),
+                )
+                progress.update(task_id, advance=1)
+                if saved:
+                    i += 1
+
+
+def _upload_solutions(problem: api.Problem):
+    console.console.print('Uploading main solution...')
+    pkg = package.find_problem_package_or_die()
+    main_solution = pkg.solutions[0]
+    if main_solution is None or main_solution.outcome != ExpectedOutcome.ACCEPTED:
+        return
+    problem.save_solution(
+        main_solution.path.name,
+        main_solution.path.read_bytes(),
+        source_type=_get_source_type(main_solution),
+        tag=api.SolutionTag.MA,
+    )
+
+    for i, solution in enumerate(pkg.solutions):
+        console.console.print(
+            f'Uploading solution [item]{solution.path.name}[/item] (tag: [item]{_get_solution_tag(solution, is_first=i == 0)}[/item])...'
+        )
+        problem.save_solution(
+            solution.path.name,
+            solution.path.read_bytes(),
+            source_type=_get_source_type(solution),
+            tag=_get_solution_tag(solution, is_first=i == 0),
+        )
+
+
+def _get_statement_for_language(language: str) -> Optional[Statement]:
+    pkg = package.find_problem_package_or_die()
+    for statement in pkg.statements:
+        if statement.language == language:
+            return statement
+    return None
+
+
+def _get_statement_blocks(statement: Statement) -> StatementBlocks:
+    # TODO: actually try to convert to rbxTeX
+    assert statement.type == StatementType.rbxTeX
+    builder_problem = StatementBuilderProblem(
+        package=package.find_problem_package_or_die(),
+        statement=statement,
+    )
+    with tempfile.TemporaryDirectory() as temp_dir:
+        return render_jinja_blocks(
+            pathlib.Path(temp_dir),
+            statement.path.read_bytes(),
+            **builder_problem.build_inner_jinja_kwargs(),
+        )
+
+
+def _upload_statement_resources(problem: api.Problem, statement: Statement):
+    assets = get_relative_assets(statement.path, statement.assets)
+    for asset, relative_asset in assets:
+        console.console.print(
+            f'Uploading statement resource [item]{relative_asset}[/item]...'
+        )
+        resource_bytes = asset.read_bytes()
+        if len(resource_bytes) >= 1024 * 1024:  # >= 1mb
+            console.console.print(
+                f'[error]Statement resource [item]{relative_asset}[/item] is too large to upload (more than 1MB).[/error]'
+            )
+            raise typer.Exit(1)
+        problem.save_statement_resource(
+            name=str(relative_asset),
+            file=resource_bytes,
+        )
+
+
+def _upload_statement(problem: api.Problem):
+    pkg = package.find_problem_package_or_die()
+
+    languages = set()
+    for statement in pkg.statements:
+        if not is_valid_lang_code(statement.language):
+            continue
+        languages.add(statement.language)
+    for language in languages:
+        statement = _get_statement_for_language(language)
+        if statement is None:
+            continue
+        if statement.type != StatementType.rbxTeX:
+            continue
+        console.console.print(
+            f'Uploading statement for language [item]{language}[/item] (polygon language: [item]{code_to_langs([language])[0]}[/item])...'
+        )
+        blocks = _get_statement_blocks(statement)
+        polygon_statement = api.Statement(
+            encoding='utf-8',
+            name=statement.title,
+            legend=blocks.blocks.get('legend'),
+            input=blocks.blocks.get('input'),
+            output=blocks.blocks.get('output'),
+            interaction=blocks.blocks.get('interaction'),
+            notes=blocks.blocks.get('notes'),
+        )
+        problem.save_statement(
+            lang=code_to_langs([language])[0], problem_statement=polygon_statement
+        )
+
+        _upload_statement_resources(problem, statement)
+
+
+def _normalize_problem_name(name: str) -> str:
+    return name.replace(' ', '-').replace('_', '-').lower()
+
+
+async def upload_problem(name: str):
+    pkg = package.find_problem_package_or_die()
+    name = _normalize_problem_name(name)
+    problem = _find_or_create_problem(name)
+    _update_problem_info(problem)
+    _update_checker(problem)
+    _update_rbx_header(problem)
+
+    if (
+        pkg.type == TaskType.COMMUNICATION
+        and package.get_interactor_or_nil() is not None
+    ):
+        _update_interactor(problem)
+
+    # if pkg.validator is not None:
+    #     _upload_validator(problem)
+
+    _upload_solutions(problem)
+    _upload_testcases(problem)
+    _upload_statement(problem)
+
+    # Commit.
+    console.console.print('Committing changes...')
+    problem.commit_changes()
+
+    console.console.print(
+        f'[success]Problem [item]{name}[/item] uploaded successfully![/success]'
+    )

rbx/box/packaging/polygon/xml_schema.py

@@ -65,6 +65,10 @@ class Checker(BaseXmlModel):
     testset: Optional[Testset] = element(default=None)
 
 
+class Interactor(BaseXmlModel):
+    source: File = element()
+
+
 class Problem(BaseXmlModel, tag='problem'):
     names: List[Name] = wrapped('names', element(tag='name'), default_factory=list)
 
@@ -84,6 +88,8 @@ class Problem(BaseXmlModel, tag='problem'):
 
     checker: Checker = wrapped('assets', element(tag='checker'))
 
+    interactor: Optional[Interactor] = wrapped('assets', element(tag='interactor'))
+
 
 class ContestProblem(BaseXmlModel):
     index: str = attr()

rbx/box/solutions.py

@@ -47,7 +47,12 @@ from rbx.box.tasks import (
     run_solution_on_testcase,
 )
 from rbx.box.testcase_extractors import extract_generation_testcases
-from rbx.box.testcase_utils import TestcaseEntry, find_built_testcases
+from rbx.box.testcase_utils import (
+    TestcaseEntry,
+    find_built_testcases,
+    parse_interaction,
+    print_interaction,
+)
 from rbx.grading.steps import (
     Evaluation,
     Outcome,
@@ -323,6 +328,19 @@ def _produce_solution_items(
     return res
 
 
+def print_best_output(output_files: List[pathlib.Path], empty_warning: bool = False):
+    for output_file in output_files:
+        if not output_file.is_file():
+            continue
+        if output_file.suffix == '.pio':
+            print_interaction(parse_interaction(output_file))
+        else:
+            console.console.print(output_file.read_text())
+        return
+    if empty_warning:
+        console.console.print('[warning]Solution produced no output.[/warning]')
+
+
 def run_solutions(
     progress: Optional[StatusProgress] = None,
     tracked_solutions: Optional[Set[str]] = None,
@@ -528,6 +546,7 @@ def _run_interactive_solutions(
                 output_dir=output_dir,
                 interactor_digest=interactor_digest,
                 verification=verification,
+                capture_pipes=True,
             )
 
         yield EvaluationItem(
@@ -589,18 +608,28 @@ async def run_and_print_interactive_solutions(
             )
 
         stdout_path = eval.log.stdout_absolute_path
-        if print:
+        if print and stdout_path is not None:
+            if pkg.type == TaskType.COMMUNICATION:
+                console.console.rule('Interaction', style='status')
+                output_files = [
+                    stdout_path.with_suffix('.pio'),
+                    stdout_path.with_suffix('.pout'),
+                ]
+                print_best_output(output_files, empty_warning=True)
+
             console.console.rule('Output', style='status')
-            if (
-                eval.testcase.output is not None
-                and stdout_path is not None
-                and stdout_path.is_file()
-            ):
-                console.console.print(stdout_path.read_text())
-            else:
-                console.console.print('[warning]Solution produced no output.[/warning]')
+            output_files = [stdout_path]
+            print_best_output(output_files, empty_warning=True)
         elif stdout_path is not None:
-            console.console.print(f'[status]Output:[/status] {stdout_path}')
+            if stdout_path.with_suffix('.pout').is_file():
+                stdout_path = stdout_path.with_suffix('.pout')
+
+            if stdout_path.is_file():
+                console.console.print(f'[status]Output:[/status] {stdout_path}')
+            if stdout_path.with_suffix('.pio').is_file():
+                console.console.print(
+                    f'[status]Interaction:[/status] {stdout_path.with_suffix(".pio")}'
+                )
             if eval.log.stderr_absolute_path is not None:
                 console.console.print(
                     f'[status]Stderr:[/status] {eval.log.stderr_absolute_path}'
@@ -860,29 +889,37 @@ def _print_solution_header(
     console.print(f'({solution_testdir})')
 
 
+@dataclasses.dataclass
+class SolutionTiming:
+    time: int
+    solution: Solution
+
+
 @dataclasses.dataclass
 class TimingSummary:
-    slowest_good: Optional[int] = None
-    fastest_slow: Optional[int] = None
+    slowest_good: Optional[SolutionTiming] = None
+    fastest_slow: Optional[SolutionTiming] = None
 
-    def add_good(self, time: int):
-        if self.slowest_good is None or time > self.slowest_good:
-            self.slowest_good = time
+    def add_good(self, time: int, solution: Solution):
+        if self.slowest_good is None or time > self.slowest_good.time:
+            self.slowest_good = SolutionTiming(time, solution)
 
-    def add_slow(self, time: int):
-        if self.fastest_slow is None or time < self.fastest_slow:
-            self.fastest_slow = time
+    def add_slow(self, time: int, solution: Solution):
+        if self.fastest_slow is None or time < self.fastest_slow.time:
+            self.fastest_slow = SolutionTiming(time, solution)
 
     def print(self, console: rich.console.Console, tl: Optional[int] = None):
         if self.slowest_good is not None:
             console.print(
-                f'Slowest [success]OK[/success] solution: {self.slowest_good} ms'
+                f'Slowest [success]OK[/success] solution: {self.slowest_good.time} ms, [item]{self.slowest_good.solution.path}[/item]'
             )
         if self.fastest_slow is not None:
-            fastest_slow = self.fastest_slow
-            if tl is not None and self.fastest_slow > tl:
+            fastest_slow = self.fastest_slow.time
+            if tl is not None and self.fastest_slow.time > tl:
                 fastest_slow = f'>{tl}'
-            console.print(f'Fastest [error]slow[/error] solution: {fastest_slow} ms')
+            console.print(
+                f'Fastest [error]slow[/error] solution: {fastest_slow} ms, [item]{self.fastest_slow.solution.path}[/item]'
+            )
 
 
 async def _print_timing(
@@ -924,11 +961,11 @@ async def _print_timing(
 
         # Get solution timings.
         if solution.outcome.match(Outcome.ACCEPTED):
-            summary.add_good(solution_time)
-            summary_per_language[solution.language].add_good(solution_time)
+            summary.add_good(solution_time, solution)
+            summary_per_language[solution.language].add_good(solution_time, solution)
         if solution.outcome.is_slow():
-            summary.add_slow(solution_time)
-            summary_per_language[solution.language].add_slow(solution_time)
+            summary.add_slow(solution_time, solution)
+            summary_per_language[solution.language].add_slow(solution_time, solution)
 
     if summary.slowest_good is None and summary.fastest_slow is None:
         return

rbx/box/testcase_utils.py

@@ -2,6 +2,8 @@ import pathlib
 import shutil
 from typing import List, Optional, Tuple
 
+import rich
+import rich.text
 import typer
 from pydantic import BaseModel
 
@@ -209,3 +211,28 @@ def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
         prefixes=(interactor_prefix, solution_prefix),
         entries=entries,
     )
+
+
+def get_alternate_interaction_texts(
+    interaction: TestcaseInteraction,
+) -> Tuple[str, str]:
+    interactor_entries = []
+    solution_entries = []
+    for entry in interaction.entries:
+        if entry.pipe == 1:
+            solution_entries.append(entry.data)
+            interactor_entries.extend(['\n'] * entry.data.count('\n'))
+        else:
+            interactor_entries.append(entry.data)
+            solution_entries.extend(['\n'] * entry.data.count('\n'))
+    return ''.join(interactor_entries), ''.join(solution_entries)
+
+
+def print_interaction(interaction: TestcaseInteraction):
+    for entry in interaction.entries:
+        text = rich.text.Text(entry.data)
+        if entry.pipe == 0:
+            text.stylize('status')
+        else:
+            text.stylize('info')
+        console.console.print(text, end='')

rbx/box/testcases/main.py

@@ -90,6 +90,7 @@ async def _generate_for_editing(
 
 
 @app.command('view, v', help='View a testcase in your default editor.')
+@package.within_problem
 @syncer.sync
 async def view(
     tc: Annotated[
@@ -126,6 +127,7 @@ async def view(
 
 
 @app.command('info, i', help='Show information about testcases.')
+@package.within_problem
 @syncer.sync
 async def info(
     pattern: Annotated[

rbx/box/unit.py

@@ -29,6 +29,16 @@ class CheckerTestEntry(BaseModel):
     answer: Optional[pathlib.Path] = None
     outcome: ExpectedOutcome
 
+    def running_tests_formatted_string(self) -> str:
+        res = []
+        if self.input:
+            res.append(f'[item]{self.input}[/item]')
+        if self.output:
+            res.append(f'[item]{self.output}[/item]')
+        if self.answer:
+            res.append(f'[item]{self.answer}[/item]')
+        return ', '.join(res)
+
 
 def _extract_validator_test_entries(
     tests: List[ValidatorTest],
@@ -91,13 +101,16 @@ async def run_validator_unit_tests(progress: StatusProgress):
         if val is not None:
             vals.append(val)
 
+    console.console.rule('Validator tests', style='info')
+    if not entries:
+        console.console.print('No validator unit tests found.')
+        return
+
     compiled_validators = validators.compile_validators(vals, progress=progress)
 
     if progress:
         progress.update('Running validator unit tests...')
 
-    console.console.rule('Validator tests', style='info')
-
     for i, test in enumerate(entries):
         val = _get_validator_for_test(test)
         if val is None:
@@ -127,7 +140,10 @@ async def run_validator_unit_tests(progress: StatusProgress):
             if info.ok:
                 console.console.print('  [status]Actual[/status] VALID')
             else:
-                console.console.print(f'  [status]Actual[/status] {info.message}')
+                console.console.print('  [status]Actual[/status] INVALID')
+
+        if info.message:
+            console.console.print(f'  [status]Message[/status] {info.message}')
 
 
 async def run_checker_unit_tests(progress: StatusProgress):
@@ -141,15 +157,19 @@ async def run_checker_unit_tests(progress: StatusProgress):
         )
         return
 
+    console.console.rule('Checker tests', style='info')
+
+    entries = _extract_checker_test_entries(pkg.unitTests.checker)
+    if not entries:
+        console.console.print('No checker unit tests found.')
+        return
+
     compiled_digest = checkers.compile_checker(progress=progress)
 
     if progress:
         progress.update('Running checker unit tests...')
 
-    console.console.rule('Checker tests', style='info')
-
     empty_file = package.get_empty_sentinel_path()
-    entries = _extract_checker_test_entries(pkg.unitTests.checker)
 
     for i, test in enumerate(entries):
         result = await checkers.check(
@@ -169,13 +189,15 @@ async def run_checker_unit_tests(progress: StatusProgress):
             else '[error]FAIL[/error]'
         )
 
-        console.console.print(f'{markup} Unit test [item]#{i + 1}[/item]')
+        console.console.print(
+            f'{markup} Unit test [item]#{i + 1}[/item] ({test.running_tests_formatted_string()})'
+        )
         console.console.print(f'  [status]Expected[/status] {test.outcome.name}')
 
         if not test.outcome.match(result.outcome):
             console.console.print(f'  [status]Actual[/status] {result.outcome.name}')
-            if result.message:
-                console.console.print(f'  [status]Message[/status] {result.message}')
+        if result.message:
+            console.console.print(f'  [status]Message[/status] {result.message}')
 
 
 @syncer.sync

rbx/resources/packagers/boca/checker.sh

@@ -14,11 +14,16 @@ read -r -d '' TestlibContent <<"EOF"
 {{testlib_content}}
 EOF
 
+read -r -d '' RbxHeaderContent <<"EOF"
+{{rbx_header_content}}
+EOF
+
 read -r -d '' CheckerContent <<"EOF"
 {{checker_content}}
 EOF
 
 printf "%s" "${TestlibContent}" >testlib.h
+printf "%s" "${RbxHeaderContent}" >rbx.h
 printf "%s" "${CheckerContent}" >$CHECKER_PATH
 
 checker_hash=($(md5sum $CHECKER_PATH))