rbx.cp 0.13.7__py3-none-any.whl → 0.14.0__py3-none-any.whl

rbx/box/unit.py

@@ -1,7 +1,6 @@
 import pathlib
 from typing import List, Optional, Set
 
-import syncer
 from pydantic import BaseModel
 
 from rbx import console
@@ -232,7 +231,6 @@ async def run_checker_unit_tests(progress: StatusProgress):
             console.console.print(f'  [status]Message[/status] {result.message}')
 
 
-@syncer.sync
 async def run_unit_tests(progress: StatusProgress):
     await run_validator_unit_tests(progress)
     await run_checker_unit_tests(progress)

rbx/box/validators.py

@@ -94,10 +94,6 @@ async def _validate_testcase(
     vars: Optional[Dict[str, Primitive]] = None,
 ) -> Tuple[bool, Optional[str], HitBounds]:
     vars = vars or {}
-    for var in vars:
-        assert (
-            var.isidentifier()
-        ), f'Variable {var} should be a valid Python identifier.'
     # TODO: check if needs to do some escaping
     var_args = [f'--{k}={v}' for k, v in vars.items()]
     var_args.extend(['--testOverviewLogFileName', 'validator.log'])

rbx/grading/judge/cacher.py

@@ -243,6 +243,12 @@ class FileCacher:
         return typing.cast(IO[bytes], self._load(digest, False))
 
     def path_for_symlink(self, digest: str) -> Optional[pathlib.Path]:
+        """Retrieve the symlink path that points to the backend file.
+
+        If the file is not in the cache, or it is stored in a transformed
+        form (such as a compressed file), this function will return None,
+        as creating a symlink to it would not be meaningful.
+        """
         if digest == storage.TOMBSTONE:
             raise TombstoneError()
 
@@ -252,7 +258,37 @@ class FileCacher:
         logger.debug('Getting symlink file path %s.', digest)
         return self.backend.path_for_symlink(digest)
 
+    def transient_path_for_symlink(self, digest: str):
+        """Retrieve a file from the storage and return a path to it.
+
+        Notice that this is different than `path_for_symlink', which
+        returns the path to the file in the backend itself, not a path
+        inside the cacher.
+
+        `path_for_symlink` should be used for persistent links, such as
+        those you create in the package folder and should live across
+        multiple runs of the tool.
+
+        `transient_path_for_symlink` should be used for transient links, such as
+        those created in the sandbox, like test inputs and compiled
+        binaries.
+        """
+        if digest == storage.TOMBSTONE:
+            raise TombstoneError()
+        self._load(digest, cache_only=True)
+
+        cache_file_path = self.file_dir / digest
+        if not cache_file_path.exists():
+            raise FileNotFoundError(f'File {digest} not found in cache.')
+        return cache_file_path
+
     def digest_from_symlink(self, link: pathlib.Path) -> Optional[str]:
+        """Retrieve the digest of the file that the symlink points to.
+
+        This is supposed to be used as a counterpart to `path_for_symlink'.
+        `digest_from_symlink(path_for_symlink(digest))` should be equivalent to
+        `digest`.
+        """
         if grading_context.is_transient():
             return None
 

rbx/grading/judge/program.py

@@ -89,6 +89,14 @@ def get_preexec_fn(params: ProgramParams):
         if params.fs_limit is not None:
             fs_limit = params.fs_limit * 1024  # in bytes
             resource.setrlimit(resource.RLIMIT_FSIZE, (fs_limit + 1, fs_limit * 2))
+        if sys.platform != 'darwin':
+            try:
+                resource.setrlimit(
+                    resource.RLIMIT_STACK,
+                    (resource.RLIM_INFINITY, resource.RLIM_INFINITY),
+                )
+            except ValueError:
+                pass
 
     return preexec_fn
 
@@ -236,7 +244,6 @@ class Program:
             cwd=self.params.chdir,
             env={**os.environ, **self.params.env},
             preexec_fn=get_preexec_fn(self.params),
-            close_fds=True,
         )
         self.start_time = monotonic()
 
@@ -244,6 +251,8 @@ class Program:
         threading.Thread(target=self._handle_alarm, daemon=True).start()
 
     def process_exit(self, exitstatus, ru) -> ProgramResult:
+        _maybe_close_files(self._files)
+
         wall_time = monotonic() - self.start_time
         cpu_time = get_cpu_time(ru)
         memory_used = get_memory_usage(ru)
@@ -283,7 +292,7 @@ class Program:
         ):
             program_codes.append(ProgramCode.OL)
 
-        return ProgramResult(
+        result = ProgramResult(
             exitcode=exitcode,
             wall_time=wall_time,
             cpu_time=cpu_time,
@@ -293,6 +302,7 @@ class Program:
             killing_signal=killing_signal,
             alarm_msg=self._alarm_msg or None,
         )
+        return result
 
     def wait(self):
         assert self.popen is not None

rbx/grading/judge/sandbox.py

@@ -359,7 +359,7 @@ class SandboxBase(abc.ABC):
 
         """
         if try_symlink and executable:
-            symlink_path = self.file_cacher.path_for_symlink(digest)
+            symlink_path = self.file_cacher.transient_path_for_symlink(digest)
             if symlink_path is not None:
                 created = self.create_symlink(
                     path,

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -155,7 +155,7 @@ class StupidSandbox(SandboxBase):
     ) -> SandboxLog:
         return SandboxLog(
             params=params.model_copy(deep=True),
-            execution_time=result.wall_time,
+            execution_time=result.cpu_time,
             memory_used=result.memory_used,
             exitcode=result.exitcode,
             exitstatus=self._get_exit_status(result),
@@ -163,6 +163,7 @@ class StupidSandbox(SandboxBase):
             other_logs={
                 'program_codes': [code.value for code in result.program_codes],
                 'alarm_msg': result.alarm_msg,
+                'wall_time': result.wall_time,
             },
         )
 

rbx/grading/judge/storage.py

@@ -415,7 +415,40 @@ class FilesystemStorage(Storage):
     def filename_from_symlink(self, link: pathlib.Path) -> Optional[str]:
         if not link.is_symlink():
             return None
-        filename = utils.abspath(link.readlink())
-        if not filename.is_file():
+
+        # Track visited symlinks to detect circular references
+        visited = set()
+        current = link
+        max_depth = 100  # Reasonable limit to prevent infinite loops
+        depth = 0
+
+        while current.is_symlink() and depth < max_depth:
+            # Convert to absolute path for consistent comparison
+            abs_current = utils.abspath(current)
+
+            # Check for circular reference
+            if abs_current in visited:
+                return None
+
+            visited.add(abs_current)
+
+            # Read the target of the symlink
+            target = current.readlink()
+
+            # If target is relative, resolve it relative to the symlink's parent directory
+            if not target.is_absolute():
+                current = utils.abspath(current.parent / target)
+            else:
+                current = utils.abspath(target)
+
+            depth += 1
+
+        # If we hit the depth limit, assume circular reference
+        if depth >= max_depth:
+            return None
+
+        if not current.is_file():
+            return None
+        if not current.is_relative_to(self.path):
             return None
-        return str(filename.relative_to(self.path))
+        return str(current.relative_to(self.path))

rbx/grading/limits.py

@@ -18,6 +18,10 @@ class Limits(BaseModel):
         default=False, description='Whether to use double TL for this language.'
     )
 
+    profile: Optional[str] = Field(
+        default=None, description='The profile that was used to get these limits.'
+    )
+
     def get_expanded_tl(self) -> Optional[int]:
         if self.time is None:
             return None

rbx/grading/steps.py

@@ -14,7 +14,7 @@ import typer
 from pydantic import BaseModel, Field
 from rich.text import Text
 
-from rbx import utils
+from rbx import testing_utils, utils
 from rbx.config import get_bits_stdcpp, get_jngen, get_testlib
 from rbx.console import console
 from rbx.grading import grading_context
@@ -389,7 +389,7 @@ def jngen_grading_input() -> GradingFileInput:
 def _expand_part(part: str, sandbox: SandboxBase) -> List[str]:
     part = part.strip()
     if part.startswith('@glob:'):
-        return [shlex.quote(str(path)) for path in sandbox.glob(part[6:])]
+        return [str(path) for path in sandbox.glob(part[6:])]
     return [part]
 
 
@@ -736,6 +736,7 @@ def compile(
         )
         console.print(f'[error]Summary:[/error] {logs[-1].get_summary()}')
         console.print(Text.from_ansi(logs[-1].log), style='default')
+        testing_utils.print_directory_tree(sandbox.get_root_path())
         return False
 
     return _process_output_artifacts(artifacts, sandbox)

rbx/resources/presets/default/contest/contest.rbx.yml

@@ -17,16 +17,26 @@ statements:
       configure:
         - type: "rbx-tex" # Convert rbxTeX to TeX
           template: "statement/template.rbx.tex"
+      vars:
+        # Turn into false to hide time limits and memory limits in the problem statement.
+        # Useful for ICPC-style contests where you distribute a separate info sheet.
+        show_limits: true
   - name: "editorial-en"
     extends: "statement-en"
     override:
       vars:
         # Whether to show the problem statement in the editorial.
         show_problem: false
+        show_limits: true
         editorial: true
     vars:
-      editorial: true
+      # Whether to render an "EDITORIAL" watermark.
       watermark: false
+      editorial: true
+  - name: "info-en"
+    extends: "statement-en"
+    path: "statement/info.rbx.tex"
+    joiner: null
 vars:
   year: 2025
   date: "2025-06-21"

rbx/resources/presets/default/contest/statement/info.rbx.tex

@@ -0,0 +1,54 @@
+\documentclass{article}
+\usepackage[a4paper, margin=1in]{geometry}
+\usepackage{multirow}
+\usepackage{multicol}
+\usepackage{graphicx}
+\usepackage{amsfonts}
+\usepackage[brazil]{babel}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+
+\usepackage[utf8]{inputenc}
+\usepackage{icpc}
+
+%\pagestyle{myheadings}
+\markright{\VAR{contest.title}}
+
+\begin{document}
+
+\begin{titlepage}
+\vspace*{\fill}
+\begin{center}
+\includegraphics[width=4cm]{logo.png}
+
+\vspace{1cm}
+{\huge{\bf \VAR{vars.year}}} \\
+
+\vspace{0.5cm}
+{\huge \bf \strInfoSheet}\\[12pt]
+{\Large \bf \VAR{contest.title}}
+\end{center}
+
+\vspace{2cm}
+
+%\subsection*{\strLimits}
+
+\begin{center}
+\begin{tabular}{c|ccc|c}
+& \multicolumn{3}{c|}{\strTimeLimit (ms)} & \multirow{2}{*}{\strMemoryLimit (MiB)} \\
+%\cline{2-4}
+{\sf \strProblem} & {\sf C/C++} &{\sf Java} & {\sf Python3} & \\
+\hline
+%- for problem in problems:
+\VAR{problem.short_name}
+& \VAR{problem.limits.timelimit_for_language('cpp')}
+& \VAR{problem.limits.timelimit_for_language('java')}
+& \VAR{problem.limits.timelimit_for_language('py')}
+& \VAR{problem.limits.memorylimit_for_language()}
+\\ \hline
+%- endfor
+\end{tabular}
+\end{center}
+\vspace*{\fill}
+\end{titlepage}
+\end{document}

rbx/resources/presets/default/problem/.gitignore

@@ -1,5 +1,6 @@
 .box/
 build/
+.limits/local.yml
 __pycache__/
 
 .DS_Store

rbx/resources/presets/default/problem/problem.rbx.yml

@@ -17,8 +17,18 @@ testcases:
 solutions:
   - path: "sols/main.cpp"
     outcome: "ACCEPTED"
-  - path: "sols/wa.cpp"
+  - path: "sols/ac-*.cpp"
+    outcome: "ACCEPTED"
+  - path: "sols/wa-*.cpp"
     outcome: "WRONG_ANSWER"
+  - path: "sols/tle-*.cpp"
+    outcome: "TIME_LIMIT_EXCEEDED"
+  - path: "sols/mle-*.cpp"
+    outcome: "MEMORY_LIMIT_EXCEEDED"
+  - path: "sols/re-*.cpp"
+    outcome: "RUNTIME_ERROR"
+  - path: "sols/fail-*.cpp"
+    outcome: "INCORRECT"
 statements:
   - name: "statement-en"
     title: "New Problem"
@@ -31,11 +41,14 @@ statements:
     configure:
       - type: "rbx-tex" # Convert rbxTeX to TeX
         template: "statement/template.rbx.tex"
+    vars:
+      # Set to false to hide time limits and memory limits in the problem statement.
+      show_limits: true
 stresses:
   - name: "stress"
     generator:
       name: "gens/gen"
-      args: "[1..<MAX_N>] @" # `@` generates a random string
+      args: "[1..<N.max>] @" # `@` generates a random string
     finder: "[sols/wa.cpp] ~ INCORRECT"
 unitTests:
   validator:
@@ -51,4 +64,9 @@ unitTests:
 # Can be used in the validator, checker, interactor, stress tests
 # and in the statement.
 vars:
-  MAX_N: 1000000000
+  # Author name to be displayed in the editorial.
+  author: "John Doe"
+  # Constraints of the problem.
+  N:
+    min: 1
+    max: 1000000000

rbx/resources/presets/default/problem/rbx.h

@@ -1,17 +1,25 @@
 #ifndef _RBX_H
 #define _RBX_H
+#include <cstdint>
+#include <limits>
 #include <optional>
 #include <stdexcept>
 #include <string>
 
 std::optional<std::string> getStringVar(std::string name) {
-  
+    if (name == "author") {
+    return "John Doe";
+  }
+
   return std::nullopt;
 }
 
-std::optional<int> getIntVar(std::string name) {
-    if (name == "MAX_N") {
-    return 1000000000;
+std::optional<int64_t> getIntVar(std::string name) {
+    if (name == "N.max") {
+    return static_cast<int64_t>(1000000000);
+  }
+  if (name == "N.min") {
+    return static_cast<int64_t>(1);
   }
 
   return std::nullopt;
@@ -29,7 +37,46 @@ std::optional<bool> getBoolVar(std::string name) {
 
 template <typename T> T getVar(std::string name);
 
-template <> int getVar<int>(std::string name) {
+template <> int32_t getVar<int32_t>(std::string name) {
+  auto opt = getIntVar(name);
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not an integer or could not be found");
+  }
+  if (opt.value() < std::numeric_limits<int32_t>::min() ||
+      opt.value() > std::numeric_limits<int32_t>::max()) {
+    throw std::runtime_error("Variable " + name + " of value " +
+                             std::to_string(opt.value()) +
+                             " does not fit in int32_t");
+  }
+  return opt.value();
+}
+
+template <> uint32_t getVar<uint32_t>(std::string name) {
+  auto opt = getIntVar(name);
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not an integer or could not be found");
+  }
+  if (opt.value() < std::numeric_limits<uint32_t>::min() ||
+      opt.value() > std::numeric_limits<uint32_t>::max()) {
+    throw std::runtime_error("Variable " + name + " of value " +
+                             std::to_string(opt.value()) +
+                             " does not fit in uint32_t");
+  }
+  return opt.value();
+}
+
+template <> int64_t getVar<int64_t>(std::string name) {
+  auto opt = getIntVar(name);
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not an integer or could not be found");
+  }
+  return opt.value();
+}
+
+template <> uint64_t getVar<uint64_t>(std::string name) {
   auto opt = getIntVar(name);
   if (!opt.has_value()) {
     throw std::runtime_error("Variable " + name +

rbx/resources/presets/default/problem/statement/statement.rbx.tex

@@ -3,7 +3,7 @@ Given two integers $A$ and $B$, determine the value of $A + B$.
 %- endblock
 
 %- block input
-The input is a single line containing two integers $A$ and $B$ ($1 \leq A, B \leq \VAR{vars.MAX_N | sci}$).
+The input is a single line containing two integers $A$ and $B$ ($\VAR{vars.N.max} \leq A, B \leq \VAR{vars.N.max | sci}$).
 %- endblock
 
 %- block output
@@ -12,4 +12,8 @@ The output must contain only one integer, the sum of $A$ and $B$.
 
 %- block notes
 No notes.
-%- endblock
+%- endblock
+
+%- block editorial
+This is the editorial.
+%- endblock