Experiments

async def run(self, output_path: WritablePathLike | None = None):
    """Run the load test across all configured concurrency levels.

    Creates a :class:`~llmeter.runner.Runner` and iterates through
    ``sequence_of_clients``, running one test per concurrency level. In
    time-bound mode (``run_duration`` is set), each level runs for a fixed
    duration. In count-bound mode, each level sends a fixed number of
    requests per client.

    Args:
        load_path: Optional (local or remote) folder to save results. If provided, individual
        Run results will be written to `{output_path}/{test_name}/{NNNNN-clients}` subfolders.
        Default: `self.output_path` if set, else no files will be saved.

    Returns:
        LoadTestResult: A result object containing one
        :class:`~llmeter.results.Result` per concurrency level, keyed by
        client count.

    Example::

        load_test = LoadTest(
            endpoint=my_endpoint,
            payload=sample_payload,
            sequence_of_clients=[1, 5, 10],
            run_duration=30,
        )
        result = await load_test.run(output_path="outputs/my_test")

        # Access individual results by client count
        result.results[5].stats["requests_per_minute"]

        # Plot all standard charts
        result.plot_results()
    """
    output_path = ensure_path(output_path or self.output_path)
    if output_path:
        test_output_path = output_path / self._test_name
    else:
        test_output_path = None
    _runner = Runner(
        endpoint=self.endpoint,
        tokenizer=self.tokenizer,
        output_path=test_output_path,
    )

    self._results = []
    for c in tqdm(
        self.sequence_of_clients, desc="Configurations", disable=_disable_tqdm
    ):
        if self.run_duration is not None:
            result = await _runner.run(
                payload=self.payload,
                clients=c,
                run_duration=self.run_duration,
                run_name=f"{c:05.0f}-clients",
                callbacks=self.callbacks,
                low_memory=self.low_memory,
                progress_bar_stats=self.progress_bar_stats,
                output_path=test_output_path,
            )
        else:
            result = await _runner.run(
                payload=self.payload,
                clients=c,
                n_requests=self._get_n_requests(c),
                run_name=f"{c:05.0f}-clients",
                callbacks=self.callbacks,
                low_memory=self.low_memory,
                progress_bar_stats=self.progress_bar_stats,
                output_path=test_output_path,
            )
        self._results.append(result)

    return LoadTestResult(
        results={r.clients: r for r in self._results},
        test_name=self._test_name,
        output_path=test_output_path,
    )

@classmethod
def load(
    cls,
    load_path: ReadablePathLike | None,
    test_name: str | None = None,
    load_responses: bool = True,
) -> "LoadTestResult":
    """Load test results from a directory.

    Args:
        load_path: Directory path containing the load test results subdirectories
        test_name: Optional name for the test. If not provided, will use the directory name
        load_responses: Whether to load individual invocation responses. Defaults to True.
            When False, only summaries and pre-computed stats are loaded.

    Returns:
        LoadTestResult: A LoadTestResult object containing the loaded results

    Raises:
        FileNotFoundError: If load_path does not exist or is None/empty
        ValueError: If no results are found in the directory
    """
    if not load_path:
        raise FileNotFoundError("Load path cannot be None or empty")

    if not isinstance(load_path, Path):
        load_path = ensure_path(load_path)

    if not load_path.exists():
        raise FileNotFoundError(f"Load path {load_path} does not exist")

    results = [
        Result.load(x, load_responses=load_responses)
        for x in load_path.iterdir()
        if x.is_dir()
    ]

    if not results:
        raise ValueError(f"No results found in {load_path}")

    return LoadTestResult(
        results={r.clients: r for r in results},
        test_name=test_name or load_path.name,
        output_path=load_path.parent,
    )