guidellm 0.4.0a21__py3-none-any.whl → 0.4.0a155__py3-none-any.whl

guidellm/request/request.py

@@ -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

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

guidellm/scheduler/queues.py

@@ -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

@@ -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