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

rbx/box/cd.py

@@ -5,7 +5,7 @@ from typing import List, Optional
 
 import typer
 
-from rbx import console
+from rbx import console, utils
 from rbx.box.sanitizers import warning_stack
 from rbx.utils import new_cd
 
@@ -13,7 +13,7 @@ from rbx.utils import new_cd
 def find_package(
     root: pathlib.Path = pathlib.Path(), consider_presets: bool = False
 ) -> Optional[pathlib.Path]:
-    root = root.resolve()
+    root = utils.abspath(root)
 
     def has_file():
         problem_yaml_path = root / 'problem.rbx.yml'

rbx/box/cli.py

@@ -577,7 +577,13 @@ async def irun(
     help='Create a new problem package.',
 )
 def create(
-    name: str,
+    name: Annotated[
+        str,
+        typer.Option(
+            help='Name of the problem to create, which will be used as the name of the new folder.',
+            prompt='What should the name of the problem be?',
+        ),
+    ],
     preset: Annotated[
         Optional[str], typer.Option(help='Preset to use when creating the problem.')
     ] = None,
@@ -914,7 +920,7 @@ def languages():
 
     for language in env.languages:
         console.console.print(
-            f'[item]{language.name}[/item], aka [item]{language.readable_name or language.name}[/item]:'
+            f'[item]{language.name}[/item], aka [item]{language.readableName or language.name}[/item]:'
         )
         console.console.print(language)
         console.console.print()

rbx/box/code.py

@@ -12,7 +12,7 @@ import rich.text
 import typer
 from pydantic import BaseModel
 
-from rbx import console
+from rbx import console, utils
 from rbx.box import download, global_package, package, setter_config, state
 from rbx.box.environment import (
     CompilationConfig,
@@ -296,7 +296,7 @@ def _prepare_for_communication(
             )
 
         if capture.merged_capture is not None:
-            merged_output_path = package.get_merged_capture_path().resolve()
+            merged_output_path = utils.abspath(package.get_merged_capture_path())
             run.sandbox_params.timeit_dups['Do'].append(merged_output_path)
 
             run.artifacts.outputs.append(

rbx/box/contest/build_contest_statements.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import typer
 
-from rbx import console, testing_utils
+from rbx import console, testing_utils, utils
 from rbx.box import cd, package
 from rbx.box.contest.contest_package import get_problems
 from rbx.box.contest.schema import Contest, ContestProblem, ContestStatement
@@ -156,7 +156,7 @@ def _build_problem_statements(
     console.console.print('Building problem-level statements...')
     extracted_problems = get_problems_for_statement(contest, statement)
     res = []
-    contest_cwd_absolute = pathlib.Path().resolve()
+    contest_cwd_absolute = utils.abspath(pathlib.Path())
     contest_assets = get_relative_assets(statement.path, statement.assets)
 
     extra_vars = dict(statement.override.vars if statement.override is not None else {})

rbx/box/contest/contest_package.py

@@ -17,7 +17,7 @@ YAML_NAME = 'contest.rbx.yml'
 
 @functools.cache
 def find_contest_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
-    root = root.resolve()
+    root = utils.abspath(root)
     contest_yaml_path = root / YAML_NAME
     while root != pathlib.PosixPath('/') and not contest_yaml_path.is_file():
         root = root.parent

rbx/box/contest/main.py

@@ -38,7 +38,13 @@ app.add_typer(
 
 @app.command('create, c', help='Create a new contest package.')
 def create(
-    path: str,
+    path: Annotated[
+        str,
+        typer.Option(
+            help='Path where to create the contest.',
+            prompt='Where should the contest be created, relative to the current directory? (e.g. "contests/ioi2024")',
+        ),
+    ],
     preset: Annotated[
         Optional[str],
         typer.Option(
@@ -108,7 +114,28 @@ def edit():
 
 @app.command('add, a', help='Add new problem to contest.')
 @within_contest
-def add(path: str, short_name: str, preset: Optional[str] = None):
+def add(
+    path: Annotated[
+        str,
+        typer.Option(
+            help='Path where to create the problem. Name part of the path will be used as the problem name.',
+            prompt='Where should the problem be created, relative to the contest root? (e.g. problems/choco will create a problem named "choco" in this directory)',
+        ),
+    ],
+    short_name: Annotated[
+        str,
+        typer.Option(
+            help='Short name of the problem. Will be used as the identifier in the contest.',
+            prompt='What should the problem be named? (e.g. "A", "B1", "B2", "Z")',
+        ),
+    ],
+    preset: Annotated[
+        Optional[str],
+        typer.Option(
+            help='Preset to use when creating the problem. If not specified, the active preset will be used.',
+        ),
+    ] = None,
+):
     problem_path = pathlib.Path(path)
     name = problem_path.stem
     utils.validate_field(ContestProblem, 'short_name', short_name)

rbx/box/environment.py

@@ -40,102 +40,149 @@ VerificationParam = Annotated[
 class FileMapping(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Path where to copy the stdin file to before running the program,
-    # relative to the sandbox root.
-    input: str = 'stdin'
+    input: str = Field(
+        default='stdin',
+        description="""Path where to copy the stdin file to before running the program,
+relative to the sandbox root.""",
+    )
 
-    # Path where to output the stdout file after running the program,
-    # relative to the sandbox root.
-    output: str = 'stdout'
+    output: str = Field(
+        default='stdout',
+        description="""Path where to output the stdout file after running the program,
+relative to the sandbox root.""",
+    )
 
-    # Path where to output the stderr file after running the program,
-    # relative to the sandbox root.
-    error: str = 'stderr'
+    error: str = Field(
+        default='stderr',
+        description="""Path where to output the stderr file after running the program,
+relative to the sandbox root.""",
+    )
 
-    # Path where to copy the compilable file to before compiling the program,
-    # relative to the sandbox root.
-    compilable: str = 'compilable'
+    compilable: str = Field(
+        default='compilable',
+        description="""Path where to copy the compilable file to before compiling the program,
+relative to the sandbox root.""",
+    )
 
-    # Path to where to output the executable file after compiling the program,
-    # relative to the sandbox root.
-    executable: str = 'executable'
+    executable: str = Field(
+        default='executable',
+        description="""Path to where to output the executable file after compiling the program,
+relative to the sandbox root.""",
+    )
 
 
 class EnvironmentSandbox(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Max. number of process to allow to run concurrently for the program.
-    maxProcesses: Optional[int] = 1
+    maxProcesses: Optional[int] = Field(
+        default=1,
+        description="""Max. number of process to allow to run concurrently for the program.""",
+    )
 
-    # Time limit in milliseconds to allow the program to run.
-    timeLimit: Optional[int] = None
+    timeLimit: Optional[int] = Field(
+        default=None,
+        description="""Time limit in milliseconds to allow the program to run.""",
+    )
 
-    # Wall time limit in milliseconds to allow the program to run.
-    wallTimeLimit: Optional[int] = None
+    wallTimeLimit: Optional[int] = Field(
+        default=None,
+        description="""Wall time limit in milliseconds to allow the program to run.""",
+    )
 
-    # Memory limit in MiB.
-    memoryLimit: Optional[int] = None
+    memoryLimit: Optional[int] = Field(
+        default=None,
+        description="""Memory limit in MiB.""",
+    )
 
-    # File size limit in KiB
-    fileSizeLimit: Optional[int] = None
+    fileSizeLimit: Optional[int] = Field(
+        default=None,
+        description="""File size limit in KiB""",
+    )
 
-    # Stack limit in MiB.
-    stackLimit: Optional[int] = None
+    stackLimit: Optional[int] = Field(
+        default=None,
+        description="""Stack limit in MiB.""",
+    )
 
-    # Whether to preserve env. variables coming from the host.
-    preserveEnv: Optional[bool] = False
+    preserveEnv: Optional[bool] = Field(
+        default=False,
+        description="""Whether to preserve env. variables coming from the host.""",
+    )
 
-    # Directories in the host that should be read-only exposed to the sandbox.
-    mirrorDirs: Optional[List[str]] = []
+    mirrorDirs: Optional[List[str]] = Field(
+        default=[],
+        description="""Directories in the host that should be read-only exposed to the sandbox.""",
+    )
 
 
 class CompilationConfig(BaseModel):
-    # Commands to compile the program.
-    commands: Optional[List[str]] = []
+    commands: Optional[List[str]] = Field(
+        default=[],
+        description="""Commands to compile the program.""",
+    )
 
-    # Sandbox configuration to use when compiling for this language.
-    sandbox: Optional[EnvironmentSandbox] = None
+    sandbox: Optional[EnvironmentSandbox] = Field(
+        default=None,
+        description="""Sandbox configuration to use when compiling for this language.""",
+    )
 
 
 class ExecutionConfig(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Command to run the program.
-    command: Optional[str] = None
+    command: Optional[str] = Field(
+        default=None,
+        description="""Command to run the program.""",
+    )
 
-    # Sandbox configuration to use when executing for this language.
-    sandbox: Optional[EnvironmentSandbox] = None
+    sandbox: Optional[EnvironmentSandbox] = Field(
+        default=None,
+        description="""Sandbox configuration to use when executing for this language.""",
+    )
 
-    # Original limits of the problem.
-    problemLimits: Limits = Field(default_factory=Limits)
+    problemLimits: Limits = Field(
+        default_factory=Limits,
+        description="""Original limits of the problem.""",
+    )
 
 
 class EnvironmentLanguage(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Identifier of this language within this environment.
-    name: str
+    name: str = Field(
+        description="""Identifier of this language within this environment."""
+    )
 
-    # Readable name for this language.
-    readable_name: Optional[str] = None
+    readableName: Optional[str] = Field(
+        default=None,
+        description="""Readable name for this language.""",
+    )
 
-    # File extension supported by this language. If there's only one language
-    # that supports a certain file extension in the environment, the tool
-    # will automatically identify the language based on such extension.
-    extension: str
+    extension: str = Field(
+        description="""File extension supported by this language. If there's only one language
+that supports a certain file extension in the environment, the tool
+will automatically identify the language based on such extension."""
+    )
 
-    # Compilation config to use when compiling programs for this language.
-    compilation: Optional[CompilationConfig] = None
+    compilation: Optional[CompilationConfig] = Field(
+        default=None,
+        description="""Compilation config to use when compiling programs for this language.""",
+    )
 
-    # Execution config to use when running programs for this language.
-    execution: ExecutionConfig
+    execution: ExecutionConfig = Field(
+        description="""Execution config to use when running programs for this language."""
+    )
 
-    # Mapping for files within the sandbox. If not specified, the default mapping
-    # for the environment will be used.
-    fileMapping: Optional[FileMapping] = None
+    fileMapping: Optional[FileMapping] = Field(
+        default=None,
+        description="""Mapping for files within the sandbox. If not specified, the default mapping
+for the environment will be used.""",
+    )
 
-    # Exntensions to apply for this language.
-    extensions: Optional[LanguageExtensions] = None
+    extensions: Optional[LanguageExtensions] = Field(
+        default=None,
+        description="""Extensions to apply for this language.""",
+    )
 
     def get_extension(self, name: str, _: Type[T]) -> Optional[T]:
         if self.extensions is None:
@@ -151,39 +198,52 @@ class EnvironmentLanguage(BaseModel):
 class TimingConfig(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Formula to use to calculate the time limit for the environment.
-    formula: str = 'step_up(max(fastest * 3, slowest * 1.5), 100)'
+    formula: str = Field(
+        default='step_up(max(fastest * 3, slowest * 1.5), 100)',
+        description="""Formula to use to calculate the time limit for the environment.""",
+    )
 
 
 class Environment(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Default mapping for files within the sandbox. Fields in the mapping can be
-    # individually overridden in the language configuration.
-    defaultFileMapping: Optional[FileMapping] = None
-
-    # Default compilation configuration to use when compiling programs. Fields in
-    # the compilation config can be individually overridden in the language configuration.
-    defaultCompilation: Optional[CompilationConfig] = None
+    defaultFileMapping: Optional[FileMapping] = Field(
+        default=None,
+        description="""Default mapping for files within the sandbox. Fields in the mapping can be
+individually overridden in the language configuration.""",
+    )
 
-    # Default execution configuration to use when running programs. Fields in the
-    # execution config can be individually overridden in the language configuration.
-    defaultExecution: Optional[ExecutionConfig] = None
+    defaultCompilation: Optional[CompilationConfig] = Field(
+        default=None,
+        description="""Default compilation configuration to use when compiling programs. Fields in
+the compilation config can be individually overridden in the language configuration.""",
+    )
 
-    # Configuration for each language supported in this environment.
-    languages: List[EnvironmentLanguage] = []
+    defaultExecution: Optional[ExecutionConfig] = Field(
+        default=None,
+        description="""Default execution configuration to use when running programs. Fields in the
+execution config can be individually overridden in the language configuration.""",
+    )
 
-    # Identifier of the sandbox used by this environment (e.g. "stupid", "isolate")
-    sandbox: str = 'stupid'
+    languages: List[EnvironmentLanguage] = Field(
+        default=[],
+        description="""Configuration for each language supported in this environment.""",
+    )
 
-    # Identifier of the preset that should be used when creating new problems.
-    preset: str = 'default'
+    sandbox: str = Field(
+        default='stupid',
+        description="""Identifier of the sandbox used by this environment (e.g. "stupid", "isolate")""",
+    )
 
-    # Timing configuration for the environment.
-    timing: TimingConfig = Field(default_factory=TimingConfig)
+    timing: TimingConfig = Field(
+        default_factory=TimingConfig,
+        description="""Timing configuration for the environment.""",
+    )
 
-    # Extensions to be added to the environment.
-    extensions: Optional[Extensions] = None
+    extensions: Optional[Extensions] = Field(
+        default=None,
+        description="""Extensions to be added to the environment.""",
+    )
 
 
 def get_app_environment_path(env: str) -> pathlib.Path:

rbx/box/formatting.py

@@ -2,6 +2,7 @@ import os
 import pathlib
 from typing import Any, Optional
 
+from rbx import utils
 from rbx.box import setter_config
 
 
@@ -23,7 +24,7 @@ def href(url: os.PathLike[str], text: Optional[str] = None, style: str = 'item')
             return f'[{style}]{text}[/{style}]'
 
     if isinstance(url, pathlib.Path):
-        url = url.resolve()
+        url = utils.abspath(url)
 
     url_str = str(url)
     if pathlib.Path(url_str).exists():

rbx/box/package.py

@@ -39,7 +39,7 @@ TEMP_DIR = None
 
 @functools.cache
 def find_problem_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
-    root = root.resolve()
+    root = utils.abspath(root)
     problem_yaml_path = root / YAML_NAME
     while root != pathlib.PosixPath('/') and not problem_yaml_path.is_file():
         root = root.parent
@@ -152,8 +152,8 @@ def get_problem_iruns_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
 def get_problem_preprocessed_path(
     item: pathlib.Path, root: pathlib.Path = pathlib.Path()
 ) -> pathlib.Path:
-    root_resolved = root.resolve()
-    item_resolved = item.resolve()
+    root_resolved = utils.abspath(root)
+    item_resolved = utils.abspath(item)
 
     if not item_resolved.is_relative_to(root_resolved):
         final_path = pathlib.Path('remote') / item_resolved.name
@@ -360,11 +360,11 @@ def get_test_groups_by_name(
 # Return each compilation file and to where it should be moved inside
 # the sandbox.
 def get_compilation_files(code: CodeItem) -> List[Tuple[pathlib.Path, pathlib.Path]]:
-    code_dir = code.path.parent.resolve()
+    code_dir = utils.abspath(code.path.parent)
 
     res = []
     for compilation_file in code.compilationFiles or []:
-        compilation_file_path = pathlib.Path(compilation_file).resolve()
+        compilation_file_path = utils.abspath(pathlib.Path(compilation_file))
         if not compilation_file_path.is_file():
             console.console.print(
                 f'[error]Compilation file [item]{compilation_file}[/item] for '

rbx/box/packaging/polygon/packager.py

@@ -4,7 +4,7 @@ from typing import List, Optional
 
 import typer
 
-from rbx import console
+from rbx import console, utils
 from rbx.box import header, package
 from rbx.box.lang import code_to_langs, is_valid_lang_code
 from rbx.box.packaging.packager import (
@@ -129,7 +129,7 @@ class PolygonPackager(BasePackager):
         shutil.copyfile(built_statement.path, final_path)
 
         return polygon_schema.Statement(
-            path=str(final_path.resolve().relative_to(into_path.resolve())),
+            path=str(utils.abspath(final_path).relative_to(utils.abspath(into_path))),
             language=language,
             type=self._statement_application_type(built_statement),  # type: ignore
         )
@@ -238,7 +238,7 @@ class PolygonContestPackager(BaseContestPackager):
         shutil.copyfile(built_statement.path, final_path)
 
         return polygon_schema.Statement(
-            path=str(final_path.resolve().relative_to(into_path.resolve())),
+            path=str(utils.abspath(final_path).relative_to(utils.abspath(into_path))),
             language=language,
             type='application/pdf',  # type: ignore
         )