rbx.cp 0.5.58__tar.gz → 0.5.61__tar.gz

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.5.58
+Version: 0.5.61
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9,<4.0

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.5.58"
+version = "0.5.61"
 description = ""
 packages = [
   {include = "rbx"}

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/rbx/box/checkers.py

@@ -60,8 +60,6 @@ def _any_failed(logs: List[Optional[RunLog]]) -> bool:
 
 
 def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
-    pkg = package.find_problem_package_or_die()
-
     is_sanitized = (
         run_log is not None
         and run_log.metadata is not None
@@ -71,7 +69,11 @@ def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
     if run_log is None:
         return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
 
-    timelimit = pkg.timelimit_for_language(run_log.get_run_language())
+    timelimit = (
+        run_log.metadata.limits.get_expanded_tl()
+        if run_log.metadata is not None
+        else None
+    )
     is_tl_unbounded = (
         run_log is not None
         and run_log.metadata is not None
@@ -81,7 +83,7 @@ def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
     if (
         run_log.time is not None
         and timelimit is not None
-        and run_log.time * 1000 > timelimit * 2
+        and run_log.time * 1000 > timelimit
         and not is_sanitized
         and not is_tl_unbounded
     ):
@@ -104,12 +106,16 @@ def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerRes
     if result.outcome == Outcome.TIME_LIMIT_EXCEEDED:
         # This already is a TLE outcome.
         return result
-    pkg = package.find_problem_package_or_die()
     is_sanitized = (
         run_log is not None
         and run_log.metadata is not None
         and run_log.metadata.is_sanitized
     )
+    timelimit = (
+        run_log.metadata.limits.time
+        if run_log is not None and run_log.metadata is not None
+        else None
+    )
     is_tl_unbounded = (
         run_log is not None
         and run_log.metadata is not None
@@ -118,8 +124,8 @@ def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerRes
     if (
         run_log is not None
         and run_log.time is not None
-        and run_log.time * 1000
-        >= pkg.timelimit_for_language(run_log.get_run_language())
+        and timelimit is not None
+        and run_log.time * 1000 >= timelimit
         and not is_sanitized
         and not is_tl_unbounded
     ):

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/rbx/box/code.py

@@ -357,6 +357,7 @@ def _prepare_run(
             is_sanitized=sanitized,
             timeLimit=sandbox_params.timeout,
             memoryLimit=sandbox_params.address_space,
+            limits=execution_options.problemLimits,
             retryIndex=retry_index,
         ),
     )

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/rbx/box/environment.py

@@ -11,6 +11,7 @@ from rbx.box.extensions import Extensions, LanguageExtensions
 from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
 from rbx.grading.judge.sandboxes.isolate import IsolateSandbox
 from rbx.grading.judge.sandboxes.stupid_sandbox import StupidSandbox
+from rbx.grading.limits import Limits
 
 T = TypeVar('T', bound=BaseModel)
 
@@ -104,6 +105,9 @@ class ExecutionConfig(BaseModel):
     # Sandbox configuration to use when executing for this language.
     sandbox: Optional[EnvironmentSandbox] = None
 
+    # Original limits of the problem.
+    problemLimits: Limits = Field(default_factory=Limits)
+
 
 class EnvironmentLanguage(BaseModel):
     model_config = ConfigDict(extra='forbid')
@@ -280,6 +284,7 @@ def merge_execution_configs(
 ) -> ExecutionConfig:
     merged_cfg = ExecutionConfig()
     merged_cfg.sandbox = EnvironmentSandbox()
+    merged_cfg.problemLimits = Limits()
     for cfg in execution_configs:
         if cfg is None:
             continue
@@ -288,6 +293,10 @@ def merge_execution_configs(
             merged_cfg.sandbox = _merge_shallow_models(
                 EnvironmentSandbox, merged_cfg.sandbox, cfg.sandbox
             )
+        if cfg.problemLimits is not None:
+            merged_cfg.problemLimits = _merge_shallow_models(
+                Limits, merged_cfg.problemLimits, cfg.problemLimits
+            )
     return merged_cfg
 
 

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/rbx/box/packaging/main.py

@@ -107,7 +107,7 @@ async def boca(
     if upload:
         from rbx.box.packaging.boca.upload import BocaUploader
 
-        uploader = BocaUploader('http://137.184.1.39/boca', 'admin', 'boca')
+        uploader = BocaUploader()
         uploader.login_and_upload(result_path)
 
 

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/rbx/box/schema.py

@@ -325,22 +325,6 @@ class Stress(BaseModel):
     )
 
 
-class Limits(BaseModel):
-    time: Optional[int] = Field(
-        default=None, description='Value to override time limit with, in milliseconds.'
-    )
-    memory: Optional[int] = Field(
-        default=None, description='Value to override memory limit with, in MB.'
-    )
-    output: Optional[int] = Field(
-        default=None, description='Value to override output limit with, in KB.'
-    )
-
-    isDoubleTL: bool = Field(
-        default=False, description='Whether to use double TL for this language.'
-    )
-
-
 class LimitModifiers(BaseModel):
     timeMultiplier: Optional[float] = Field(
         default=None, description='Multiplier for time limit.'

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/rbx/box/solutions.py

@@ -36,7 +36,6 @@ from rbx.box.generators import (
 from rbx.box.schema import (
     ExpectedOutcome,
     GeneratorCall,
-    Limits,
     Solution,
     TaskType,
     Testcase,
@@ -53,6 +52,7 @@ from rbx.box.testcase_utils import (
     parse_interaction,
     print_interaction,
 )
+from rbx.grading.limits import Limits
 from rbx.grading.steps import (
     Evaluation,
     Outcome,
@@ -736,10 +736,12 @@ def get_capped_evals_formatted_time(
     max_time = _get_evals_time_in_ms(evals)
     has_tle = any(eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED for eval in evals)
     timelimits = [
-        eval.log.metadata.timeLimit
+        eval.log.metadata.limits.get_expanded_tl()
         for eval in evals
-        if eval.log.metadata is not None and eval.log.metadata.timeLimit is not None
+        if eval.log.metadata is not None
     ]
+    timelimits = [tl for tl in timelimits if tl is not None]
+
     tl = None
     if timelimits:
         tl = min(timelimits)
@@ -954,10 +956,12 @@ async def _print_timing(
         # Get solution TL.
         solution_time = _get_evals_time_in_ms(all_evals)
         solution_tls = [
-            eval.log.metadata.timeLimit
+            eval.log.metadata.limits.get_expanded_tl()
             for eval in all_evals
-            if eval.log.metadata is not None and eval.log.metadata.timeLimit is not None
+            if eval.log.metadata is not None
         ]
+        solution_tls = [tl for tl in solution_tls if tl is not None]
+
         solution_tl = 0
         if solution_tls:
             solution_tl = min(solution_tls)

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/rbx/box/tasks.py

@@ -5,8 +5,9 @@ from rbx.box import checkers, package, state
 from rbx.box.code import CommunicationItem, run_communication, run_item
 from rbx.box.environment import EnvironmentSandbox, ExecutionConfig, VerificationLevel
 from rbx.box.retries import Retrier
-from rbx.box.schema import Limits, Solution, Testcase
+from rbx.box.schema import Solution, Testcase
 from rbx.grading.judge.sandbox import SandboxBase
+from rbx.grading.limits import Limits
 from rbx.grading.steps import (
     DigestOrDest,
     DigestOrSource,
@@ -146,7 +147,7 @@ def _get_execution_config(
         sandbox.wallTimeLimit = sandbox.timeLimit * 2
     sandbox.memoryLimit = limits.memory
     sandbox.fileSizeLimit = limits.output
-    return ExecutionConfig(sandbox=sandbox)
+    return ExecutionConfig(sandbox=sandbox, problemLimits=limits)
 
 
 async def _run_communication_solution_on_testcase(

rbx_cp-0.5.61/rbx/grading/limits.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class Limits(BaseModel):
+    time: Optional[int] = Field(
+        default=None, description='Value to override time limit with, in milliseconds.'
+    )
+    memory: Optional[int] = Field(
+        default=None, description='Value to override memory limit with, in MB.'
+    )
+    output: Optional[int] = Field(
+        default=None, description='Value to override output limit with, in KB.'
+    )
+
+    isDoubleTL: bool = Field(
+        default=False, description='Whether to use double TL for this language.'
+    )
+
+    def get_expanded_tl(self) -> Optional[int]:
+        if self.time is None:
+            return None
+        if self.isDoubleTL:
+            return self.time * 2
+        return self.time

{rbx_cp-0.5.58 → rbx_cp-0.5.61}/rbx/grading/steps.py

@@ -15,7 +15,7 @@ from enum import Enum
 from typing import IO, Any, Dict, Iterable, List, Optional, Tuple, Union
 
 import typer
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from rich.text import Text
 
 from rbx import utils
@@ -24,6 +24,7 @@ from rbx.console import console
 from rbx.grading import processing_context
 from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
 from rbx.grading.judge.storage import Storage, copyfileobj
+from rbx.grading.limits import Limits
 
 MAX_STDOUT_LEN = 1024 * 1024 * 128  # 128 MB
 
@@ -188,6 +189,7 @@ class TestcaseIO(BaseModel):
 class RunLogMetadata(BaseModel):
     language: Optional[str] = None
     is_sanitized: bool = False
+    limits: Limits = Field(default_factory=Limits)
     timeLimit: Optional[int] = None
     memoryLimit: Optional[int] = None
     retryIndex: Optional[int] = None