PyPI - guidellm - Versions diffs - 0.3.1__py3-none-any.whl → 0.6.0a5__py3-none-any.whl - Mend

guidellm 0.3.1py3-none-any.whl → 0.6.0a5py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (141) hide show

guidellm/__init__.py +5 -2
guidellm/__main__.py +524 -255
guidellm/backends/__init__.py +33 -0
guidellm/backends/backend.py +109 -0
guidellm/backends/openai.py +340 -0
guidellm/backends/response_handlers.py +428 -0
guidellm/benchmark/__init__.py +69 -39
guidellm/benchmark/benchmarker.py +160 -316
guidellm/benchmark/entrypoints.py +560 -127
guidellm/benchmark/outputs/__init__.py +24 -0
guidellm/benchmark/outputs/console.py +633 -0
guidellm/benchmark/outputs/csv.py +721 -0
guidellm/benchmark/outputs/html.py +473 -0
guidellm/benchmark/outputs/output.py +169 -0
guidellm/benchmark/outputs/serialized.py +69 -0
guidellm/benchmark/profiles.py +718 -0
guidellm/benchmark/progress.py +553 -556
guidellm/benchmark/scenarios/__init__.py +40 -0
guidellm/benchmark/scenarios/chat.json +6 -0
guidellm/benchmark/scenarios/rag.json +6 -0
guidellm/benchmark/schemas/__init__.py +66 -0
guidellm/benchmark/schemas/base.py +402 -0
guidellm/benchmark/schemas/generative/__init__.py +55 -0
guidellm/benchmark/schemas/generative/accumulator.py +841 -0
guidellm/benchmark/schemas/generative/benchmark.py +163 -0
guidellm/benchmark/schemas/generative/entrypoints.py +381 -0
guidellm/benchmark/schemas/generative/metrics.py +927 -0
guidellm/benchmark/schemas/generative/report.py +158 -0
guidellm/data/__init__.py +34 -4
guidellm/data/builders.py +541 -0
guidellm/data/collators.py +16 -0
guidellm/data/config.py +120 -0
guidellm/data/deserializers/__init__.py +49 -0
guidellm/data/deserializers/deserializer.py +141 -0
guidellm/data/deserializers/file.py +223 -0
guidellm/data/deserializers/huggingface.py +94 -0
guidellm/data/deserializers/memory.py +194 -0
guidellm/data/deserializers/synthetic.py +246 -0
guidellm/data/entrypoints.py +52 -0
guidellm/data/loaders.py +190 -0
guidellm/data/preprocessors/__init__.py +27 -0
guidellm/data/preprocessors/formatters.py +410 -0
guidellm/data/preprocessors/mappers.py +196 -0
guidellm/data/preprocessors/preprocessor.py +30 -0
guidellm/data/processor.py +29 -0
guidellm/data/schemas.py +175 -0
guidellm/data/utils/__init__.py +6 -0
guidellm/data/utils/dataset.py +94 -0
guidellm/extras/__init__.py +4 -0
guidellm/extras/audio.py +220 -0
guidellm/extras/vision.py +242 -0
guidellm/logger.py +2 -2
guidellm/mock_server/__init__.py +8 -0
guidellm/mock_server/config.py +84 -0
guidellm/mock_server/handlers/__init__.py +17 -0
guidellm/mock_server/handlers/chat_completions.py +280 -0
guidellm/mock_server/handlers/completions.py +280 -0
guidellm/mock_server/handlers/tokenizer.py +142 -0
guidellm/mock_server/models.py +510 -0
guidellm/mock_server/server.py +238 -0
guidellm/mock_server/utils.py +302 -0
guidellm/scheduler/__init__.py +69 -26
guidellm/scheduler/constraints/__init__.py +49 -0
guidellm/scheduler/constraints/constraint.py +325 -0
guidellm/scheduler/constraints/error.py +411 -0
guidellm/scheduler/constraints/factory.py +182 -0
guidellm/scheduler/constraints/request.py +312 -0
guidellm/scheduler/constraints/saturation.py +722 -0
guidellm/scheduler/environments.py +252 -0
guidellm/scheduler/scheduler.py +137 -368
guidellm/scheduler/schemas.py +358 -0
guidellm/scheduler/strategies.py +617 -0
guidellm/scheduler/worker.py +413 -419
guidellm/scheduler/worker_group.py +712 -0
guidellm/schemas/__init__.py +65 -0
guidellm/schemas/base.py +417 -0
guidellm/schemas/info.py +188 -0
guidellm/schemas/request.py +235 -0
guidellm/schemas/request_stats.py +349 -0
guidellm/schemas/response.py +124 -0
guidellm/schemas/statistics.py +1018 -0
guidellm/{config.py → settings.py} +31 -24
guidellm/utils/__init__.py +71 -8
guidellm/utils/auto_importer.py +98 -0
guidellm/utils/cli.py +132 -5
guidellm/utils/console.py +566 -0
guidellm/utils/encoding.py +778 -0
guidellm/utils/functions.py +159 -0
guidellm/utils/hf_datasets.py +1 -2
guidellm/utils/hf_transformers.py +4 -4
guidellm/utils/imports.py +9 -0
guidellm/utils/messaging.py +1118 -0
guidellm/utils/mixins.py +115 -0
guidellm/utils/random.py +3 -4
guidellm/utils/registry.py +220 -0
guidellm/utils/singleton.py +133 -0
guidellm/utils/synchronous.py +159 -0
guidellm/utils/text.py +163 -50
guidellm/utils/typing.py +41 -0
guidellm/version.py +2 -2
guidellm-0.6.0a5.dist-info/METADATA +364 -0
guidellm-0.6.0a5.dist-info/RECORD +109 -0
guidellm/backend/__init__.py +0 -23
guidellm/backend/backend.py +0 -259
guidellm/backend/openai.py +0 -708
guidellm/backend/response.py +0 -136
guidellm/benchmark/aggregator.py +0 -760
guidellm/benchmark/benchmark.py +0 -837
guidellm/benchmark/output.py +0 -997
guidellm/benchmark/profile.py +0 -409
guidellm/benchmark/scenario.py +0 -104
guidellm/data/prideandprejudice.txt.gz +0 -0
guidellm/dataset/__init__.py +0 -22
guidellm/dataset/creator.py +0 -213
guidellm/dataset/entrypoints.py +0 -42
guidellm/dataset/file.py +0 -92
guidellm/dataset/hf_datasets.py +0 -62
guidellm/dataset/in_memory.py +0 -132
guidellm/dataset/synthetic.py +0 -287
guidellm/objects/__init__.py +0 -18
guidellm/objects/pydantic.py +0 -89
guidellm/objects/statistics.py +0 -953
guidellm/preprocess/__init__.py +0 -3
guidellm/preprocess/dataset.py +0 -374
guidellm/presentation/__init__.py +0 -28
guidellm/presentation/builder.py +0 -27
guidellm/presentation/data_models.py +0 -232
guidellm/presentation/injector.py +0 -66
guidellm/request/__init__.py +0 -18
guidellm/request/loader.py +0 -284
guidellm/request/request.py +0 -79
guidellm/request/types.py +0 -10
guidellm/scheduler/queues.py +0 -25
guidellm/scheduler/result.py +0 -155
guidellm/scheduler/strategy.py +0 -495
guidellm-0.3.1.dist-info/METADATA +0 -329
guidellm-0.3.1.dist-info/RECORD +0 -62
{guidellm-0.3.1.dist-info → guidellm-0.6.0a5.dist-info}/WHEEL +0 -0
{guidellm-0.3.1.dist-info → guidellm-0.6.0a5.dist-info}/entry_points.txt +0 -0
{guidellm-0.3.1.dist-info → guidellm-0.6.0a5.dist-info}/licenses/LICENSE +0 -0
{guidellm-0.3.1.dist-info → guidellm-0.6.0a5.dist-info}/top_level.txt +0 -0

guidellm/presentation/injector.py DELETED Viewed

@@ -1,66 +0,0 @@
-import re
-from pathlib import Path
-from typing import Union
-from loguru import logger
-from guidellm.config import settings
-from guidellm.utils.text import load_text
-def create_report(js_data: dict, output_path: Union[str, Path]) -> Path:
-    """
-    Creates a report from the dictionary and saves it to the output path.
-    :param js_data: dict with match str and json data to inject
-    :type js_data: dict
-    :param output_path: the file to save the report to.
-    :type output_path: str
-    :return: the path to the saved report
-    :rtype: str
-    """
-    if not isinstance(output_path, Path):
-        output_path = Path(output_path)
-    html_content = load_text(settings.report_generation.source)
-    report_content = inject_data(
-        js_data,
-        html_content,
-    )
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    output_path.write_text(report_content)
-    return output_path
-def inject_data(
-    js_data: dict,
-    html: str,
-) -> str:
-    """
-    Injects the json data into the HTML,
-    replacing placeholders only within the <head> section.
-    :param js_data: the json data to inject
-    :type js_data: dict
-    :param html: the html to inject the data into
-    :type html: str
-    :return: the html with the json data injected
-    :rtype: str
-    """
-    head_match = re.search(r"<head[^>]*>(.*?)</head>", html, re.DOTALL | re.IGNORECASE)
-    if not head_match:
-        logger.warning("<head> section missing, returning original HTML.")
-        return html
-    head_content = head_match.group(1)
-    # Replace placeholders only inside the <head> content
-    for placeholder, script in js_data.items():
-        head_content = head_content.replace(placeholder, script)
-    # Rebuild the HTML
-    new_head = f"<head>{head_content}</head>"
-    return html[: head_match.start()] + new_head + html[head_match.end() :]

guidellm/request/__init__.py DELETED Viewed

@@ -1,18 +0,0 @@
-from .loader import (
-    GenerativeRequestLoader,
-    GenerativeRequestLoaderDescription,
-    RequestLoader,
-    RequestLoaderDescription,
-)
-from .request import GenerationRequest
-from .types import RequestT, ResponseT
-__all__ = [
-    "GenerationRequest",
-    "GenerativeRequestLoader",
-    "GenerativeRequestLoaderDescription",
-    "RequestLoader",
-    "RequestLoaderDescription",
-    "RequestT",
-    "ResponseT",
-]

guidellm/request/loader.py DELETED Viewed

@@ -1,284 +0,0 @@
-from abc import abstractmethod
-from collections.abc import Iterable, Iterator
-from pathlib import Path
-from typing import (
-    Any,
-    Literal,
-    Optional,
-    Union,
-)
-from datasets import Dataset, DatasetDict, IterableDataset, IterableDatasetDict
-from transformers import PreTrainedTokenizerBase  # type: ignore[import]
-from guidellm.config import settings
-from guidellm.dataset import ColumnInputTypes, load_dataset
-from guidellm.objects import StandardBaseModel
-from guidellm.request.request import GenerationRequest
-__all__ = [
-    "GenerativeRequestLoader",
-    "GenerativeRequestLoaderDescription",
-    "RequestLoader",
-    "RequestLoaderDescription",
-]
-class RequestLoaderDescription(StandardBaseModel):
-    type_: Literal["request_loader"] = "request_loader"
-class RequestLoader(Iterable):
-    @abstractmethod
-    def __iter__(self) -> Iterator: ...
-    @abstractmethod
-    def __len__(self) -> int: ...
-    @property
-    @abstractmethod
-    def description(self) -> RequestLoaderDescription: ...
-class GenerativeRequestLoaderDescription(RequestLoaderDescription):
-    type_: Literal["generative_request_loader"] = "generative_request_loader"  # type: ignore[assignment]
-    data: str
-    data_args: Optional[dict[str, Any]]
-    processor: str
-    processor_args: Optional[dict[str, Any]]
-class GenerativeRequestLoader(RequestLoader):
-    DEFAULT_PROMPT_COLUMNS = [
-        "prompt",
-        "prompts",
-        "instruction",
-        "instructions",
-        "question",
-        "questions",
-        "input",
-        "inputs",
-        "context",
-        "content",
-        "conversation",
-        "conversations",
-        "turn",
-        "turns",
-        "text",
-    ]
-    def __init__(
-        self,
-        data: Union[
-            str,
-            Path,
-            Iterable[Union[str, dict[str, Any]]],
-            Dataset,
-            DatasetDict,
-            IterableDataset,
-            IterableDatasetDict,
-        ],
-        data_args: Optional[dict[str, Any]],
-        processor: Optional[Union[str, Path, PreTrainedTokenizerBase]],
-        processor_args: Optional[dict[str, Any]],
-        shuffle: bool = True,
-        iter_type: Literal["finite", "infinite"] = "finite",
-        random_seed: int = 42,
-    ):
-        self.data = data
-        self.data_args = data_args
-        dataset, args_column_mappings = load_dataset(
-            data,
-            data_args,
-            processor,
-            processor_args,
-            random_seed,
-        )
-        self.dataset = dataset
-        self.processor = processor
-        self.processor_args = processor_args
-        self.shuffle = shuffle
-        self.iter_type = iter_type
-        self.random_seed = random_seed
-        self.column_mappings = self._create_column_mappings(args_column_mappings)
-        self.preserve_iter_state = iter_type == "infinite"  # ensure no caching requests
-        self._preserved_iter = None
-    def __iter__(self) -> Iterator[GenerationRequest]:
-        scope_create_count = 0
-        while (dataset_iter := self._get_dataset_iter(scope_create_count)) is not None:
-            scope_create_count += 1
-            for item in dataset_iter:
-                yield self._create_request(item)
-            self._preserved_iter = None
-    def __len__(self) -> int:
-        if self.iter_type == "finite":
-            return self.num_unique_items()
-        raise ValueError(f"Unable to determine length of dataset: {self.data}")
-    @property
-    def description(self) -> GenerativeRequestLoaderDescription:
-        return GenerativeRequestLoaderDescription(
-            data=str(self.data),
-            data_args=self.data_args,
-            processor=str(self.processor),
-            processor_args=self.processor_args,
-        )
-    def num_unique_items(self, raise_err: bool = True) -> int:
-        try:
-            return len(self.dataset)
-        except Exception:  # noqa: BLE001, S110
-            pass
-        dataset_size = self.dataset.info.dataset_size
-        if dataset_size is not None:
-            return dataset_size
-        if raise_err:
-            raise ValueError("Unable to determine number of items in the dataset")
-        return -1
-    def _create_column_mappings(
-        self,
-        args_column_mappings: dict[ColumnInputTypes, str],
-    ) -> dict[ColumnInputTypes, str]:
-        column_mappings: dict[ColumnInputTypes, str] = {}
-        if "text_column" in args_column_mappings:
-            column_mappings["prompt_column"] = args_column_mappings["text_column"]
-        else:
-            column_mappings["prompt_column"] = self._extract_text_column()
-        if "prompt_tokens_count_column" in args_column_mappings:
-            column_mappings["prompt_tokens_count_column"] = args_column_mappings[
-                "prompt_tokens_count_column"
-            ]
-        elif prompt_tokens_count_column := self._extract_prompt_tokens_count_column():
-            column_mappings["prompt_tokens_count_column"] = prompt_tokens_count_column
-        if "output_tokens_count_column" in args_column_mappings:
-            column_mappings["output_tokens_count_column"] = args_column_mappings[
-                "output_tokens_count_column"
-            ]
-        elif output_tokens_count_column := self._extract_output_tokens_count_column():
-            column_mappings["output_tokens_count_column"] = output_tokens_count_column
-        return column_mappings
-    def _extract_text_column(self) -> str:
-        column_names = self._dataset_columns(
-            err_msg=(
-                "Unable to determine text column from dataset and it is required. "
-                "To specify the text column, set the 'text_column' key in the "
-                "'data_args' dictionary."
-            )
-        )
-        if not column_names:
-            raise ValueError(
-                "Unable to determine text column from dataset and it is required. "
-                "To specify the text column, set the 'text_column' key in the "
-                "'data_args' dictionary."
-            )
-        if len(column_names) == 1:
-            return column_names[0]
-        for def_column in self.DEFAULT_PROMPT_COLUMNS:
-            if def_column in column_names:
-                return def_column
-        raise ValueError(
-            f"Unable to determine text column from dataset columns: {column_names}. "
-            "To specify the text column, set the 'text_column' key in the "
-            "'data_args' dictionary."
-        )
-    def _extract_prompt_tokens_count_column(self) -> Optional[str]:
-        column_names = self._dataset_columns()
-        if column_names and "prompt_tokens_count" in column_names:
-            return "prompt_tokens_count"
-        if column_names and "prompt_tokens" in column_names:
-            return "prompt_tokens"
-        return None
-    def _extract_output_tokens_count_column(self) -> Optional[str]:
-        column_names = self._dataset_columns()
-        if column_names and "output_tokens_count" in column_names:
-            return "output_tokens_count"
-        if column_names and "output_tokens" in column_names:
-            return "output_tokens"
-        return None
-    def _dataset_columns(self, err_msg: Optional[str] = None) -> Optional[list[str]]:
-        try:
-            column_names = self.dataset.column_names
-            if not column_names and err_msg:
-                raise ValueError(f"No column names found in dataset: {self.data}")
-        except Exception as err:
-            if err_msg:
-                raise ValueError(err_msg) from err
-            column_names = None
-        return column_names
-    def _get_dataset_iter(
-        self, scope_create_count: int
-    ) -> Optional[Iterator[dict[str, Any]]]:
-        if scope_create_count > 0 and self.iter_type != "infinite":
-            return None
-        if self.preserve_iter_state and self._preserved_iter is not None:
-            return self._preserved_iter
-        dataset = (
-            self.dataset
-            if not self.shuffle
-            else self.dataset.shuffle(seed=self.random_seed)
-        )
-        dataset_iter = iter(dataset)
-        if self.preserve_iter_state:
-            self._preserved_iter = dataset_iter
-        return dataset_iter
-    def _create_request(self, item: dict[str, Any]) -> GenerationRequest:
-        prompt_tokens = (
-            item[self.column_mappings["prompt_tokens_count_column"]]
-            if "prompt_tokens_count_column" in self.column_mappings
-            else None
-        )
-        output_tokens = (
-            item[self.column_mappings["output_tokens_count_column"]]
-            if "output_tokens_count_column" in self.column_mappings
-            else None
-        )
-        return GenerationRequest(
-            request_type=settings.preferred_route,
-            content=item[self.column_mappings["prompt_column"]],
-            stats=(
-                {"prompt_tokens": prompt_tokens} if prompt_tokens is not None else {}
-            ),
-            constraints=(
-                {"output_tokens": output_tokens} if output_tokens is not None else {}
-            ),
-        )

guidellm/request/request.py DELETED Viewed

@@ -1,79 +0,0 @@
-import uuid
-from typing import Any, Literal, Optional
-from pydantic import Field
-from guidellm.objects.pydantic import StandardBaseModel
-__all__ = ["GenerationRequest"]
-class GenerationRequest(StandardBaseModel):
-    """
-    A class representing a request for generation.
-    This class is used to encapsulate the details of a generation request,
-    including the request ID, type, content, parameters, statistics, and constraints.
-    It is designed to be used with the BackendRequestsWorker class to handle
-    the generation process.
-    :param request_id: The unique identifier for the request.
-    :param request_type: The type of request (e.g., text, chat).
-    :param content: The content for the request to send to the backend.
-        If request_type is 'text', this should be a string or list of strings
-        which will be resolved by backend.text_completions.
-        If request_type is 'chat', this should be a string,
-        a list of (str, Dict[str, Union[str, Dict[str, str]], Path, Image]),
-        or Any raw content which will be resolved by backend.chat_completions.
-        If raw content, raw_content=True must be passed in the params.
-    :param params: Additional parameters for the request passed in as kwargs.
-        For an http backend, these are passed into the body of the request.
-    :param stats: Statistics for the request, such as the number of prompt tokens.
-        Used for tracking and reporting purposes.
-    :param constraints: Constraints for the request, such as the maximum number
-        of output tokens. Used for controlling the behavior of the backend.
-    """
-    request_id: Optional[str] = Field(
-        default_factory=lambda: str(uuid.uuid4()),
-        description="The unique identifier for the request.",
-    )
-    request_type: Literal["text_completions", "chat_completions"] = Field(
-        default="text_completions",
-        description=(
-            "The type of request (e.g., text, chat). "
-            "If request_type='text_completions', resolved by backend.text_completions. "
-            "If request_typ='chat_completions', resolved by backend.chat_completions."
-        ),
-    )
-    content: Any = Field(
-        description=(
-            "The content for the request to send to the backend. "
-            "If request_type is 'text', this should be a string or list of strings "
-            "which will be resolved by backend.text_completions. "
-            "If request_type is 'chat', this should be a string, "
-            "a list of (str, Dict[str, Union[str, Dict[str, str]], Path, Image]), "
-            "or Any raw content which will be resolved by backend.chat_completions. "
-            "If raw content, raw_content=True must be passed in the params."
-        )
-    )
-    params: dict[str, Any] = Field(
-        default_factory=dict,
-        description=(
-            "Additional parameters for the request that will be passed in as kwargs. "
-            "For an http backend, these are passed into the body of the request. "
-        ),
-    )
-    stats: dict[Literal["prompt_tokens"], int] = Field(
-        default_factory=dict,
-        description=(
-            "Statistics for the request, such as the number of prompt tokens. "
-            "Used for tracking and reporting purposes."
-        ),
-    )
-    constraints: dict[Literal["output_tokens"], int] = Field(
-        default_factory=dict,
-        description=(
-            "Constraints for the request, such as the maximum number of output tokens. "
-            "Used for controlling the behavior of the backend."
-        ),
-    )

guidellm/request/types.py DELETED Viewed

@@ -1,10 +0,0 @@
-from typing import TypeVar
-__all__ = [
-    "RequestT",
-    "ResponseT",
-]
-RequestT = TypeVar("RequestT")
-ResponseT = TypeVar("ResponseT")

guidellm/scheduler/queues.py DELETED Viewed

@@ -1,25 +0,0 @@
-"""
-Helper module for importing the correct queue types.
-"""
-from dataclasses import dataclass
-from queue import Empty as QueueEmpty
-from queue import Full as QueueFull
-from queue import Queue
-from typing import Generic
-from guidellm.request.types import RequestT, ResponseT
-from guidellm.scheduler.result import WorkerProcessRequest, WorkerProcessResult
-__all__ = [
-    "MPQueues",
-    "Queue",
-    "QueueEmpty",
-    "QueueFull",
-]
-@dataclass
-class MPQueues(Generic[RequestT, ResponseT]):
-    requests: Queue[WorkerProcessRequest[RequestT, ResponseT]]
-    responses: Queue[WorkerProcessResult[RequestT, ResponseT]]

guidellm/scheduler/result.py DELETED Viewed

@@ -1,155 +0,0 @@
-from dataclasses import dataclass
-from typing import (
-    Generic,
-    Literal,
-    Optional,
-)
-from guidellm.objects import StandardBaseModel
-from guidellm.request.types import RequestT, ResponseT
-from guidellm.scheduler.strategy import SchedulingStrategy
-__all__ = [
-    "SchedulerRequestInfo",
-    "SchedulerRequestResult",
-    "SchedulerResult",
-    "SchedulerRunInfo",
-    "WorkerProcessRequest",
-    "WorkerProcessResult",
-]
-class SchedulerRunInfo(StandardBaseModel):
-    """
-    Information about the current run of the scheduler.
-    This class holds metadata about the scheduling run,
-    including the start and end times, the number of processes,
-    and the scheduling strategy used.
-    It also tracks the number of requests created, queued, pending,
-    and completed during the run.
-    :param start_time: The start time of the scheduling run.
-    :param end_time: The end time of the scheduling run;
-        if None, then this will be math.inf.
-    :param end_number: The maximum number of requests to be processed;
-        if None, then this will be math.inf.
-    :param processes: The number of processes used in the scheduling run.
-    :param strategy: The scheduling strategy used in the run.
-        This should be an instance of SchedulingStrategy.
-    :param created_requests: The number of requests created during the run.
-    :param queued_requests: The number of requests queued during the run.
-    :param scheduled_requests: The number of requests scheduled during the run.
-        (requests pending being sent to the worker but recieved by a process)
-    :param processing_requests: The number of requests actively being run.
-    :param completed_requests: The number of requests completed during the run.
-    """
-    start_time: float
-    end_time: float
-    end_number: float
-    processes: int
-    strategy: SchedulingStrategy
-    created_requests: int = 0
-    queued_requests: int = 0
-    scheduled_requests: int = 0
-    processing_requests: int = 0
-    completed_requests: int = 0
-class SchedulerRequestInfo(StandardBaseModel):
-    """
-    Information about a specific request run through the scheduler.
-    This class holds metadata about the request, including
-    the targeted start time, queued time, start time, end time,
-    and the process ID that handled the request.
-    :param targeted_start_time: The targeted start time for the request (time.time()).
-    :param queued_time: The time the request was queued (time.time()).
-    :param scheduled_time: The time the request was scheduled (time.time())
-        (any sleep time before the request was sent to the worker).
-    :param worker_start: The time the worker started processing request (time.time()).
-    :param worker_end: The time the worker finished processing request. (time.time()).
-    :param process_id: The ID of the underlying process that handled the request.
-    """
-    requested: bool = False
-    completed: bool = False
-    errored: bool = False
-    canceled: bool = False
-    targeted_start_time: float = -1
-    queued_time: float = -1
-    dequeued_time: float = -1
-    scheduled_time: float = -1
-    worker_start: float = -1
-    request_start: float = -1
-    request_end: float = -1
-    worker_end: float = -1
-    process_id: int = -1
-class SchedulerResult(StandardBaseModel):
-    """
-    The yielded, iterative result for a scheduler run.
-    These are triggered on the start and end of the run,
-    as well as on the start and end of each request.
-    Depending on the type, it will hold the request and response
-    along with information and statistics about the request and general run.
-    :param type_: The type of the result, which can be one of:
-        - "run_start": Indicates the start of the run.
-        - "run_complete": Indicates the completion of the run (teardown happens after).
-        - "request_start": Indicates the start of a request.
-        - "request_complete": Indicates the completion of a request.
-    :param request: The request that was processed.
-    :param response: The response from the worker for the request.
-    :param request_info: Information about the request, including
-        the targeted start time, queued time, start time, end time,
-        and the process ID that handled the request.
-    :param run_info: Information about the current run of the scheduler,
-        including the start and end times, the number of processes,
-        and the scheduling strategy used.
-        It also tracks the number of requests created, queued, pending,
-        and completed during the run.
-    """
-    pydantic_type: Literal["scheduler_result"] = "scheduler_result"
-    type_: Literal[
-        "run_start",
-        "run_complete",
-        "request_scheduled",
-        "request_start",
-        "request_complete",
-    ]
-    run_info: SchedulerRunInfo
-class SchedulerRequestResult(
-    SchedulerResult,
-    Generic[RequestT, ResponseT],
-):
-    pydantic_type: Literal["scheduler_request_result"] = "scheduler_request_result"  # type: ignore[assignment]
-    type_: Literal[
-        "request_scheduled",
-        "request_start",
-        "request_complete",
-    ]
-    request: RequestT
-    request_info: SchedulerRequestInfo
-    response: Optional[ResponseT] = None
-@dataclass
-class WorkerProcessRequest(Generic[RequestT, ResponseT]):
-    request: RequestT
-    timeout_time: float
-    queued_time: float
-@dataclass
-class WorkerProcessResult(Generic[RequestT, ResponseT]):
-    type_: Literal["request_scheduled", "request_start", "request_complete"]
-    request: RequestT
-    response: Optional[ResponseT]
-    info: SchedulerRequestInfo

guidellm 0.3.1__py3-none-any.whl → 0.6.0a5__py3-none-any.whl

guidellm 0.3.1py3-none-any.whl → 0.6.0a5py3-none-any.whl