rbx.cp 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

rbx/grading/profiling.py

@@ -0,0 +1,126 @@
+import contextvars
+import functools
+import math
+import threading
+import time
+
+ALL_CONTEXTS_BY_NAME = {}
+_ALL_CONTEXTS_BY_NAME_LOCK = threading.Lock()
+
+
+@functools.cache
+def _get_threadsafe_context(name: str) -> 'Context':
+    with _ALL_CONTEXTS_BY_NAME_LOCK:
+        if name not in ALL_CONTEXTS_BY_NAME:
+            ALL_CONTEXTS_BY_NAME[name] = Context(name)
+        return ALL_CONTEXTS_BY_NAME[name]
+
+
+class Distribution:
+    def __init__(self):
+        self.values = []
+
+    def add(self, value: float):
+        self.values.append(value)
+
+    def mean(self) -> float:
+        return sum(self.values) / len(self.values)
+
+    def median(self) -> float:
+        return sorted(self.values)[len(self.values) // 2]
+
+    def stddev(self) -> float:
+        mean = self.mean()
+        return math.sqrt(sum((x - mean) ** 2 for x in self.values) / len(self.values))
+
+
+class Context:
+    def __init__(self, name: str):
+        self.name = name
+        self._lock = threading.Lock()
+        self.distributions = {}
+        self.counters = {}
+
+    def add_to_distribution(self, name: str, value: float):
+        with self._lock:
+            if name not in self.distributions:
+                self.distributions[name] = Distribution()
+            self.distributions[name].add(value)
+
+    def add_to_counter(self, name: str):
+        with self._lock:
+            if name not in self.counters:
+                self.counters[name] = 0
+            self.counters[name] += 1
+
+    def print_summary(self):
+        with self._lock:
+            print(f'{self.name}:')
+            for name, distribution in sorted(self.distributions.items()):
+                print(f'  ~ {name}: {distribution.mean():.2f}')
+            for name, count in sorted(self.counters.items()):
+                print(f'  + {name}: {count}')
+
+
+profiling_stack_var = contextvars.ContextVar(
+    'profiling_stack', default=[_get_threadsafe_context('root')]
+)
+
+
+def _push_profiling_stack(name: str):
+    return profiling_stack_var.set(
+        profiling_stack_var.get() + [_get_threadsafe_context(name)]
+    )
+
+
+class PushContext:
+    def __init__(self, name: str):
+        self.name = name
+        self.token = None
+
+    def __enter__(self):
+        self.token = _push_profiling_stack(self.name)
+        return profiling_stack_var.get()[-1]
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.token is not None:
+            profiling_stack_var.reset(self.token)
+
+
+def print_summary():
+    print('\n' + ('-') * 3 + '\n')
+    with _ALL_CONTEXTS_BY_NAME_LOCK:
+        for context in ALL_CONTEXTS_BY_NAME.values():
+            context.print_summary()
+
+
+### Public API
+
+
+class Profiler:
+    def __init__(self, name: str, start: bool = False):
+        self.name = name
+        self.start_time = 0
+        if start:
+            self.start()
+
+    def start(self):
+        self.start_time = time.monotonic()
+        return self
+
+    def stop(self):
+        self.end_time = time.monotonic()
+        self.duration = self.end_time - self.start_time
+        for context in profiling_stack_var.get():
+            context.add_to_distribution(self.name, self.duration)
+
+    def __enter__(self):
+        return self.start()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.stop()
+
+
+def add_to_counter(name: str):
+    for context in profiling_stack_var.get():
+        context.add_to_counter(name)

rbx/grading/steps.py

@@ -20,9 +20,10 @@ from rich.text import Text
 from rbx import utils
 from rbx.config import get_bits_stdcpp, get_jngen, get_testlib
 from rbx.console import console
-from rbx.grading import processing_context
+from rbx.grading import grading_context, processing_context
+from rbx.grading.judge.cacher import FileCacher
 from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
-from rbx.grading.judge.storage import Storage, copyfileobj
+from rbx.grading.judge.storage import copyfileobj
 from rbx.grading.limits import Limits
 
 MAX_STDOUT_LEN = 1024 * 1024 * 128  # 128 MB
@@ -139,6 +140,8 @@ class GradingFileInput(BaseModel):
     digest: Optional[DigestHolder] = None
     # Whether the destination file should be marked as an executable.
     executable: bool = False
+    # Whether to track file through its hash (disable for optimization).
+    hash: bool = True
 
 
 class GradingFileOutput(BaseModel):
@@ -161,15 +164,15 @@ class GradingFileOutput(BaseModel):
     # Whether to touch the file before the command runs.
     touch: bool = False
 
-    def get_file(self, storage: Storage) -> Optional[IO[bytes]]:
+    def get_file(self, cacher: FileCacher) -> Optional[IO[bytes]]:
         if self.dest is not None:
             if self.optional and not self.dest.exists():
                 return None
             return self.dest.open('rb')
         if self.digest is not None and self.digest.value is not None:
-            if self.optional and not storage.exists(self.digest.value):
+            if self.optional and not cacher.exists(self.digest.value):
                 return None
-            return storage.get_file(self.digest.value)
+            return cacher.get_file(self.digest.value)
         raise ValueError('No file to get')
 
 
@@ -308,11 +311,14 @@ def _process_input_artifacts(artifacts: GradingArtifacts, sandbox: SandboxBase):
 
 
 def _process_output_artifacts(
-    artifacts: GradingArtifacts, sandbox: SandboxBase
+    artifacts: GradingArtifacts,
+    sandbox: SandboxBase,
 ) -> bool:
     for output_artifact in artifacts.outputs:
         if output_artifact.hash and output_artifact.digest is None:
-            output_artifact.digest = DigestHolder()
+            if not grading_context.is_no_cache():
+                # If cache is enabled, track this file in cache.
+                output_artifact.digest = DigestHolder()
         if not sandbox.file_exists(output_artifact.src):
             if output_artifact.optional:
                 continue
@@ -322,21 +328,43 @@ def _process_output_artifacts(
             return False
 
         if output_artifact.digest is not None:
-            output_artifact.digest.value = sandbox.get_file_to_storage(
-                output_artifact.src, trunc_len=output_artifact.maxlen
-            )
+            # Put it in the cache, possibly compressing it if it's an executable.
+            with grading_context.compression(
+                use_compression=True,
+                when=output_artifact.executable,
+            ):
+                output_artifact.digest.value = sandbox.get_file_to_storage(
+                    output_artifact.src, trunc_len=output_artifact.maxlen
+                )
         if output_artifact.dest is None:
             continue
         dst: pathlib.Path = artifacts.root / output_artifact.dest
         # Ensure dst directory exists.
+
         dst.parent.mkdir(parents=True, exist_ok=True)
-        with dst.open('wb') as f:
-            with sandbox.get_file(output_artifact.src) as sb_f:
-                copyfileobj(
-                    sb_f,
-                    f,
-                    maxlen=output_artifact.maxlen,
+
+        if (
+            output_artifact.digest is not None
+            and output_artifact.digest.value is not None
+            and (
+                path_to_symlink := sandbox.file_cacher.path_for_symlink(
+                    output_artifact.digest.value
                 )
+            )
+            is not None
+        ):
+            # File is in the persistent cache, store a symlink to it.
+            dst.unlink(missing_ok=True)
+            dst.symlink_to(path_to_symlink)
+        else:
+            # File is not in the persistent cache, copy it.
+            with dst.open('wb') as f:
+                with sandbox.get_file(output_artifact.src) as sb_f:
+                    copyfileobj(
+                        sb_f,
+                        f,
+                        maxlen=output_artifact.maxlen,
+                    )
         if output_artifact.executable:
             dst.chmod(0o755)
     return True
@@ -495,7 +523,8 @@ def _get_system_bits_stdcpp(command: str) -> Optional[GradingFileInput]:
         if not bits_candidate.is_file():
             continue
         return GradingFileInput(
-            src=bits_candidate.resolve().absolute(), dest=pathlib.Path('bits/stdc++.h')
+            src=utils.abspath(bits_candidate),
+            dest=pathlib.Path('bits/stdc++.h'),
         )
     return None
 

rbx/grading/steps_with_caching.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Optional, Tuple
 
-from rbx.grading import steps
+from rbx.grading import grading_context, profiling, steps
 from rbx.grading.caching import DependencyCache, NoCacheException
 from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
 from rbx.grading.steps import (
@@ -27,17 +27,24 @@ def compile(
     artifacts.logs = GradingLogsHolder()
 
     ok = True
+    cached_profile = profiling.Profiler('steps.compile[cached]', start=True)
     with dependency_cache(
         commands, [artifacts], params.get_cacheable_params()
     ) as is_cached:
-        if not is_cached and not steps.compile(
-            commands=commands,
-            params=params,
-            artifacts=artifacts,
-            sandbox=sandbox,
-        ):
-            ok = False
-            raise NoCacheException()
+        if not is_cached:
+            with profiling.Profiler('steps.compile'):
+                profiling.add_to_counter('steps.compile')
+                ok = steps.compile(
+                    commands=commands,
+                    params=params,
+                    artifacts=artifacts,
+                    sandbox=sandbox,
+                )
+                if not ok:
+                    raise NoCacheException()
+        else:
+            cached_profile.stop()
+            profiling.add_to_counter('steps.compile[cached]')
 
     return ok
 
@@ -56,16 +63,25 @@ async def run(
     if metadata is not None and metadata.retryIndex is not None:
         cacheable_params['__retry_index__'] = metadata.retryIndex
 
-    with dependency_cache([command], [artifacts], cacheable_params) as is_cached:
-        if not is_cached:
-            await steps.run(
-                command=command,
-                params=params,
-                artifacts=artifacts,
-                sandbox=sandbox,
-                metadata=metadata,
-            )
-
+    with grading_context.cache_level(
+        grading_context.CacheLevel.NO_CACHE,
+        when=grading_context.is_compilation_only,
+    ):
+        cached_profile = profiling.Profiler('steps.run[cached]', start=True)
+        with dependency_cache([command], [artifacts], cacheable_params) as is_cached:
+            if not is_cached:
+                with profiling.Profiler('steps.run'):
+                    profiling.add_to_counter('steps.run')
+                    await steps.run(
+                        command=command,
+                        params=params,
+                        artifacts=artifacts,
+                        sandbox=sandbox,
+                        metadata=metadata,
+                    )
+            else:
+                cached_profile.stop()
+                profiling.add_to_counter('steps.run[cached]')
     return artifacts.logs.run
 
 
@@ -91,13 +107,23 @@ async def run_coordinated(
     if solution.metadata is not None and solution.metadata.retryIndex is not None:
         cacheable_params['solution.__retry_index__'] = solution.metadata.retryIndex
 
-    with dependency_cache(
-        [interactor.command, solution.command],
-        [interactor.artifacts, solution.artifacts],
-        cacheable_params,
-    ) as is_cached:
-        if not is_cached:
-            await steps.run_coordinated(interactor, solution)
+    with grading_context.cache_level(
+        grading_context.CacheLevel.NO_CACHE,
+        when=grading_context.is_compilation_only,
+    ):
+        cached_profile = profiling.Profiler('steps.run_coordinated[cached]', start=True)
+        with dependency_cache(
+            [interactor.command, solution.command],
+            [interactor.artifacts, solution.artifacts],
+            cacheable_params,
+        ) as is_cached:
+            if not is_cached:
+                with profiling.Profiler('steps.run_coordinated'):
+                    profiling.add_to_counter('steps.run_coordinated')
+                    await steps.run_coordinated(interactor, solution)
+            else:
+                cached_profile.stop()
+                profiling.add_to_counter('steps.run_coordinated[cached]')
 
     return (
         interactor.artifacts.logs.run,

rbx/resources/envs/default.rbx.yml

@@ -18,7 +18,7 @@ defaultExecution:
     memoryLimit: 1024 # 1gb
 languages:
   - name: "cpp"
-    readable_name: "C++17"
+    readableName: "C++17"
     extension: "cpp"
     compilation:
       commands:
@@ -28,10 +28,9 @@ languages:
     fileMapping:
       compilable: "compilable.cpp"
   - name: "py"
-    readable_name: "Python3"
+    readableName: "Python3"
     extension: "py"
     execution:
       command: "python3 {executable}"
     fileMapping:
       executable: "executable.py"
-

rbx/resources/envs/isolate.rbx.yml

@@ -18,7 +18,7 @@ defaultExecution:
     memoryLimit: 1024 # 1gb
 languages:
   - name: "cpp"
-    readable_name: "C++17"
+    readableName: "C++17"
     extension: "cpp"
     compilation:
       commands:
@@ -28,10 +28,9 @@ languages:
     fileMapping:
       compilable: "compilable.cpp"
   - name: "py"
-    readable_name: "Python3"
+    readableName: "Python3"
     extension: "py"
     execution:
       command: "/usr/bin/python3 {executable}"
     fileMapping:
       executable: "executable.py"
-

rbx/resources/presets/default/contest/.gitignore

@@ -0,0 +1,6 @@
+.box/
+build/
+
+*.o
+*.aux
+*.log

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

@@ -8,9 +8,22 @@ statements:
     language: "en"
     path: "statement/contest.rbx.tex"
     type: "jinja-tex"
-    assets: ["statement/olymp.sty", "statement/*.png"]
+    assets:
+      - "statement/icpc.sty"
+      - "statement/*.png"
+      - "statement/instructions.tex"
     joiner: {type: "tex2pdf"}
     override:
       configure:
         - type: "rbx-tex" # Convert rbxTeX to TeX
           template: "statement/template.rbx.tex"
+  - name: "editorial-en"
+    extends: "statement-en"
+    vars:
+      editorial: true
+      watermark: true
+      # Whether to show the problem statement in the editorial.
+      show_problem: false
+vars:
+  year: 2025
+  date: "2025-06-21"

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

@@ -1,97 +1,35 @@
-
-\documentclass[titlepage, oneside, a4paper]{article}
-
-\usepackage {import}
-\usepackage[margin=25mm, left=17mm, right=17mm]{geometry}
-\usepackage[utf8]{inputenc}
-\usepackage[english]{babel}
-\usepackage{amsmath}
-\usepackage{amssymb}
-\usepackage{fancyhdr}
-\usepackage{comment}
-\usepackage{olymp}
-\usepackage{epigraph}
-\usepackage{expdlist}
-\usepackage{graphicx}
-\usepackage{ulem}
-\usepackage{lastpage}
-
-%- for problem in problems
-%- if problem.blocks.preamble is defined
-\VAR{problem.blocks.preamble}
+\documentclass[a4paper,11pt]{article}
+
+\def\lang{\VAR{lang}}
+\usepackage{icpc}
+\usepackage{import}
+
+\def\Year{\VAR{vars.year}}
+\def\Title{\VAR{contest.title}}
+\def\Date{\VAR{vars.date}}
+
+%- if vars.editorial is truthy and vars.watermark is truthy
+\AddToHook{shipout/foreground}{
+       \begin{tikzpicture}[overlay, remember picture]
+            \node[text=gray, rotate=45, scale=8, opacity=0.3]
+				at (0.5\paperwidth,-0.6\paperheight) {EDITORIAL};
+        \end{tikzpicture}
+    }
 %- endif
-%- endfor
-
-\def\showSourceFileName{1}
-\newif\ifintentionallyblankpages % comment this out to add blank pages
-
-\pagestyle{fancy}
-\fancyhf{}
-\renewcommand{\footrulewidth}{0.4pt}
-
-%- if contest is defined
-\title{\VAR{contest.title or ""}}
-\author{\VAR{contest.location if contest.location is defined else ""}}
-\date{\VAR{contest.date if contest.date is defined else ""}}
-%- else
-\title{}
-\author{}
-\date{}
-%- endif
-
-\makeatletter
-\let\newtitle\@title
-\let\newauthor\@author
-\let\newdate\@date
-\makeatother
-
-\rhead{\newtitle}
-\lhead{\newauthor}
-\lfoot{\newdate}
-\rfoot{\thepage}
 
 \begin{document}
 
-%- if contest is defined
-\begin{frontpage}{\newtitle}{\newauthor}{\newdate}
-	\begin{itemize}
-		\item Sobre a prova:
-		      \begin{enumerate}
-			      \item A prova tem duração de 5 horas;
-		      \end{enumerate}
-		\item Sobre a entrada:
-		      \begin{enumerate}
-			      \item A entrada do seu programa deve ser lida da entrada padrão (standard input);
-			      \item Quando uma linha da entrada contém vários valores, estes são separados por um único espaço em branco, a menos que explicitado o contrário no enunciado do problema;
-			      \item Toda linha da entrada terminará com um caractere final-de-linha.
-		      \end{enumerate}
-
-		\item Sobre a saída:
-		      \begin{enumerate}
-			      \item A saída de seu programa deve ser escrita na saída padrão;
-			      \item Quando uma linha da saída contém vários valores, estes devem ser separados por um único espaço em branco, a menos que explicitado o contrário no enunciado do problema;
-			      \item Toda linha da saída deve terminar com um caractere final-de-linha.
-		      \end{enumerate}
-
-		\item Sobre as submissões:
-		      \begin{enumerate}
-			      \item Você deve submeter o código fonte das suas soluções;
-			      \item Os comandos utilizados para compilação serão:
-			            \begin{enumerate}
-				            %- for language in languages:
-				            \item \VAR{language.name | escape}: \VAR{language.command | escape}
-				                  %- endfor
-			            \end{enumerate}
-			      \item Para linguagem Java, o nome da classe principal do arquivo deve ser \textbf{Main}. A classe deve ser pública.
-		      \end{enumerate}
-		      \centering\vspace*{\fill}\textbf{Este caderno contém \VAR{problems | length} problema(s) e \pageref{LastPage} página(s)} \\
-		      \vspace*{\fill}
-	\end{itemize}
-\end{frontpage}
+%- if vars.editorial is truthy
+\InsertEditorialTitlePage
+%- else
+\InsertTitlePage
+\input{instructions.tex}
 %- endif
 
 %- for problem in problems
+\stepcounter{problemcounter}
 \subimport{\VAR{problem.path | parent}/}{\VAR{problem.path | stem}}
 %- endfor
 
+\label{lastpage}
 \end{document}

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

@@ -0,0 +1,40 @@
+\section*{General Information}
+
+This task sheet consists of \pageref*{lastpage} pages (not counting the cover), numbered from 1 to \pageref*{lastpage}. Check if the sheet is complete.
+
+\subsection*{Input}
+
+\begin{itemize}
+  \item The input must be read from standard input.
+
+	\item All lines in the input, including the last one, end with a line break character (\texttt{\textbackslash n}).
+
+	\item When the input contains multiple space-separated values, there is exactly one whitespace character between two consecutive values on the same line.
+\end{itemize}
+
+\subsection*{Output}
+
+\begin{itemize}
+	\item The output must be written to standard output.
+
+	\item The output must follow the format specified in the problem statement. The output must not contain any extra data.
+
+	\item All lines in the output, including the last one, must end with a line break character (\texttt{\textbackslash n}).
+
+	\item When a line in the output displays multiple space-separated values, there must be exactly one whitespace character between two consecutive values.
+
+	\item When an output value is a real number, use at least the number of decimal places corresponding to the precision required in the problem statement.
+\end{itemize}
+
+% \subsection*{Interactive Problems}
+
+% The contest may contain interactive problems. In this type of problem, the input data provided to your program may not be predetermined but is instead specifically constructed for your solution. The judge writes a special program (the interactor), whose output is transferred to your solution's input, and your program's output is sent to the interactor's input. In other words, your solution and the interactor exchange data and may decide what to print based on the communication history.
+
+% When writing a solution for an interactive problem, it is important to remember that if you print any data, it may first be stored in an internal \textit{buffer} and not immediately transferred to the interactor. To avoid this situation, you must use a special \textit{flush} operation every time you print data. These flush operations are available in the standard libraries of almost all programming languages:
+
+% \begin{itemize}
+% 	\item \texttt{fflush(stdout)} in \texttt{C}.
+% 	\item \texttt{cout.flush()} in \texttt{C++}.
+% 	\item \texttt{sys.stdout.flush()} in \texttt{Python}.
+% 	\item \texttt{System.out.flush()} in \texttt{Java}.
+% \end{itemize}

rbx/resources/presets/default/env.rbx.yml

@@ -0,0 +1,67 @@
+---
+sandbox: "stupid"
+defaultCompilation:
+  sandbox:
+    maxProcesses: 1000
+    timeLimit: 50000 # 50 seconds
+    wallTimeLimit: 50000 # 50 seconds
+    memoryLimit: 1024 # 1gb
+defaultExecution:
+  sandbox:
+    # Useful for checkers, validators, etc.
+    timeLimit: 50000 # 50 seconds
+    wallTimeLimit: 50000 # 50 seconds
+    memoryLimit: 1024 # 1gb
+languages:
+  - name: "cpp"
+    readableName: "C++20"
+    extension: "cpp"
+    compilation:
+      commands: ["g++ -std=c++20 -O2 -o {executable} {compilable}"]
+    execution:
+      command: "./{executable}"
+    fileMapping:
+      compilable: "compilable.cpp"
+    extensions:
+      boca:
+        bocaLanguage: "cc"
+  - name: "c"
+    readableName: "C"
+    extension: "c"
+    compilation:
+      commands: ["gcc -std=gnu11 -O2 -lm -o {executable} {compilable}"]
+    execution:
+      command: "./{executable}"
+    fileMapping:
+      compilable: "compilable.c"
+  - name: "py"
+    readableName: "Python3"
+    extension: "py"
+    execution:
+      command: "python3 {executable}"
+    fileMapping:
+      executable: "executable.py"
+    extensions:
+      boca:
+        bocaLanguage: "py3"
+  - name: "java"
+    readableName: "Java"
+    extension: "java"
+    compilation:
+      commands:
+        - "javac -Xlint -encoding UTF-8 {compilable}"
+        - "jar cvf {executable} @glob:*.class"
+    execution:
+      command:
+        "java -Xss100m -Xmx{{memory}}m -Xms{{initialMemory}}m -cp {executable}
+        Main"
+    fileMapping:
+      compilable: "Main.java"
+      executable: "Main.jar"
+extensions:
+  boca:
+    languages: ["c", "cc", "java", "py3"]
+    flags:
+      c: "-O2 -lm -static"
+      cc: "-std=c++20 -O2 -lm -static"
+    preferContestLetter: true

rbx/resources/presets/default/preset.rbx.yml

@@ -4,11 +4,15 @@ name: "default"
 uri: "rsalesc/rbx/rbx/resources/presets/default"
 problem: "problem"
 contest: "contest"
+env: "env.rbx.yml"
 tracking:
   problem:
+    - path: ".gitignore"
+    - path: "statement/icpc.sty"
     - path: "statement/template.rbx.tex"
-    - path: "statement/olymp.sty"
   contest:
+    - path: ".gitignore"
+    - path: "statement/icpc.sty"
     - path: "statement/template.rbx.tex"
-    - path: "statement/olymp.sty"
     - path: "statement/contest.rbx.tex"
+      symlink: true