rbx.cp 0.13.8__py3-none-any.whl → 0.16.0__py3-none-any.whl

rbx/box/generators.py

@@ -378,7 +378,8 @@ async def generate_testcases(
 
 
 async def generate_output_for_testcase(
-    main_solution_digest: str,
+    model_solution: CodeItem,
+    model_solution_digest: str,
     testcase: Testcase,
     interactor_digest: Optional[str] = None,
     capture_pipes: Optional[bool] = None,
@@ -387,13 +388,9 @@ async def generate_output_for_testcase(
     testcase.inputPath.parent.mkdir(parents=True, exist_ok=True)
     testcase.outputPath.parent.mkdir(parents=True, exist_ok=True)
 
-    main_solution = package.get_main_solution()
-    if main_solution is None:
-        return
-
     eval: Evaluation = await run_solution_on_testcase(
-        main_solution,
-        main_solution_digest,
+        model_solution,
+        model_solution_digest,
         None,
         testcase,
         interactor_digest=interactor_digest,
@@ -439,7 +436,7 @@ async def generate_outputs_for_testcases(
     needs_output = _needs_output(generation_entries)
 
     main_solution = package.get_main_solution()
-    solution_digest: Optional[str] = None
+    solution_digest_map = {}
 
     pkg = package.find_problem_package_or_die()
 
@@ -452,11 +449,30 @@ async def generate_outputs_for_testcases(
         if progress:
             progress.update('Compiling main solution...')
         try:
-            solution_digest = compile_item(main_solution)
+            solution_digest_map[main_solution.path] = compile_item(main_solution)
         except:
             console.console.print('[error]Failed compiling main solution.[/error]')
             raise
 
+    for entry in generation_entries:
+        if (
+            entry.model_solution is not None
+            and entry.model_solution.path not in solution_digest_map
+        ):
+            if progress:
+                progress.update(
+                    f'Compiling model solution [item]{entry.model_solution.path}[/item]...'
+                )
+            try:
+                solution_digest_map[entry.model_solution.path] = compile_item(
+                    entry.model_solution
+                )
+            except:
+                console.console.print(
+                    f'[error]Failed compiling model solution [item]{entry.model_solution.path}[/item].[/error]'
+                )
+                raise
+
     gen_runs_dir = package.get_problem_runs_dir() / '.gen'
     shutil.rmtree(str(gen_runs_dir), ignore_errors=True)
     gen_runs_dir.mkdir(parents=True, exist_ok=True)
@@ -476,15 +492,17 @@ async def generate_outputs_for_testcases(
             continue
 
         assert needs_output
+        model_solution = entry.model_solution or main_solution
         if (
-            main_solution is None or solution_digest is None
+            model_solution is None or model_solution.path not in solution_digest_map
         ) and not tc.outputPath.is_file():
             console.console.print(
-                '[error]No main solution found to generate outputs for testcases.[/error]',
+                '[error]No main/model solution found to generate outputs for testcases.[/error]',
             )
             raise typer.Exit(1)
 
-        assert solution_digest is not None
+        assert model_solution is not None
+        model_solution_digest = solution_digest_map[model_solution.path]
         capture_pipes = None
         if (
             pkg.type == TaskType.COMMUNICATION
@@ -497,7 +515,8 @@ async def generate_outputs_for_testcases(
             )
 
         await generate_output_for_testcase(
-            solution_digest,
+            model_solution,
+            model_solution_digest,
             tc,
             interactor_digest=interactor_digest,
             capture_pipes=capture_pipes,

rbx/box/git_utils.py

@@ -1,7 +1,9 @@
 import pathlib
-from typing import Optional
+import subprocess
+from typing import List, Optional
 
 import git
+import semver
 
 
 def get_repo_or_nil(
@@ -26,3 +28,29 @@ def get_any_remote(repo: git.Repo) -> Optional[git.Remote]:
         if remote.exists():
             return remote
     return None
+
+
+def _parse_tag_from_ref(ref: str) -> str:
+    return ref.split('/')[-1].split('^{}')[0]
+
+
+def ls_remote_tags(uri: str) -> List[str]:
+    completed_process = subprocess.run(
+        ['git', 'ls-remote', '--tags', uri],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return [
+        _parse_tag_from_ref(line.split('\t')[1])
+        for line in completed_process.stdout.split('\n')
+        if line
+    ]
+
+
+def latest_remote_tag(uri: str) -> str:
+    tags = ls_remote_tags(uri)
+    valid_tags = [tag for tag in tags if semver.Version.is_valid(tag)]
+    if not valid_tags:
+        raise ValueError(f'No valid tags found for {uri}')
+    return sorted(valid_tags, key=semver.VersionInfo.parse)[-1]

rbx/box/limits_info.py

@@ -0,0 +1,161 @@
+import contextvars
+import pathlib
+from typing import Optional
+
+import typer
+
+from rbx import console, utils
+from rbx.box import package
+from rbx.box.environment import VerificationLevel
+from rbx.box.schema import LimitsProfile
+from rbx.grading.limits import Limits
+
+profile_var = contextvars.ContextVar[Optional[str]]('profile', default=None)
+
+
+def get_active_profile() -> Optional[str]:
+    return profile_var.get()
+
+
+class use_profile:
+    def __init__(self, profile: Optional[str]):
+        self.profile = profile
+        self.token = None
+
+    def __enter__(self):
+        self.token = profile_var.set(self.profile)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.token is not None:
+            profile_var.reset(self.token)
+
+
+def _expand_limits_profile(
+    limits_profile: LimitsProfile, root: pathlib.Path
+) -> LimitsProfile:
+    pkg = package.find_problem_package_or_die(root=root)
+    res = LimitsProfile(
+        timeLimit=pkg.timeLimit,
+        memoryLimit=pkg.memoryLimit,
+        outputLimit=pkg.outputLimit,
+    )
+    for language, modifier in pkg.modifiers.items():
+        res.modifiers[language] = modifier.model_copy(deep=True)
+
+    if limits_profile.inheritFromPackage:
+        return res
+
+    time_is_overridden = limits_profile.timeLimit is not None
+    memory_is_overridden = limits_profile.memoryLimit is not None
+    output_is_overridden = limits_profile.outputLimit is not None
+    if time_is_overridden:
+        res.timeLimit = limits_profile.timeLimit
+    if memory_is_overridden:
+        res.memoryLimit = limits_profile.memoryLimit
+    if output_is_overridden:
+        res.outputLimit = limits_profile.outputLimit
+
+    for modifier in res.modifiers.values():
+        # Clean up modifiers coming from the package that are not overridden
+        # by the base limits profile.
+        if time_is_overridden:
+            modifier.time = None
+        if memory_is_overridden:
+            modifier.memory = None
+
+    for language, modifier in limits_profile.modifiers.items():
+        if modifier.time is not None:
+            res.modifiers[language].time = modifier.time
+        if modifier.timeMultiplier is not None:
+            res.modifiers[language].timeMultiplier = modifier.timeMultiplier
+        if modifier.memory is not None:
+            res.modifiers[language].memory = modifier.memory
+    return res
+
+
+def _get_limits_from_profile(
+    language: Optional[str],
+    limits_profile: LimitsProfile,
+    source_profile: Optional[str],
+    verification: VerificationLevel,
+    root: pathlib.Path,
+) -> Limits:
+    limits_profile = _expand_limits_profile(limits_profile, root=root)
+    return Limits(
+        time=limits_profile.timelimit_for_language(language),
+        memory=limits_profile.memorylimit_for_language(language),
+        output=limits_profile.outputLimit,
+        isDoubleTL=verification.value >= VerificationLevel.FULL.value,
+        profile=source_profile,
+    )
+
+
+def get_saved_limits_profile(
+    profile: str = 'local', root: pathlib.Path = pathlib.Path()
+) -> Optional[LimitsProfile]:
+    limits_path = package.get_limits_file(profile, root=root)
+    if not limits_path.exists():
+        return None
+    return utils.model_from_yaml(LimitsProfile, limits_path.read_text())
+
+
+def get_package_limits_profile(root: pathlib.Path = pathlib.Path()) -> LimitsProfile:
+    profile = LimitsProfile(inheritFromPackage=True)
+    return _expand_limits_profile(profile, root=root)
+
+
+def get_package_limits(
+    verification: VerificationLevel = VerificationLevel.NONE,
+    root: pathlib.Path = pathlib.Path(),
+) -> Limits:
+    return _get_limits_from_profile(
+        language=None,
+        limits_profile=get_package_limits_profile(root=root),
+        source_profile=None,
+        verification=verification,
+        root=root,
+    )
+
+
+def get_limits_profile(
+    profile: Optional[str] = None,
+    fallback_to_package_profile: bool = True,
+    root: pathlib.Path = pathlib.Path(),
+) -> LimitsProfile:
+    if profile is None:
+        return get_package_limits_profile(root=root)
+    saved_profile = get_saved_limits_profile(profile, root=root)
+    if saved_profile is None:
+        if fallback_to_package_profile:
+            return get_package_limits_profile(root=root)
+        console.console.print(
+            f'[error]Limits profile [item]{profile}[/item] not found.[/error]'
+        )
+        raise typer.Exit(1)
+    return _expand_limits_profile(saved_profile, root=root)
+
+
+def get_limits(
+    language: Optional[str] = None,
+    profile: Optional[str] = None,
+    fallback_to_package_profile: bool = True,
+    verification: VerificationLevel = VerificationLevel.NONE,
+    root: pathlib.Path = pathlib.Path(),
+) -> Limits:
+    source_profile = None
+    limits_profile = LimitsProfile(inheritFromPackage=True)
+    if profile is not None:
+        specified_limits_profile = get_saved_limits_profile(profile, root=root)
+        if specified_limits_profile is not None:
+            limits_profile = specified_limits_profile
+            source_profile = profile
+        elif not fallback_to_package_profile:
+            console.console.print(
+                f'[error]Limits profile [item]{profile}[/item] not found.[/error]'
+            )
+            raise typer.Exit(1)
+
+    res = _get_limits_from_profile(
+        language, limits_profile, source_profile, verification, root=root
+    )
+    return res

rbx/box/package.py

@@ -12,6 +12,7 @@ from rbx import console, utils
 from rbx.box import cd, global_package
 from rbx.box.environment import get_sandbox_type
 from rbx.box.global_package import get_cache_fingerprint
+from rbx.box.sanitizers import issue_stack
 from rbx.box.schema import (
     CodeItem,
     ExpectedOutcome,
@@ -80,7 +81,13 @@ def within_problem(func):
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
         with cd.new_package_cd(find_problem()):
-            return func(*args, **kwargs)
+            issue_level_token = issue_stack.issue_level_var.set(
+                issue_stack.IssueLevel.DETAILED
+            )
+            ret = func(*args, **kwargs)
+            issue_stack.print_current_report()
+            issue_stack.issue_level_var.reset(issue_level_token)
+            return ret
 
     return wrapper
 
@@ -147,6 +154,16 @@ def get_problem_iruns_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     return iruns_dir
 
 
+def get_limits_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    limits_dir = root / '.limits'
+    limits_dir.mkdir(parents=True, exist_ok=True)
+    return limits_dir
+
+
+def get_limits_file(profile: str, root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    return get_limits_dir(root) / f'{profile}.yml'
+
+
 def get_problem_preprocessed_path(
     item: pathlib.Path, root: pathlib.Path = pathlib.Path()
 ) -> pathlib.Path:

rbx/box/packaging/boca/boca_language_utils.py

@@ -0,0 +1,26 @@
+import typing
+
+from rbx.box.environment import get_environment, get_language
+from rbx.box.packaging.boca.extension import BocaLanguage, BocaLanguageExtension
+
+
+def get_rbx_language_from_boca_language(boca_language: BocaLanguage) -> str:
+    for language in get_environment().languages:
+        language_extension = language.get_extension_or_default(
+            language.name, BocaLanguageExtension
+        )
+        if language_extension.bocaLanguage == boca_language:
+            return language.name
+    return boca_language
+
+
+def get_boca_language_from_rbx_language(rbx_language: str) -> BocaLanguage:
+    language = get_language(rbx_language)
+    language_extension = language.get_extension_or_default(
+        'boca', BocaLanguageExtension
+    )
+    if language_extension.bocaLanguage:
+        return typing.cast(BocaLanguage, language_extension.bocaLanguage)
+    if rbx_language.lower() in typing.get_args(BocaLanguage):
+        return typing.cast(BocaLanguage, rbx_language.lower())
+    raise ValueError(f'No Boca language found for Rbx language {rbx_language}')

rbx/box/packaging/boca/boca_outcome_utils.py

@@ -0,0 +1,10 @@
+from rbx.box.schema import ExpectedOutcome
+
+
+def simplify_rbx_expected_outcome(outcome: ExpectedOutcome) -> ExpectedOutcome:
+    if outcome in [
+        ExpectedOutcome.OUTPUT_LIMIT_EXCEEDED,
+        ExpectedOutcome.MEMORY_LIMIT_EXCEEDED,
+    ]:
+        return ExpectedOutcome.RUNTIME_ERROR
+    return outcome

rbx/box/packaging/boca/packager.py

@@ -6,7 +6,7 @@ from typing import List
 import typer
 
 from rbx import console
-from rbx.box import header, naming, package
+from rbx.box import header, limits_info, naming, package
 from rbx.box.environment import get_extension_or_default
 from rbx.box.packaging.boca.extension import BocaExtension, BocaLanguage
 from rbx.box.packaging.packager import BasePackager, BuiltStatement
@@ -71,12 +71,14 @@ class BocaPackager(BasePackager):
         )
 
     def _get_pkg_timelimit(self, language: BocaLanguage) -> int:
-        pkg = package.find_problem_package_or_die()
-        return pkg.timelimit_for_language(language)
+        limits = limits_info.get_limits(language, profile='boca')
+        assert limits.time is not None
+        return limits.time
 
     def _get_pkg_memorylimit(self, language: BocaLanguage) -> int:
-        pkg = package.find_problem_package_or_die()
-        return pkg.memorylimit_for_language(language)
+        limits = limits_info.get_limits(language, profile='boca')
+        assert limits.memory is not None
+        return limits.memory
 
     def _get_number_of_runs(self, language: BocaLanguage) -> int:
         pkg = package.find_problem_package_or_die()

rbx/box/packaging/contest_main.py

@@ -6,7 +6,7 @@ import syncer
 import typer
 
 from rbx import annotations, console
-from rbx.box import cd, environment, package
+from rbx.box import cd, environment, limits_info, package
 from rbx.box.contest import build_contest_statements, contest_package
 from rbx.box.packaging.packager import (
     BaseContestPackager,
@@ -28,6 +28,11 @@ async def run_contest_packager(
 ):
     contest = contest_package.find_contest_package_or_die()
 
+    if limits_info.get_saved_limits_profile(contest_packager_cls.name()) is not None:
+        console.console.print(
+            f'[warning]Using saved limits profile for [item]{contest_packager_cls.name()}[/item].[/warning]'
+        )
+
     # Build problem-level packages.
     built_packages = []
     for problem in contest.problems:
@@ -52,21 +57,24 @@ async def run_contest_packager(
     statement_types = packager.statement_types()
     built_statements = []
 
-    for statement_type in statement_types:
-        languages = packager.languages()
-        for language in languages:
-            statement = packager.get_statement_for_language(language)
-            statement_path = build_contest_statements.build_statement(
-                statement, contest, statement_type
-            )
-            built_statements.append(
-                BuiltContestStatement(statement, statement_path, statement_type)
-            )
+    with limits_info.use_profile(contest_packager_cls.name()):
+        for statement_type in statement_types:
+            languages = packager.languages()
+            for language in languages:
+                statement = packager.get_statement_for_language(language)
+                statement_path = build_contest_statements.build_statement(
+                    statement, contest, statement_type
+                )
+                built_statements.append(
+                    BuiltContestStatement(statement, statement_path, statement_type)
+                )
 
     console.console.print(f'Packaging contest for [item]{packager.name()}[/item]...')
 
     # Build contest-level package.
-    with tempfile.TemporaryDirectory() as td:
+    with tempfile.TemporaryDirectory() as td, limits_info.use_profile(
+        contest_packager_cls.name()
+    ):
         result_path = packager.package(
             built_packages, pathlib.Path('build'), pathlib.Path(td), built_statements
         )

rbx/box/packaging/packager.py

@@ -8,7 +8,7 @@ from typing import List, Tuple, Type
 import typer
 
 from rbx import console
-from rbx.box import environment, header, naming, package
+from rbx.box import environment, header, limits_info, naming, package
 from rbx.box.contest import contest_package
 from rbx.box.contest.schema import ContestProblem, ContestStatement
 from rbx.box.formatting import href
@@ -103,8 +103,9 @@ class BasePackager(ABC):
 
 
 class BaseContestPackager(ABC):
+    @classmethod
     @abstractmethod
-    def name(self) -> str:
+    def name(cls) -> str:
         pass
 
     @abstractmethod
@@ -180,11 +181,17 @@ async def run_packager(
 
     header.generate_header()
 
-    if not await builder.verify(verification=verification):
+    if limits_info.get_saved_limits_profile(packager_cls.name()) is not None:
         console.console.print(
-            '[error]Build or verification failed, check the report.[/error]'
+            f'[warning]Using saved limits profile for [item]{packager_cls.name()}[/item].[/warning]'
         )
-        raise typer.Exit(1)
+
+    with limits_info.use_profile(packager_cls.name()):
+        if not await builder.verify(verification=verification):
+            console.console.print(
+                '[error]Build or verification failed, check the report.[/error]'
+            )
+            raise typer.Exit(1)
 
     pkg = package.find_problem_package_or_die()
 
@@ -199,18 +206,21 @@ async def run_packager(
     statement_types = packager.statement_types()
     built_statements = []
 
-    for statement_type in statement_types:
-        languages = packager.languages()
-        for language in languages:
-            statement = packager.get_statement_for_language(language)
-            statement_path = build_statement(statement, pkg, statement_type)
-            built_statements.append(
-                BuiltStatement(statement, statement_path, statement_type)
-            )
+    with limits_info.use_profile(packager_cls.name()):
+        for statement_type in statement_types:
+            languages = packager.languages()
+            for language in languages:
+                statement = packager.get_statement_for_language(language)
+                statement_path = build_statement(statement, pkg, statement_type)
+                built_statements.append(
+                    BuiltStatement(statement, statement_path, statement_type)
+                )
 
     console.console.print(f'Packaging problem for [item]{packager.name()}[/item]...')
 
-    with tempfile.TemporaryDirectory() as td:
+    with tempfile.TemporaryDirectory() as td, limits_info.use_profile(
+        packager_cls.name()
+    ):
         result_path = packager.package(
             package.get_build_path(), pathlib.Path(td), built_statements
         )

rbx/box/packaging/polygon/packager.py

@@ -5,7 +5,7 @@ from typing import List, Optional
 import typer
 
 from rbx import console, utils
-from rbx.box import header, package
+from rbx.box import header, limits_info, package
 from rbx.box.lang import code_to_lang, code_to_langs, is_valid_lang_code
 from rbx.box.packaging.packager import (
     BaseContestPackager,
@@ -123,10 +123,14 @@ class PolygonPackager(BasePackager):
 
         testcases = self.get_flattened_built_testcases()
 
+        limits = limits_info.get_limits(None, profile='polygon')
+        assert limits.time is not None
+        assert limits.memory is not None
+
         return polygon_schema.Testset(
             name='tests',
-            timelimit=pkg.timelimit_for_language(None),
-            memorylimit=pkg.memorylimit_for_language(None) * 1024 * 1024,
+            timelimit=limits.time,
+            memorylimit=limits.memory * 1024 * 1024,
             size=len(testcases),
             inputPattern='tests/%03d',
             answerPattern='tests/%03d.a',

rbx/box/packaging/polygon/upload.py

@@ -8,7 +8,7 @@ import rich.progress
 import typer
 
 from rbx import console
-from rbx.box import header, package
+from rbx.box import header, limits_info, package
 from rbx.box.generators import get_all_built_testcases
 from rbx.box.lang import code_to_langs, is_valid_lang_code
 from rbx.box.packaging.polygon import polygon_api as api
@@ -250,6 +250,7 @@ def _get_statement_blocks(statement: Statement) -> StatementBlocks:
     pkg = package.find_problem_package_or_die()
     # TODO: pull this from a library, too hacky at the moment
     builder_problem = StatementBuilderProblem(
+        limits=limits_info.get_limits_profile(profile='polygon'),
         package=pkg,
         statement=statement,
         vars={