rbx.cp 0.5.50__py3-none-any.whl → 0.5.52__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

@@ -5,7 +5,7 @@ import dataclasses
 import pathlib
 import shutil
 from collections.abc import Iterator
-from typing import Dict, Iterable, List, Optional, Set, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
 
 import rich
 import rich.live
@@ -16,7 +16,7 @@ import typer
 from pydantic import BaseModel
 
 from rbx import console, utils
-from rbx.box import checkers, package
+from rbx.box import checkers, environment, package
 from rbx.box.code import (
     SanitizationLevel,
     compile_item,
@@ -889,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(
@@ -953,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
@@ -1236,6 +1244,16 @@ async def print_run_report(
     return ok
 
 
+def _step_up(x: Any, step: int) -> int:
+    x = int(x)
+    return (x + step - 1) // step * step
+
+
+def _step_down(x: Any, step: int) -> int:
+    x = int(x)
+    return x // step * step
+
+
 async def estimate_time_limit(
     console: rich.console.Console,
     result: RunSolutionResult,
@@ -1254,12 +1272,12 @@ async def estimate_time_limit(
     for solution in result.skeleton.solutions:
         timings = []
         for evals in structured_evaluations[str(solution.path)].values():
-            for eval in evals:
-                if eval is None:
+            for ev in evals:
+                if ev is None:
                     continue
-                eval = await eval()
-                if eval.log.time is not None:
-                    timings.append(int(eval.log.time * 1000))
+                ev = await ev()
+                if ev.log.time is not None:
+                    timings.append(int(ev.log.time * 1000))
 
         if not timings:
             console.print(
@@ -1293,7 +1311,19 @@ async def estimate_time_limit(
             f'Slowest language: {slowest_language} ({slowest_language_time} ms)'
         )
 
-    estimated_tl = int(max(fastest_time * 3, slowest_time * 1.5))
-    console.print(f'[success]Estimated time limit:[/success] {estimated_tl} ms')
+    env = environment.get_environment()
+    estimated_tl = int(
+        eval(
+            env.timing.formula,
+            {
+                'fastest': fastest_time,
+                'slowest': slowest_time,
+                'step_up': _step_up,
+                'step_down': _step_down,
+            },
+        )
+    )
 
+    console.print(f'Using formula: {env.timing.formula}')
+    console.print(f'[success]Estimated time limit:[/success] {estimated_tl} ms')
     return estimated_tl

rbx/box/stresses.py

@@ -1,8 +1,8 @@
-import functools
 import time
 from shutil import rmtree
 from typing import List, Optional
 
+import async_lru
 import syncer
 import typer
 from pydantic import BaseModel
@@ -147,7 +147,7 @@ async def run_stress(
             else None,
         )
 
-        @functools.cache
+        @async_lru.alru_cache
         async def run_solution_fn(
             solution: str,
             retry_index: Optional[int] = None,
@@ -197,7 +197,7 @@ async def run_stress(
                 raise typer.Exit(1)
             expected_output_path = main_testcase_log.stdout_absolute_path
 
-        @functools.cache
+        @async_lru.alru_cache
         async def run_solution_and_checker_fn(
             call: finder_parser.FinderCall,
             input_path=input_path,
@@ -242,9 +242,12 @@ async def run_stress(
                 checker_result=eval.result,
             )
 
-        runner = finder_parser.FinderTreeRunner(
-            runner=syncer.sync(run_solution_and_checker_fn)
-        )
+        @syncer.sync
+        async def run_fn(*args, **kwargs):
+            # Wrap the runner in a syncer.sync to make it work with the finder parser.
+            return await run_solution_and_checker_fn(*args, **kwargs)
+
+        runner = finder_parser.FinderTreeRunner(runner=run_fn)
         finder_outcome: finder_parser.FinderOutcome = runner.transform(parsed_finder)
 
         internal_error_results = [

rbx/box/testcase_utils.py

@@ -213,6 +213,21 @@ def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
     )
 
 
+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)

rbx/box/ui/captured_log.py

@@ -8,7 +8,7 @@ import re
 import signal
 import struct
 import termios
-from typing import Callable, List, Optional
+from typing import Callable, List, Optional, Tuple
 
 import pyte
 import textual
@@ -321,10 +321,14 @@ class LogDisplay(ScrollView, can_focus=True):
                 loop.remove_reader(pout)
             event.set()
 
-        async def cleanup():
+        async def cleanup(wait_tp: Optional[Tuple[int, int]] = None):
+            if self.exitcode is not None:
+                return
             try:
                 loop.remove_reader(pout)
-                _, exitstatus = os.waitpid(pid, os.WNOHANG)
+                if wait_tp is None:
+                    wait_tp = os.waitpid(pid, os.WNOHANG)
+                _, exitstatus = wait_tp
                 exitcode = os.waitstatus_to_exitcode(exitstatus)
                 self.exitcode = exitcode
             except ChildProcessError:
@@ -352,8 +356,8 @@ class LogDisplay(ScrollView, can_focus=True):
         async def wait():
             while True:
                 try:
-                    if os.waitpid(pid, os.WNOHANG) != (0, 0):
-                        await cleanup()
+                    if (wait_tp := os.waitpid(pid, os.WNOHANG)) != (0, 0):
+                        await cleanup(wait_tp)
                 except ChildProcessError:
                     break
                 await asyncio.sleep(0.5)

rbx/box/ui/css/app.tcss

@@ -3,7 +3,7 @@ Screen {
         color: $text;
 }
 
-rbxApp > Screen {
+Screen {
         align: center middle;
 }