Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/PyOpenGL-3.1.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

vllm/lib/python3.10/site-packages/PyOpenGL-3.1.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.2
+Name: PyOpenGL
+Version: 3.1.0
+Summary: Standard OpenGL bindings for Python
+Home-page: http://pyopengl.sourceforge.net
+Download-URL: http://sourceforge.net/projects/pyopengl/files/PyOpenGL/
+Author: Mike C. Fletcher
+Author-email: mcfletch@vrplumber.com
+License: BSD
+Keywords: Graphics,3D,OpenGL,GLU,GLUT,GLE,GLX,EXT,ARB,Mesa,ctypes
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: summary

vllm/lib/python3.10/site-packages/PyOpenGL-3.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vllm/lib/python3.10/site-packages/PyOpenGL-3.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+OpenGL

vllm/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

vllm/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.1
+Name: async-timeout
+Version: 5.0.1
+Summary: Timeout context manager for asyncio programs
+Home-page: https://github.com/aio-libs/async-timeout
+Author: Andrew Svetlov <andrew.svetlov@gmail.com>
+Author-email: andrew.svetlov@gmail.com
+License: Apache 2
+Project-URL: Chat: Gitter, https://gitter.im/aio-libs/Lobby
+Project-URL: CI: GitHub Actions, https://github.com/aio-libs/async-timeout/actions
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/async-timeout
+Project-URL: GitHub: issues, https://github.com/aio-libs/async-timeout/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/async-timeout
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+async-timeout
+=============
+.. image:: https://travis-ci.com/aio-libs/async-timeout.svg?branch=master
+    :target: https://travis-ci.com/aio-libs/async-timeout
+.. image:: https://codecov.io/gh/aio-libs/async-timeout/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/aio-libs/async-timeout
+.. image:: https://img.shields.io/pypi/v/async-timeout.svg
+    :target: https://pypi.python.org/pypi/async-timeout
+.. image:: https://badges.gitter.im/Join%20Chat.svg
+    :target: https://gitter.im/aio-libs/Lobby
+    :alt: Chat on Gitter
+
+asyncio-compatible timeout context manager.
+
+
+
+DEPRECATED
+----------
+
+This library has effectively been upstreamed into Python 3.11+.
+
+Therefore this library is considered deprecated and no longer actively supported.
+
+Version 5.0+ provides dual-mode when executed on Python 3.11+:
+``asyncio_timeout.Timeout`` is fully compatible with ``asyncio.Timeout`` *and* old
+versions of the library.
+
+Anyway, using upstream is highly recommended. ``asyncio_timeout`` exists only for the
+sake of backward compatibility, easy supporting both old and new Python by the same
+code, and easy misgration.
+
+If rescheduling API is not important and only ``async with timeout(...): ...`` functionality is required,
+a user could apply conditional import::
+
+    if sys.version_info >= (3, 11):
+        from asyncio import timeout, timeout_at
+    else:
+        from async_timeout import timeout, timeout_at
+
+
+Usage example
+-------------
+
+
+The context manager is useful in cases when you want to apply timeout
+logic around block of code or in cases when ``asyncio.wait_for()`` is
+not suitable. Also it's much faster than ``asyncio.wait_for()``
+because ``timeout`` doesn't create a new task.
+
+The ``timeout(delay, *, loop=None)`` call returns a context manager
+that cancels a block on *timeout* expiring::
+
+   from async_timeout import timeout
+   async with timeout(1.5):
+       await inner()
+
+1. If ``inner()`` is executed faster than in ``1.5`` seconds nothing
+   happens.
+2. Otherwise ``inner()`` is cancelled internally by sending
+   ``asyncio.CancelledError`` into but ``asyncio.TimeoutError`` is
+   raised outside of context manager scope.
+
+*timeout* parameter could be ``None`` for skipping timeout functionality.
+
+
+Alternatively, ``timeout_at(when)`` can be used for scheduling
+at the absolute time::
+
+   loop = asyncio.get_event_loop()
+   now = loop.time()
+
+   async with timeout_at(now + 1.5):
+       await inner()
+
+
+Please note: it is not POSIX time but a time with
+undefined starting base, e.g. the time of the system power on.
+
+
+Context manager has ``.expired()`` / ``.expired`` for check if timeout happens
+exactly in context manager::
+
+   async with timeout(1.5) as cm:
+       await inner()
+   print(cm.expired())  # recommended api
+   print(cm.expired)    # compatible api
+
+The property is ``True`` if ``inner()`` execution is cancelled by
+timeout context manager.
+
+If ``inner()`` call explicitly raises ``TimeoutError`` ``cm.expired``
+is ``False``.
+
+The scheduled deadline time is available as ``.when()`` / ``.deadline``::
+
+   async with timeout(1.5) as cm:
+       cm.when()    # recommended api
+       cm.deadline  # compatible api
+
+Not finished yet timeout can be rescheduled by ``shift()``
+or ``update()`` methods::
+
+   async with timeout(1.5) as cm:
+       # recommended api
+       cm.reschedule(cm.when() + 1)  # add another second on waiting
+       # compatible api
+       cm.shift(1)  # add another second on waiting
+       cm.update(loop.time() + 5)  # reschedule to now+5 seconds
+
+Rescheduling is forbidden if the timeout is expired or after exit from ``async with``
+code block.
+
+
+Disable scheduled timeout::
+
+   async with timeout(1.5) as cm:
+       cm.reschedule(None)  # recommended api
+       cm.reject()          # compatible api
+
+
+
+Installation
+------------
+
+::
+
+   $ pip install async-timeout
+
+The library is Python 3 only!
+
+
+
+Authors and License
+-------------------
+
+The module is written by Andrew Svetlov.
+
+It's *Apache 2* licensed and freely available.

vllm/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vllm/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+async_timeout

vllm/lib/python3.10/site-packages/rich_toolkit/__init__.py

@@ -0,0 +1,3 @@
+from .toolkit import RichToolkit, RichToolkitTheme
+
+__all__ = ["RichToolkit", "RichToolkitTheme"]

vllm/lib/python3.10/site-packages/rich_toolkit/input.py

@@ -0,0 +1,192 @@
+import string
+from typing import Any, Optional, Tuple
+from abc import ABC, abstractmethod
+
+import click
+from rich.console import Console, Group, RenderableType
+from rich.control import Control
+from rich.live_render import LiveRender
+
+from rich_toolkit.styles.base import BaseStyle
+
+
+class TextInputHandler:
+    DOWN_KEY = "\x1b[B"
+    UP_KEY = "\x1b[A"
+    LEFT_KEY = "\x1b[D"
+    RIGHT_KEY = "\x1b[C"
+    BACKSPACE_KEY = "\x7f"
+    DELETE_KEY = "\x1b[3~"
+
+    def __init__(self, cursor_offset: int = 0):
+        self.text = ""
+        self.cursor_position = 0
+        self._cursor_offset = cursor_offset
+
+    def _move_cursor_left(self) -> None:
+        self.cursor_position = max(0, self.cursor_position - 1)
+
+    def _move_cursor_right(self) -> None:
+        self.cursor_position = min(len(self.text), self.cursor_position + 1)
+
+    def _insert_char(self, char: str) -> None:
+        self.text = (
+            self.text[: self.cursor_position] + char + self.text[self.cursor_position :]
+        )
+        self._move_cursor_right()
+
+    def _delete_char(self) -> None:
+        if self.cursor_position == 0:
+            return
+
+        self.text = (
+            self.text[: self.cursor_position - 1] + self.text[self.cursor_position :]
+        )
+        self._move_cursor_left()
+
+    def _delete_forward(self) -> None:
+        if self.cursor_position == len(self.text):
+            return
+
+        self.text = (
+            self.text[: self.cursor_position] + self.text[self.cursor_position + 1 :]
+        )
+
+    def update_text(self, text: str) -> None:
+        if text == self.BACKSPACE_KEY:
+            self._delete_char()
+        elif text == self.DELETE_KEY:
+            self._delete_forward()
+        elif text == self.LEFT_KEY:
+            self._move_cursor_left()
+        elif text == self.RIGHT_KEY:
+            self.cursor_position = min(len(self.text), self.cursor_position + 1)
+        elif text in (self.UP_KEY, self.DOWN_KEY):
+            pass
+        else:
+            for char in text:
+                if char in string.printable:
+                    self._insert_char(char)
+
+    def fix_cursor(self) -> Tuple[Control, ...]:
+        return (Control.move_to_column(self._cursor_offset + self.cursor_position),)
+
+
+class LiveInput(ABC, TextInputHandler):
+    def __init__(
+        self,
+        console: Console,
+        style: Optional[BaseStyle] = None,
+        cursor_offset: int = 0,
+        **metadata: Any,
+    ):
+        self.console = console
+        self._live_render = LiveRender("")
+
+        if style is None:
+            self._live_render = LiveRender("")
+        else:
+            self._live_render = style.decorate_class(LiveRender, **metadata)("")
+
+        self._padding_bottom = 1
+
+        super().__init__(cursor_offset=cursor_offset)
+
+    @abstractmethod
+    def render_result(self) -> RenderableType:
+        raise NotImplementedError
+
+    @abstractmethod
+    def render_input(self) -> RenderableType:
+        raise NotImplementedError
+
+    @property
+    def should_show_cursor(self) -> bool:
+        return True
+
+    def position_cursor(self) -> Tuple[Control, ...]:
+        return (self._live_render.position_cursor(),)
+
+    def _refresh(self, show_result: bool = False) -> None:
+        renderable = self.render_result() if show_result else self.render_input()
+
+        self._live_render.set_renderable(renderable)
+
+        self._render(show_result)
+
+    def _render(self, show_result: bool = False) -> None:
+        after = self.fix_cursor() if not show_result else ()
+
+        self.console.print(
+            Control.show_cursor(self.should_show_cursor),
+            *self.position_cursor(),
+            self._live_render,
+            *after,
+        )
+
+
+class Input(LiveInput):
+    def __init__(
+        self,
+        console: Console,
+        title: str,
+        style: Optional[BaseStyle] = None,
+        default: str = "",
+        cursor_offset: int = 0,
+        password: bool = False,
+        **metadata: Any,
+    ):
+        self.title = title
+        self.default = default
+        self.password = password
+
+        self.console = console
+        self.style = style
+
+        super().__init__(
+            console=console, style=style, cursor_offset=cursor_offset, **metadata
+        )
+
+    def render_result(self) -> RenderableType:
+        if self.password:
+            return self.title
+
+        return self.title + " [result]" + (self.text or self.default)
+
+    def render_input(self) -> Group:
+        text = self.text
+
+        if self.password:
+            text = "*" * len(self.text)
+
+        # if there's no default value, add a space to keep the cursor visible
+        # and, most importantly, in the right place
+        default = self.default or " "
+
+        text = f"[text]{text}[/]" if self.text else f"[placeholder]{default }[/]"
+
+        return Group(self.title, text)
+
+    def ask(self) -> str:
+        self._refresh()
+
+        while True:
+            try:
+                key = click.getchar()
+
+                if key == "\r":
+                    break
+
+                self.update_text(key)
+
+            except KeyboardInterrupt:
+                exit()
+
+            self._refresh()
+
+        self._refresh(show_result=True)
+
+        for _ in range(self._padding_bottom):
+            self.console.print()
+
+        return self.text or self.default

vllm/lib/python3.10/site-packages/rich_toolkit/menu.py

@@ -0,0 +1,302 @@
+from typing import Generic, List, Optional, Tuple, TypeVar, cast
+
+import click
+from rich import get_console
+from rich.console import Console, Group, RenderableType
+from rich.control import Control
+from rich.segment import ControlType
+from rich.text import Text
+from rich.live_render import LiveRender
+from typing_extensions import Any, Literal, TypedDict
+
+from .styles.base import BaseStyle
+from .input import TextInputHandler, LiveInput
+
+ReturnValue = TypeVar("ReturnValue")
+
+
+class Option(TypedDict, Generic[ReturnValue]):
+    name: str
+    value: ReturnValue
+
+
+class Menu(Generic[ReturnValue], LiveInput):
+    DOWN_KEYS = [TextInputHandler.DOWN_KEY, "j"]
+    UP_KEYS = [TextInputHandler.UP_KEY, "k"]
+    LEFT_KEYS = [TextInputHandler.LEFT_KEY, "h"]
+    RIGHT_KEYS = [TextInputHandler.RIGHT_KEY, "l"]
+
+    current_selection_char = "●"
+    selection_char = "○"
+    filter_prompt = "Filter: "
+
+    def __init__(
+        self,
+        title: str,
+        options: List[Option[ReturnValue]],
+        inline: bool = False,
+        allow_filtering: bool = False,
+        *,
+        style: Optional[BaseStyle] = None,
+        console: Optional[Console] = None,
+        cursor_offset: int = 0,
+        **metadata: Any,
+    ):
+        self.console = console or get_console()
+
+        self.title = Text.from_markup(title)
+        self.inline = inline
+        self.allow_filtering = allow_filtering
+
+        self.selected = 0
+
+        self.metadata = metadata
+        self.style = style
+
+        self._options = options
+
+        self._padding_bottom = 1
+
+        cursor_offset = cursor_offset + len(self.filter_prompt)
+
+        super().__init__(
+            console=self.console,
+            style=self.style,
+            cursor_offset=cursor_offset,
+            **metadata,
+        )
+
+    def get_key(self) -> Optional[str]:
+        char = click.getchar()
+
+        if char == "\r":
+            return "enter"
+
+        if self.allow_filtering:
+            left_keys, right_keys = [[self.LEFT_KEY], [self.RIGHT_KEY]]
+            down_keys, up_keys = [[self.DOWN_KEY], [self.UP_KEY]]
+        else:
+            left_keys, right_keys = self.LEFT_KEYS, self.RIGHT_KEYS
+            down_keys, up_keys = self.DOWN_KEYS, self.UP_KEYS
+
+        next_keys, prev_keys = (
+            (right_keys, left_keys) if self.inline else (down_keys, up_keys)
+        )
+
+        if char in next_keys:
+            return "next"
+        if char in prev_keys:
+            return "prev"
+
+        if self.allow_filtering:
+            return char
+
+        return None
+
+    @property
+    def options(self) -> List[Option[ReturnValue]]:
+        if self.allow_filtering:
+            return [
+                option
+                for option in self._options
+                if self.text.lower() in option["name"].lower()
+            ]
+
+        return self._options
+
+    def _update_selection(self, key: Literal["next", "prev"]) -> None:
+        if key == "next":
+            self.selected += 1
+        elif key == "prev":
+            self.selected -= 1
+
+        if self.selected < 0:
+            self.selected = len(self.options) - 1
+
+        if self.selected >= len(self.options):
+            self.selected = 0
+
+    def render_input(self) -> RenderableType:
+        menu = Text(justify="left")
+
+        selected_prefix = Text(self.current_selection_char + " ")
+        not_selected_prefix = Text(self.selection_char + " ")
+
+        separator = Text("\t" if self.inline else "\n")
+
+        for id_, option in enumerate(self.options):
+            if id_ == self.selected:
+                prefix = selected_prefix
+                style = self.console.get_style("selected")
+            else:
+                prefix = not_selected_prefix
+                style = self.console.get_style("text")
+
+            menu.append(Text.assemble(prefix, option["name"], separator, style=style))
+
+        # TODO: inline is not wrapped (maybe that's good?)
+
+        if not self.options:
+            # menu.append("No results found", style=self.console.get_style("text"))
+            menu = Text("No results found\n\n", style=self.console.get_style("text"))
+
+        h = 0
+        if self._live_render._shape is not None:
+            _, h = self._live_render._shape
+
+        filter = (
+            [
+                Text.assemble(
+                    (self.filter_prompt, self.console.get_style("text")),
+                    (self.text, self.console.get_style("text")),
+                    "\n",
+                )
+            ]
+            if self.allow_filtering
+            else []
+        )
+
+        return Group(self.title, *filter, *menu)
+
+    def render_result(self) -> RenderableType:
+        result_text = Text()
+
+        result_text.append(self.title)
+        result_text.append(" ")
+        result_text.append(
+            self.options[self.selected]["name"],
+            style=self.console.get_style("result"),
+        )
+
+        return result_text
+
+    def update_text(self, text: str) -> None:
+        current_selection: Optional[str] = None
+
+        if self.options:
+            current_selection = self.options[self.selected]["name"]
+
+        super().update_text(text)
+
+        if current_selection:
+            matching_index = next(
+                (
+                    index
+                    for index, option in enumerate(self.options)
+                    if option["name"] == current_selection
+                ),
+                0,
+            )
+
+            self.selected = matching_index
+
+    def _handle_enter(self) -> bool:
+        if self.allow_filtering and self.text and len(self.options) == 0:
+            return False
+
+        return True
+
+    def reposition_cursor(self) -> Control:
+        if self.allow_filtering:
+            if self._live_render._shape is None:
+                return Control()
+
+            _, height = self._live_render._shape
+
+            move_down = height - 2
+
+            return Control(
+                (ControlType.CURSOR_DOWN, move_down),
+                ControlType.CARRIAGE_RETURN,
+                (ControlType.ERASE_IN_LINE, 2),
+                *(
+                    (
+                        (ControlType.CURSOR_UP, 1),
+                        (ControlType.ERASE_IN_LINE, 2),
+                    )
+                    * (height - 1)
+                ),
+            )
+
+        return self._live_render.position_cursor()
+
+    def position_cursor(self) -> Tuple[Control, ...]:
+        """Positions the cursor at the end of the menu.
+
+        It moves the cursor up based on the size of the menu when filtering
+        is enabled. It does by taking into account the size of the menu
+        and the fact that we moved the cursor up in the previous render.
+
+        We use the shape of the menu to calculate the number of times we
+        need to move the cursor up, we do this because the options are
+        dynamic and we need the current size* of the menu to calculate
+        the correct position of the cursor.
+
+        * Current size means the previous size of the menu, but I say
+        current because we haven't rendered the updated menu yet :)
+        """
+        original = super().position_cursor()
+
+        if self._live_render._shape is None or not self.allow_filtering:
+            return original
+
+        _, height = self._live_render._shape
+
+        move_down = height - 2
+
+        return (
+            Control(
+                (ControlType.CURSOR_DOWN, move_down),
+            ),
+            *original,
+        )
+
+    def fix_cursor(self) -> Tuple[Control, ...]:
+        """Fixes the position of cursor after rendering the menu.
+
+        It moves the cursor up based on the size of the menu, but
+        only if allow_filtering is enabled. (We don't show the cursor
+        when filtering is disabled.)
+        """
+        move_cursor = ()
+
+        if self.allow_filtering:
+            height = len(self.options) + 1 if self.options else 2
+
+            move_cursor = (Control((ControlType.CURSOR_UP, height)),)
+
+        return (*super().fix_cursor(), *move_cursor)
+
+    @property
+    def should_show_cursor(self) -> bool:
+        return self.allow_filtering
+
+    def ask(self) -> ReturnValue:
+        self._refresh()
+
+        while True:
+            try:
+                key = self.get_key()
+
+                if key == "enter":
+                    if self._handle_enter():
+                        break
+
+                elif key is not None:
+                    if key in ["next", "prev"]:
+                        key = cast(Literal["next", "prev"], key)
+                        self._update_selection(key)
+                    else:
+                        self.update_text(key)
+
+            except KeyboardInterrupt:
+                exit()
+
+            self._refresh()
+
+        self._refresh(show_result=True)
+
+        for _ in range(self._padding_bottom):
+            self.console.print()
+
+        return self.options[self.selected]["value"]

vllm/lib/python3.10/site-packages/rich_toolkit/progress.py

@@ -0,0 +1,86 @@
+from typing import List, Optional
+
+from rich.console import Console
+from rich.live import Live
+from typing_extensions import Any, Literal
+
+from .styles.base import BaseStyle
+
+
+class Progress(Live):
+    def __init__(
+        self,
+        title: str,
+        style: Optional[BaseStyle] = None,
+        console: Optional[Console] = None,
+        transient: bool = False,
+        transient_on_error: bool = False,
+        inline_logs: bool = False,
+        lines_to_show: int = -1,
+    ) -> None:
+        self.current_message = title
+        self.style = style
+        self.is_error = False
+        self._transient_on_error = transient_on_error
+        self._inline_logs = inline_logs
+        self._lines_to_show = lines_to_show
+
+        self.logs: List[str] = []
+
+        super().__init__(console=console, refresh_per_second=8, transient=transient)
+
+    # TODO: remove this once rich uses "Self"
+    def __enter__(self) -> "Progress":
+        self.start(refresh=self._renderable is not None)
+
+        return self
+
+    def get_renderable(self) -> Any:
+        current_message = self.current_message
+
+        if not self.style:
+            return current_message
+
+        animation_status: Literal["started", "stopped", "error"] = (
+            "started" if self._started else "stopped"
+        )
+
+        if self.is_error:
+            animation_status = "error"
+
+        content = current_message
+
+        if self._inline_logs:
+            lines_to_show = (
+                self.logs[-self._lines_to_show :]
+                if self._lines_to_show > 0
+                else self.logs
+            )
+
+            content = "\n".join(
+                [
+                    self.style.decorate_progress_log_line(
+                        line,
+                        index=index,
+                        max_lines=self._lines_to_show,
+                        total_lines=len(lines_to_show),
+                    )
+                    for index, line in enumerate(lines_to_show)
+                ]
+            )
+
+        return self.style.with_decoration(
+            content,
+            animation_status=animation_status,
+        )
+
+    def log(self, text: str) -> None:
+        if self._inline_logs:
+            self.logs.append(text)
+        else:
+            self.current_message = text
+
+    def set_error(self, text: str) -> None:
+        self.current_message = text
+        self.is_error = True
+        self.transient = self._transient_on_error

vllm/lib/python3.10/site-packages/rich_toolkit/styles/__init__.py

@@ -0,0 +1,9 @@
+from .fancy import FancyStyle
+from .tagged import TaggedStyle
+from .minimal import MinimalStyle
+
+__all__ = [
+    "FancyStyle",
+    "TaggedStyle",
+    "MinimalStyle",
+]

vllm/lib/python3.10/site-packages/rich_toolkit/styles/base.py

@@ -0,0 +1,144 @@
+from abc import ABC, abstractmethod
+from typing import Any, Generator, Iterable, List, Type, TypeVar
+
+from rich.color import Color
+from rich.console import (
+    Console,
+    ConsoleOptions,
+    ConsoleRenderable,
+    RenderableType,
+    RenderResult,
+)
+from rich.segment import Segment
+from rich.text import Text
+from typing_extensions import Literal
+
+from rich_toolkit.utils.colors import lighten
+
+ConsoleRenderableClass = TypeVar(
+    "ConsoleRenderableClass", bound=Type[ConsoleRenderable]
+)
+
+
+ANIMATION_STATUS = Literal["started", "stopped", "error", "no_animation"]
+
+
+class BaseStyle(ABC):
+    result_color: Color
+    decoration_size: int
+
+    def __init__(self) -> None:
+        self.padding = 2
+        self.cursor_offset = 0
+
+        self._animation_counter = 0
+        self.decoration_size = 2
+
+    def empty_line(self) -> Text:
+        return Text(" ")
+
+    def with_decoration(
+        self,
+        *renderables: RenderableType,
+        animation_status: ANIMATION_STATUS = "no_animation",
+        **metadata: Any,
+    ) -> ConsoleRenderable:
+        class WithDecoration:
+            @staticmethod
+            def __rich_console__(
+                console: Console, options: ConsoleOptions
+            ) -> RenderResult:
+                for content in renderables:
+                    # our styles are potentially adding some paddings on the left
+                    # and right sides, so we need to adjust the max_width to
+                    # make sure that rich takes that into account
+                    options = options.update(
+                        max_width=console.width - self.decoration_size
+                    )
+
+                    lines = console.render_lines(content, options, pad=False)
+
+                    for line in Segment.split_lines(
+                        self.decorate(
+                            lines=lines,
+                            console=console,
+                            animation_status=animation_status,
+                            **metadata,
+                        )
+                    ):
+                        yield from line
+                        yield Segment.line()
+
+        return WithDecoration()
+
+    def decorate_class(
+        self, klass: ConsoleRenderableClass, **metadata: Any
+    ) -> ConsoleRenderableClass:
+        style = self
+
+        class Decorated(klass):  # type: ignore[valid-type,misc]
+            def __rich_console__(
+                self, console: Console, options: ConsoleOptions
+            ) -> RenderResult:
+                lines = Segment.split_lines(super().__rich_console__(console, options))  # type: ignore
+
+                yield from style.decorate(lines=lines, console=console, **metadata)
+
+        return Decorated  # type: ignore
+
+    def decorate_progress_log_line(
+        self, line: str, index: int, max_lines: int = -1, total_lines: int = -1
+    ) -> str:
+        if max_lines == -1:
+            return line
+
+        # Adjust minimum brightness based on number of lines
+        # Fewer lines = higher minimum brightness
+        min_brightness = max(0.4, 1.0 - (total_lines / max_lines) * 0.6)
+        brightness_range = 1.0 - min_brightness
+
+        # Calculate brightness based on position in the sequence
+        brightness_pct = (index / total_lines) * brightness_range + min_brightness
+
+        # Apply brightness to RGB values
+        r = g = b = int(255 * brightness_pct)
+
+        color = f"#{r:02x}{g:02x}{b:02x}"
+
+        return f"[{color}]" + line
+
+    @abstractmethod
+    def decorate(
+        self,
+        console: Console,
+        lines: Iterable[List[Segment]],
+        animation_status: ANIMATION_STATUS = "no_animation",
+        **kwargs: Any,
+    ) -> Generator[Segment, None, None]:
+        raise NotImplementedError()
+
+    def _get_animation_colors(
+        self,
+        console: Console,
+        steps: int = 5,
+        animation_status: ANIMATION_STATUS = "started",
+        **metadata: Any,
+    ) -> List[Color]:
+        animated = animation_status == "started"
+
+        if animation_status == "error":
+            base_color = console.get_style("error").color
+
+            if base_color is None:
+                base_color = Color.parse("red")
+
+        else:
+            base_color = console.get_style("progress").bgcolor
+
+        if not base_color:
+            base_color = Color.parse("white")
+
+        if animated and base_color.triplet is not None:
+            return [lighten(base_color, 0.1 * i) for i in range(0, steps)]
+
+        return [base_color] * steps

vllm/lib/python3.10/site-packages/rich_toolkit/styles/fancy.py

@@ -0,0 +1,63 @@
+from typing import Any, Generator, Iterable, List
+
+from rich._loop import loop_first_last
+from rich.console import (
+    Console,
+)
+from rich.segment import Segment
+from rich.style import Style
+from rich.text import Text
+
+
+from .base import ANIMATION_STATUS, BaseStyle
+
+
+class FancyStyle(BaseStyle):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.cursor_offset = 2
+        self.decoration_size = 2
+
+    def decorate(
+        self,
+        console: Console,
+        lines: Iterable[List[Segment]],
+        animation_status: ANIMATION_STATUS = "no_animation",
+        **metadata: Any,
+    ) -> Generator[Segment, None, None]:
+        if animation_status != "no_animation":
+            colors = self._get_animation_colors(
+                console, animation_status=animation_status, **metadata
+            )
+
+            self._animation_counter += 1
+
+            color_index = self._animation_counter % len(colors)
+
+            for first, last, line in loop_first_last(lines):
+                if first:
+                    yield Segment("◆ ", style=Style(color=colors[color_index]))
+                else:
+                    yield Segment("│ ")
+                yield from line
+                yield Segment.line()
+
+            return
+
+        for first, last, line in loop_first_last(lines):
+            if first:
+                decoration = "┌ " if metadata.get("title", False) else "◆ "
+            elif last:
+                decoration = "└ "
+            else:
+                decoration = "│ "
+
+            yield Segment(decoration)
+            yield from line
+
+            if not last:
+                yield Segment.line()
+
+    def empty_line(self) -> Text:
+        return Text("│")

vllm/lib/python3.10/site-packages/rich_toolkit/styles/minimal.py

@@ -0,0 +1,59 @@
+from typing import Any, Generator, Iterable, List
+
+from rich._loop import loop_first_last
+from rich.console import (
+    Console,
+)
+from rich.segment import Segment
+from rich.style import Style
+from rich.text import Text
+
+
+from .base import ANIMATION_STATUS, BaseStyle
+
+
+class MinimalStyle(BaseStyle):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.cursor_offset = 2
+        self.decoration_size = 2
+
+    def decorate(
+        self,
+        console: Console,
+        lines: Iterable[List[Segment]],
+        animation_status: ANIMATION_STATUS = "no_animation",
+        **metadata: Any,
+    ) -> Generator[Segment, None, None]:
+        if animation_status != "no_animation":
+            block = "●"
+            colors = self._get_animation_colors(
+                console, animation_status=animation_status, **metadata
+            )
+
+            self._animation_counter += 1
+
+            color_index = self._animation_counter % len(colors)
+
+            for first, last, line in loop_first_last(lines):
+                if first:
+                    yield Segment(f"{block} ", style=Style(color=colors[color_index]))
+                else:
+                    yield Segment(" " * 2)
+                yield from line
+                yield Segment.line()
+
+            return
+
+        for first, last, line in loop_first_last(lines):
+            decoration = " " * 2
+
+            yield Segment(decoration)
+            yield from line
+
+            if not last:
+                yield Segment.line()
+
+    def empty_line(self) -> Text:
+        return Text("")

vllm/lib/python3.10/site-packages/rich_toolkit/styles/tagged.py

@@ -0,0 +1,100 @@
+from typing import Any, Generator, Iterable, List
+
+from rich._loop import loop_first_last
+from rich.console import Console
+from rich.segment import Segment
+from rich.style import Style
+
+from .base import ANIMATION_STATUS, BaseStyle
+
+
+class TaggedStyle(BaseStyle):
+    def __init__(self, *args, **kwargs) -> None:
+        self.tag_width = kwargs.pop("tag_width", 14)
+
+        super().__init__(*args, **kwargs)
+
+        self.padding = 2
+        self.cursor_offset = self.tag_width + self.padding
+        self.decoration_size = self.tag_width + self.padding
+
+    def _render_tag(
+        self,
+        text: str,
+        console: Console,
+        **metadata: Any,
+    ) -> Generator[Segment, None, None]:
+        style_name = "tag.title" if metadata.get("title", False) else "tag"
+
+        style = console.get_style(style_name)
+
+        if text:
+            text = f" {text} "
+
+        left_padding = self.tag_width - len(text)
+        left_padding = max(0, left_padding)
+
+        yield Segment(" " * left_padding)
+        yield Segment(text, style=style)
+        yield Segment(" " * self.padding)
+
+    def decorate(
+        self,
+        console: Console,
+        lines: Iterable[List[Segment]],
+        animation_status: ANIMATION_STATUS = "no_animation",
+        **metadata: Any,
+    ) -> Generator[Segment, None, None]:
+        if animation_status != "no_animation":
+            yield from self.decorate_with_animation(
+                lines=lines,
+                console=console,
+                animation_status=animation_status,
+                **metadata,
+            )
+
+            return
+
+        tag = metadata.get("tag", "")
+
+        for first, last, line in loop_first_last(lines):
+            text = tag if first else ""
+            yield from self._render_tag(text, console=console, **metadata)
+            yield from line
+
+            if not last:
+                yield Segment.line()
+
+    def decorate_with_animation(
+        self,
+        console: Console,
+        lines: Iterable[List[Segment]],
+        animation_status: ANIMATION_STATUS = "no_animation",
+        **metadata: Any,
+    ) -> Generator[Segment, None, None]:
+        block = "█"
+        block_length = 5
+        colors = self._get_animation_colors(
+            console, steps=block_length, animation_status=animation_status, **metadata
+        )
+
+        left_padding = self.tag_width - block_length
+        left_padding = max(0, left_padding)
+
+        self._animation_counter += 1
+
+        for first, _, line in loop_first_last(lines):
+            if first:
+                yield Segment(" " * left_padding)
+
+                for j in range(block_length):
+                    color_index = (j + self._animation_counter) % len(colors)
+                    yield Segment(block, style=Style(color=colors[color_index]))
+
+            else:
+                yield Segment(" " * self.tag_width)
+
+            yield Segment(" " * self.padding)
+
+            yield from line
+            yield Segment.line()

vllm/lib/python3.10/site-packages/rich_toolkit/toolkit.py

@@ -0,0 +1,118 @@
+from typing import Any, Dict, List, Union
+
+from rich.console import Console, RenderableType
+from rich.theme import Theme
+
+from .styles.base import BaseStyle
+from .input import Input
+from .menu import Menu, Option, ReturnValue
+from .progress import Progress
+
+
+class RichToolkitTheme:
+    def __init__(self, style: BaseStyle, theme: Dict[str, str]) -> None:
+        self.style = style
+        self.rich_theme = Theme(theme)
+
+
+class RichToolkit:
+    def __init__(
+        self,
+        theme: RichToolkitTheme,
+        handle_keyboard_interrupts: bool = True,
+    ) -> None:
+        self.console = Console(theme=theme.rich_theme)
+        self.theme = theme
+        self.handle_keyboard_interrupts = handle_keyboard_interrupts
+
+    def __enter__(self):
+        self.console.print()
+        return self
+
+    def __exit__(
+        self, exc_type: Any, exc_value: Any, traceback: Any
+    ) -> Union[bool, None]:
+        if self.handle_keyboard_interrupts and exc_type is KeyboardInterrupt:
+            # we want to handle keyboard interrupts gracefully, instead of showing a traceback
+            # or any other error message
+            return True
+
+        self.console.print()
+
+    def print_title(self, title: str, **metadata: Any) -> None:
+        self.console.print(
+            self.theme.style.with_decoration(title, title=True, **metadata)
+        )
+
+    def print(self, *renderables: RenderableType, **metadata: Any) -> None:
+        self.console.print(self.theme.style.with_decoration(*renderables, **metadata))
+
+    def print_as_string(self, *renderables: RenderableType, **metadata: Any) -> str:
+        with self.console.capture() as capture:
+            self.print(*renderables, **metadata)
+
+        return capture.get().rstrip()
+
+    def print_line(self) -> None:
+        self.console.print(self.theme.style.empty_line())
+
+    def confirm(self, title: str, **metadata: Any) -> bool:
+        return self.ask(
+            title=title,
+            options=[
+                Option({"value": True, "name": "Yes"}),
+                Option({"value": False, "name": "No"}),
+            ],
+            inline=True,
+            **metadata,
+        )
+
+    def ask(
+        self,
+        title: str,
+        options: List[Option[ReturnValue]],
+        inline: bool = False,
+        allow_filtering: bool = False,
+        **metadata: Any,
+    ) -> ReturnValue:
+        return Menu(
+            title=title,
+            options=options,
+            console=self.console,
+            style=self.theme.style,
+            inline=inline,
+            allow_filtering=allow_filtering,
+            cursor_offset=self.theme.style.cursor_offset,
+            **metadata,
+        ).ask()
+
+    def input(
+        self, title: str, default: str = "", password: bool = False, **metadata: Any
+    ) -> str:
+        return Input(
+            console=self.console,
+            style=self.theme.style,
+            title=title,
+            default=default,
+            cursor_offset=self.theme.style.cursor_offset,
+            password=password,
+            **metadata,
+        ).ask()
+
+    def progress(
+        self,
+        title: str,
+        transient: bool = False,
+        transient_on_error: bool = False,
+        inline_logs: bool = False,
+        lines_to_show: int = -1,
+    ) -> Progress:
+        return Progress(
+            title=title,
+            console=self.console,
+            style=self.theme.style,
+            transient=transient,
+            transient_on_error=transient_on_error,
+            inline_logs=inline_logs,
+            lines_to_show=lines_to_show,
+        )

vllm/lib/python3.10/site-packages/rich_toolkit/utils/colors.py

@@ -0,0 +1,14 @@
+from rich.color import Color
+from rich.color_triplet import ColorTriplet
+
+
+def lighten(color: Color, amount: float) -> Color:
+    assert color.triplet
+
+    r, g, b = color.triplet
+
+    r = int(r + (255 - r) * amount)
+    g = int(g + (255 - g) * amount)
+    b = int(b + (255 - b) * amount)
+
+    return Color.from_triplet(ColorTriplet(r, g, b))

vllm/lib/python3.10/site-packages/tiktoken_ext/openai_public.py

@@ -0,0 +1,127 @@
+from tiktoken.load import data_gym_to_mergeable_bpe_ranks, load_tiktoken_bpe
+
+ENDOFTEXT = "<|endoftext|>"
+FIM_PREFIX = "<|fim_prefix|>"
+FIM_MIDDLE = "<|fim_middle|>"
+FIM_SUFFIX = "<|fim_suffix|>"
+ENDOFPROMPT = "<|endofprompt|>"
+
+
+def gpt2():
+    mergeable_ranks = data_gym_to_mergeable_bpe_ranks(
+        vocab_bpe_file="https://openaipublic.blob.core.windows.net/gpt-2/encodings/main/vocab.bpe",
+        encoder_json_file="https://openaipublic.blob.core.windows.net/gpt-2/encodings/main/encoder.json",
+        vocab_bpe_hash="1ce1664773c50f3e0cc8842619a93edc4624525b728b188a9e0be33b7726adc5",
+        encoder_json_hash="196139668be63f3b5d6574427317ae82f612a97c5d1cdaf36ed2256dbf636783",
+    )
+    return {
+        "name": "gpt2",
+        "explicit_n_vocab": 50257,
+        # The pattern in the original GPT-2 release is:
+        # r"""'s|'t|'re|'ve|'m|'ll|'d| ?[\p{L}]+| ?[\p{N}]+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""
+        # This is equivalent, but executes faster:
+        "pat_str": r"""'(?:[sdmt]|ll|ve|re)| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""",
+        "mergeable_ranks": mergeable_ranks,
+        "special_tokens": {ENDOFTEXT: 50256},
+    }
+
+
+def r50k_base():
+    mergeable_ranks = load_tiktoken_bpe(
+        "https://openaipublic.blob.core.windows.net/encodings/r50k_base.tiktoken",
+        expected_hash="306cd27f03c1a714eca7108e03d66b7dc042abe8c258b44c199a7ed9838dd930",
+    )
+    return {
+        "name": "r50k_base",
+        "explicit_n_vocab": 50257,
+        "pat_str": r"""'(?:[sdmt]|ll|ve|re)| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""",
+        "mergeable_ranks": mergeable_ranks,
+        "special_tokens": {ENDOFTEXT: 50256},
+    }
+
+
+def p50k_base():
+    mergeable_ranks = load_tiktoken_bpe(
+        "https://openaipublic.blob.core.windows.net/encodings/p50k_base.tiktoken",
+        expected_hash="94b5ca7dff4d00767bc256fdd1b27e5b17361d7b8a5f968547f9f23eb70d2069",
+    )
+    return {
+        "name": "p50k_base",
+        "explicit_n_vocab": 50281,
+        "pat_str": r"""'(?:[sdmt]|ll|ve|re)| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""",
+        "mergeable_ranks": mergeable_ranks,
+        "special_tokens": {ENDOFTEXT: 50256},
+    }
+
+
+def p50k_edit():
+    mergeable_ranks = load_tiktoken_bpe(
+        "https://openaipublic.blob.core.windows.net/encodings/p50k_base.tiktoken",
+        expected_hash="94b5ca7dff4d00767bc256fdd1b27e5b17361d7b8a5f968547f9f23eb70d2069",
+    )
+    special_tokens = {ENDOFTEXT: 50256, FIM_PREFIX: 50281, FIM_MIDDLE: 50282, FIM_SUFFIX: 50283}
+    return {
+        "name": "p50k_edit",
+        "pat_str": r"""'(?:[sdmt]|ll|ve|re)| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""",
+        "mergeable_ranks": mergeable_ranks,
+        "special_tokens": special_tokens,
+    }
+
+
+def cl100k_base():
+    mergeable_ranks = load_tiktoken_bpe(
+        "https://openaipublic.blob.core.windows.net/encodings/cl100k_base.tiktoken",
+        expected_hash="223921b76ee99bde995b7ff738513eef100fb51d18c93597a113bcffe865b2a7",
+    )
+    special_tokens = {
+        ENDOFTEXT: 100257,
+        FIM_PREFIX: 100258,
+        FIM_MIDDLE: 100259,
+        FIM_SUFFIX: 100260,
+        ENDOFPROMPT: 100276,
+    }
+    return {
+        "name": "cl100k_base",
+        "pat_str": r"""'(?i:[sdmt]|ll|ve|re)|[^\r\n\p{L}\p{N}]?+\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]++[\r\n]*|\s*[\r\n]|\s+(?!\S)|\s+""",
+        "mergeable_ranks": mergeable_ranks,
+        "special_tokens": special_tokens,
+    }
+
+
+def o200k_base():
+    mergeable_ranks = load_tiktoken_bpe(
+        "https://openaipublic.blob.core.windows.net/encodings/o200k_base.tiktoken",
+        expected_hash="446a9538cb6c348e3516120d7c08b09f57c36495e2acfffe59a5bf8b0cfb1a2d",
+    )
+    special_tokens = {
+        ENDOFTEXT: 199999,
+        ENDOFPROMPT: 200018,
+    }
+    # This regex could be made more efficient
+    pat_str = "|".join(
+        [
+            r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?""",
+            r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]+[\p{Ll}\p{Lm}\p{Lo}\p{M}]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?""",
+            r"""\p{N}{1,3}""",
+            r""" ?[^\s\p{L}\p{N}]+[\r\n/]*""",
+            r"""\s*[\r\n]+""",
+            r"""\s+(?!\S)""",
+            r"""\s+""",
+        ]
+    )
+    return {
+        "name": "o200k_base",
+        "pat_str": pat_str,
+        "mergeable_ranks": mergeable_ranks,
+        "special_tokens": special_tokens,
+    }
+
+
+ENCODING_CONSTRUCTORS = {
+    "gpt2": gpt2,
+    "r50k_base": r50k_base,
+    "p50k_base": p50k_base,
+    "p50k_edit": p50k_edit,
+    "cl100k_base": cl100k_base,
+    "o200k_base": o200k_base,
+}

vllm/lib/python3.10/site-packages/wheel/cli/__init__.py

@@ -0,0 +1,155 @@
+"""
+Wheel command-line utility.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from argparse import ArgumentTypeError
+
+
+class WheelError(Exception):
+    pass
+
+
+def unpack_f(args: argparse.Namespace) -> None:
+    from .unpack import unpack
+
+    unpack(args.wheelfile, args.dest)
+
+
+def pack_f(args: argparse.Namespace) -> None:
+    from .pack import pack
+
+    pack(args.directory, args.dest_dir, args.build_number)
+
+
+def convert_f(args: argparse.Namespace) -> None:
+    from .convert import convert
+
+    convert(args.files, args.dest_dir, args.verbose)
+
+
+def tags_f(args: argparse.Namespace) -> None:
+    from .tags import tags
+
+    names = (
+        tags(
+            wheel,
+            args.python_tag,
+            args.abi_tag,
+            args.platform_tag,
+            args.build,
+            args.remove,
+        )
+        for wheel in args.wheel
+    )
+
+    for name in names:
+        print(name)
+
+
+def version_f(args: argparse.Namespace) -> None:
+    from .. import __version__
+
+    print(f"wheel {__version__}")
+
+
+def parse_build_tag(build_tag: str) -> str:
+    if build_tag and not build_tag[0].isdigit():
+        raise ArgumentTypeError("build tag must begin with a digit")
+    elif "-" in build_tag:
+        raise ArgumentTypeError("invalid character ('-') in build tag")
+
+    return build_tag
+
+
+TAGS_HELP = """\
+Make a new wheel with given tags. Any tags unspecified will remain the same.
+Starting the tags with a "+" will append to the existing tags. Starting with a
+"-" will remove a tag (use --option=-TAG syntax). Multiple tags can be
+separated by ".". The original file will remain unless --remove is given.  The
+output filename(s) will be displayed on stdout for further processing.
+"""
+
+
+def parser():
+    p = argparse.ArgumentParser()
+    s = p.add_subparsers(help="commands")
+
+    unpack_parser = s.add_parser("unpack", help="Unpack wheel")
+    unpack_parser.add_argument(
+        "--dest", "-d", help="Destination directory", default="."
+    )
+    unpack_parser.add_argument("wheelfile", help="Wheel file")
+    unpack_parser.set_defaults(func=unpack_f)
+
+    repack_parser = s.add_parser("pack", help="Repack wheel")
+    repack_parser.add_argument("directory", help="Root directory of the unpacked wheel")
+    repack_parser.add_argument(
+        "--dest-dir",
+        "-d",
+        default=os.path.curdir,
+        help="Directory to store the wheel (default %(default)s)",
+    )
+    repack_parser.add_argument(
+        "--build-number", help="Build tag to use in the wheel name"
+    )
+    repack_parser.set_defaults(func=pack_f)
+
+    convert_parser = s.add_parser("convert", help="Convert egg or wininst to wheel")
+    convert_parser.add_argument("files", nargs="*", help="Files to convert")
+    convert_parser.add_argument(
+        "--dest-dir",
+        "-d",
+        default=os.path.curdir,
+        help="Directory to store wheels (default %(default)s)",
+    )
+    convert_parser.add_argument("--verbose", "-v", action="store_true")
+    convert_parser.set_defaults(func=convert_f)
+
+    tags_parser = s.add_parser(
+        "tags", help="Add or replace the tags on a wheel", description=TAGS_HELP
+    )
+    tags_parser.add_argument("wheel", nargs="*", help="Existing wheel(s) to retag")
+    tags_parser.add_argument(
+        "--remove",
+        action="store_true",
+        help="Remove the original files, keeping only the renamed ones",
+    )
+    tags_parser.add_argument(
+        "--python-tag", metavar="TAG", help="Specify an interpreter tag(s)"
+    )
+    tags_parser.add_argument("--abi-tag", metavar="TAG", help="Specify an ABI tag(s)")
+    tags_parser.add_argument(
+        "--platform-tag", metavar="TAG", help="Specify a platform tag(s)"
+    )
+    tags_parser.add_argument(
+        "--build", type=parse_build_tag, metavar="BUILD", help="Specify a build tag"
+    )
+    tags_parser.set_defaults(func=tags_f)
+
+    version_parser = s.add_parser("version", help="Print version and exit")
+    version_parser.set_defaults(func=version_f)
+
+    help_parser = s.add_parser("help", help="Show this help")
+    help_parser.set_defaults(func=lambda args: p.print_help())
+
+    return p
+
+
+def main():
+    p = parser()
+    args = p.parse_args()
+    if not hasattr(args, "func"):
+        p.print_help()
+    else:
+        try:
+            args.func(args)
+            return 0
+        except WheelError as e:
+            print(e, file=sys.stderr)
+
+    return 1

vllm/lib/python3.10/site-packages/wheel/cli/convert.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import os.path
+import re
+import shutil
+import tempfile
+import zipfile
+from glob import iglob
+
+from .._bdist_wheel import bdist_wheel
+from ..wheelfile import WheelFile
+from . import WheelError
+
+try:
+    from setuptools import Distribution
+except ImportError:
+    from distutils.dist import Distribution
+
+egg_info_re = re.compile(
+    r"""
+    (?P<name>.+?)-(?P<ver>.+?)
+    (-(?P<pyver>py\d\.\d+)
+     (-(?P<arch>.+?))?
+    )?.egg$""",
+    re.VERBOSE,
+)
+
+
+class _bdist_wheel_tag(bdist_wheel):
+    # allow the client to override the default generated wheel tag
+    # The default bdist_wheel implementation uses python and abi tags
+    # of the running python process. This is not suitable for
+    # generating/repackaging prebuild binaries.
+
+    full_tag_supplied = False
+    full_tag = None  # None or a (pytag, soabitag, plattag) triple
+
+    def get_tag(self):
+        if self.full_tag_supplied and self.full_tag is not None:
+            return self.full_tag
+        else:
+            return bdist_wheel.get_tag(self)
+
+
+def egg2wheel(egg_path: str, dest_dir: str) -> None:
+    filename = os.path.basename(egg_path)
+    match = egg_info_re.match(filename)
+    if not match:
+        raise WheelError(f"Invalid egg file name: {filename}")
+
+    egg_info = match.groupdict()
+    dir = tempfile.mkdtemp(suffix="_e2w")
+    if os.path.isfile(egg_path):
+        # assume we have a bdist_egg otherwise
+        with zipfile.ZipFile(egg_path) as egg:
+            egg.extractall(dir)
+    else:
+        # support buildout-style installed eggs directories
+        for pth in os.listdir(egg_path):
+            src = os.path.join(egg_path, pth)
+            if os.path.isfile(src):
+                shutil.copy2(src, dir)
+            else:
+                shutil.copytree(src, os.path.join(dir, pth))
+
+    pyver = egg_info["pyver"]
+    if pyver:
+        pyver = egg_info["pyver"] = pyver.replace(".", "")
+
+    arch = (egg_info["arch"] or "any").replace(".", "_").replace("-", "_")
+
+    # assume all binary eggs are for CPython
+    abi = "cp" + pyver[2:] if arch != "any" else "none"
+
+    root_is_purelib = egg_info["arch"] is None
+    if root_is_purelib:
+        bw = bdist_wheel(Distribution())
+    else:
+        bw = _bdist_wheel_tag(Distribution())
+
+    bw.root_is_pure = root_is_purelib
+    bw.python_tag = pyver
+    bw.plat_name_supplied = True
+    bw.plat_name = egg_info["arch"] or "any"
+    if not root_is_purelib:
+        bw.full_tag_supplied = True
+        bw.full_tag = (pyver, abi, arch)
+
+    dist_info_dir = os.path.join(dir, "{name}-{ver}.dist-info".format(**egg_info))
+    bw.egg2dist(os.path.join(dir, "EGG-INFO"), dist_info_dir)
+    bw.write_wheelfile(dist_info_dir, generator="egg2wheel")
+    wheel_name = "{name}-{ver}-{pyver}-{}-{}.whl".format(abi, arch, **egg_info)
+    with WheelFile(os.path.join(dest_dir, wheel_name), "w") as wf:
+        wf.write_files(dir)
+
+    shutil.rmtree(dir)
+
+
+def parse_wininst_info(wininfo_name: str, egginfo_name: str | None):
+    """Extract metadata from filenames.
+
+    Extracts the 4 metadataitems needed (name, version, pyversion, arch) from
+    the installer filename and the name of the egg-info directory embedded in
+    the zipfile (if any).
+
+    The egginfo filename has the format::
+
+        name-ver(-pyver)(-arch).egg-info
+
+    The installer filename has the format::
+
+        name-ver.arch(-pyver).exe
+
+    Some things to note:
+
+    1. The installer filename is not definitive. An installer can be renamed
+       and work perfectly well as an installer. So more reliable data should
+       be used whenever possible.
+    2. The egg-info data should be preferred for the name and version, because
+       these come straight from the distutils metadata, and are mandatory.
+    3. The pyver from the egg-info data should be ignored, as it is
+       constructed from the version of Python used to build the installer,
+       which is irrelevant - the installer filename is correct here (even to
+       the point that when it's not there, any version is implied).
+    4. The architecture must be taken from the installer filename, as it is
+       not included in the egg-info data.
+    5. Architecture-neutral installers still have an architecture because the
+       installer format itself (being executable) is architecture-specific. We
+       should therefore ignore the architecture if the content is pure-python.
+    """
+
+    egginfo = None
+    if egginfo_name:
+        egginfo = egg_info_re.search(egginfo_name)
+        if not egginfo:
+            raise ValueError(f"Egg info filename {egginfo_name} is not valid")
+
+    # Parse the wininst filename
+    # 1. Distribution name (up to the first '-')
+    w_name, sep, rest = wininfo_name.partition("-")
+    if not sep:
+        raise ValueError(f"Installer filename {wininfo_name} is not valid")
+
+    # Strip '.exe'
+    rest = rest[:-4]
+    # 2. Python version (from the last '-', must start with 'py')
+    rest2, sep, w_pyver = rest.rpartition("-")
+    if sep and w_pyver.startswith("py"):
+        rest = rest2
+        w_pyver = w_pyver.replace(".", "")
+    else:
+        # Not version specific - use py2.py3. While it is possible that
+        # pure-Python code is not compatible with both Python 2 and 3, there
+        # is no way of knowing from the wininst format, so we assume the best
+        # here (the user can always manually rename the wheel to be more
+        # restrictive if needed).
+        w_pyver = "py2.py3"
+    # 3. Version and architecture
+    w_ver, sep, w_arch = rest.rpartition(".")
+    if not sep:
+        raise ValueError(f"Installer filename {wininfo_name} is not valid")
+
+    if egginfo:
+        w_name = egginfo.group("name")
+        w_ver = egginfo.group("ver")
+
+    return {"name": w_name, "ver": w_ver, "arch": w_arch, "pyver": w_pyver}
+
+
+def wininst2wheel(path: str, dest_dir: str) -> None:
+    with zipfile.ZipFile(path) as bdw:
+        # Search for egg-info in the archive
+        egginfo_name = None
+        for filename in bdw.namelist():
+            if ".egg-info" in filename:
+                egginfo_name = filename
+                break
+
+        info = parse_wininst_info(os.path.basename(path), egginfo_name)
+
+        root_is_purelib = True
+        for zipinfo in bdw.infolist():
+            if zipinfo.filename.startswith("PLATLIB"):
+                root_is_purelib = False
+                break
+        if root_is_purelib:
+            paths = {"purelib": ""}
+        else:
+            paths = {"platlib": ""}
+
+        dist_info = "{name}-{ver}".format(**info)
+        datadir = f"{dist_info}.data/"
+
+        # rewrite paths to trick ZipFile into extracting an egg
+        # XXX grab wininst .ini - between .exe, padding, and first zip file.
+        members: list[str] = []
+        egginfo_name = ""
+        for zipinfo in bdw.infolist():
+            key, basename = zipinfo.filename.split("/", 1)
+            key = key.lower()
+            basepath = paths.get(key, None)
+            if basepath is None:
+                basepath = datadir + key.lower() + "/"
+            oldname = zipinfo.filename
+            newname = basepath + basename
+            zipinfo.filename = newname
+            del bdw.NameToInfo[oldname]
+            bdw.NameToInfo[newname] = zipinfo
+            # Collect member names, but omit '' (from an entry like "PLATLIB/"
+            if newname:
+                members.append(newname)
+            # Remember egg-info name for the egg2dist call below
+            if not egginfo_name:
+                if newname.endswith(".egg-info"):
+                    egginfo_name = newname
+                elif ".egg-info/" in newname:
+                    egginfo_name, sep, _ = newname.rpartition("/")
+        dir = tempfile.mkdtemp(suffix="_b2w")
+        bdw.extractall(dir, members)
+
+    # egg2wheel
+    abi = "none"
+    pyver = info["pyver"]
+    arch = (info["arch"] or "any").replace(".", "_").replace("-", "_")
+    # Wininst installers always have arch even if they are not
+    # architecture-specific (because the format itself is).
+    # So, assume the content is architecture-neutral if root is purelib.
+    if root_is_purelib:
+        arch = "any"
+    # If the installer is architecture-specific, it's almost certainly also
+    # CPython-specific.
+    if arch != "any":
+        pyver = pyver.replace("py", "cp")
+    wheel_name = "-".join((dist_info, pyver, abi, arch))
+    if root_is_purelib:
+        bw = bdist_wheel(Distribution())
+    else:
+        bw = _bdist_wheel_tag(Distribution())
+
+    bw.root_is_pure = root_is_purelib
+    bw.python_tag = pyver
+    bw.plat_name_supplied = True
+    bw.plat_name = info["arch"] or "any"
+
+    if not root_is_purelib:
+        bw.full_tag_supplied = True
+        bw.full_tag = (pyver, abi, arch)
+
+    dist_info_dir = os.path.join(dir, f"{dist_info}.dist-info")
+    bw.egg2dist(os.path.join(dir, egginfo_name), dist_info_dir)
+    bw.write_wheelfile(dist_info_dir, generator="wininst2wheel")
+
+    wheel_path = os.path.join(dest_dir, wheel_name)
+    with WheelFile(wheel_path, "w") as wf:
+        wf.write_files(dir)
+
+    shutil.rmtree(dir)
+
+
+def convert(files: list[str], dest_dir: str, verbose: bool) -> None:
+    for pat in files:
+        for installer in iglob(pat):
+            if os.path.splitext(installer)[1] == ".egg":
+                conv = egg2wheel
+            else:
+                conv = wininst2wheel
+
+            if verbose:
+                print(f"{installer}... ", flush=True)
+
+            conv(installer, dest_dir)
+            if verbose:
+                print("OK")

vllm/lib/python3.10/site-packages/wheel/cli/pack.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import email.policy
+import os.path
+import re
+from email.generator import BytesGenerator
+from email.parser import BytesParser
+
+from wheel.cli import WheelError
+from wheel.wheelfile import WheelFile
+
+DIST_INFO_RE = re.compile(r"^(?P<namever>(?P<name>.+?)-(?P<ver>\d.*?))\.dist-info$")
+
+
+def pack(directory: str, dest_dir: str, build_number: str | None) -> None:
+    """Repack a previously unpacked wheel directory into a new wheel file.
+
+    The .dist-info/WHEEL file must contain one or more tags so that the target
+    wheel file name can be determined.
+
+    :param directory: The unpacked wheel directory
+    :param dest_dir: Destination directory (defaults to the current directory)
+    """
+    # Find the .dist-info directory
+    dist_info_dirs = [
+        fn
+        for fn in os.listdir(directory)
+        if os.path.isdir(os.path.join(directory, fn)) and DIST_INFO_RE.match(fn)
+    ]
+    if len(dist_info_dirs) > 1:
+        raise WheelError(f"Multiple .dist-info directories found in {directory}")
+    elif not dist_info_dirs:
+        raise WheelError(f"No .dist-info directories found in {directory}")
+
+    # Determine the target wheel filename
+    dist_info_dir = dist_info_dirs[0]
+    name_version = DIST_INFO_RE.match(dist_info_dir).group("namever")
+
+    # Read the tags and the existing build number from .dist-info/WHEEL
+    wheel_file_path = os.path.join(directory, dist_info_dir, "WHEEL")
+    with open(wheel_file_path, "rb") as f:
+        info = BytesParser(policy=email.policy.compat32).parse(f)
+        tags: list[str] = info.get_all("Tag", [])
+        existing_build_number = info.get("Build")
+
+        if not tags:
+            raise WheelError(
+                f"No tags present in {dist_info_dir}/WHEEL; cannot determine target "
+                f"wheel filename"
+            )
+
+    # Set the wheel file name and add/replace/remove the Build tag in .dist-info/WHEEL
+    build_number = build_number if build_number is not None else existing_build_number
+    if build_number is not None:
+        del info["Build"]
+        if build_number:
+            info["Build"] = build_number
+            name_version += "-" + build_number
+
+        if build_number != existing_build_number:
+            with open(wheel_file_path, "wb") as f:
+                BytesGenerator(f, maxheaderlen=0).flatten(info)
+
+    # Reassemble the tags for the wheel file
+    tagline = compute_tagline(tags)
+
+    # Repack the wheel
+    wheel_path = os.path.join(dest_dir, f"{name_version}-{tagline}.whl")
+    with WheelFile(wheel_path, "w") as wf:
+        print(f"Repacking wheel as {wheel_path}...", end="", flush=True)
+        wf.write_files(directory)
+
+    print("OK")
+
+
+def compute_tagline(tags: list[str]) -> str:
+    """Compute a tagline from a list of tags.
+
+    :param tags: A list of tags
+    :return: A tagline
+    """
+    impls = sorted({tag.split("-")[0] for tag in tags})
+    abivers = sorted({tag.split("-")[1] for tag in tags})
+    platforms = sorted({tag.split("-")[2] for tag in tags})
+    return "-".join([".".join(impls), ".".join(abivers), ".".join(platforms)])

vllm/lib/python3.10/site-packages/wheel/cli/tags.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import email.policy
+import itertools
+import os
+from collections.abc import Iterable
+from email.parser import BytesParser
+
+from ..wheelfile import WheelFile
+
+
+def _compute_tags(original_tags: Iterable[str], new_tags: str | None) -> set[str]:
+    """Add or replace tags. Supports dot-separated tags"""
+    if new_tags is None:
+        return set(original_tags)
+
+    if new_tags.startswith("+"):
+        return {*original_tags, *new_tags[1:].split(".")}
+
+    if new_tags.startswith("-"):
+        return set(original_tags) - set(new_tags[1:].split("."))
+
+    return set(new_tags.split("."))
+
+
+def tags(
+    wheel: str,
+    python_tags: str | None = None,
+    abi_tags: str | None = None,
+    platform_tags: str | None = None,
+    build_tag: str | None = None,
+    remove: bool = False,
+) -> str:
+    """Change the tags on a wheel file.
+
+    The tags are left unchanged if they are not specified. To specify "none",
+    use ["none"]. To append to the previous tags, a tag should start with a
+    "+".  If a tag starts with "-", it will be removed from existing tags.
+    Processing is done left to right.
+
+    :param wheel: The paths to the wheels
+    :param python_tags: The Python tags to set
+    :param abi_tags: The ABI tags to set
+    :param platform_tags: The platform tags to set
+    :param build_tag: The build tag to set
+    :param remove: Remove the original wheel
+    """
+    with WheelFile(wheel, "r") as f:
+        assert f.filename, f"{f.filename} must be available"
+
+        wheel_info = f.read(f.dist_info_path + "/WHEEL")
+        info = BytesParser(policy=email.policy.compat32).parsebytes(wheel_info)
+
+        original_wheel_name = os.path.basename(f.filename)
+        namever = f.parsed_filename.group("namever")
+        build = f.parsed_filename.group("build")
+        original_python_tags = f.parsed_filename.group("pyver").split(".")
+        original_abi_tags = f.parsed_filename.group("abi").split(".")
+        original_plat_tags = f.parsed_filename.group("plat").split(".")
+
+    tags: list[str] = info.get_all("Tag", [])
+    existing_build_tag = info.get("Build")
+
+    impls = {tag.split("-")[0] for tag in tags}
+    abivers = {tag.split("-")[1] for tag in tags}
+    platforms = {tag.split("-")[2] for tag in tags}
+
+    if impls != set(original_python_tags):
+        msg = f"Wheel internal tags {impls!r} != filename tags {original_python_tags!r}"
+        raise AssertionError(msg)
+
+    if abivers != set(original_abi_tags):
+        msg = f"Wheel internal tags {abivers!r} != filename tags {original_abi_tags!r}"
+        raise AssertionError(msg)
+
+    if platforms != set(original_plat_tags):
+        msg = (
+            f"Wheel internal tags {platforms!r} != filename tags {original_plat_tags!r}"
+        )
+        raise AssertionError(msg)
+
+    if existing_build_tag != build:
+        msg = (
+            f"Incorrect filename '{build}' "
+            f"& *.dist-info/WHEEL '{existing_build_tag}' build numbers"
+        )
+        raise AssertionError(msg)
+
+    # Start changing as needed
+    if build_tag is not None:
+        build = build_tag
+
+    final_python_tags = sorted(_compute_tags(original_python_tags, python_tags))
+    final_abi_tags = sorted(_compute_tags(original_abi_tags, abi_tags))
+    final_plat_tags = sorted(_compute_tags(original_plat_tags, platform_tags))
+
+    final_tags = [
+        namever,
+        ".".join(final_python_tags),
+        ".".join(final_abi_tags),
+        ".".join(final_plat_tags),
+    ]
+    if build:
+        final_tags.insert(1, build)
+
+    final_wheel_name = "-".join(final_tags) + ".whl"
+
+    if original_wheel_name != final_wheel_name:
+        del info["Tag"], info["Build"]
+        for a, b, c in itertools.product(
+            final_python_tags, final_abi_tags, final_plat_tags
+        ):
+            info["Tag"] = f"{a}-{b}-{c}"
+        if build:
+            info["Build"] = build
+
+        original_wheel_path = os.path.join(
+            os.path.dirname(f.filename), original_wheel_name
+        )
+        final_wheel_path = os.path.join(os.path.dirname(f.filename), final_wheel_name)
+
+        with WheelFile(original_wheel_path, "r") as fin, WheelFile(
+            final_wheel_path, "w"
+        ) as fout:
+            fout.comment = fin.comment  # preserve the comment
+            for item in fin.infolist():
+                if item.is_dir():
+                    continue
+                if item.filename == f.dist_info_path + "/RECORD":
+                    continue
+                if item.filename == f.dist_info_path + "/WHEEL":
+                    fout.writestr(item, info.as_bytes())
+                else:
+                    fout.writestr(item, fin.read(item))
+
+        if remove:
+            os.remove(original_wheel_path)
+
+    return final_wheel_name

vllm/lib/python3.10/site-packages/wheel/cli/unpack.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..wheelfile import WheelFile
+
+
+def unpack(path: str, dest: str = ".") -> None:
+    """Unpack a wheel.
+
+    Wheel content will be unpacked to {dest}/{name}-{ver}, where {name}
+    is the package name and {ver} its version.
+
+    :param path: The path to the wheel.
+    :param dest: Destination directory (default to current directory).
+    """
+    with WheelFile(path) as wf:
+        namever = wf.parsed_filename.group("namever")
+        destination = Path(dest) / namever
+        print(f"Unpacking to: {destination}...", end="", flush=True)
+        for zinfo in wf.filelist:
+            wf.extract(zinfo, destination)
+
+            # Set permissions to the same values as they were set in the archive
+            # We have to do this manually due to
+            # https://github.com/python/cpython/issues/59999
+            permissions = zinfo.external_attr >> 16 & 0o777
+            destination.joinpath(zinfo.filename).chmod(permissions)
+
+    print("OK")