guidellm 0.3.0a15__py3-none-any.whl → 0.3.0a16__py3-none-any.whl

guidellm/__main__.py

@@ -1,4 +1,5 @@
 import asyncio
+import codecs
 import json
 from pathlib import Path
 from typing import get_args
@@ -8,6 +9,7 @@ import click
 from guidellm.backend import BackendType
 from guidellm.benchmark import ProfileType, benchmark_generative_text
 from guidellm.config import print_config
+from guidellm.preprocess.dataset import ShortPromptStrategy, process_dataset
 from guidellm.scheduler import StrategyType
 
 STRATEGY_PROFILE_CHOICES = set(
@@ -280,6 +282,20 @@ def benchmark(
     )
 
 
+def decode_escaped_str(_ctx, _param, value):
+    """
+    Click auto adds characters. For example, when using --pad-char "\n",
+    it parses it as "\\n". This method decodes the string to handle escape
+    sequences correctly.
+    """
+    if value is None:
+        return None
+    try:
+        return codecs.decode(value, "unicode_escape")
+    except Exception as e:
+        raise click.BadParameter(f"Could not decode escape sequences: {e}") from e
+
+
 @cli.command(
     help=(
         "Print out the available configuration settings that can be set "
@@ -290,5 +306,139 @@ def config():
     print_config()
 
 
+@cli.group(help="General preprocessing tools and utilities.")
+def preprocess():
+    pass
+
+
+@preprocess.command(
+    help=(
+        "Convert a dataset to have specific prompt and output token sizes.\n"
+        "DATA: Path to the input dataset or dataset ID.\n"
+        "OUTPUT_PATH: Path to save the converted dataset, including file suffix."
+    )
+)
+@click.argument(
+    "data",
+    type=str,
+    required=True,
+)
+@click.argument(
+    "output_path",
+    type=click.Path(file_okay=True, dir_okay=False, writable=True, resolve_path=True),
+    required=True,
+)
+@click.option(
+    "--processor",
+    type=str,
+    required=True,
+    help=(
+        "The processor or tokenizer to use to calculate token counts for statistics "
+        "and synthetic data generation."
+    ),
+)
+@click.option(
+    "--processor-args",
+    default=None,
+    callback=parse_json,
+    help=(
+        "A JSON string containing any arguments to pass to the processor constructor "
+        "as a dict with **kwargs."
+    ),
+)
+@click.option(
+    "--data-args",
+    callback=parse_json,
+    help=(
+        "A JSON string containing any arguments to pass to the dataset creation "
+        "as a dict with **kwargs."
+    ),
+)
+@click.option(
+    "--short-prompt-strategy",
+    type=click.Choice([s.value for s in ShortPromptStrategy]),
+    default=ShortPromptStrategy.IGNORE.value,
+    show_default=True,
+    help="Strategy to handle prompts shorter than the target length. ",
+)
+@click.option(
+    "--pad-char",
+    type=str,
+    default="",
+    callback=decode_escaped_str,
+    help="The token to pad short prompts with when using the 'pad' strategy.",
+)
+@click.option(
+    "--concat-delimiter",
+    type=str,
+    default="",
+    help=(
+        "The delimiter to use when concatenating prompts that are too short."
+        " Used when strategy is 'concatenate'."
+    ),
+)
+@click.option(
+    "--prompt-tokens",
+    type=str,
+    default=None,
+    help="Prompt tokens config (JSON, YAML file or key=value string)",
+)
+@click.option(
+    "--output-tokens",
+    type=str,
+    default=None,
+    help="Output tokens config (JSON, YAML file or key=value string)",
+)
+@click.option(
+    "--push-to-hub",
+    is_flag=True,
+    help="Set this flag to push the converted dataset to the Hugging Face Hub.",
+)
+@click.option(
+    "--hub-dataset-id",
+    type=str,
+    default=None,
+    help="The Hugging Face Hub dataset ID to push to. "
+    "Required if --push-to-hub is used.",
+)
+@click.option(
+    "--random-seed",
+    type=int,
+    default=42,
+    show_default=True,
+    help="Random seed for prompt token sampling and output tokens sampling.",
+)
+def dataset(
+    data,
+    output_path,
+    processor,
+    processor_args,
+    data_args,
+    short_prompt_strategy,
+    pad_char,
+    concat_delimiter,
+    prompt_tokens,
+    output_tokens,
+    push_to_hub,
+    hub_dataset_id,
+    random_seed,
+):
+    process_dataset(
+        data=data,
+        output_path=output_path,
+        processor=processor,
+        prompt_tokens=prompt_tokens,
+        output_tokens=output_tokens,
+        processor_args=processor_args,
+        data_args=data_args,
+        short_prompt_strategy=short_prompt_strategy,
+        pad_char=pad_char,
+        concat_delimiter=concat_delimiter,
+        push_to_hub=push_to_hub,
+        hub_dataset_id=hub_dataset_id,
+        random_seed=random_seed,
+    )
+
+
 if __name__ == "__main__":
     cli()

guidellm/preprocess/__init__.py

@@ -0,0 +1,3 @@
+from .dataset import ShortPromptStrategy, process_dataset
+
+__all__ = ["ShortPromptStrategy", "process_dataset"]

guidellm/preprocess/dataset.py

@@ -0,0 +1,374 @@
+import json
+import os
+from collections.abc import Iterator
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Optional, Union
+
+import yaml
+from datasets import Dataset
+from loguru import logger
+from pydantic import BaseModel, Field
+from transformers import PreTrainedTokenizerBase
+
+from guidellm.dataset import load_dataset as guidellm_load_dataset
+from guidellm.utils import IntegerRangeSampler, check_load_processor
+from guidellm.utils.hf_datasets import SUPPORTED_TYPES, save_dataset_to_file
+
+
+class PromptTooShortError(Exception):
+    pass
+
+
+class ShortPromptStrategy(str, Enum):
+    IGNORE = "ignore"
+    CONCATENATE = "concatenate"
+    PAD = "pad"
+    ERROR = "error"
+
+
+def handle_ignore_strategy(
+    current_prompt: str,
+    min_prompt_tokens: int,
+    tokenizer: PreTrainedTokenizerBase,
+    **_kwargs,
+) -> Optional[str]:
+    """
+    Ignores prompts that are shorter than the required minimum token length.
+
+    :param current_prompt: The input prompt string.
+    :param min_prompt_tokens: Minimum required token count.
+    :param tokenizer: Tokenizer used to count tokens.
+    :return: The prompt if it meets the length, otherwise None.
+    """
+
+    if len(tokenizer.encode(current_prompt)) < min_prompt_tokens:
+        logger.warning("Prompt too short, ignoring")
+        return None
+    return current_prompt
+
+
+def handle_concatenate_strategy(
+    current_prompt: str,
+    min_prompt_tokens: int,
+    dataset_iterator: Iterator[dict[str, Any]],
+    prompt_column: str,
+    tokenizer: PreTrainedTokenizerBase,
+    concat_delimiter: str,
+    **_kwargs,
+) -> Optional[str]:
+    """
+    Concatenates prompts until the minimum token requirement is met.
+
+    :param current_prompt: The initial prompt.
+    :param min_prompt_tokens: Target minimum token length.
+    :param dataset_iterator: Iterator to fetch more prompts.
+    :param prompt_column: Column key for prompt extraction.
+    :param tokenizer: Tokenizer used to count tokens.
+    :param concat_delimiter: Delimiter to use between prompts.
+    :return: Concatenated prompt or None if not enough data.
+    """
+
+    tokens_len = len(tokenizer.encode(current_prompt))
+    while tokens_len < min_prompt_tokens:
+        try:
+            next_row = next(dataset_iterator)
+        except StopIteration:
+            logger.warning(
+                "Could not concatenate enough prompts to reach minimum length, ignoring"
+            )
+            return None
+        current_prompt += concat_delimiter + next_row[prompt_column]
+        tokens_len = len(tokenizer.encode(current_prompt))
+    return current_prompt
+
+
+def handle_pad_strategy(
+    current_prompt: str,
+    min_prompt_tokens: int,
+    tokenizer: PreTrainedTokenizerBase,
+    pad_char: str,
+    pad_multiplier: int = 2,
+    **_kwargs,
+) -> str:
+    """
+    Pads the prompt with a character until it reaches the minimum token length.
+
+    :param current_prompt: The input prompt.
+    :param min_prompt_tokens: Desired minimum token count.
+    :param tokenizer: Tokenizer used to count tokens.
+    :param pad_char: Character used for padding.
+    :param pad_multiplier: Multiplier for padding character length.
+    :return: Padded prompt string.
+    """
+
+    tokens = tokenizer.encode(current_prompt)
+    pad_count = 1
+    prompt = current_prompt
+    while len(tokens) < min_prompt_tokens:
+        prompt += pad_char * pad_count
+        tokens = tokenizer.encode(prompt)
+        pad_count *= pad_multiplier
+    return prompt
+
+
+def handle_error_strategy(
+    current_prompt: str,
+    min_prompt_tokens: int,
+    tokenizer: PreTrainedTokenizerBase,
+    **_kwargs,
+) -> Optional[str]:
+    """
+    Raises an error if the prompt is too short.
+
+    :param current_prompt: The input prompt.
+    :param min_prompt_tokens: Required token count.
+    :param tokenizer: Tokenizer used to count tokens.
+    :return: The input prompt if valid.
+    :raises PromptTooShortError: If the prompt is too short.
+    """
+
+    prompt_len = len(tokenizer.encode(current_prompt))
+    if prompt_len < min_prompt_tokens:
+        raise PromptTooShortError(
+            f"Found too short prompt: {current_prompt}, with length: {prompt_len}. "
+            f"Minimum length required: {min_prompt_tokens}.",
+        )
+    return current_prompt
+
+
+STRATEGY_HANDLERS: dict[ShortPromptStrategy, Callable] = {
+    ShortPromptStrategy.IGNORE: handle_ignore_strategy,
+    ShortPromptStrategy.CONCATENATE: handle_concatenate_strategy,
+    ShortPromptStrategy.PAD: handle_pad_strategy,
+    ShortPromptStrategy.ERROR: handle_error_strategy,
+}
+
+
+class TokensConfig(BaseModel):
+    average: int = Field(
+        description="The average number of tokens.",
+        gt=0,
+    )
+    stdev: Optional[int] = Field(
+        description="The standard deviation of the tokens.",
+        gt=0,
+        default=None,
+    )
+    min: Optional[int] = Field(
+        description="The minimum number of tokens.",
+        gt=0,
+        default=None,
+    )
+    max: Optional[int] = Field(
+        description="The maximum number of tokens.",
+        gt=0,
+        default=None,
+    )
+
+    @staticmethod
+    def parse_str(data: Union[str, Path]) -> "TokensConfig":
+        """
+        Parses a string or path into a TokensConfig object. Supports:
+        - JSON string
+        - key=value pairs
+        - file path to .yaml/.config
+
+        :param data: String or path containing configuration.
+        :return: Parsed TokensConfig instance.
+        :raises ValueError: If the format is not recognized.
+        """
+
+        if (
+            isinstance(data, Path)
+            or data.strip().endswith(".config")
+            or data.strip().endswith(".yaml")
+        ):
+            return TokensConfig.parse_config_file(data)
+
+        if data.strip().startswith("{"):
+            return TokensConfig.parse_json(data)
+
+        if data.count("=") > 1:
+            return TokensConfig.parse_key_value_pairs(data)
+
+        raise ValueError(
+            f"Unsupported data format. Expected JSON or key-value pairs, got {data}"
+        )
+
+    @staticmethod
+    def parse_json(data: str) -> "TokensConfig":
+        config_dict = json.loads(data.strip())
+
+        return TokensConfig(**config_dict)
+
+    @staticmethod
+    def parse_key_value_pairs(data: str) -> "TokensConfig":
+        config_dict = {}
+        items = data.strip().split(",")
+        for item in items:
+            key, value = item.split("=")
+            config_dict[key.strip()] = (
+                int(value.strip()) if value.strip().isnumeric() else value.strip()
+            )
+
+        return TokensConfig(**config_dict)  # type: ignore[arg-type]
+
+    @staticmethod
+    def parse_config_file(data: Union[str, Path]) -> "TokensConfig":
+        with Path(data).open("r") as file:
+            config_dict = yaml.safe_load(file)
+
+        return TokensConfig(**config_dict)
+
+
+def _validate_output_suffix(output_path: Union[str, Path]) -> None:
+    output_path = Path(output_path)
+    suffix = output_path.suffix.lower()
+    if suffix not in SUPPORTED_TYPES:
+        raise ValueError(
+            f"Unsupported file suffix '{suffix}' in output_path '{output_path}'. "
+            f"Only {SUPPORTED_TYPES} are supported."
+        )
+
+
+def process_dataset(
+    data: Union[str, Path],
+    output_path: Union[str, Path],
+    processor: Union[str, Path, PreTrainedTokenizerBase],
+    prompt_tokens: Union[str, Path],
+    output_tokens: Union[str, Path],
+    processor_args: Optional[dict[str, Any]] = None,
+    data_args: Optional[dict[str, Any]] = None,
+    short_prompt_strategy: ShortPromptStrategy = ShortPromptStrategy.IGNORE,
+    pad_char: Optional[str] = None,
+    concat_delimiter: Optional[str] = None,
+    push_to_hub: bool = False,
+    hub_dataset_id: Optional[str] = None,
+    random_seed: int = 42,
+) -> None:
+    """
+    Main method to process and save a dataset with sampled prompt/output token counts.
+
+    :param data: Path or identifier for dataset input.
+    :param output_path: File path to save the processed dataset.
+    :param processor: Tokenizer object or its config.
+    :param prompt_tokens: Prompt token config string or file.
+    :param output_tokens: Output token config string or file.
+    :param processor_args: Optional processor arguments.
+    :param data_args: Optional data loading arguments.
+    :param short_prompt_strategy: Strategy for handling short prompts.
+    :param pad_char: Character used when padding short prompts.
+    :param concat_delimiter: Delimiter for concatenation strategy.
+    :param push_to_hub: Whether to push to Hugging Face Hub.
+    :param hub_dataset_id: Dataset ID on Hugging Face Hub.
+    :param random_seed: Seed for random sampling.
+    :raises ValueError: If output path is invalid or pushing conditions unmet.
+    """
+
+    _validate_output_suffix(output_path)
+    logger.info(
+        f"Starting dataset conversion | Input: {data} | Output directory: {output_path}"
+    )
+
+    dataset, column_mappings = guidellm_load_dataset(
+        data, data_args, processor, processor_args
+    )
+    tokenizer = check_load_processor(
+        processor,
+        processor_args,
+        "dataset conversion.",
+    )
+    prompt_column = column_mappings.get("prompt_column")
+    output_column = column_mappings.get(
+        "output_tokens_count_column", "output_tokens_count"
+    )
+
+    prompt_tokens_cfg = TokensConfig.parse_str(prompt_tokens)
+    output_tokens_cfg = TokensConfig.parse_str(output_tokens)
+
+    prompt_token_sampler = iter(
+        IntegerRangeSampler(
+            average=prompt_tokens_cfg.average,
+            variance=prompt_tokens_cfg.stdev,
+            min_value=prompt_tokens_cfg.min,
+            max_value=prompt_tokens_cfg.max,
+            random_seed=random_seed,
+        )
+    )
+
+    output_token_sampler = iter(
+        IntegerRangeSampler(
+            average=output_tokens_cfg.average,
+            variance=output_tokens_cfg.stdev,
+            min_value=output_tokens_cfg.min,
+            max_value=output_tokens_cfg.max,
+            random_seed=random_seed,
+        )
+    )
+
+    dataset_iterator = iter(dataset)
+    processed_prompts = []
+    prompt_handler = STRATEGY_HANDLERS[short_prompt_strategy]
+
+    for prompt_row in dataset_iterator:
+        prompt_text = prompt_row[prompt_column]
+        target_prompt_len = next(prompt_token_sampler)
+
+        prompt_text = prompt_handler(
+            current_prompt=prompt_text,
+            min_prompt_tokens=target_prompt_len,
+            dataset_iterator=dataset_iterator,
+            prompt_column=prompt_column,
+            tokenizer=tokenizer,
+            pad_char=pad_char,
+            concat_delimiter=concat_delimiter,
+        )
+        if prompt_text is None:
+            continue
+
+        tokens = tokenizer.encode(prompt_text)
+        if len(tokens) > target_prompt_len:
+            prompt_text = tokenizer.decode(tokens[:target_prompt_len])
+
+        processed_prompt = prompt_row.copy()
+        processed_prompt[prompt_column] = prompt_text
+        processed_prompt["prompt_tokens_count"] = target_prompt_len
+        processed_prompt[output_column] = next(output_token_sampler)
+
+        processed_prompts.append(processed_prompt)
+
+    if not processed_prompts:
+        logger.error("No prompts remained after processing")
+        return
+
+    logger.info(f"Generated processed dataset with {len(processed_prompts)} prompts")
+
+    processed_dataset = Dataset.from_list(processed_prompts)
+    save_dataset_to_file(processed_dataset, output_path)
+    logger.info(f"Conversion completed. Dataset saved to: {output_path}")
+
+    if push_to_hub:
+        push_dataset_to_hub(hub_dataset_id, processed_dataset)
+        logger.info(f"Pushed dataset to: {hub_dataset_id}")
+
+
+def push_dataset_to_hub(
+    hub_dataset_id: Optional[str],
+    processed_dataset: Dataset,
+) -> None:
+    """
+    Pushes the processed dataset to Hugging Face Hub using HF_TOKEN.
+
+    :param hub_dataset_id: Identifier on the Hub to push to.
+    :param processed_dataset: HuggingFace Dataset object.
+    :raises ValueError: If hub_dataset_id or HF_TOKEN is not available.
+    """
+
+    hf_token = os.environ.get("HF_TOKEN")
+    if not hub_dataset_id or not hf_token:
+        raise ValueError(
+            "hub_dataset_id and HF_TOKEN env var must be provided when push_to_hub"
+            " is True"
+        )
+    processed_dataset.push_to_hub(hub_dataset_id, token=hf_token)

guidellm/utils/__init__.py

@@ -1,4 +1,8 @@
 from .colors import Colors
+from .hf_datasets import (
+    SUPPORTED_TYPES,
+    save_dataset_to_file,
+)
 from .hf_transformers import (
     check_load_processor,
 )
@@ -14,6 +18,7 @@ from .text import (
 )
 
 __all__ = [
+    "SUPPORTED_TYPES",
     "Colors",
     "EndlessTextCreator",
     "IntegerRangeSampler",
@@ -22,6 +27,7 @@ __all__ = [
     "filter_text",
     "is_puncutation",
     "load_text",
+    "save_dataset_to_file",
     "split_text",
     "split_text_list_by_length",
 ]

guidellm/utils/hf_datasets.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+from typing import Union
+
+from datasets import Dataset
+
+SUPPORTED_TYPES = {
+    ".json",
+    ".jsonl",
+    ".csv",
+    ".parquet",
+}
+
+
+def save_dataset_to_file(dataset: Dataset, output_path: Union[str, Path]) -> None:
+    """
+    Saves a HuggingFace Dataset to file in a supported format.
+
+    :param dataset: Dataset to save.
+    :param output_path: Output file path (.json, .jsonl, .csv, .parquet).
+    :raises ValueError: If the file extension is not supported.
+    """
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    suffix = output_path.suffix.lower()
+
+    if suffix == ".csv":
+        dataset.to_csv(output_path)
+    elif suffix in {".json", ".jsonl"}:
+        dataset.to_json(output_path)
+    elif suffix == ".parquet":
+        dataset.to_parquet(output_path)
+    else:
+        raise ValueError(
+            f"Unsupported file suffix '{suffix}' in output_path'{output_path}'."
+            f" Only {SUPPORTED_TYPES} are supported."
+        )

{guidellm-0.3.0a15.dist-info → guidellm-0.3.0a16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guidellm
-Version: 0.3.0a15
+Version: 0.3.0a16
 Summary: Guidance platform for deploying and managing large language models.
 Author: Red Hat
 License-Expression: Apache-2.0

{guidellm-0.3.0a15.dist-info → guidellm-0.3.0a16.dist-info}/RECORD

@@ -1,5 +1,5 @@
 guidellm/__init__.py,sha256=qXCx-HonNByJ2PDKqOUnD7CcbxA7cazNKyqKigwyuyE,1139
-guidellm/__main__.py,sha256=nevPBoYwQEG-rRE7Bq08GGEOpQkVlMxFoWg_PYVEIdI,7880
+guidellm/__main__.py,sha256=QwExTHhseN2JjHoclUPI1H_yspshOS_mtZ84466CnPE,11751
 guidellm/config.py,sha256=-JuirSy1EDkQnXHfLKBV_PeQGFwi5nL088BKeCgh9Xo,6087
 guidellm/logger.py,sha256=O4sU2QKHn_swJIEmayiEt6nIXzGHGmXqZ_Mg8CdIE5Q,2609
 guidellm/version.py,sha256=XZeUwR24DzG1AjuKV0s8cRyc0Xv8cPiqXYSZTt7xQVg,127
@@ -27,6 +27,8 @@ guidellm/dataset/synthetic.py,sha256=PXYj06X9QuSJ98oGR7PmFVQYuqwacbq5OCnt45X2LTs
 guidellm/objects/__init__.py,sha256=FJg5REEBg9hSuMAYnGAud9IxBcASpZuDwYDYEmwdnTY,384
 guidellm/objects/pydantic.py,sha256=oF5SkXlNZLNXpnoGoJb3QHNvqDwFRLSsiPIecf8E-_g,1850
 guidellm/objects/statistics.py,sha256=xf0PyCnJjIcvgOyD_YHgqtvgN4W8-crGi9u3v5u78Tw,36950
+guidellm/preprocess/__init__.py,sha256=6mRs1atYwYkdX4txez_bEVk-_nCDsNt5Wo20eWZ24jA,112
+guidellm/preprocess/dataset.py,sha256=P-TJEebcWnUFGczImc7AOi90vJ4sakZtU8NSYWhJXlM,12318
 guidellm/request/__init__.py,sha256=Y7_O6lcOHwP-ld4VusCvHg_PfqMDyGPwjVHv_LesAL8,347
 guidellm/request/loader.py,sha256=TN3S8gOOnseuTEztSYKRFiUy-13Wl3L64h2PLyxZKWs,9075
 guidellm/request/request.py,sha256=BCf0Ua0h1oOj0y6HCyUh71r5tfFeS0fDrpaoU-UnMj4,3576
@@ -36,14 +38,15 @@ guidellm/scheduler/scheduler.py,sha256=xRrCkLtf_MeWB0iPYVBk1rhJUn-zb4vd2B7YkmnCs
 guidellm/scheduler/strategy.py,sha256=MjSQvyBUK9-JIdPOHVEuTdNzzuIhVIfBeu2_Z98A7ak,18629
 guidellm/scheduler/types.py,sha256=zHZ94-zEYo4LkU3qrfT3BRoZioicDMCQDiY8hYHnkfI,130
 guidellm/scheduler/worker.py,sha256=f1FjI9JJRbz39rTIJRFJ-drcdavJGuPlJC_iQrUa4N0,17629
-guidellm/utils/__init__.py,sha256=Z16u81mF1GIrhgdGlCJ6v12pOikwxz4gU2cfMSjyMnU,524
+guidellm/utils/__init__.py,sha256=l1PZxQvk6gYQshUCEPbB8CU42eB2mHn1TVDEKGYIA5c,651
 guidellm/utils/colors.py,sha256=D0IGz8A346-Pt5qgnP3S5uV-VgngJoXbfToVCOna41k,175
+guidellm/utils/hf_datasets.py,sha256=C99cB4StbhjC8XtnzLLGe6A0TYrs63EapQZJQmQr8dI,1023
 guidellm/utils/hf_transformers.py,sha256=3iF40l02VEWOcS8kasO8TSws0Lp3cE-NyiqoB9GnHuA,1021
 guidellm/utils/random.py,sha256=elA8HZ3AIN5T2pa7cgq35OVK__0SQmZVS4IzxJaOpvw,1310
 guidellm/utils/text.py,sha256=Xn6JUWy3B7gi1l0UkBFLizV9fnZ_kM3OQDMLlIZqsgE,6347
-guidellm-0.3.0a15.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-guidellm-0.3.0a15.dist-info/METADATA,sha256=39eUHI7Udw947xQq_3Oviy0GXOlEmcMWhP_yhL0D5f4,18061
-guidellm-0.3.0a15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guidellm-0.3.0a15.dist-info/entry_points.txt,sha256=DzLFEg47fF7qY1b-9laPz9jg0KSKJ1_D9TbF93kLz_E,51
-guidellm-0.3.0a15.dist-info/top_level.txt,sha256=EXRGjnvFtL6MeZTe0tnHRMYcEWUW3vEqoG2zO7vFOtk,9
-guidellm-0.3.0a15.dist-info/RECORD,,
+guidellm-0.3.0a16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+guidellm-0.3.0a16.dist-info/METADATA,sha256=UTrH_IXV6S90HMUX9jPnAX80LLlgd3yYCMshNH8K0Mo,18061
+guidellm-0.3.0a16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guidellm-0.3.0a16.dist-info/entry_points.txt,sha256=DzLFEg47fF7qY1b-9laPz9jg0KSKJ1_D9TbF93kLz_E,51
+guidellm-0.3.0a16.dist-info/top_level.txt,sha256=EXRGjnvFtL6MeZTe0tnHRMYcEWUW3vEqoG2zO7vFOtk,9
+guidellm-0.3.0a16.dist-info/RECORD,,