rbx.cp 0.5.0__py3-none-any.whl

rbx/grading/steps_with_caching_run_test.py

@@ -0,0 +1,429 @@
+import os
+import pathlib
+import sys
+
+from rbx.grading import steps_with_caching
+from rbx.grading.caching import DependencyCache
+from rbx.grading.judge.cacher import FileCacher
+from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
+from rbx.grading.steps import (
+    DigestOrSource,
+    GradingArtifacts,
+    GradingFileInput,
+    GradingFileOutput,
+    RunLogMetadata,
+)
+
+
+def test_run_from_digest(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+    artifacts = GradingArtifacts()
+    artifacts.inputs.append(
+        GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+    )
+    artifacts.outputs.append(
+        GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=pathlib.Path('out.txt'))
+    )
+    steps_with_caching.run(
+        f'{sys.executable} executable.py',
+        params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+        sandbox=sandbox,
+        artifacts=artifacts,
+        dependency_cache=dependency_cache,
+        metadata=RunLogMetadata(),
+    )
+
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert artifacts.logs.run is not None
+    assert artifacts.logs.run.metadata is not None
+    assert not artifacts.logs.cached
+
+
+def test_run_from_disk(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+):
+    pathlib.Path('executable.py').write_text('print(42)')
+
+    executable = DigestOrSource.create(pathlib.Path('executable.py'))
+    artifacts = GradingArtifacts()
+    artifacts.inputs.append(
+        GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+    )
+    artifacts.outputs.append(
+        GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=pathlib.Path('out.txt'))
+    )
+    steps_with_caching.run(
+        f'{sys.executable} executable.py',
+        params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+        sandbox=sandbox,
+        artifacts=artifacts,
+        dependency_cache=dependency_cache,
+    )
+
+    assert (cleandir / 'out.txt').read_text().strip() == '42'
+    assert artifacts.logs is not None
+    assert artifacts.logs.run is not None
+    assert not artifacts.logs.cached
+
+
+def test_run_caches_intermediate_digest_if_dest_changes(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    another_artifacts = configure_and_run_with_dest(pathlib.Path('another-out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert another_artifacts.logs.cached
+
+
+def test_run_overwrite_changed_file_with_storage_value(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').write_text('42')
+
+    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert another_artifacts.logs.cached
+
+
+def test_run_recreates_deleted_file_with_storage_value(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').unlink()
+
+    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert another_artifacts.logs.cached
+
+
+def test_run_overwrite_exec_bit_when_changed(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(
+                **executable.expand(),
+                dest=pathlib.Path('executable.py'),
+            )
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=pathlib.Path('box-out.txt'), dest=dest, executable=True
+            )
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+    assert os.access('out.txt', os.X_OK)
+
+    pathlib.Path('out.txt').chmod(0o644)
+
+    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert another_artifacts.logs.cached
+    assert os.access('out.txt', os.X_OK)
+
+
+def test_run_evicts_when_changed_file_and_no_hash(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest, hash=False)
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').write_text('42')
+
+    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert not another_artifacts.logs.cached
+
+
+def test_run_evicts_when_exec_bit_different_and_no_hash(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=pathlib.Path('box-out.txt'), dest=dest, hash=False, executable=True
+            )
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').chmod(0o0644)
+
+    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert not another_artifacts.logs.cached
+
+
+def test_run_evicts_when_input_fingerprint_changes(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+):
+    def configure_and_run() -> GradingArtifacts:
+        executable = DigestOrSource.create(pathlib.Path('executable.py'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=pathlib.Path('box-out.txt'),
+                dest=pathlib.Path('out.txt'),
+            )
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    pathlib.Path('executable.py').write_text('print(5)')
+
+    artifacts = configure_and_run()
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('executable.py').write_text('print(42)')
+
+    another_artifacts = configure_and_run()
+    assert (cleandir / 'out.txt').read_text().strip() == '42'
+    assert another_artifacts.logs is not None
+    assert not another_artifacts.logs.cached
+
+
+def test_run_evicts_when_output_is_deleted_and_no_hash(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+):
+    def configure_and_run() -> GradingArtifacts:
+        executable = DigestOrSource.create(pathlib.Path('executable.py'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=pathlib.Path('box-out.txt'),
+                dest=pathlib.Path('out.txt'),
+                hash=False,
+            )
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    pathlib.Path('executable.py').write_text('print(5)')
+
+    artifacts = configure_and_run()
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').unlink()
+
+    another_artifacts = configure_and_run()
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert not another_artifacts.logs.cached
+
+
+def test_run_misses_when_input_file_changes(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    def configure_and_run(number: int) -> GradingArtifacts:
+        executable = DigestOrSource.create(
+            file_cacher.put_file_text(f'print({number})')
+        )
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=pathlib.Path('box-out.txt'),
+                dest=pathlib.Path('out.txt'),
+                hash=False,
+            )
+        )
+        steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    artifacts = configure_and_run(5)
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').write_text('42')
+
+    another_artifacts = configure_and_run(42)
+    assert (cleandir / 'out.txt').read_text().strip() == '42'
+    assert another_artifacts.logs is not None
+    assert not another_artifacts.logs.cached

rbx/grading_utils.py

@@ -0,0 +1,148 @@
+import pathlib
+from pathlib import PosixPath
+from typing import List
+
+from rbx import config
+from rbx.config import Artifact, Language, format_vars
+from rbx.grading import steps
+from rbx.grading.judge.sandbox import MERGE_STDERR, SandboxParams
+from rbx.grading.steps import (
+    GradingArtifacts,
+    GradingFileInput,
+    GradingFileOutput,
+    TestcaseIO,
+)
+from rbx.schema import DumpedProblem, Problem
+
+
+def build_formatted_command(
+    command: str, problem: DumpedProblem, lang: Language
+) -> str:
+    return format_vars(
+        command,
+        **problem.get_vars(),
+        file=lang.get_file(problem.code),
+        submit_file=lang.get_submit_file(problem.code),
+    )
+
+
+def build_preprocess_commands(problem: DumpedProblem, lang: Language) -> List[str]:
+    return [
+        build_formatted_command(cmd, problem, lang) for cmd in (lang.preprocess or [])
+    ]
+
+
+def build_preprocess_sandbox_params() -> SandboxParams:
+    params = SandboxParams(
+        max_processes=None,
+        preserve_env=True,
+    )
+    params.add_mapped_directory(pathlib.Path('/usr'))
+    params.add_mapped_directory(pathlib.Path('/etc'))
+    return params
+
+
+def build_compile_grading_artifacts(
+    problem: DumpedProblem, lang: Language
+) -> GradingArtifacts:
+    res = GradingArtifacts(root=PosixPath('.'))
+    file = lang.get_file(problem.code)
+    submit_file = lang.get_submit_file(problem.code)
+    # Copy input file.
+    res.inputs.append(GradingFileInput(src=PosixPath(file), dest=PosixPath(file)))
+    # Copy output file.
+    if lang.has_submit_file():
+        res.outputs.append(
+            GradingFileOutput(
+                src=PosixPath(submit_file),
+                dest=PosixPath(submit_file),
+            )
+        )
+    # Copy other artifacts.
+    for artifact_name, artifact_cfg in lang.artifacts.items():
+        artifact_cfg = artifact_cfg or Artifact()
+        artifact_path = format_vars(
+            artifact_name, **problem.get_vars(), file=file, submit_file=submit_file
+        )
+        res.outputs.append(
+            GradingFileOutput(
+                src=PosixPath(artifact_path),
+                dest=PosixPath(artifact_cfg.filename or artifact_path),
+                optional=artifact_cfg.optional,
+                executable=artifact_cfg.executable,
+            )
+        )
+
+    return res
+
+
+def build_run_sandbox_params(problem: Problem, has_input: bool) -> SandboxParams:
+    params = SandboxParams()
+    params.timeout = problem.timeLimit * 2
+    params.wallclock_timeout = problem.timeLimit * 5
+    params.address_space = problem.memoryLimit or 1024  # 1 GB
+    params.set_stdall(
+        stdin=PosixPath('stdin.txt') if has_input else None,
+        stdout=PosixPath('stdout.txt'),
+        stderr=MERGE_STDERR,
+    )
+    return params
+
+
+def build_run_grading_artifacts(
+    testcase: TestcaseIO, persist_root: pathlib.Path
+) -> GradingArtifacts:
+    res = GradingArtifacts(root=PosixPath('.'))
+    res.inputs.append(
+        GradingFileInput(
+            src=testcase.input,
+            dest=PosixPath('stdin.txt'),
+        )
+    )
+    res.outputs.append(
+        GradingFileOutput(
+            src=PosixPath('stdout.txt'),
+            dest=persist_root / f'stdout-{testcase.index}.txt',
+            maxlen=steps.MAX_STDOUT_LEN,
+        )
+    )
+    return res
+
+
+def build_checker_compile_grading_artifacts(
+    problem: DumpedProblem, persist_root: pathlib.Path
+) -> GradingArtifacts:
+    res = GradingArtifacts(root=PosixPath('.'))
+    if not problem.checker:
+        return res
+
+    checker_path = PosixPath(problem.checker)
+    if not checker_path.is_file():
+        checker_path = config.get_builtin_checker(problem.checker)
+    if not checker_path:
+        return res
+
+    res.inputs.append(GradingFileInput(src=checker_path, dest=PosixPath('checker.cpp')))
+    testlib = config.get_testlib()
+    if testlib.is_file():
+        res.inputs.append(GradingFileInput(src=testlib, dest=PosixPath('testlib.h')))
+    res.outputs.append(
+        GradingFileOutput(
+            src=PosixPath('checker'), dest=persist_root / 'checker', executable=True
+        )
+    )
+    return res
+
+
+def build_checker_run_grading_artifacts(
+    problem: DumpedProblem, persist_root: pathlib.Path
+) -> GradingArtifacts:
+    res = GradingArtifacts(root=PosixPath('.'))
+    if not problem.checker:
+        return res
+    res.inputs.append(
+        GradingFileInput(
+            src=persist_root / 'checker', dest=PosixPath('checker'), executable=True
+        )
+    )
+    return res

rbx/hydration.py

@@ -0,0 +1,101 @@
+import pathlib
+from typing import List, Optional, Tuple
+
+from rbx import config, hydration, metadata
+from rbx.console import console
+from rbx.schema import DumpedProblem, Testcase
+from rbx.test import get_testcases_io
+
+
+def get_testcase_paths(
+    root: pathlib.Path, problem: DumpedProblem, i: int
+) -> Tuple[pathlib.Path, pathlib.Path]:
+    return (root / f'{problem.code}.{i}.in', root / f'{problem.code}.{i}.out')
+
+
+def hydrate_problem(root: pathlib.Path, problem: DumpedProblem):
+    for i, testcase in enumerate(problem.tests or []):
+        in_path, out_path = get_testcase_paths(root, problem, i)
+        in_path.write_text(testcase.input)
+        out_path.write_text(testcase.output)
+
+
+def add_testcase(root: pathlib.Path, problem: DumpedProblem, testcase: Testcase):
+    problem_path = metadata.find_problem_path_by_code(problem.code, root)
+    if not problem_path or not problem_path.is_file():
+        console.print(
+            f'[error]Problem [item]{problem.pretty_name()}[/item] not found.[/error]'
+        )
+        return
+
+    # Pick next number.
+    i = max([tc.index for tc in get_testcases_io(problem, root)] + [-1]) + 1
+    in_path, out_path = get_testcase_paths(root, problem, i)
+    in_path.write_text(testcase.input)
+    out_path.write_text(testcase.output)
+
+    console.print(
+        f'Added testcase [item]{i}[/item] to problem [item]{problem.pretty_name()}[/item].'
+    )
+
+
+def remove_testcase(root: pathlib.Path, problem: DumpedProblem, i: int):
+    problem_path = metadata.find_problem_path_by_code(problem.code, root)
+    if not problem_path or not problem_path.is_file():
+        console.print(
+            f'[error]Problem [item]{problem.pretty_name()}[/item] not found.[/error]'
+        )
+        return
+
+    testcases = get_testcases_io(problem, root)
+    testcases = [testcase for testcase in testcases if testcase.index == i]
+    if not testcases:
+        console.print(
+            f'[error]Testcase [item]{i}[/item] not found in problem [item]{problem.pretty_name()}[/item].[/error]'
+        )
+        return
+    if testcases[0].input:
+        testcases[0].input.unlink(missing_ok=True)
+    if testcases[0].output:
+        testcases[0].output.unlink(missing_ok=True)
+
+    console.print(
+        f'Removed testcase [item]{i}[/item] from problem [item]{problem.pretty_name()}[/item].'
+    )
+
+
+def edit_testcase(root: pathlib.Path, problem: DumpedProblem, i: int):
+    problem_path = metadata.find_problem_path_by_code(problem.code, root)
+    if not problem_path or not problem_path.is_file():
+        console.print(
+            f'[error]Problem [item]{problem.pretty_name()}[/item] not found.[/error]'
+        )
+        return
+
+    testcases = get_testcases_io(problem, root)
+    testcases = [testcase for testcase in testcases if testcase.index == i]
+    if not testcases:
+        console.print(
+            f'[error]Testcase [item]{i}[/item] not found in problem [item]{problem.pretty_name()}[/item].[/error]'
+        )
+        return
+
+    paths: List[Optional[pathlib.Path]] = [testcases[0].input, testcases[0].output]
+    config.open_editor(*[path for path in paths if path is not None and path.is_file()])
+
+
+def main(problem: Optional[str] = None):
+    problems_to_hydrate = []
+    if not problem:
+        problems_to_hydrate = metadata.find_problems()
+    else:
+        dumped_problem = metadata.find_problem_by_anything(problem)
+        problems_to_hydrate.append(dumped_problem)
+
+    root = pathlib.Path()
+
+    for dumped_problem in problems_to_hydrate:
+        console.print(
+            f'Hydrating problem [item]{dumped_problem.pretty_name()}[/item]...'
+        )
+        hydration.hydrate_problem(root, dumped_problem)