Refactor to use kwargs

Author: albertoperdomo2

src/guidellm/__main__.py

@@ -162,27 +162,18 @@ def benchmark():
     help=(
         "Benchmark rate(s) to test. Meaning depends on profile: "
         "sweep=number of benchmarks, concurrent=concurrent requests, "
-        "async/constant/poisson=requests per second. "
-        "Not used for incremental profile."
+        "async/constant/poisson=requests per second, "
+        "incremental=start rate in requests per second."
     ),
 )
 @click.option(
-    "--start-rate",
-    type=float,
-    default=BenchmarkGenerativeTextArgs.get_default("start_rate"),
-    help="Initial rate for incremental profile in requests per second.",
-)
-@click.option(
-    "--increment-factor",
-    type=float,
-    default=BenchmarkGenerativeTextArgs.get_default("increment_factor"),
-    help="Factor by which to increase rate over time for incremental profile.",
-)
-@click.option(
-    "--rate-limit",
-    type=int,
-    default=BenchmarkGenerativeTextArgs.get_default("rate_limit"),
-    help="Maximum rate cap for incremental profile.",
+    "--profile-kwargs",
+    callback=cli_tools.parse_json,
+    default=BenchmarkGenerativeTextArgs.get_default("profile_kwargs"),
+    help=(
+        "JSON string of arguments to pass to the profile. "
+        'For incremental: {"increment_factor": 0.5, "rate_limit": 100}.'
+    ),
 )
 # Backend configuration
 @click.option(

src/guidellm/benchmark/entrypoints.py

@@ -268,6 +268,7 @@ async def resolve_profile(
     max_error_rate: float | None,
     max_global_error_rate: float | None,
     console: Console | None = None,
+    profile_kwargs: dict[str, Any] | None = None,
 ) -> Profile:
     """
     Resolve and configure a benchmark profile with rate and constraint settings.
@@ -306,6 +307,7 @@ async def resolve_profile(
             rate=rate,
             random_seed=random_seed,
             constraints={**constraints},
+            **(profile_kwargs or {}),
         )
     elif constraints:
         raise ValueError(
@@ -413,6 +415,7 @@ async def benchmark_generative_text(
         max_error_rate=args.max_error_rate,
         max_global_error_rate=args.max_global_error_rate,
         console=console,
+        profile_kwargs=args.profile_kwargs,
     )
     output_formats = await resolve_output_formats(
         output_formats=args.output_formats,

src/guidellm/benchmark/profile.py

@@ -729,7 +729,7 @@ class IncrementalProfile(ThroughputProfile):
     increment_factor: PositiveFloat = Field(
         description="Factor by which to increase the rate over time",
     )
-    rate_limit: PositiveInt | None = Field(
+    rate_limit: PositiveFloat | None = Field(
         default=None,
         description="Maximum rate cap after which load remains constant",
     )
@@ -747,48 +747,47 @@ def resolve_args(
         rate_type: str,
         rate: list[float] | None,
         random_seed: int,
-        start_rate: float | None = None,
         increment_factor: float | None = None,
-        rate_limit: int | None = None,
+        rate_limit: float | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         """
         Resolve arguments for incremental profile construction.
 
         :param rate_type: Profile type identifier
-        :param rate: Rate parameter (must be None for incremental)
+        :param rate: Start rate in requests per second
         :param random_seed: Random seed (ignored)
-        :param start_rate: Initial rate in requests per second
         :param increment_factor: Rate increase factor over time
         :param rate_limit: Optional maximum rate cap
         :param kwargs: Additional arguments passed through unchanged
         :return: Resolved arguments dictionary
-        :raises ValueError: If rate is not None or required params missing
+        :raises ValueError: If required params missing or invalid
         """
         _ = random_seed  # unused
         if rate_type != "incremental":
             raise ValueError("Rate type must be 'incremental' for incremental profile")
 
-        if rate is not None:
+        # For incremental profile, rate is used as start_rate
+        start_rate = rate[0] if isinstance(rate, list) and rate else rate
+        if start_rate is None:
             raise ValueError(
-                "rate does not apply to incremental profile, it must be set to None "
-                "or not set at all. Use start_rate and increment_factor instead."
+                "rate is required for incremental profile (used as start_rate)"
             )
 
-        if start_rate is None:
-            raise ValueError("start_rate is required for incremental profile")
-
         if increment_factor is None:
-            raise ValueError("increment_factor is required for incremental profile")
+            raise ValueError(
+                "increment_factor is required for incremental profile. "
+                "Pass it via --profile-kwargs '{\"increment_factor\": <value>}'"
+            )
 
         if start_rate <= 0:
-            raise ValueError("start_rate must be a positive number")
+            raise ValueError("rate (start_rate) must be a positive number")
 
         if increment_factor <= 0:
             raise ValueError("increment_factor must be a positive number")
 
         if rate_limit is not None and rate_limit <= 0:
-            raise ValueError("rate_limit must be a positive integer")
+            raise ValueError("rate_limit must be a positive number")
 
         kwargs["start_rate"] = start_rate
         kwargs["increment_factor"] = increment_factor

src/guidellm/benchmark/schemas.py

@@ -1840,17 +1840,8 @@ def get_default(cls: type[BenchmarkGenerativeTextArgs], field: str) -> Any:
     rate: float | list[float] | None = Field(
         default=None, description="Request rate(s) for rate-based scheduling"
     )
-    start_rate: float | None = Field(
-        default=None,
-        description="Initial rate for incremental profile in requests per second",
-    )
-    increment_factor: float | None = Field(
-        default=None,
-        description="Factor by which to increase rate over time for incremental profile",
-    )
-    rate_limit: int | None = Field(
-        default=None,
-        description="Maximum rate cap for incremental profile",
+    profile_kwargs: dict[str, Any] | None = Field(
+        default=None, description="Additional profile-specific configuration arguments"
     )
     # Backend configuration
     backend: BackendType | Backend = Field(

src/guidellm/scheduler/strategies.py

@@ -543,7 +543,7 @@ class AsyncIncrementalStrategy(ThroughputStrategy):
         description="Factor by which to increase the rate over time",
         gt=0,
     )
-    rate_limit: int | None = Field(
+    rate_limit: float | None = Field(
         default=None,
         description="Maximum rate cap after which load remains constant",
         gt=0,