rbx.cp 0.5.66__py3-none-any.whl → 0.5.67__py3-none-any.whl

rbx/box/checkers.py

@@ -91,8 +91,10 @@ def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
 
     if run_log.exitstatus in [SandboxBase.EXIT_SIGNAL, SandboxBase.EXIT_NONZERO_RETURN]:
         return CheckerResult(outcome=Outcome.RUNTIME_ERROR)
-    if run_log.exitstatus in [SandboxBase.EXIT_TIMEOUT, SandboxBase.EXIT_TIMEOUT_WALL]:
+    if run_log.exitstatus == SandboxBase.EXIT_TIMEOUT:
         return CheckerResult(outcome=Outcome.TIME_LIMIT_EXCEEDED)
+    if run_log.exitstatus == SandboxBase.EXIT_TIMEOUT_WALL:
+        return CheckerResult(outcome=Outcome.IDLENESS_LIMIT_EXCEEDED)
     if run_log.exitstatus == SandboxBase.EXIT_MEMORY_LIMIT_EXCEEDED:
         return CheckerResult(outcome=Outcome.MEMORY_LIMIT_EXCEEDED)
     if run_log.exitstatus == SandboxBase.EXIT_SANDBOX_ERROR:
@@ -103,7 +105,7 @@ def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
 
 
 def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerResult:
-    if result.outcome == Outcome.TIME_LIMIT_EXCEEDED:
+    if result.outcome.is_slow():
         # This already is a TLE outcome.
         return result
     is_sanitized = (

rbx/box/cli.py

@@ -552,18 +552,17 @@ def create(
 @syncer.sync
 async def stress(
     name: Annotated[
-        str,
+        Optional[str],
         typer.Argument(
-            help='Name of the stress test to run (specified in problem.rbx.yml), '
-            'or the generator to run, in case -g is specified.'
+            help='Name of the stress test to run (specified in problem.rbx.yml).'
         ),
-    ],
+    ] = None,
     generator_args: Annotated[
         Optional[str],
         typer.Option(
             '--generator',
             '-g',
-            help='Run generator [name] with these args.',
+            help='Generator call to use to generate a single test for execution.',
         ),
     ] = None,
     finder: Annotated[
@@ -610,9 +609,9 @@ async def stress(
 
     with utils.StatusProgress('Running stress...') as s:
         report = await stresses.run_stress(
-            name,
             timeout,
-            args=generator_args,
+            name=name,
+            generator_call=generator_args,
             finder=finder,
             findingsLimit=findings,
             progress=s,

rbx/box/compile.py

@@ -3,7 +3,7 @@ import pathlib
 import typer
 
 from rbx import annotations, console
-from rbx.box import code, package
+from rbx.box import code, package, remote
 from rbx.box.code import SanitizationLevel
 from rbx.box.sanitizers import warning_stack
 from rbx.box.schema import CodeItem
@@ -35,6 +35,8 @@ def _compile(item: CodeItem, sanitized: SanitizationLevel, warnings: bool):
 def any(path: str, sanitized: bool = False, warnings: bool = False):
     pkg = package.find_problem_package_or_die()
 
+    path = str(remote.expand_file(path))
+
     solution = package.get_solution_or_nil(path)
     if solution is not None:
         _compile(

rbx/box/formatting.py

@@ -1,10 +1,14 @@
 import os
 import pathlib
-from typing import Optional
+from typing import Any, Optional
 
 from rbx.box import setter_config
 
 
+def ref(text: Any) -> str:
+    return f'[item]{text}[/item]'
+
+
 def href(url: os.PathLike[str], text: Optional[str] = None, style: str = 'item') -> str:
     custom_text = False
     if text is None:

rbx/box/generators.py

@@ -110,7 +110,10 @@ def get_all_built_testcases() -> Dict[str, List[Testcase]]:
 
 
 def get_call_from_string(call_str: str) -> GeneratorCall:
-    name, args = call_str.split(None, 1)
+    try:
+        name, args = call_str.split(None, 1)
+    except ValueError:
+        return GeneratorCall(name=call_str, args='')
     return GeneratorCall(name=name, args=args)
 
 
@@ -317,10 +320,7 @@ async def generate_output_for_testcase(
         capture_pipes=True,
     )
 
-    if (
-        eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-        and eval.result.no_tle_outcome == Outcome.ACCEPTED
-    ):
+    if eval.result.outcome.is_slow() and eval.result.no_tle_outcome == Outcome.ACCEPTED:
         console.console.print(
             f'[warning]Testcase [item]{testcase.inputPath}[/item] finished in TLE, but test was generated successfully.[/warning]'
         )

rbx/box/package.py

@@ -21,6 +21,7 @@ from rbx.box.schema import (
     Package,
     Solution,
     Stress,
+    TaskType,
     TestcaseGroup,
     TestcaseSubgroup,
 )
@@ -32,6 +33,7 @@ from rbx.grading.judge.storage import FilesystemStorage, Storage
 
 YAML_NAME = 'problem.rbx.yml'
 _DEFAULT_CHECKER = 'wcmp.cpp'
+_NOOP_CHECKER = 'noop.cpp'
 TEMP_DIR = None
 CACHE_STEP_VERSION = 1
 
@@ -290,13 +292,19 @@ def get_validator_or_nil(root: pathlib.Path = pathlib.Path()) -> Optional[CodeIt
     return package.validator
 
 
+@functools.cache
+def get_default_checker(root: pathlib.Path = pathlib.Path()) -> CodeItem:
+    package = find_problem_package_or_die(root)
+    if package.type == TaskType.COMMUNICATION:
+        return CodeItem(path=get_builtin_checker(_NOOP_CHECKER).absolute())
+    return CodeItem(path=get_builtin_checker(_DEFAULT_CHECKER).absolute())
+
+
 @functools.cache
 def get_checker(root: pathlib.Path = pathlib.Path()) -> CodeItem:
     package = find_problem_package_or_die(root)
 
-    return package.checker or CodeItem(
-        path=get_builtin_checker(_DEFAULT_CHECKER).absolute()
-    )
+    return package.checker or get_default_checker(root)
 
 
 @functools.cache

rbx/box/packaging/boca/upload.py

@@ -290,6 +290,7 @@ class BocaUploader:
         if tmp_file is None:
             self.raw_error('Error while downloading run:\nDownloaded file is None.')
         final_path = into_dir / filename.with_stem(f'{run_number}-{site_number}')
+        final_path.parent.mkdir(parents=True, exist_ok=True)
         shutil.move(tmp_file, final_path)
         return final_path
 

rbx/box/presets/__init__.py

@@ -3,7 +3,6 @@ import shutil
 import tempfile
 from typing import Annotated, Iterable, List, Optional, Sequence, Union
 
-import questionary
 import rich
 import rich.prompt
 import typer
@@ -498,6 +497,8 @@ def copy_local_preset(
     if preset_remote_uri is None:
         return
 
+    import questionary
+
     add_submodule = questionary.confirm(
         'The preset is installed from a remote Git repository. Do you want to add it as a submodule of your project?',
         default=False,

rbx/box/remote.py

@@ -0,0 +1,151 @@
+import pathlib
+import re
+from abc import ABC, abstractmethod
+from typing import List, Optional, Tuple, Union
+
+import typer
+
+from rbx import console
+from rbx.box import cd, package
+from rbx.box.formatting import href, ref
+
+PathLike = Union[str, pathlib.Path]
+
+
+class Expander(ABC):
+    def get_remote_path(self, path: pathlib.Path) -> pathlib.Path:
+        return package.get_problem_remote_dir() / path
+
+    def cacheable_paths(self, path: pathlib.Path) -> List[pathlib.Path]:
+        return []
+
+    def cacheable_globs(self, path: pathlib.Path) -> List[str]:
+        return []
+
+    @abstractmethod
+    def expand(self, path: pathlib.Path) -> Optional[pathlib.Path]:
+        pass
+
+
+class BocaExpander(Expander):
+    BOCA_REGEX = re.compile(r'\@boca\/(\d+)(?:\-(\d+))?')
+
+    def get_match(self, path_str: str) -> Optional[Tuple[int, int]]:
+        match = self.BOCA_REGEX.match(path_str)
+        if match is None:
+            return None
+        run_number = int(match.group(1))
+        site_number = int(match.group(2)) if match.group(2) is not None else 1
+        return run_number, site_number
+
+    def get_boca_folder(self) -> pathlib.Path:
+        return self.get_remote_path(pathlib.Path('boca'))
+
+    def get_boca_path(self, run_number: int, site_number: int) -> pathlib.Path:
+        return self.get_boca_folder() / f'{run_number}-{site_number}'
+
+    def cacheable_globs(self, path: pathlib.Path) -> List[str]:
+        match = self.get_match(str(path))
+        if match is None:
+            return []
+        run_number, site_number = match
+        return [str(self.get_boca_path(run_number, site_number)) + '.*']
+
+    def expand(self, path: pathlib.Path) -> Optional[pathlib.Path]:
+        from rbx.box.packaging.boca import upload as boca_upload
+
+        match = self.get_match(str(path))
+        if match is None:
+            return None
+        run_number, site_number = match
+
+        boca_uploader = boca_upload.get_boca_uploader()
+        boca_uploader.login()
+        sol_path = boca_uploader.download_run(
+            run_number, site_number, self.get_boca_folder()
+        )
+        console.console.print(f'Downloaded {href(sol_path)} from BOCA...')
+        return sol_path
+
+
+REGISTERED_EXPANDERS: List['Expander'] = [
+    BocaExpander(),
+]
+
+
+def _relative_to_pkg(path: pathlib.Path) -> pathlib.Path:
+    return path.resolve().relative_to(pathlib.Path.cwd())
+
+
+def _try_cacheable_paths(
+    path: pathlib.Path, expander: Expander
+) -> Optional[pathlib.Path]:
+    cached_paths = expander.cacheable_paths(path)
+    for cached_path in cached_paths:
+        if cached_path.exists():
+            return _relative_to_pkg(cached_path)
+    return None
+
+
+def _try_cacheable_globs(
+    path: pathlib.Path, expander: Expander
+) -> Optional[pathlib.Path]:
+    cached_globs = expander.cacheable_globs(path)
+    for cached_glob in cached_globs:
+        rel_glob = _relative_to_pkg(pathlib.Path(cached_glob))
+        globbed = list(pathlib.Path.cwd().glob(str(rel_glob)))
+        if not globbed:
+            continue
+        return _relative_to_pkg(globbed[0])
+    return None
+
+
+def _try_cache(path: pathlib.Path, expander: Expander) -> Optional[pathlib.Path]:
+    cached = _try_cacheable_paths(path, expander)
+    if cached is not None:
+        return cached
+    return _try_cacheable_globs(path, expander)
+
+
+def _expand_path(path: pathlib.Path) -> Optional[pathlib.Path]:
+    if not cd.is_problem_package():
+        console.console.print(
+            f'Skipping expansion of {ref(path)} because we are not in a problem package.'
+        )
+        raise typer.Exit(1)
+
+    for expander in REGISTERED_EXPANDERS:
+        cached = _try_cache(path, expander)
+        if cached is not None:
+            return cached
+        expanded = expander.expand(path)
+        if expanded is not None:
+            return _relative_to_pkg(expanded)
+    return None
+
+
+def _expand_paths(paths: List[pathlib.Path]) -> List[pathlib.Path]:
+    res = []
+    for path in paths:
+        if not str(path).startswith('@'):
+            res.append(path)
+            continue
+        expanded = _expand_path(path)
+        if expanded is None:
+            continue
+        res.append(expanded)
+    return res
+
+
+def expand_files(files: List[str]) -> List[pathlib.Path]:
+    return _expand_paths([pathlib.Path(file) for file in files])
+
+
+def expand_file(file: str) -> pathlib.Path:
+    res = expand_files([file])
+    if len(res) != 1:
+        console.console.print(
+            f'Could not expand {ref(file)} because it is not a valid expansion.'
+        )
+        raise typer.Exit(1)
+    return res[0]

rbx/box/retries.py

@@ -18,10 +18,7 @@ def _both_accepted(eval_a: Evaluation, eval_b: Evaluation) -> bool:
 
 
 def _any_tle(eval_a: Evaluation, eval_b: Evaluation) -> bool:
-    return (
-        eval_a.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-        or eval_b.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-    )
+    return eval_a.result.outcome.is_slow() or eval_b.result.outcome.is_slow()
 
 
 def _get_faster(eval_a: Evaluation, eval_b: Evaluation) -> Evaluation:
@@ -130,13 +127,10 @@ class Retrier:
 
     def should_repeat(self, eval: Evaluation) -> bool:
         if self.is_stress:
-            if (
-                eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-                and self.retries_for_stress > 0
-            ):
+            if eval.result.outcome.is_slow() and self.retries_for_stress > 0:
                 self.retries_for_stress -= 1
                 return True
-        if eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED and self.retries > 0:
+        if eval.result.outcome.is_slow() and self.retries > 0:
             self.retries -= 1
             return True
         if self.reps > 0:

rbx/box/schema.py

@@ -57,6 +57,9 @@ def expand_var(value: Primitive) -> Primitive:
 
 
 class ExpectedOutcome(AutoEnum):
+    ANY = alias('any')  # type: ignore
+    """Expected outcome for any outcome."""
+
     ACCEPTED = alias('accepted', 'ac', 'correct')  # type: ignore
     """Expected outcome for correct solutions (AC)."""
 
@@ -97,6 +100,8 @@ class ExpectedOutcome(AutoEnum):
     Especially useful for environments where TLE and RTE are indistinguishable."""
 
     def style(self) -> str:
+        if self == ExpectedOutcome.ANY:
+            return 'orange'
         if self == ExpectedOutcome.ACCEPTED:
             return 'green'
         if self == ExpectedOutcome.WRONG_ANSWER:
@@ -114,29 +119,39 @@ class ExpectedOutcome(AutoEnum):
     def is_slow(self) -> bool:
         return self in [ExpectedOutcome.TIME_LIMIT_EXCEEDED, ExpectedOutcome.TLE_OR_RTE]
 
+    def matches_tle_and_is_incorrect(self) -> bool:
+        return self.match(Outcome.TIME_LIMIT_EXCEEDED) and not self.match(
+            Outcome.ACCEPTED
+        )
+
     def match(self, outcome: Outcome) -> bool:
+        if self == ExpectedOutcome.ANY:
+            return True
         if self == ExpectedOutcome.ACCEPTED:
             return outcome == Outcome.ACCEPTED
         if self == ExpectedOutcome.ACCEPTED_OR_TLE:
-            return outcome in {Outcome.ACCEPTED, Outcome.TIME_LIMIT_EXCEEDED}
+            return outcome in {Outcome.ACCEPTED} or outcome.is_slow()
         if self == ExpectedOutcome.WRONG_ANSWER:
             return outcome == Outcome.WRONG_ANSWER
         if self == ExpectedOutcome.INCORRECT:
-            return outcome in {
-                Outcome.WRONG_ANSWER,
-                Outcome.RUNTIME_ERROR,
-                Outcome.MEMORY_LIMIT_EXCEEDED,
-                Outcome.TIME_LIMIT_EXCEEDED,
-                Outcome.OUTPUT_LIMIT_EXCEEDED,
-            }
+            return (
+                outcome
+                in {
+                    Outcome.WRONG_ANSWER,
+                    Outcome.RUNTIME_ERROR,
+                    Outcome.MEMORY_LIMIT_EXCEEDED,
+                    Outcome.OUTPUT_LIMIT_EXCEEDED,
+                }
+                or outcome.is_slow()
+            )
         if self == ExpectedOutcome.RUNTIME_ERROR:
             return outcome == Outcome.RUNTIME_ERROR
         if self == ExpectedOutcome.TIME_LIMIT_EXCEEDED:
-            return outcome == Outcome.TIME_LIMIT_EXCEEDED
+            return outcome.is_slow()
         if self == ExpectedOutcome.MEMORY_LIMIT_EXCEEDED:
             return outcome == Outcome.MEMORY_LIMIT_EXCEEDED
         if self == ExpectedOutcome.TLE_OR_RTE:
-            return outcome in {Outcome.TIME_LIMIT_EXCEEDED, Outcome.RUNTIME_ERROR}
+            return outcome in {Outcome.RUNTIME_ERROR} or outcome.is_slow()
         if self == ExpectedOutcome.OUTPUT_LIMIT_EXCEEDED:
             return outcome == Outcome.OUTPUT_LIMIT_EXCEEDED
         return False

rbx/box/solutions.py

@@ -16,7 +16,7 @@ import typer
 from pydantic import BaseModel
 
 from rbx import console, utils
-from rbx.box import checkers, environment, package, state
+from rbx.box import checkers, environment, package, remote, state
 from rbx.box.code import (
     SanitizationLevel,
     compile_item,
@@ -130,7 +130,7 @@ class RunSolutionResult:
 
 def is_fast(solution: Solution) -> bool:
     # If solution has TLE tag, it is considered slow.
-    return not solution.outcome.match(Outcome.TIME_LIMIT_EXCEEDED)
+    return not solution.outcome.is_slow()
 
 
 def get_matching_solutions(expected_outcome: ExpectedOutcome) -> List[Solution]:
@@ -720,74 +720,38 @@ def _get_solution_repr(sol: Solution) -> List[Tuple[str, str]]:
     ]
 
 
-# TODO: refactor this function
-def _expand_remote_sol(sol: str) -> Optional[str]:
-    from rbx.box.packaging.boca import upload as boca_upload
-
-    # Only BOCA supported for now.
-    assert sol.startswith('@')
-    sol = sol[1:]
-    if '-' in sol:
-        run_number, site_number = sol.split('-', 1)
-        run_number = int(run_number)
-        site_number = int(site_number)
-    else:
-        run_number = int(sol)
-        site_number = 1
-
-    expected_glob = (
-        package.get_problem_remote_dir('boca') / f'{run_number}-{site_number}.*'
-    )
-    expected_glob = expected_glob.relative_to(pathlib.Path.cwd())
-    for path in pathlib.Path.cwd().glob(str(expected_glob)):
-        if path.is_file():
-            relpath = path.resolve().relative_to(pathlib.Path.cwd())
-            console.console.print(f'Retrieving {href(relpath)} from cache...')
-            return str(relpath)
-
-    boca_uploader = boca_upload.get_boca_uploader()
-    boca_uploader.login()
-    sol_path = boca_uploader.download_run(
-        run_number, site_number, package.get_problem_remote_dir('boca')
-    )
-    console.console.print(f'Downloaded {href(sol_path)} from BOCA...')
-    return str(sol_path.resolve().relative_to(pathlib.Path.cwd()))
-
-
-def _expand_remote_sols(sols: List[str]) -> List[str]:
-    res = []
-    for sol in sols:
-        if not sol.startswith('@'):
-            res.append(sol)
-            continue
-        expanded = _expand_remote_sol(sol)
-        if expanded is None:
-            continue
-        res.append(expanded)
-    return res
-
-
-def expand_solutions(sols: List[str]) -> List[Solution]:
+def expand_solutions_with_source(sols: List[str]) -> List[Tuple[Solution, bool]]:
     pkg = package.find_problem_package_or_die()
-    seen_sols = {str(sol.path): sol for sol in pkg.solutions}
+    pkg_sols = {str(sol.path): sol for sol in pkg.solutions}
 
     # Download remote sols.
-    sols = _expand_remote_sols(sols)
+    sols = remote.expand_files(sols)
 
     # Ensure sols exist.
     sols = [sol for sol in sols if pathlib.Path(sol).is_file()]
 
-    res = []
+    seen_sols = set()
+    res: List[Tuple[Solution, bool]] = []
     for sol in sols:
         if sol in seen_sols:
-            res.append(seen_sols[sol])
+            # This solution was already added.
+            continue
+        if sol in pkg_sols:
+            # This solution is in the package.
+            res.append((pkg_sols[sol], False))
         else:
+            # This solution is fetched from some source.
             res.append(
-                Solution(path=pathlib.Path(sol), outcome=ExpectedOutcome.ACCEPTED)
+                (Solution(path=pathlib.Path(sol), outcome=ExpectedOutcome.ANY), True)
             )
+        seen_sols.add(sol)
     return res
 
 
+def expand_solutions(sols: List[str]) -> List[Solution]:
+    return [sol for sol, _ in expand_solutions_with_source(sols)]
+
+
 async def pick_solutions(
     tracked_solutions: Optional[Set[str]],
     extra_solutions: Optional[List[str]] = None,
@@ -830,7 +794,7 @@ def get_outcome_style_verdict(outcome: Outcome) -> str:
         return 'green'
     if outcome == Outcome.WRONG_ANSWER:
         return 'red'
-    if outcome == Outcome.TIME_LIMIT_EXCEEDED:
+    if outcome.is_slow():
         return 'yellow'
     if outcome == Outcome.RUNTIME_ERROR:
         return 'blue'
@@ -843,7 +807,7 @@ def get_outcome_markup_verdict(outcome: Outcome) -> str:
     res = '✓'
     if outcome != Outcome.ACCEPTED:
         res = '✗'
-    if outcome == Outcome.TIME_LIMIT_EXCEEDED:
+    if outcome.is_slow():
         res = '⧖'
     if outcome == Outcome.RUNTIME_ERROR:
         res = '✗'
@@ -873,6 +837,19 @@ def get_full_testcase_markup_verdict(eval: Evaluation) -> str:
 def _get_evals_time_in_ms(evals: List[Evaluation]) -> int:
     if not evals:
         return 0
+    evals_with_ile = [
+        eval for eval in evals if eval.result.outcome == Outcome.IDLENESS_LIMIT_EXCEEDED
+    ]
+    for eval in evals_with_ile:
+        # Try every way of estimating a ILE max timelimit.
+        if eval.log.metadata is None:
+            continue
+        if eval.log.metadata.limits is not None:
+            expanded_tl = eval.log.metadata.limits.get_expanded_tl()
+            if expanded_tl is not None:
+                return expanded_tl
+        if eval.log.metadata.timeLimit is not None:
+            return eval.log.metadata.timeLimit
     return max(int((eval.log.time or 0.0) * 1000) for eval in evals)
 
 
@@ -893,7 +870,10 @@ def get_capped_evals_formatted_time(
     pkg = package.find_problem_package_or_die()
 
     max_time = _get_evals_time_in_ms(evals)
-    has_tle = any(eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED for eval in evals)
+    has_tle = any(eval.result.outcome.is_slow() for eval in evals)
+    has_ile = any(
+        eval.result.outcome == Outcome.IDLENESS_LIMIT_EXCEEDED for eval in evals
+    )
     timelimits = [
         eval.log.metadata.limits.get_expanded_tl()
         for eval in evals
@@ -911,7 +891,7 @@ def get_capped_evals_formatted_time(
             # Using double TL for verification.
             tl = tl * 2
 
-    if has_tle and max_time >= tl:
+    if has_tle and max_time >= tl or has_ile:
         return f'>{tl} ms'
     return f'{max_time} ms'
 
@@ -996,8 +976,7 @@ def get_solution_outcome_report(
         ):
             no_tle_bad_verdicts.add(eval.result.no_tle_outcome)
         has_plain_tle = has_plain_tle or (
-            eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-            and eval.result.no_tle_outcome is None
+            eval.result.outcome.is_slow() and eval.result.no_tle_outcome is None
         )
         has_sanitizer_warnings = (
             has_sanitizer_warnings or eval.result.sanitizer_warnings
@@ -1030,9 +1009,7 @@ def get_solution_outcome_report(
             report_got_verdicts = {Outcome.ACCEPTED}
 
     evals_time = _get_evals_time_in_ms(evals)
-    expected_outcome_is_tle = solution.outcome.match(
-        Outcome.TIME_LIMIT_EXCEEDED
-    ) and not solution.outcome.match(Outcome.ACCEPTED)
+    expected_outcome_is_tle = solution.outcome.matches_tle_and_is_incorrect()
     if (
         # Running verification with double TL.
         verification.value >= VerificationLevel.FULL.value

rbx/box/stresses.py

@@ -8,7 +8,7 @@ import typer
 from pydantic import BaseModel
 
 from rbx import console
-from rbx.box import checkers, package, validators
+from rbx.box import checkers, generators, package, validators
 from rbx.box.code import SanitizationLevel, compile_item, run_item
 from rbx.box.generators import (
     GenerationMetadata,
@@ -51,10 +51,10 @@ def _compile_finder(finder: CodeItem) -> str:
 
 
 async def run_stress(
-    name: str,
     timeoutInSeconds: int,
+    name: Optional[str] = None,
     finder: Optional[str] = None,
-    args: Optional[str] = None,
+    generator_call: Optional[str] = None,
     findingsLimit: int = 1,
     verbose: bool = False,
     progress: Optional[StatusProgress] = None,
@@ -68,12 +68,23 @@ async def run_stress(
         raise typer.Exit(1)
 
     if finder:
+        if generator_call is None:
+            console.console.print(
+                '[error]Generator arguments are required for stress testing. Specify them through the [item]-g[/item] flag.[/error]'
+            )
+            raise typer.Exit(1)
+        generator = generators.get_call_from_string(generator_call)
         stress = Stress(
-            name=f'{name}',
-            generator=GeneratorCall(name=name, args=args or ''),
+            name=f'{generator.name}',
+            generator=generator,
             finder=finder,
         )
     else:
+        if name is None:
+            console.console.print(
+                '[error]Invalid stress test paramaters. Either provide a stress test name, or provide a finder expression (-f) and generator arguments (-g).[/error]'
+            )
+            raise typer.Exit(1)
         stress = package.get_stress(name)
 
     call = stress.generator
@@ -258,7 +269,7 @@ async def run_stress(
 
         if internal_error_results:
             console.console.print(
-                f'[error]Checkers failed during stress test [item]{name}[/item] with args [info]{expanded_generator_call.name} {expanded_generator_call.args}[/info][/error]'
+                f'[error]Checkers failed during stress test [item]{stress.name}[/item] with args [info]{expanded_generator_call.name} {expanded_generator_call.args}[/info][/error]'
             )
             for internal_error_result in internal_error_results:
                 assert internal_error_result.checker is not None