Add files using upload-large-folder tool

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

@@ -0,0 +1,38 @@
+from ._monitor import TMonitor, TqdmSynchronisationWarning
+from ._tqdm_pandas import tqdm_pandas
+from .cli import main  # TODO: remove in v5.0.0
+from .gui import tqdm as tqdm_gui  # TODO: remove in v5.0.0
+from .gui import trange as tgrange  # TODO: remove in v5.0.0
+from .std import (
+    TqdmDeprecationWarning, TqdmExperimentalWarning, TqdmKeyError, TqdmMonitorWarning,
+    TqdmTypeError, TqdmWarning, tqdm, trange)
+from .version import __version__
+
+__all__ = ['tqdm', 'tqdm_gui', 'trange', 'tgrange', 'tqdm_pandas',
+           'tqdm_notebook', 'tnrange', 'main', 'TMonitor',
+           'TqdmTypeError', 'TqdmKeyError',
+           'TqdmWarning', 'TqdmDeprecationWarning',
+           'TqdmExperimentalWarning',
+           'TqdmMonitorWarning', 'TqdmSynchronisationWarning',
+           '__version__']
+
+
+def tqdm_notebook(*args, **kwargs):  # pragma: no cover
+    """See tqdm.notebook.tqdm for full documentation"""
+    from warnings import warn
+
+    from .notebook import tqdm as _tqdm_notebook
+    warn("This function will be removed in tqdm==5.0.0\n"
+         "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`",
+         TqdmDeprecationWarning, stacklevel=2)
+    return _tqdm_notebook(*args, **kwargs)
+
+
+def tnrange(*args, **kwargs):  # pragma: no cover
+    """Shortcut for `tqdm.notebook.tqdm(range(*args), **kwargs)`."""
+    from warnings import warn
+
+    from .notebook import trange as _tnrange
+    warn("Please use `tqdm.notebook.trange` instead of `tqdm.tnrange`",
+         TqdmDeprecationWarning, stacklevel=2)
+    return _tnrange(*args, **kwargs)

vllm/lib/python3.10/site-packages/tqdm/_main.py

@@ -0,0 +1,9 @@
+from warnings import warn
+
+from .cli import *  # NOQA
+from .cli import __all__  # NOQA
+from .std import TqdmDeprecationWarning
+
+warn("This function will be removed in tqdm==5.0.0\n"
+     "Please use `tqdm.cli.*` instead of `tqdm._main.*`",
+     TqdmDeprecationWarning, stacklevel=2)

vllm/lib/python3.10/site-packages/tqdm/_monitor.py

@@ -0,0 +1,95 @@
+import atexit
+from threading import Event, Thread, current_thread
+from time import time
+from warnings import warn
+
+__all__ = ["TMonitor", "TqdmSynchronisationWarning"]
+
+
+class TqdmSynchronisationWarning(RuntimeWarning):
+    """tqdm multi-thread/-process errors which may cause incorrect nesting
+    but otherwise no adverse effects"""
+    pass
+
+
+class TMonitor(Thread):
+    """
+    Monitoring thread for tqdm bars.
+    Monitors if tqdm bars are taking too much time to display
+    and readjusts miniters automatically if necessary.
+
+    Parameters
+    ----------
+    tqdm_cls  : class
+        tqdm class to use (can be core tqdm or a submodule).
+    sleep_interval  : float
+        Time to sleep between monitoring checks.
+    """
+    _test = {}  # internal vars for unit testing
+
+    def __init__(self, tqdm_cls, sleep_interval):
+        Thread.__init__(self)
+        self.daemon = True  # kill thread when main killed (KeyboardInterrupt)
+        self.woken = 0  # last time woken up, to sync with monitor
+        self.tqdm_cls = tqdm_cls
+        self.sleep_interval = sleep_interval
+        self._time = self._test.get("time", time)
+        self.was_killed = self._test.get("Event", Event)()
+        atexit.register(self.exit)
+        self.start()
+
+    def exit(self):
+        self.was_killed.set()
+        if self is not current_thread():
+            self.join()
+        return self.report()
+
+    def get_instances(self):
+        # returns a copy of started `tqdm_cls` instances
+        return [i for i in self.tqdm_cls._instances.copy()
+                # Avoid race by checking that the instance started
+                if hasattr(i, 'start_t')]
+
+    def run(self):
+        cur_t = self._time()
+        while True:
+            # After processing and before sleeping, notify that we woke
+            # Need to be done just before sleeping
+            self.woken = cur_t
+            # Sleep some time...
+            self.was_killed.wait(self.sleep_interval)
+            # Quit if killed
+            if self.was_killed.is_set():
+                return
+            # Then monitor!
+            # Acquire lock (to access _instances)
+            with self.tqdm_cls.get_lock():
+                cur_t = self._time()
+                # Check tqdm instances are waiting too long to print
+                instances = self.get_instances()
+                for instance in instances:
+                    # Check event in loop to reduce blocking time on exit
+                    if self.was_killed.is_set():
+                        return
+                    # Only if mininterval > 1 (else iterations are just slow)
+                    # and last refresh exceeded maxinterval
+                    if (
+                        instance.miniters > 1
+                        and (cur_t - instance.last_print_t) >= instance.maxinterval
+                    ):
+                        # force bypassing miniters on next iteration
+                        # (dynamic_miniters adjusts mininterval automatically)
+                        instance.miniters = 1
+                        # Refresh now! (works only for manual tqdm)
+                        instance.refresh(nolock=True)
+                    # Remove accidental long-lived strong reference
+                    del instance
+                if instances != self.get_instances():  # pragma: nocover
+                    warn("Set changed size during iteration" +
+                         " (see https://github.com/tqdm/tqdm/issues/481)",
+                         TqdmSynchronisationWarning, stacklevel=2)
+                # Remove accidental long-lived strong references
+                del instances
+
+    def report(self):
+        return not self.was_killed.is_set()

vllm/lib/python3.10/site-packages/tqdm/_tqdm_gui.py

@@ -0,0 +1,9 @@
+from warnings import warn
+
+from .gui import *  # NOQA
+from .gui import __all__  # NOQA
+from .std import TqdmDeprecationWarning
+
+warn("This function will be removed in tqdm==5.0.0\n"
+     "Please use `tqdm.gui.*` instead of `tqdm._tqdm_gui.*`",
+     TqdmDeprecationWarning, stacklevel=2)

vllm/lib/python3.10/site-packages/tqdm/_tqdm_notebook.py

@@ -0,0 +1,9 @@
+from warnings import warn
+
+from .notebook import *  # NOQA
+from .notebook import __all__  # NOQA
+from .std import TqdmDeprecationWarning
+
+warn("This function will be removed in tqdm==5.0.0\n"
+     "Please use `tqdm.notebook.*` instead of `tqdm._tqdm_notebook.*`",
+     TqdmDeprecationWarning, stacklevel=2)

vllm/lib/python3.10/site-packages/tqdm/_tqdm_pandas.py

@@ -0,0 +1,24 @@
+import sys
+
+__author__ = "github.com/casperdcl"
+__all__ = ['tqdm_pandas']
+
+
+def tqdm_pandas(tclass, **tqdm_kwargs):
+    """
+    Registers the given `tqdm` instance with
+    `pandas.core.groupby.DataFrameGroupBy.progress_apply`.
+    """
+    from tqdm import TqdmDeprecationWarning
+
+    if isinstance(tclass, type) or (getattr(tclass, '__name__', '').startswith(
+            'tqdm_')):  # delayed adapter case
+        TqdmDeprecationWarning(
+            "Please use `tqdm.pandas(...)` instead of `tqdm_pandas(tqdm, ...)`.",
+            fp_write=getattr(tqdm_kwargs.get('file', None), 'write', sys.stderr.write))
+        tclass.pandas(**tqdm_kwargs)
+    else:
+        TqdmDeprecationWarning(
+            "Please use `tqdm.pandas(...)` instead of `tqdm_pandas(tqdm(...))`.",
+            fp_write=getattr(tclass.fp, 'write', sys.stderr.write))
+        type(tclass).pandas(deprecated_t=tclass)

vllm/lib/python3.10/site-packages/tqdm/_utils.py

@@ -0,0 +1,11 @@
+from warnings import warn
+
+from .std import TqdmDeprecationWarning
+from .utils import (  # NOQA, pylint: disable=unused-import
+    CUR_OS, IS_NIX, IS_WIN, RE_ANSI, Comparable, FormatReplace, SimpleTextIOWrapper,
+    _environ_cols_wrapper, _is_ascii, _is_utf, _screen_shape_linux, _screen_shape_tput,
+    _screen_shape_windows, _screen_shape_wrapper, _supports_unicode, _term_move_up, colorama)
+
+warn("This function will be removed in tqdm==5.0.0\n"
+     "Please use `tqdm.utils.*` instead of `tqdm._utils.*`",
+     TqdmDeprecationWarning, stacklevel=2)

vllm/lib/python3.10/site-packages/tqdm/asyncio.py

@@ -0,0 +1,93 @@
+"""
+Asynchronous progressbar decorator for iterators.
+Includes a default `range` iterator printing to `stderr`.
+
+Usage:
+>>> from tqdm.asyncio import trange, tqdm
+>>> async for i in trange(10):
+...     ...
+"""
+import asyncio
+from sys import version_info
+
+from .std import tqdm as std_tqdm
+
+__author__ = {"github.com/": ["casperdcl"]}
+__all__ = ['tqdm_asyncio', 'tarange', 'tqdm', 'trange']
+
+
+class tqdm_asyncio(std_tqdm):
+    """
+    Asynchronous-friendly version of tqdm.
+    """
+    def __init__(self, iterable=None, *args, **kwargs):
+        super().__init__(iterable, *args, **kwargs)
+        self.iterable_awaitable = False
+        if iterable is not None:
+            if hasattr(iterable, "__anext__"):
+                self.iterable_next = iterable.__anext__
+                self.iterable_awaitable = True
+            elif hasattr(iterable, "__next__"):
+                self.iterable_next = iterable.__next__
+            else:
+                self.iterable_iterator = iter(iterable)
+                self.iterable_next = self.iterable_iterator.__next__
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        try:
+            if self.iterable_awaitable:
+                res = await self.iterable_next()
+            else:
+                res = self.iterable_next()
+            self.update()
+            return res
+        except StopIteration:
+            self.close()
+            raise StopAsyncIteration
+        except BaseException:
+            self.close()
+            raise
+
+    def send(self, *args, **kwargs):
+        return self.iterable.send(*args, **kwargs)
+
+    @classmethod
+    def as_completed(cls, fs, *, loop=None, timeout=None, total=None, **tqdm_kwargs):
+        """
+        Wrapper for `asyncio.as_completed`.
+        """
+        if total is None:
+            total = len(fs)
+        kwargs = {}
+        if version_info[:2] < (3, 10):
+            kwargs['loop'] = loop
+        yield from cls(asyncio.as_completed(fs, timeout=timeout, **kwargs),
+                       total=total, **tqdm_kwargs)
+
+    @classmethod
+    async def gather(cls, *fs, loop=None, timeout=None, total=None, **tqdm_kwargs):
+        """
+        Wrapper for `asyncio.gather`.
+        """
+        async def wrap_awaitable(i, f):
+            return i, await f
+
+        ifs = [wrap_awaitable(i, f) for i, f in enumerate(fs)]
+        res = [await f for f in cls.as_completed(ifs, loop=loop, timeout=timeout,
+                                                 total=total, **tqdm_kwargs)]
+        return [i for _, i in sorted(res)]
+
+
+def tarange(*args, **kwargs):
+    """
+    A shortcut for `tqdm.asyncio.tqdm(range(*args), **kwargs)`.
+    """
+    return tqdm_asyncio(range(*args), **kwargs)
+
+
+# Aliases
+tqdm = tqdm_asyncio
+trange = tarange

vllm/lib/python3.10/site-packages/tqdm/auto.py

@@ -0,0 +1,40 @@
+"""
+Enables multiple commonly used features.
+
+Method resolution order:
+
+- `tqdm.autonotebook` without import warnings
+- `tqdm.asyncio`
+- `tqdm.std` base class
+
+Usage:
+>>> from tqdm.auto import trange, tqdm
+>>> for i in trange(10):
+...     ...
+"""
+import warnings
+
+from .std import TqdmExperimentalWarning
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", category=TqdmExperimentalWarning)
+    from .autonotebook import tqdm as notebook_tqdm
+
+from .asyncio import tqdm as asyncio_tqdm
+from .std import tqdm as std_tqdm
+
+if notebook_tqdm != std_tqdm:
+    class tqdm(notebook_tqdm, asyncio_tqdm):  # pylint: disable=inconsistent-mro
+        pass
+else:
+    tqdm = asyncio_tqdm
+
+
+def trange(*args, **kwargs):
+    """
+    A shortcut for `tqdm.auto.tqdm(range(*args), **kwargs)`.
+    """
+    return tqdm(range(*args), **kwargs)
+
+
+__all__ = ["tqdm", "trange"]

vllm/lib/python3.10/site-packages/tqdm/autonotebook.py

@@ -0,0 +1,29 @@
+"""
+Automatically choose between `tqdm.notebook` and `tqdm.std`.
+
+Usage:
+>>> from tqdm.autonotebook import trange, tqdm
+>>> for i in trange(10):
+...     ...
+"""
+import sys
+from warnings import warn
+
+try:
+    get_ipython = sys.modules['IPython'].get_ipython
+    if 'IPKernelApp' not in get_ipython().config:  # pragma: no cover
+        raise ImportError("console")
+    from .notebook import WARN_NOIPYW, IProgress
+    if IProgress is None:
+        from .std import TqdmWarning
+        warn(WARN_NOIPYW, TqdmWarning, stacklevel=2)
+        raise ImportError('ipywidgets')
+except Exception:
+    from .std import tqdm, trange
+else:  # pragma: no cover
+    from .notebook import tqdm, trange
+    from .std import TqdmExperimentalWarning
+    warn("Using `tqdm.autonotebook.tqdm` in notebook mode."
+         " Use `tqdm.tqdm` instead to force console mode"
+         " (e.g. in jupyter console)", TqdmExperimentalWarning, stacklevel=2)
+__all__ = ["tqdm", "trange"]

vllm/lib/python3.10/site-packages/tqdm/contrib/__init__.py

@@ -0,0 +1,92 @@
+"""
+Thin wrappers around common functions.
+
+Subpackages contain potentially unstable extensions.
+"""
+from warnings import warn
+
+from ..auto import tqdm as tqdm_auto
+from ..std import TqdmDeprecationWarning, tqdm
+from ..utils import ObjectWrapper
+
+__author__ = {"github.com/": ["casperdcl"]}
+__all__ = ['tenumerate', 'tzip', 'tmap']
+
+
+class DummyTqdmFile(ObjectWrapper):
+    """Dummy file-like that will write to tqdm"""
+
+    def __init__(self, wrapped):
+        super().__init__(wrapped)
+        self._buf = []
+
+    def write(self, x, nolock=False):
+        nl = b"\n" if isinstance(x, bytes) else "\n"
+        pre, sep, post = x.rpartition(nl)
+        if sep:
+            blank = type(nl)()
+            tqdm.write(blank.join(self._buf + [pre, sep]),
+                       end=blank, file=self._wrapped, nolock=nolock)
+            self._buf = [post]
+        else:
+            self._buf.append(x)
+
+    def __del__(self):
+        if self._buf:
+            blank = type(self._buf[0])()
+            try:
+                tqdm.write(blank.join(self._buf), end=blank, file=self._wrapped)
+            except (OSError, ValueError):
+                pass
+
+
+def builtin_iterable(func):
+    """Returns `func`"""
+    warn("This function has no effect, and will be removed in tqdm==5.0.0",
+         TqdmDeprecationWarning, stacklevel=2)
+    return func
+
+
+def tenumerate(iterable, start=0, total=None, tqdm_class=tqdm_auto, **tqdm_kwargs):
+    """
+    Equivalent of `numpy.ndenumerate` or builtin `enumerate`.
+
+    Parameters
+    ----------
+    tqdm_class  : [default: tqdm.auto.tqdm].
+    """
+    try:
+        import numpy as np
+    except ImportError:
+        pass
+    else:
+        if isinstance(iterable, np.ndarray):
+            return tqdm_class(np.ndenumerate(iterable), total=total or iterable.size,
+                              **tqdm_kwargs)
+    return enumerate(tqdm_class(iterable, total=total, **tqdm_kwargs), start)
+
+
+def tzip(iter1, *iter2plus, **tqdm_kwargs):
+    """
+    Equivalent of builtin `zip`.
+
+    Parameters
+    ----------
+    tqdm_class  : [default: tqdm.auto.tqdm].
+    """
+    kwargs = tqdm_kwargs.copy()
+    tqdm_class = kwargs.pop("tqdm_class", tqdm_auto)
+    for i in zip(tqdm_class(iter1, **kwargs), *iter2plus):
+        yield i
+
+
+def tmap(function, *sequences, **tqdm_kwargs):
+    """
+    Equivalent of builtin `map`.
+
+    Parameters
+    ----------
+    tqdm_class  : [default: tqdm.auto.tqdm].
+    """
+    for i in tzip(*sequences, **tqdm_kwargs):
+        yield function(*i)

vllm/lib/python3.10/site-packages/tqdm/contrib/bells.py

@@ -0,0 +1,26 @@
+"""
+Even more features than `tqdm.auto` (all the bells & whistles):
+
+- `tqdm.auto`
+- `tqdm.tqdm.pandas`
+- `tqdm.contrib.telegram`
+    + uses `${TQDM_TELEGRAM_TOKEN}` and `${TQDM_TELEGRAM_CHAT_ID}`
+- `tqdm.contrib.discord`
+    + uses `${TQDM_DISCORD_TOKEN}` and `${TQDM_DISCORD_CHANNEL_ID}`
+"""
+__all__ = ['tqdm', 'trange']
+import warnings
+from os import getenv
+
+if getenv("TQDM_SLACK_TOKEN") and getenv("TQDM_SLACK_CHANNEL"):
+    from .slack import tqdm, trange
+elif getenv("TQDM_TELEGRAM_TOKEN") and getenv("TQDM_TELEGRAM_CHAT_ID"):
+    from .telegram import tqdm, trange
+elif getenv("TQDM_DISCORD_TOKEN") and getenv("TQDM_DISCORD_CHANNEL_ID"):
+    from .discord import tqdm, trange
+else:
+    from ..auto import tqdm, trange
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", category=FutureWarning)
+    tqdm.pandas()

vllm/lib/python3.10/site-packages/tqdm/contrib/concurrent.py

@@ -0,0 +1,105 @@
+"""
+Thin wrappers around `concurrent.futures`.
+"""
+from contextlib import contextmanager
+from operator import length_hint
+from os import cpu_count
+
+from ..auto import tqdm as tqdm_auto
+from ..std import TqdmWarning
+
+__author__ = {"github.com/": ["casperdcl"]}
+__all__ = ['thread_map', 'process_map']
+
+
+@contextmanager
+def ensure_lock(tqdm_class, lock_name=""):
+    """get (create if necessary) and then restore `tqdm_class`'s lock"""
+    old_lock = getattr(tqdm_class, '_lock', None)  # don't create a new lock
+    lock = old_lock or tqdm_class.get_lock()  # maybe create a new lock
+    lock = getattr(lock, lock_name, lock)  # maybe subtype
+    tqdm_class.set_lock(lock)
+    yield lock
+    if old_lock is None:
+        del tqdm_class._lock
+    else:
+        tqdm_class.set_lock(old_lock)
+
+
+def _executor_map(PoolExecutor, fn, *iterables, **tqdm_kwargs):
+    """
+    Implementation of `thread_map` and `process_map`.
+
+    Parameters
+    ----------
+    tqdm_class  : [default: tqdm.auto.tqdm].
+    max_workers  : [default: min(32, cpu_count() + 4)].
+    chunksize  : [default: 1].
+    lock_name  : [default: "":str].
+    """
+    kwargs = tqdm_kwargs.copy()
+    if "total" not in kwargs:
+        kwargs["total"] = length_hint(iterables[0])
+    tqdm_class = kwargs.pop("tqdm_class", tqdm_auto)
+    max_workers = kwargs.pop("max_workers", min(32, cpu_count() + 4))
+    chunksize = kwargs.pop("chunksize", 1)
+    lock_name = kwargs.pop("lock_name", "")
+    with ensure_lock(tqdm_class, lock_name=lock_name) as lk:
+        # share lock in case workers are already using `tqdm`
+        with PoolExecutor(max_workers=max_workers, initializer=tqdm_class.set_lock,
+                          initargs=(lk,)) as ex:
+            return list(tqdm_class(ex.map(fn, *iterables, chunksize=chunksize), **kwargs))
+
+
+def thread_map(fn, *iterables, **tqdm_kwargs):
+    """
+    Equivalent of `list(map(fn, *iterables))`
+    driven by `concurrent.futures.ThreadPoolExecutor`.
+
+    Parameters
+    ----------
+    tqdm_class  : optional
+        `tqdm` class to use for bars [default: tqdm.auto.tqdm].
+    max_workers  : int, optional
+        Maximum number of workers to spawn; passed to
+        `concurrent.futures.ThreadPoolExecutor.__init__`.
+        [default: max(32, cpu_count() + 4)].
+    """
+    from concurrent.futures import ThreadPoolExecutor
+    return _executor_map(ThreadPoolExecutor, fn, *iterables, **tqdm_kwargs)
+
+
+def process_map(fn, *iterables, **tqdm_kwargs):
+    """
+    Equivalent of `list(map(fn, *iterables))`
+    driven by `concurrent.futures.ProcessPoolExecutor`.
+
+    Parameters
+    ----------
+    tqdm_class  : optional
+        `tqdm` class to use for bars [default: tqdm.auto.tqdm].
+    max_workers  : int, optional
+        Maximum number of workers to spawn; passed to
+        `concurrent.futures.ProcessPoolExecutor.__init__`.
+        [default: min(32, cpu_count() + 4)].
+    chunksize  : int, optional
+        Size of chunks sent to worker processes; passed to
+        `concurrent.futures.ProcessPoolExecutor.map`. [default: 1].
+    lock_name  : str, optional
+        Member of `tqdm_class.get_lock()` to use [default: mp_lock].
+    """
+    from concurrent.futures import ProcessPoolExecutor
+    if iterables and "chunksize" not in tqdm_kwargs:
+        # default `chunksize=1` has poor performance for large iterables
+        # (most time spent dispatching items to workers).
+        longest_iterable_len = max(map(length_hint, iterables))
+        if longest_iterable_len > 1000:
+            from warnings import warn
+            warn("Iterable length %d > 1000 but `chunksize` is not set."
+                 " This may seriously degrade multiprocess performance."
+                 " Set `chunksize=1` or more." % longest_iterable_len,
+                 TqdmWarning, stacklevel=2)
+    if "lock_name" not in tqdm_kwargs:
+        tqdm_kwargs = tqdm_kwargs.copy()
+        tqdm_kwargs["lock_name"] = "mp_lock"
+    return _executor_map(ProcessPoolExecutor, fn, *iterables, **tqdm_kwargs)

vllm/lib/python3.10/site-packages/tqdm/contrib/discord.py

@@ -0,0 +1,156 @@
+"""
+Sends updates to a Discord bot.
+
+Usage:
+>>> from tqdm.contrib.discord import tqdm, trange
+>>> for i in trange(10, token='{token}', channel_id='{channel_id}'):
+...     ...
+
+![screenshot](https://tqdm.github.io/img/screenshot-discord.png)
+"""
+from os import getenv
+from warnings import warn
+
+from requests import Session
+from requests.utils import default_user_agent
+
+from ..auto import tqdm as tqdm_auto
+from ..std import TqdmWarning
+from ..version import __version__
+from .utils_worker import MonoWorker
+
+__author__ = {"github.com/": ["casperdcl", "guigoruiz1"]}
+__all__ = ['DiscordIO', 'tqdm_discord', 'tdrange', 'tqdm', 'trange']
+
+
+class DiscordIO(MonoWorker):
+    """Non-blocking file-like IO using a Discord Bot."""
+    API = "https://discord.com/api/v10"
+    UA = f"tqdm (https://tqdm.github.io, {__version__}) {default_user_agent()}"
+
+    def __init__(self, token, channel_id):
+        """Creates a new message in the given `channel_id`."""
+        super().__init__()
+        self.token = token
+        self.channel_id = channel_id
+        self.session = Session()
+        self.text = self.__class__.__name__
+        self.message_id
+
+    @property
+    def message_id(self):
+        if hasattr(self, '_message_id'):
+            return self._message_id
+        try:
+            res = self.session.post(
+                f'{self.API}/channels/{self.channel_id}/messages',
+                headers={'Authorization': f'Bot {self.token}', 'User-Agent': self.UA},
+                json={'content': f"`{self.text}`"}).json()
+        except Exception as e:
+            tqdm_auto.write(str(e))
+        else:
+            if res.get('error_code') == 429:
+                warn("Creation rate limit: try increasing `mininterval`.",
+                     TqdmWarning, stacklevel=2)
+            else:
+                self._message_id = res['id']
+                return self._message_id
+
+    def write(self, s):
+        """Replaces internal `message_id`'s text with `s`."""
+        if not s:
+            s = "..."
+        s = s.replace('\r', '').strip()
+        if s == self.text:
+            return  # avoid duplicate message Bot error
+        message_id = self.message_id
+        if message_id is None:
+            return
+        self.text = s
+        try:
+            future = self.submit(
+                self.session.patch,
+                f'{self.API}/channels/{self.channel_id}/messages/{message_id}',
+                headers={'Authorization': f'Bot {self.token}', 'User-Agent': self.UA},
+                json={'content': f"`{self.text}`"})
+        except Exception as e:
+            tqdm_auto.write(str(e))
+        else:
+            return future
+
+    def delete(self):
+        """Deletes internal `message_id`."""
+        try:
+            future = self.submit(
+                self.session.delete,
+                f'{self.API}/channels/{self.channel_id}/messages/{self.message_id}',
+                headers={'Authorization': f'Bot {self.token}', 'User-Agent': self.UA})
+        except Exception as e:
+            tqdm_auto.write(str(e))
+        else:
+            return future
+
+
+class tqdm_discord(tqdm_auto):
+    """
+    Standard `tqdm.auto.tqdm` but also sends updates to a Discord Bot.
+    May take a few seconds to create (`__init__`).
+
+    - create a discord bot (not public, no requirement of OAuth2 code
+      grant, only send message permissions) & invite it to a channel:
+      <https://discordpy.readthedocs.io/en/latest/discord.html>
+    - copy the bot `{token}` & `{channel_id}` and paste below
+
+    >>> from tqdm.contrib.discord import tqdm, trange
+    >>> for i in tqdm(iterable, token='{token}', channel_id='{channel_id}'):
+    ...     ...
+    """
+    def __init__(self, *args, **kwargs):
+        """
+        Parameters
+        ----------
+        token  : str, required. Discord bot token
+            [default: ${TQDM_DISCORD_TOKEN}].
+        channel_id  : int, required. Discord channel ID
+            [default: ${TQDM_DISCORD_CHANNEL_ID}].
+
+        See `tqdm.auto.tqdm.__init__` for other parameters.
+        """
+        if not kwargs.get('disable'):
+            kwargs = kwargs.copy()
+            self.dio = DiscordIO(
+                kwargs.pop('token', getenv('TQDM_DISCORD_TOKEN')),
+                kwargs.pop('channel_id', getenv('TQDM_DISCORD_CHANNEL_ID')))
+        super().__init__(*args, **kwargs)
+
+    def display(self, **kwargs):
+        super().display(**kwargs)
+        fmt = self.format_dict
+        if fmt.get('bar_format', None):
+            fmt['bar_format'] = fmt['bar_format'].replace(
+                '<bar/>', '{bar:10u}').replace('{bar}', '{bar:10u}')
+        else:
+            fmt['bar_format'] = '{l_bar}{bar:10u}{r_bar}'
+        self.dio.write(self.format_meter(**fmt))
+
+    def clear(self, *args, **kwargs):
+        super().clear(*args, **kwargs)
+        if not self.disable:
+            self.dio.write("")
+
+    def close(self):
+        if self.disable:
+            return
+        super().close()
+        if not (self.leave or (self.leave is None and self.pos == 0)):
+            self.dio.delete()
+
+
+def tdrange(*args, **kwargs):
+    """Shortcut for `tqdm.contrib.discord.tqdm(range(*args), **kwargs)`."""
+    return tqdm_discord(range(*args), **kwargs)
+
+
+# Aliases
+tqdm = tqdm_discord
+trange = tdrange

vllm/lib/python3.10/site-packages/tqdm/contrib/itertools.py

@@ -0,0 +1,35 @@
+"""
+Thin wrappers around `itertools`.
+"""
+import itertools
+
+from ..auto import tqdm as tqdm_auto
+
+__author__ = {"github.com/": ["casperdcl"]}
+__all__ = ['product']
+
+
+def product(*iterables, **tqdm_kwargs):
+    """
+    Equivalent of `itertools.product`.
+
+    Parameters
+    ----------
+    tqdm_class  : [default: tqdm.auto.tqdm].
+    """
+    kwargs = tqdm_kwargs.copy()
+    tqdm_class = kwargs.pop("tqdm_class", tqdm_auto)
+    try:
+        lens = list(map(len, iterables))
+    except TypeError:
+        total = None
+    else:
+        total = 1
+        for i in lens:
+            total *= i
+        kwargs.setdefault("total", total)
+    with tqdm_class(**kwargs) as t:
+        it = itertools.product(*iterables)
+        for i in it:
+            yield i
+            t.update()

vllm/lib/python3.10/site-packages/tqdm/contrib/slack.py

@@ -0,0 +1,120 @@
+"""
+Sends updates to a Slack app.
+
+Usage:
+>>> from tqdm.contrib.slack import tqdm, trange
+>>> for i in trange(10, token='{token}', channel='{channel}'):
+...     ...
+
+![screenshot](https://tqdm.github.io/img/screenshot-slack.png)
+"""
+import logging
+from os import getenv
+
+try:
+    from slack_sdk import WebClient
+except ImportError:
+    raise ImportError("Please `pip install slack-sdk`")
+
+from ..auto import tqdm as tqdm_auto
+from .utils_worker import MonoWorker
+
+__author__ = {"github.com/": ["0x2b3bfa0", "casperdcl"]}
+__all__ = ['SlackIO', 'tqdm_slack', 'tsrange', 'tqdm', 'trange']
+
+
+class SlackIO(MonoWorker):
+    """Non-blocking file-like IO using a Slack app."""
+    def __init__(self, token, channel):
+        """Creates a new message in the given `channel`."""
+        super().__init__()
+        self.client = WebClient(token=token)
+        self.text = self.__class__.__name__
+        try:
+            self.message = self.client.chat_postMessage(channel=channel, text=self.text)
+        except Exception as e:
+            tqdm_auto.write(str(e))
+            self.message = None
+
+    def write(self, s):
+        """Replaces internal `message`'s text with `s`."""
+        if not s:
+            s = "..."
+        s = s.replace('\r', '').strip()
+        if s == self.text:
+            return  # skip duplicate message
+        message = self.message
+        if message is None:
+            return
+        self.text = s
+        try:
+            future = self.submit(self.client.chat_update, channel=message['channel'],
+                                 ts=message['ts'], text='`' + s + '`')
+        except Exception as e:
+            tqdm_auto.write(str(e))
+        else:
+            return future
+
+
+class tqdm_slack(tqdm_auto):
+    """
+    Standard `tqdm.auto.tqdm` but also sends updates to a Slack app.
+    May take a few seconds to create (`__init__`).
+
+    - create a Slack app with the `chat:write` scope & invite it to a
+      channel: <https://api.slack.com/authentication/basics>
+    - copy the bot `{token}` & `{channel}` and paste below
+    >>> from tqdm.contrib.slack import tqdm, trange
+    >>> for i in tqdm(iterable, token='{token}', channel='{channel}'):
+    ...     ...
+    """
+    def __init__(self, *args, **kwargs):
+        """
+        Parameters
+        ----------
+        token  : str, required. Slack token
+            [default: ${TQDM_SLACK_TOKEN}].
+        channel  : int, required. Slack channel
+            [default: ${TQDM_SLACK_CHANNEL}].
+        mininterval  : float, optional.
+          Minimum of [default: 1.5] to avoid rate limit.
+
+        See `tqdm.auto.tqdm.__init__` for other parameters.
+        """
+        if not kwargs.get('disable'):
+            kwargs = kwargs.copy()
+            logging.getLogger("HTTPClient").setLevel(logging.WARNING)
+            self.sio = SlackIO(
+                kwargs.pop('token', getenv("TQDM_SLACK_TOKEN")),
+                kwargs.pop('channel', getenv("TQDM_SLACK_CHANNEL")))
+            kwargs['mininterval'] = max(1.5, kwargs.get('mininterval', 1.5))
+        super().__init__(*args, **kwargs)
+
+    def display(self, **kwargs):
+        super().display(**kwargs)
+        fmt = self.format_dict
+        if fmt.get('bar_format', None):
+            fmt['bar_format'] = fmt['bar_format'].replace(
+                '<bar/>', '`{bar:10}`').replace('{bar}', '`{bar:10u}`')
+        else:
+            fmt['bar_format'] = '{l_bar}`{bar:10}`{r_bar}'
+        if fmt['ascii'] is False:
+            fmt['ascii'] = [":black_square:", ":small_blue_diamond:", ":large_blue_diamond:",
+                            ":large_blue_square:"]
+            fmt['ncols'] = 336
+        self.sio.write(self.format_meter(**fmt))
+
+    def clear(self, *args, **kwargs):
+        super().clear(*args, **kwargs)
+        if not self.disable:
+            self.sio.write("")
+
+
+def tsrange(*args, **kwargs):
+    """Shortcut for `tqdm.contrib.slack.tqdm(range(*args), **kwargs)`."""
+    return tqdm_slack(range(*args), **kwargs)
+
+
+# Aliases
+tqdm = tqdm_slack
+trange = tsrange

vllm/lib/python3.10/site-packages/tqdm/contrib/telegram.py

@@ -0,0 +1,153 @@
+"""
+Sends updates to a Telegram bot.
+
+Usage:
+>>> from tqdm.contrib.telegram import tqdm, trange
+>>> for i in trange(10, token='{token}', chat_id='{chat_id}'):
+...     ...
+
+![screenshot](https://tqdm.github.io/img/screenshot-telegram.gif)
+"""
+from os import getenv
+from warnings import warn
+
+from requests import Session
+
+from ..auto import tqdm as tqdm_auto
+from ..std import TqdmWarning
+from .utils_worker import MonoWorker
+
+__author__ = {"github.com/": ["casperdcl"]}
+__all__ = ['TelegramIO', 'tqdm_telegram', 'ttgrange', 'tqdm', 'trange']
+
+
+class TelegramIO(MonoWorker):
+    """Non-blocking file-like IO using a Telegram Bot."""
+    API = 'https://api.telegram.org/bot'
+
+    def __init__(self, token, chat_id):
+        """Creates a new message in the given `chat_id`."""
+        super().__init__()
+        self.token = token
+        self.chat_id = chat_id
+        self.session = Session()
+        self.text = self.__class__.__name__
+        self.message_id
+
+    @property
+    def message_id(self):
+        if hasattr(self, '_message_id'):
+            return self._message_id
+        try:
+            res = self.session.post(
+                self.API + '%s/sendMessage' % self.token,
+                data={'text': '`' + self.text + '`', 'chat_id': self.chat_id,
+                      'parse_mode': 'MarkdownV2'}).json()
+        except Exception as e:
+            tqdm_auto.write(str(e))
+        else:
+            if res.get('error_code') == 429:
+                warn("Creation rate limit: try increasing `mininterval`.",
+                     TqdmWarning, stacklevel=2)
+            else:
+                self._message_id = res['result']['message_id']
+                return self._message_id
+
+    def write(self, s):
+        """Replaces internal `message_id`'s text with `s`."""
+        if not s:
+            s = "..."
+        s = s.replace('\r', '').strip()
+        if s == self.text:
+            return  # avoid duplicate message Bot error
+        message_id = self.message_id
+        if message_id is None:
+            return
+        self.text = s
+        try:
+            future = self.submit(
+                self.session.post, self.API + '%s/editMessageText' % self.token,
+                data={'text': '`' + s + '`', 'chat_id': self.chat_id,
+                      'message_id': message_id, 'parse_mode': 'MarkdownV2'})
+        except Exception as e:
+            tqdm_auto.write(str(e))
+        else:
+            return future
+
+    def delete(self):
+        """Deletes internal `message_id`."""
+        try:
+            future = self.submit(
+                self.session.post, self.API + '%s/deleteMessage' % self.token,
+                data={'chat_id': self.chat_id, 'message_id': self.message_id})
+        except Exception as e:
+            tqdm_auto.write(str(e))
+        else:
+            return future
+
+
+class tqdm_telegram(tqdm_auto):
+    """
+    Standard `tqdm.auto.tqdm` but also sends updates to a Telegram Bot.
+    May take a few seconds to create (`__init__`).
+
+    - create a bot <https://core.telegram.org/bots#6-botfather>
+    - copy its `{token}`
+    - add the bot to a chat and send it a message such as `/start`
+    - go to <https://api.telegram.org/bot`{token}`/getUpdates> to find out
+      the `{chat_id}`
+    - paste the `{token}` & `{chat_id}` below
+
+    >>> from tqdm.contrib.telegram import tqdm, trange
+    >>> for i in tqdm(iterable, token='{token}', chat_id='{chat_id}'):
+    ...     ...
+    """
+    def __init__(self, *args, **kwargs):
+        """
+        Parameters
+        ----------
+        token  : str, required. Telegram token
+            [default: ${TQDM_TELEGRAM_TOKEN}].
+        chat_id  : str, required. Telegram chat ID
+            [default: ${TQDM_TELEGRAM_CHAT_ID}].
+
+        See `tqdm.auto.tqdm.__init__` for other parameters.
+        """
+        if not kwargs.get('disable'):
+            kwargs = kwargs.copy()
+            self.tgio = TelegramIO(
+                kwargs.pop('token', getenv('TQDM_TELEGRAM_TOKEN')),
+                kwargs.pop('chat_id', getenv('TQDM_TELEGRAM_CHAT_ID')))
+        super().__init__(*args, **kwargs)
+
+    def display(self, **kwargs):
+        super().display(**kwargs)
+        fmt = self.format_dict
+        if fmt.get('bar_format', None):
+            fmt['bar_format'] = fmt['bar_format'].replace(
+                '<bar/>', '{bar:10u}').replace('{bar}', '{bar:10u}')
+        else:
+            fmt['bar_format'] = '{l_bar}{bar:10u}{r_bar}'
+        self.tgio.write(self.format_meter(**fmt))
+
+    def clear(self, *args, **kwargs):
+        super().clear(*args, **kwargs)
+        if not self.disable:
+            self.tgio.write("")
+
+    def close(self):
+        if self.disable:
+            return
+        super().close()
+        if not (self.leave or (self.leave is None and self.pos == 0)):
+            self.tgio.delete()
+
+
+def ttgrange(*args, **kwargs):
+    """Shortcut for `tqdm.contrib.telegram.tqdm(range(*args), **kwargs)`."""
+    return tqdm_telegram(range(*args), **kwargs)
+
+
+# Aliases
+tqdm = tqdm_telegram
+trange = ttgrange

vllm/lib/python3.10/site-packages/tqdm/contrib/utils_worker.py

@@ -0,0 +1,38 @@
+"""
+IO/concurrency helpers for `tqdm.contrib`.
+"""
+from collections import deque
+from concurrent.futures import ThreadPoolExecutor
+
+from ..auto import tqdm as tqdm_auto
+
+__author__ = {"github.com/": ["casperdcl"]}
+__all__ = ['MonoWorker']
+
+
+class MonoWorker(object):
+    """
+    Supports one running task and one waiting task.
+    The waiting task is the most recent submitted (others are discarded).
+    """
+    def __init__(self):
+        self.pool = ThreadPoolExecutor(max_workers=1)
+        self.futures = deque([], 2)
+
+    def submit(self, func, *args, **kwargs):
+        """`func(*args, **kwargs)` may replace currently waiting task."""
+        futures = self.futures
+        if len(futures) == futures.maxlen:
+            running = futures.popleft()
+            if not running.done():
+                if len(futures):  # clear waiting
+                    waiting = futures.pop()
+                    waiting.cancel()
+                futures.appendleft(running)  # re-insert running
+        try:
+            waiting = self.pool.submit(func, *args, **kwargs)
+        except Exception as e:
+            tqdm_auto.write(str(e))
+        else:
+            futures.append(waiting)
+            return waiting

vllm/lib/python3.10/site-packages/tqdm/dask.py

@@ -0,0 +1,44 @@
+from functools import partial
+
+from dask.callbacks import Callback
+
+from .auto import tqdm as tqdm_auto
+
+__author__ = {"github.com/": ["casperdcl"]}
+__all__ = ['TqdmCallback']
+
+
+class TqdmCallback(Callback):
+    """Dask callback for task progress."""
+    def __init__(self, start=None, pretask=None, tqdm_class=tqdm_auto,
+                 **tqdm_kwargs):
+        """
+        Parameters
+        ----------
+        tqdm_class  : optional
+            `tqdm` class to use for bars [default: `tqdm.auto.tqdm`].
+        tqdm_kwargs  : optional
+            Any other arguments used for all bars.
+        """
+        super().__init__(start=start, pretask=pretask)
+        if tqdm_kwargs:
+            tqdm_class = partial(tqdm_class, **tqdm_kwargs)
+        self.tqdm_class = tqdm_class
+
+    def _start_state(self, _, state):
+        self.pbar = self.tqdm_class(total=sum(
+            len(state[k]) for k in ['ready', 'waiting', 'running', 'finished']))
+
+    def _posttask(self, *_, **__):
+        self.pbar.update()
+
+    def _finish(self, *_, **__):
+        self.pbar.close()
+
+    def display(self):
+        """Displays in the current cell in Notebooks."""
+        container = getattr(self.bar, 'container', None)
+        if container is None:
+            return
+        from .notebook import display
+        display(container)

vllm/lib/python3.10/site-packages/tqdm/notebook.py

@@ -0,0 +1,317 @@
+"""
+IPython/Jupyter Notebook progressbar decorator for iterators.
+Includes a default `range` iterator printing to `stderr`.
+
+Usage:
+>>> from tqdm.notebook import trange, tqdm
+>>> for i in trange(10):
+...     ...
+"""
+# import compatibility functions and utilities
+import re
+import sys
+from html import escape
+from weakref import proxy
+
+# to inherit from the tqdm class
+from .std import tqdm as std_tqdm
+
+if True:  # pragma: no cover
+    # import IPython/Jupyter base widget and display utilities
+    IPY = 0
+    try:  # IPython 4.x
+        import ipywidgets
+        IPY = 4
+    except ImportError:  # IPython 3.x / 2.x
+        IPY = 32
+        import warnings
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                'ignore', message=".*The `IPython.html` package has been deprecated.*")
+            try:
+                import IPython.html.widgets as ipywidgets  # NOQA: F401
+            except ImportError:
+                pass
+
+    try:  # IPython 4.x / 3.x
+        if IPY == 32:
+            from IPython.html.widgets import HTML
+            from IPython.html.widgets import FloatProgress as IProgress
+            from IPython.html.widgets import HBox
+            IPY = 3
+        else:
+            from ipywidgets import HTML
+            from ipywidgets import FloatProgress as IProgress
+            from ipywidgets import HBox
+    except ImportError:
+        try:  # IPython 2.x
+            from IPython.html.widgets import HTML
+            from IPython.html.widgets import ContainerWidget as HBox
+            from IPython.html.widgets import FloatProgressWidget as IProgress
+            IPY = 2
+        except ImportError:
+            IPY = 0
+            IProgress = None
+            HBox = object
+
+    try:
+        from IPython.display import display  # , clear_output
+    except ImportError:
+        pass
+
+__author__ = {"github.com/": ["lrq3000", "casperdcl", "alexanderkuk"]}
+__all__ = ['tqdm_notebook', 'tnrange', 'tqdm', 'trange']
+WARN_NOIPYW = ("IProgress not found. Please update jupyter and ipywidgets."
+               " See https://ipywidgets.readthedocs.io/en/stable"
+               "/user_install.html")
+
+
+class TqdmHBox(HBox):
+    """`ipywidgets.HBox` with a pretty representation"""
+    def _json_(self, pretty=None):
+        pbar = getattr(self, 'pbar', None)
+        if pbar is None:
+            return {}
+        d = pbar.format_dict
+        if pretty is not None:
+            d["ascii"] = not pretty
+        return d
+
+    def __repr__(self, pretty=False):
+        pbar = getattr(self, 'pbar', None)
+        if pbar is None:
+            return super().__repr__()
+        return pbar.format_meter(**self._json_(pretty))
+
+    def _repr_pretty_(self, pp, *_, **__):
+        pp.text(self.__repr__(True))
+
+
+class tqdm_notebook(std_tqdm):
+    """
+    Experimental IPython/Jupyter Notebook widget using tqdm!
+    """
+    @staticmethod
+    def status_printer(_, total=None, desc=None, ncols=None):
+        """
+        Manage the printing of an IPython/Jupyter Notebook progress bar widget.
+        """
+        # Fallback to text bar if there's no total
+        # DEPRECATED: replaced with an 'info' style bar
+        # if not total:
+        #    return super(tqdm_notebook, tqdm_notebook).status_printer(file)
+
+        # fp = file
+
+        # Prepare IPython progress bar
+        if IProgress is None:  # #187 #451 #558 #872
+            raise ImportError(WARN_NOIPYW)
+        if total:
+            pbar = IProgress(min=0, max=total)
+        else:  # No total? Show info style bar with no progress tqdm status
+            pbar = IProgress(min=0, max=1)
+            pbar.value = 1
+            pbar.bar_style = 'info'
+            if ncols is None:
+                pbar.layout.width = "20px"
+
+        ltext = HTML()
+        rtext = HTML()
+        if desc:
+            ltext.value = desc
+        container = TqdmHBox(children=[ltext, pbar, rtext])
+        # Prepare layout
+        if ncols is not None:  # use default style of ipywidgets
+            # ncols could be 100, "100px", "100%"
+            ncols = str(ncols)  # ipywidgets only accepts string
+            try:
+                if int(ncols) > 0:  # isnumeric and positive
+                    ncols += 'px'
+            except ValueError:
+                pass
+            pbar.layout.flex = '2'
+            container.layout.width = ncols
+            container.layout.display = 'inline-flex'
+            container.layout.flex_flow = 'row wrap'
+
+        return container
+
+    def display(self, msg=None, pos=None,
+                # additional signals
+                close=False, bar_style=None, check_delay=True):
+        # Note: contrary to native tqdm, msg='' does NOT clear bar
+        # goal is to keep all infos if error happens so user knows
+        # at which iteration the loop failed.
+
+        # Clear previous output (really necessary?)
+        # clear_output(wait=1)
+
+        if not msg and not close:
+            d = self.format_dict
+            # remove {bar}
+            d['bar_format'] = (d['bar_format'] or "{l_bar}<bar/>{r_bar}").replace(
+                "{bar}", "<bar/>")
+            msg = self.format_meter(**d)
+
+        ltext, pbar, rtext = self.container.children
+        pbar.value = self.n
+
+        if msg:
+            msg = msg.replace(' ', u'\u2007')  # fix html space padding
+            # html escape special characters (like '&')
+            if '<bar/>' in msg:
+                left, right = map(escape, re.split(r'\|?<bar/>\|?', msg, maxsplit=1))
+            else:
+                left, right = '', escape(msg)
+
+            # Update description
+            ltext.value = left
+            # never clear the bar (signal: msg='')
+            if right:
+                rtext.value = right
+
+        # Change bar style
+        if bar_style:
+            # Hack-ish way to avoid the danger bar_style being overridden by
+            # success because the bar gets closed after the error...
+            if pbar.bar_style != 'danger' or bar_style != 'success':
+                pbar.bar_style = bar_style
+
+        # Special signal to close the bar
+        if close and pbar.bar_style != 'danger':  # hide only if no error
+            try:
+                self.container.close()
+            except AttributeError:
+                self.container.visible = False
+            self.container.layout.visibility = 'hidden'  # IPYW>=8
+
+        if check_delay and self.delay > 0 and not self.displayed:
+            display(self.container)
+            self.displayed = True
+
+    @property
+    def colour(self):
+        if hasattr(self, 'container'):
+            return self.container.children[-2].style.bar_color
+
+    @colour.setter
+    def colour(self, bar_color):
+        if hasattr(self, 'container'):
+            self.container.children[-2].style.bar_color = bar_color
+
+    def __init__(self, *args, **kwargs):
+        """
+        Supports the usual `tqdm.tqdm` parameters as well as those listed below.
+
+        Parameters
+        ----------
+        display  : Whether to call `display(self.container)` immediately
+            [default: True].
+        """
+        kwargs = kwargs.copy()
+        # Setup default output
+        file_kwarg = kwargs.get('file', sys.stderr)
+        if file_kwarg is sys.stderr or file_kwarg is None:
+            kwargs['file'] = sys.stdout  # avoid the red block in IPython
+
+        # Initialize parent class + avoid printing by using gui=True
+        kwargs['gui'] = True
+        # convert disable = None to False
+        kwargs['disable'] = bool(kwargs.get('disable', False))
+        colour = kwargs.pop('colour', None)
+        display_here = kwargs.pop('display', True)
+        super().__init__(*args, **kwargs)
+        if self.disable or not kwargs['gui']:
+            self.disp = lambda *_, **__: None
+            return
+
+        # Get bar width
+        self.ncols = '100%' if self.dynamic_ncols else kwargs.get("ncols", None)
+
+        # Replace with IPython progress bar display (with correct total)
+        unit_scale = 1 if self.unit_scale is True else self.unit_scale or 1
+        total = self.total * unit_scale if self.total else self.total
+        self.container = self.status_printer(self.fp, total, self.desc, self.ncols)
+        self.container.pbar = proxy(self)
+        self.displayed = False
+        if display_here and self.delay <= 0:
+            display(self.container)
+            self.displayed = True
+        self.disp = self.display
+        self.colour = colour
+
+        # Print initial bar state
+        if not self.disable:
+            self.display(check_delay=False)
+
+    def __iter__(self):
+        try:
+            it = super().__iter__()
+            for obj in it:
+                # return super(tqdm...) will not catch exception
+                yield obj
+        # NB: except ... [ as ...] breaks IPython async KeyboardInterrupt
+        except:  # NOQA
+            self.disp(bar_style='danger')
+            raise
+        # NB: don't `finally: close()`
+        # since this could be a shared bar which the user will `reset()`
+
+    def update(self, n=1):
+        try:
+            return super().update(n=n)
+        # NB: except ... [ as ...] breaks IPython async KeyboardInterrupt
+        except:  # NOQA
+            # cannot catch KeyboardInterrupt when using manual tqdm
+            # as the interrupt will most likely happen on another statement
+            self.disp(bar_style='danger')
+            raise
+        # NB: don't `finally: close()`
+        # since this could be a shared bar which the user will `reset()`
+
+    def close(self):
+        if self.disable:
+            return
+        super().close()
+        # Try to detect if there was an error or KeyboardInterrupt
+        # in manual mode: if n < total, things probably got wrong
+        if self.total and self.n < self.total:
+            self.disp(bar_style='danger', check_delay=False)
+        else:
+            if self.leave:
+                self.disp(bar_style='success', check_delay=False)
+            else:
+                self.disp(close=True, check_delay=False)
+
+    def clear(self, *_, **__):
+        pass
+
+    def reset(self, total=None):
+        """
+        Resets to 0 iterations for repeated use.
+
+        Consider combining with `leave=True`.
+
+        Parameters
+        ----------
+        total  : int or float, optional. Total to use for the new bar.
+        """
+        if self.disable:
+            return super().reset(total=total)
+        _, pbar, _ = self.container.children
+        pbar.bar_style = ''
+        if total is not None:
+            pbar.max = total
+            if not self.total and self.ncols is None:  # no longer unknown total
+                pbar.layout.width = None  # reset width
+        return super().reset(total=total)
+
+
+def tnrange(*args, **kwargs):
+    """Shortcut for `tqdm.notebook.tqdm(range(*args), **kwargs)`."""
+    return tqdm_notebook(range(*args), **kwargs)
+
+
+# Aliases
+tqdm = tqdm_notebook
+trange = tnrange

vllm/lib/python3.10/site-packages/tqdm/rich.py

@@ -0,0 +1,151 @@
+"""
+`rich.progress` decorator for iterators.
+
+Usage:
+>>> from tqdm.rich import trange, tqdm
+>>> for i in trange(10):
+...     ...
+"""
+from warnings import warn
+
+from rich.progress import (
+    BarColumn, Progress, ProgressColumn, Text, TimeElapsedColumn, TimeRemainingColumn, filesize)
+
+from .std import TqdmExperimentalWarning
+from .std import tqdm as std_tqdm
+
+__author__ = {"github.com/": ["casperdcl"]}
+__all__ = ['tqdm_rich', 'trrange', 'tqdm', 'trange']
+
+
+class FractionColumn(ProgressColumn):
+    """Renders completed/total, e.g. '0.5/2.3 G'."""
+    def __init__(self, unit_scale=False, unit_divisor=1000):
+        self.unit_scale = unit_scale
+        self.unit_divisor = unit_divisor
+        super().__init__()
+
+    def render(self, task):
+        """Calculate common unit for completed and total."""
+        completed = int(task.completed)
+        total = int(task.total)
+        if self.unit_scale:
+            unit, suffix = filesize.pick_unit_and_suffix(
+                total,
+                ["", "K", "M", "G", "T", "P", "E", "Z", "Y"],
+                self.unit_divisor,
+            )
+        else:
+            unit, suffix = filesize.pick_unit_and_suffix(total, [""], 1)
+        precision = 0 if unit == 1 else 1
+        return Text(
+            f"{completed/unit:,.{precision}f}/{total/unit:,.{precision}f} {suffix}",
+            style="progress.download")
+
+
+class RateColumn(ProgressColumn):
+    """Renders human readable transfer speed."""
+    def __init__(self, unit="", unit_scale=False, unit_divisor=1000):
+        self.unit = unit
+        self.unit_scale = unit_scale
+        self.unit_divisor = unit_divisor
+        super().__init__()
+
+    def render(self, task):
+        """Show data transfer speed."""
+        speed = task.speed
+        if speed is None:
+            return Text(f"? {self.unit}/s", style="progress.data.speed")
+        if self.unit_scale:
+            unit, suffix = filesize.pick_unit_and_suffix(
+                speed,
+                ["", "K", "M", "G", "T", "P", "E", "Z", "Y"],
+                self.unit_divisor,
+            )
+        else:
+            unit, suffix = filesize.pick_unit_and_suffix(speed, [""], 1)
+        precision = 0 if unit == 1 else 1
+        return Text(f"{speed/unit:,.{precision}f} {suffix}{self.unit}/s",
+                    style="progress.data.speed")
+
+
+class tqdm_rich(std_tqdm):  # pragma: no cover
+    """Experimental rich.progress GUI version of tqdm!"""
+    # TODO: @classmethod: write()?
+    def __init__(self, *args, **kwargs):
+        """
+        This class accepts the following parameters *in addition* to
+        the parameters accepted by `tqdm`.
+
+        Parameters
+        ----------
+        progress  : tuple, optional
+            arguments for `rich.progress.Progress()`.
+        options  : dict, optional
+            keyword arguments for `rich.progress.Progress()`.
+        """
+        kwargs = kwargs.copy()
+        kwargs['gui'] = True
+        # convert disable = None to False
+        kwargs['disable'] = bool(kwargs.get('disable', False))
+        progress = kwargs.pop('progress', None)
+        options = kwargs.pop('options', {}).copy()
+        super().__init__(*args, **kwargs)
+
+        if self.disable:
+            return
+
+        warn("rich is experimental/alpha", TqdmExperimentalWarning, stacklevel=2)
+        d = self.format_dict
+        if progress is None:
+            progress = (
+                "[progress.description]{task.description}"
+                "[progress.percentage]{task.percentage:>4.0f}%",
+                BarColumn(bar_width=None),
+                FractionColumn(
+                    unit_scale=d['unit_scale'], unit_divisor=d['unit_divisor']),
+                "[", TimeElapsedColumn(), "<", TimeRemainingColumn(),
+                ",", RateColumn(unit=d['unit'], unit_scale=d['unit_scale'],
+                                unit_divisor=d['unit_divisor']), "]"
+            )
+        options.setdefault('transient', not self.leave)
+        self._prog = Progress(*progress, **options)
+        self._prog.__enter__()
+        self._task_id = self._prog.add_task(self.desc or "", **d)
+
+    def close(self):
+        if self.disable:
+            return
+        self.display()  # print 100%, vis #1306
+        super().close()
+        self._prog.__exit__(None, None, None)
+
+    def clear(self, *_, **__):
+        pass
+
+    def display(self, *_, **__):
+        if not hasattr(self, '_prog'):
+            return
+        self._prog.update(self._task_id, completed=self.n, description=self.desc)
+
+    def reset(self, total=None):
+        """
+        Resets to 0 iterations for repeated use.
+
+        Parameters
+        ----------
+        total  : int or float, optional. Total to use for the new bar.
+        """
+        if hasattr(self, '_prog'):
+            self._prog.reset(total=total)
+        super().reset(total=total)
+
+
+def trrange(*args, **kwargs):
+    """Shortcut for `tqdm.rich.tqdm(range(*args), **kwargs)`."""
+    return tqdm_rich(range(*args), **kwargs)
+
+
+# Aliases
+tqdm = tqdm_rich
+trange = trrange

vllm/lib/python3.10/site-packages/tqdm/std.py

@@ -0,0 +1,1524 @@
+"""
+Customisable progressbar decorator for iterators.
+Includes a default `range` iterator printing to `stderr`.
+
+Usage:
+>>> from tqdm import trange, tqdm
+>>> for i in trange(10):
+...     ...
+"""
+import sys
+from collections import OrderedDict, defaultdict
+from contextlib import contextmanager
+from datetime import datetime, timedelta, timezone
+from numbers import Number
+from time import time
+from warnings import warn
+from weakref import WeakSet
+
+from ._monitor import TMonitor
+from .utils import (
+    CallbackIOWrapper, Comparable, DisableOnWriteError, FormatReplace, SimpleTextIOWrapper,
+    _is_ascii, _screen_shape_wrapper, _supports_unicode, _term_move_up, disp_len, disp_trim,
+    envwrap)
+
+__author__ = "https://github.com/tqdm/tqdm#contributions"
+__all__ = ['tqdm', 'trange',
+           'TqdmTypeError', 'TqdmKeyError', 'TqdmWarning',
+           'TqdmExperimentalWarning', 'TqdmDeprecationWarning',
+           'TqdmMonitorWarning']
+
+
+class TqdmTypeError(TypeError):
+    pass
+
+
+class TqdmKeyError(KeyError):
+    pass
+
+
+class TqdmWarning(Warning):
+    """base class for all tqdm warnings.
+
+    Used for non-external-code-breaking errors, such as garbled printing.
+    """
+    def __init__(self, msg, fp_write=None, *a, **k):
+        if fp_write is not None:
+            fp_write("\n" + self.__class__.__name__ + ": " + str(msg).rstrip() + '\n')
+        else:
+            super().__init__(msg, *a, **k)
+
+
+class TqdmExperimentalWarning(TqdmWarning, FutureWarning):
+    """beta feature, unstable API and behaviour"""
+    pass
+
+
+class TqdmDeprecationWarning(TqdmWarning, DeprecationWarning):
+    # not suppressed if raised
+    pass
+
+
+class TqdmMonitorWarning(TqdmWarning, RuntimeWarning):
+    """tqdm monitor errors which do not affect external functionality"""
+    pass
+
+
+def TRLock(*args, **kwargs):
+    """threading RLock"""
+    try:
+        from threading import RLock
+        return RLock(*args, **kwargs)
+    except (ImportError, OSError):  # pragma: no cover
+        pass
+
+
+class TqdmDefaultWriteLock(object):
+    """
+    Provide a default write lock for thread and multiprocessing safety.
+    Works only on platforms supporting `fork` (so Windows is excluded).
+    You must initialise a `tqdm` or `TqdmDefaultWriteLock` instance
+    before forking in order for the write lock to work.
+    On Windows, you need to supply the lock from the parent to the children as
+    an argument to joblib or the parallelism lib you use.
+    """
+    # global thread lock so no setup required for multithreading.
+    # NB: Do not create multiprocessing lock as it sets the multiprocessing
+    # context, disallowing `spawn()`/`forkserver()`
+    th_lock = TRLock()
+
+    def __init__(self):
+        # Create global parallelism locks to avoid racing issues with parallel
+        # bars works only if fork available (Linux/MacOSX, but not Windows)
+        cls = type(self)
+        root_lock = cls.th_lock
+        if root_lock is not None:
+            root_lock.acquire()
+        cls.create_mp_lock()
+        self.locks = [lk for lk in [cls.mp_lock, cls.th_lock] if lk is not None]
+        if root_lock is not None:
+            root_lock.release()
+
+    def acquire(self, *a, **k):
+        for lock in self.locks:
+            lock.acquire(*a, **k)
+
+    def release(self):
+        for lock in self.locks[::-1]:  # Release in inverse order of acquisition
+            lock.release()
+
+    def __enter__(self):
+        self.acquire()
+
+    def __exit__(self, *exc):
+        self.release()
+
+    @classmethod
+    def create_mp_lock(cls):
+        if not hasattr(cls, 'mp_lock'):
+            try:
+                from multiprocessing import RLock
+                cls.mp_lock = RLock()
+            except (ImportError, OSError):  # pragma: no cover
+                cls.mp_lock = None
+
+    @classmethod
+    def create_th_lock(cls):
+        assert hasattr(cls, 'th_lock')
+        warn("create_th_lock not needed anymore", TqdmDeprecationWarning, stacklevel=2)
+
+
+class Bar(object):
+    """
+    `str.format`-able bar with format specifiers: `[width][type]`
+
+    - `width`
+      + unspecified (default): use `self.default_len`
+      + `int >= 0`: overrides `self.default_len`
+      + `int < 0`: subtract from `self.default_len`
+    - `type`
+      + `a`: ascii (`charset=self.ASCII` override)
+      + `u`: unicode (`charset=self.UTF` override)
+      + `b`: blank (`charset="  "` override)
+    """
+    ASCII = " 123456789#"
+    UTF = u" " + u''.join(map(chr, range(0x258F, 0x2587, -1)))
+    BLANK = "  "
+    COLOUR_RESET = '\x1b[0m'
+    COLOUR_RGB = '\x1b[38;2;%d;%d;%dm'
+    COLOURS = {'BLACK': '\x1b[30m', 'RED': '\x1b[31m', 'GREEN': '\x1b[32m',
+               'YELLOW': '\x1b[33m', 'BLUE': '\x1b[34m', 'MAGENTA': '\x1b[35m',
+               'CYAN': '\x1b[36m', 'WHITE': '\x1b[37m'}
+
+    def __init__(self, frac, default_len=10, charset=UTF, colour=None):
+        if not 0 <= frac <= 1:
+            warn("clamping frac to range [0, 1]", TqdmWarning, stacklevel=2)
+            frac = max(0, min(1, frac))
+        assert default_len > 0
+        self.frac = frac
+        self.default_len = default_len
+        self.charset = charset
+        self.colour = colour
+
+    @property
+    def colour(self):
+        return self._colour
+
+    @colour.setter
+    def colour(self, value):
+        if not value:
+            self._colour = None
+            return
+        try:
+            if value.upper() in self.COLOURS:
+                self._colour = self.COLOURS[value.upper()]
+            elif value[0] == '#' and len(value) == 7:
+                self._colour = self.COLOUR_RGB % tuple(
+                    int(i, 16) for i in (value[1:3], value[3:5], value[5:7]))
+            else:
+                raise KeyError
+        except (KeyError, AttributeError):
+            warn("Unknown colour (%s); valid choices: [hex (#00ff00), %s]" % (
+                 value, ", ".join(self.COLOURS)),
+                 TqdmWarning, stacklevel=2)
+            self._colour = None
+
+    def __format__(self, format_spec):
+        if format_spec:
+            _type = format_spec[-1].lower()
+            try:
+                charset = {'a': self.ASCII, 'u': self.UTF, 'b': self.BLANK}[_type]
+            except KeyError:
+                charset = self.charset
+            else:
+                format_spec = format_spec[:-1]
+            if format_spec:
+                N_BARS = int(format_spec)
+                if N_BARS < 0:
+                    N_BARS += self.default_len
+            else:
+                N_BARS = self.default_len
+        else:
+            charset = self.charset
+            N_BARS = self.default_len
+
+        nsyms = len(charset) - 1
+        bar_length, frac_bar_length = divmod(int(self.frac * N_BARS * nsyms), nsyms)
+
+        res = charset[-1] * bar_length
+        if bar_length < N_BARS:  # whitespace padding
+            res = res + charset[frac_bar_length] + charset[0] * (N_BARS - bar_length - 1)
+        return self.colour + res + self.COLOUR_RESET if self.colour else res
+
+
+class EMA(object):
+    """
+    Exponential moving average: smoothing to give progressively lower
+    weights to older values.
+
+    Parameters
+    ----------
+    smoothing  : float, optional
+        Smoothing factor in range [0, 1], [default: 0.3].
+        Increase to give more weight to recent values.
+        Ranges from 0 (yields old value) to 1 (yields new value).
+    """
+    def __init__(self, smoothing=0.3):
+        self.alpha = smoothing
+        self.last = 0
+        self.calls = 0
+
+    def __call__(self, x=None):
+        """
+        Parameters
+        ----------
+        x  : float
+            New value to include in EMA.
+        """
+        beta = 1 - self.alpha
+        if x is not None:
+            self.last = self.alpha * x + beta * self.last
+            self.calls += 1
+        return self.last / (1 - beta ** self.calls) if self.calls else self.last
+
+
+class tqdm(Comparable):
+    """
+    Decorate an iterable object, returning an iterator which acts exactly
+    like the original iterable, but prints a dynamically updating
+    progressbar every time a value is requested.
+
+    Parameters
+    ----------
+    iterable  : iterable, optional
+        Iterable to decorate with a progressbar.
+        Leave blank to manually manage the updates.
+    desc  : str, optional
+        Prefix for the progressbar.
+    total  : int or float, optional
+        The number of expected iterations. If unspecified,
+        len(iterable) is used if possible. If float("inf") or as a last
+        resort, only basic progress statistics are displayed
+        (no ETA, no progressbar).
+        If `gui` is True and this parameter needs subsequent updating,
+        specify an initial arbitrary large positive number,
+        e.g. 9e9.
+    leave  : bool, optional
+        If [default: True], keeps all traces of the progressbar
+        upon termination of iteration.
+        If `None`, will leave only if `position` is `0`.
+    file  : `io.TextIOWrapper` or `io.StringIO`, optional
+        Specifies where to output the progress messages
+        (default: sys.stderr). Uses `file.write(str)` and `file.flush()`
+        methods.  For encoding, see `write_bytes`.
+    ncols  : int, optional
+        The width of the entire output message. If specified,
+        dynamically resizes the progressbar to stay within this bound.
+        If unspecified, attempts to use environment width. The
+        fallback is a meter width of 10 and no limit for the counter and
+        statistics. If 0, will not print any meter (only stats).
+    mininterval  : float, optional
+        Minimum progress display update interval [default: 0.1] seconds.
+    maxinterval  : float, optional
+        Maximum progress display update interval [default: 10] seconds.
+        Automatically adjusts `miniters` to correspond to `mininterval`
+        after long display update lag. Only works if `dynamic_miniters`
+        or monitor thread is enabled.
+    miniters  : int or float, optional
+        Minimum progress display update interval, in iterations.
+        If 0 and `dynamic_miniters`, will automatically adjust to equal
+        `mininterval` (more CPU efficient, good for tight loops).
+        If > 0, will skip display of specified number of iterations.
+        Tweak this and `mininterval` to get very efficient loops.
+        If your progress is erratic with both fast and slow iterations
+        (network, skipping items, etc) you should set miniters=1.
+    ascii  : bool or str, optional
+        If unspecified or False, use unicode (smooth blocks) to fill
+        the meter. The fallback is to use ASCII characters " 123456789#".
+    disable  : bool, optional
+        Whether to disable the entire progressbar wrapper
+        [default: False]. If set to None, disable on non-TTY.
+    unit  : str, optional
+        String that will be used to define the unit of each iteration
+        [default: it].
+    unit_scale  : bool or int or float, optional
+        If 1 or True, the number of iterations will be reduced/scaled
+        automatically and a metric prefix following the
+        International System of Units standard will be added
+        (kilo, mega, etc.) [default: False]. If any other non-zero
+        number, will scale `total` and `n`.
+    dynamic_ncols  : bool, optional
+        If set, constantly alters `ncols` and `nrows` to the
+        environment (allowing for window resizes) [default: False].
+    smoothing  : float, optional
+        Exponential moving average smoothing factor for speed estimates
+        (ignored in GUI mode). Ranges from 0 (average speed) to 1
+        (current/instantaneous speed) [default: 0.3].
+    bar_format  : str, optional
+        Specify a custom bar string formatting. May impact performance.
+        [default: '{l_bar}{bar}{r_bar}'], where
+        l_bar='{desc}: {percentage:3.0f}%|' and
+        r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, '
+            '{rate_fmt}{postfix}]'
+        Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt,
+            percentage, elapsed, elapsed_s, ncols, nrows, desc, unit,
+            rate, rate_fmt, rate_noinv, rate_noinv_fmt,
+            rate_inv, rate_inv_fmt, postfix, unit_divisor,
+            remaining, remaining_s, eta.
+        Note that a trailing ": " is automatically removed after {desc}
+        if the latter is empty.
+    initial  : int or float, optional
+        The initial counter value. Useful when restarting a progress
+        bar [default: 0]. If using float, consider specifying `{n:.3f}`
+        or similar in `bar_format`, or specifying `unit_scale`.
+    position  : int, optional
+        Specify the line offset to print this bar (starting from 0)
+        Automatic if unspecified.
+        Useful to manage multiple bars at once (eg, from threads).
+    postfix  : dict or *, optional
+        Specify additional stats to display at the end of the bar.
+        Calls `set_postfix(**postfix)` if possible (dict).
+    unit_divisor  : float, optional
+        [default: 1000], ignored unless `unit_scale` is True.
+    write_bytes  : bool, optional
+        Whether to write bytes. If (default: False) will write unicode.
+    lock_args  : tuple, optional
+        Passed to `refresh` for intermediate output
+        (initialisation, iterating, and updating).
+    nrows  : int, optional
+        The screen height. If specified, hides nested bars outside this
+        bound. If unspecified, attempts to use environment height.
+        The fallback is 20.
+    colour  : str, optional
+        Bar colour (e.g. 'green', '#00ff00').
+    delay  : float, optional
+        Don't display until [default: 0] seconds have elapsed.
+    gui  : bool, optional
+        WARNING: internal parameter - do not use.
+        Use tqdm.gui.tqdm(...) instead. If set, will attempt to use
+        matplotlib animations for a graphical output [default: False].
+
+    Returns
+    -------
+    out  : decorated iterator.
+    """
+
+    monitor_interval = 10  # set to 0 to disable the thread
+    monitor = None
+    _instances = WeakSet()
+
+    @staticmethod
+    def format_sizeof(num, suffix='', divisor=1000):
+        """
+        Formats a number (greater than unity) with SI Order of Magnitude
+        prefixes.
+
+        Parameters
+        ----------
+        num  : float
+            Number ( >= 1) to format.
+        suffix  : str, optional
+            Post-postfix [default: ''].
+        divisor  : float, optional
+            Divisor between prefixes [default: 1000].
+
+        Returns
+        -------
+        out  : str
+            Number with Order of Magnitude SI unit postfix.
+        """
+        for unit in ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z']:
+            if abs(num) < 999.5:
+                if abs(num) < 99.95:
+                    if abs(num) < 9.995:
+                        return f'{num:1.2f}{unit}{suffix}'
+                    return f'{num:2.1f}{unit}{suffix}'
+                return f'{num:3.0f}{unit}{suffix}'
+            num /= divisor
+        return f'{num:3.1f}Y{suffix}'
+
+    @staticmethod
+    def format_interval(t):
+        """
+        Formats a number of seconds as a clock time, [H:]MM:SS
+
+        Parameters
+        ----------
+        t  : int
+            Number of seconds.
+
+        Returns
+        -------
+        out  : str
+            [H:]MM:SS
+        """
+        mins, s = divmod(int(t), 60)
+        h, m = divmod(mins, 60)
+        return f'{h:d}:{m:02d}:{s:02d}' if h else f'{m:02d}:{s:02d}'
+
+    @staticmethod
+    def format_num(n):
+        """
+        Intelligent scientific notation (.3g).
+
+        Parameters
+        ----------
+        n  : int or float or Numeric
+            A Number.
+
+        Returns
+        -------
+        out  : str
+            Formatted number.
+        """
+        f = f'{n:.3g}'.replace('e+0', 'e+').replace('e-0', 'e-')
+        n = str(n)
+        return f if len(f) < len(n) else n
+
+    @staticmethod
+    def status_printer(file):
+        """
+        Manage the printing and in-place updating of a line of characters.
+        Note that if the string is longer than a line, then in-place
+        updating may not work (it will print a new line at each refresh).
+        """
+        fp = file
+        fp_flush = getattr(fp, 'flush', lambda: None)  # pragma: no cover
+        if fp in (sys.stderr, sys.stdout):
+            getattr(sys.stderr, 'flush', lambda: None)()
+            getattr(sys.stdout, 'flush', lambda: None)()
+
+        def fp_write(s):
+            fp.write(str(s))
+            fp_flush()
+
+        last_len = [0]
+
+        def print_status(s):
+            len_s = disp_len(s)
+            fp_write('\r' + s + (' ' * max(last_len[0] - len_s, 0)))
+            last_len[0] = len_s
+
+        return print_status
+
+    @staticmethod
+    def format_meter(n, total, elapsed, ncols=None, prefix='', ascii=False, unit='it',
+                     unit_scale=False, rate=None, bar_format=None, postfix=None,
+                     unit_divisor=1000, initial=0, colour=None, **extra_kwargs):
+        """
+        Return a string-based progress bar given some parameters
+
+        Parameters
+        ----------
+        n  : int or float
+            Number of finished iterations.
+        total  : int or float
+            The expected total number of iterations. If meaningless (None),
+            only basic progress statistics are displayed (no ETA).
+        elapsed  : float
+            Number of seconds passed since start.
+        ncols  : int, optional
+            The width of the entire output message. If specified,
+            dynamically resizes `{bar}` to stay within this bound
+            [default: None]. If `0`, will not print any bar (only stats).
+            The fallback is `{bar:10}`.
+        prefix  : str, optional
+            Prefix message (included in total width) [default: ''].
+            Use as {desc} in bar_format string.
+        ascii  : bool, optional or str, optional
+            If not set, use unicode (smooth blocks) to fill the meter
+            [default: False]. The fallback is to use ASCII characters
+            " 123456789#".
+        unit  : str, optional
+            The iteration unit [default: 'it'].
+        unit_scale  : bool or int or float, optional
+            If 1 or True, the number of iterations will be printed with an
+            appropriate SI metric prefix (k = 10^3, M = 10^6, etc.)
+            [default: False]. If any other non-zero number, will scale
+            `total` and `n`.
+        rate  : float, optional
+            Manual override for iteration rate.
+            If [default: None], uses n/elapsed.
+        bar_format  : str, optional
+            Specify a custom bar string formatting. May impact performance.
+            [default: '{l_bar}{bar}{r_bar}'], where
+            l_bar='{desc}: {percentage:3.0f}%|' and
+            r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, '
+              '{rate_fmt}{postfix}]'
+            Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt,
+              percentage, elapsed, elapsed_s, ncols, nrows, desc, unit,
+              rate, rate_fmt, rate_noinv, rate_noinv_fmt,
+              rate_inv, rate_inv_fmt, postfix, unit_divisor,
+              remaining, remaining_s, eta.
+            Note that a trailing ": " is automatically removed after {desc}
+            if the latter is empty.
+        postfix  : *, optional
+            Similar to `prefix`, but placed at the end
+            (e.g. for additional stats).
+            Note: postfix is usually a string (not a dict) for this method,
+            and will if possible be set to postfix = ', ' + postfix.
+            However other types are supported (#382).
+        unit_divisor  : float, optional
+            [default: 1000], ignored unless `unit_scale` is True.
+        initial  : int or float, optional
+            The initial counter value [default: 0].
+        colour  : str, optional
+            Bar colour (e.g. 'green', '#00ff00').
+
+        Returns
+        -------
+        out  : Formatted meter and stats, ready to display.
+        """
+
+        # sanity check: total
+        if total and n >= (total + 0.5):  # allow float imprecision (#849)
+            total = None
+
+        # apply custom scale if necessary
+        if unit_scale and unit_scale not in (True, 1):
+            if total:
+                total *= unit_scale
+            n *= unit_scale
+            if rate:
+                rate *= unit_scale  # by default rate = self.avg_dn / self.avg_dt
+            unit_scale = False
+
+        elapsed_str = tqdm.format_interval(elapsed)
+
+        # if unspecified, attempt to use rate = average speed
+        # (we allow manual override since predicting time is an arcane art)
+        if rate is None and elapsed:
+            rate = (n - initial) / elapsed
+        inv_rate = 1 / rate if rate else None
+        format_sizeof = tqdm.format_sizeof
+        rate_noinv_fmt = ((format_sizeof(rate) if unit_scale else f'{rate:5.2f}')
+                          if rate else '?') + unit + '/s'
+        rate_inv_fmt = (
+            (format_sizeof(inv_rate) if unit_scale else f'{inv_rate:5.2f}')
+            if inv_rate else '?') + 's/' + unit
+        rate_fmt = rate_inv_fmt if inv_rate and inv_rate > 1 else rate_noinv_fmt
+
+        if unit_scale:
+            n_fmt = format_sizeof(n, divisor=unit_divisor)
+            total_fmt = format_sizeof(total, divisor=unit_divisor) if total is not None else '?'
+        else:
+            n_fmt = str(n)
+            total_fmt = str(total) if total is not None else '?'
+
+        try:
+            postfix = ', ' + postfix if postfix else ''
+        except TypeError:
+            pass
+
+        remaining = (total - n) / rate if rate and total else 0
+        remaining_str = tqdm.format_interval(remaining) if rate else '?'
+        try:
+            eta_dt = (datetime.now() + timedelta(seconds=remaining)
+                      if rate and total else datetime.fromtimestamp(0, timezone.utc))
+        except OverflowError:
+            eta_dt = datetime.max
+
+        # format the stats displayed to the left and right sides of the bar
+        if prefix:
+            # old prefix setup work around
+            bool_prefix_colon_already = (prefix[-2:] == ": ")
+            l_bar = prefix if bool_prefix_colon_already else prefix + ": "
+        else:
+            l_bar = ''
+
+        r_bar = f'| {n_fmt}/{total_fmt} [{elapsed_str}<{remaining_str}, {rate_fmt}{postfix}]'
+
+        # Custom bar formatting
+        # Populate a dict with all available progress indicators
+        format_dict = {
+            # slight extension of self.format_dict
+            'n': n, 'n_fmt': n_fmt, 'total': total, 'total_fmt': total_fmt,
+            'elapsed': elapsed_str, 'elapsed_s': elapsed,
+            'ncols': ncols, 'desc': prefix or '', 'unit': unit,
+            'rate': inv_rate if inv_rate and inv_rate > 1 else rate,
+            'rate_fmt': rate_fmt, 'rate_noinv': rate,
+            'rate_noinv_fmt': rate_noinv_fmt, 'rate_inv': inv_rate,
+            'rate_inv_fmt': rate_inv_fmt,
+            'postfix': postfix, 'unit_divisor': unit_divisor,
+            'colour': colour,
+            # plus more useful definitions
+            'remaining': remaining_str, 'remaining_s': remaining,
+            'l_bar': l_bar, 'r_bar': r_bar, 'eta': eta_dt,
+            **extra_kwargs}
+
+        # total is known: we can predict some stats
+        if total:
+            # fractional and percentage progress
+            frac = n / total
+            percentage = frac * 100
+
+            l_bar += f'{percentage:3.0f}%|'
+
+            if ncols == 0:
+                return l_bar[:-1] + r_bar[1:]
+
+            format_dict.update(l_bar=l_bar)
+            if bar_format:
+                format_dict.update(percentage=percentage)
+
+                # auto-remove colon for empty `{desc}`
+                if not prefix:
+                    bar_format = bar_format.replace("{desc}: ", '')
+            else:
+                bar_format = "{l_bar}{bar}{r_bar}"
+
+            full_bar = FormatReplace()
+            nobar = bar_format.format(bar=full_bar, **format_dict)
+            if not full_bar.format_called:
+                return nobar  # no `{bar}`; nothing else to do
+
+            # Formatting progress bar space available for bar's display
+            full_bar = Bar(frac,
+                           max(1, ncols - disp_len(nobar)) if ncols else 10,
+                           charset=Bar.ASCII if ascii is True else ascii or Bar.UTF,
+                           colour=colour)
+            if not _is_ascii(full_bar.charset) and _is_ascii(bar_format):
+                bar_format = str(bar_format)
+            res = bar_format.format(bar=full_bar, **format_dict)
+            return disp_trim(res, ncols) if ncols else res
+
+        elif bar_format:
+            # user-specified bar_format but no total
+            l_bar += '|'
+            format_dict.update(l_bar=l_bar, percentage=0)
+            full_bar = FormatReplace()
+            nobar = bar_format.format(bar=full_bar, **format_dict)
+            if not full_bar.format_called:
+                return nobar
+            full_bar = Bar(0,
+                           max(1, ncols - disp_len(nobar)) if ncols else 10,
+                           charset=Bar.BLANK, colour=colour)
+            res = bar_format.format(bar=full_bar, **format_dict)
+            return disp_trim(res, ncols) if ncols else res
+        else:
+            # no total: no progressbar, ETA, just progress stats
+            return (f'{(prefix + ": ") if prefix else ""}'
+                    f'{n_fmt}{unit} [{elapsed_str}, {rate_fmt}{postfix}]')
+
+    def __new__(cls, *_, **__):
+        instance = object.__new__(cls)
+        with cls.get_lock():  # also constructs lock if non-existent
+            cls._instances.add(instance)
+            # create monitoring thread
+            if cls.monitor_interval and (cls.monitor is None
+                                         or not cls.monitor.report()):
+                try:
+                    cls.monitor = TMonitor(cls, cls.monitor_interval)
+                except Exception as e:  # pragma: nocover
+                    warn("tqdm:disabling monitor support"
+                         " (monitor_interval = 0) due to:\n" + str(e),
+                         TqdmMonitorWarning, stacklevel=2)
+                    cls.monitor_interval = 0
+        return instance
+
+    @classmethod
+    def _get_free_pos(cls, instance=None):
+        """Skips specified instance."""
+        positions = {abs(inst.pos) for inst in cls._instances
+                     if inst is not instance and hasattr(inst, "pos")}
+        return min(set(range(len(positions) + 1)).difference(positions))
+
+    @classmethod
+    def _decr_instances(cls, instance):
+        """
+        Remove from list and reposition another unfixed bar
+        to fill the new gap.
+
+        This means that by default (where all nested bars are unfixed),
+        order is not maintained but screen flicker/blank space is minimised.
+        (tqdm<=4.44.1 moved ALL subsequent unfixed bars up.)
+        """
+        with cls._lock:
+            try:
+                cls._instances.remove(instance)
+            except KeyError:
+                # if not instance.gui:  # pragma: no cover
+                #     raise
+                pass  # py2: maybe magically removed already
+            # else:
+            if not instance.gui:
+                last = (instance.nrows or 20) - 1
+                # find unfixed (`pos >= 0`) overflow (`pos >= nrows - 1`)
+                instances = list(filter(
+                    lambda i: hasattr(i, "pos") and last <= i.pos,
+                    cls._instances))
+                # set first found to current `pos`
+                if instances:
+                    inst = min(instances, key=lambda i: i.pos)
+                    inst.clear(nolock=True)
+                    inst.pos = abs(instance.pos)
+
+    @classmethod
+    def write(cls, s, file=None, end="\n", nolock=False):
+        """Print a message via tqdm (without overlap with bars)."""
+        fp = file if file is not None else sys.stdout
+        with cls.external_write_mode(file=file, nolock=nolock):
+            # Write the message
+            fp.write(s)
+            fp.write(end)
+
+    @classmethod
+    @contextmanager
+    def external_write_mode(cls, file=None, nolock=False):
+        """
+        Disable tqdm within context and refresh tqdm when exits.
+        Useful when writing to standard output stream
+        """
+        fp = file if file is not None else sys.stdout
+
+        try:
+            if not nolock:
+                cls.get_lock().acquire()
+            # Clear all bars
+            inst_cleared = []
+            for inst in getattr(cls, '_instances', []):
+                # Clear instance if in the target output file
+                # or if write output + tqdm output are both either
+                # sys.stdout or sys.stderr (because both are mixed in terminal)
+                if hasattr(inst, "start_t") and (inst.fp == fp or all(
+                        f in (sys.stdout, sys.stderr) for f in (fp, inst.fp))):
+                    inst.clear(nolock=True)
+                    inst_cleared.append(inst)
+            yield
+            # Force refresh display of bars we cleared
+            for inst in inst_cleared:
+                inst.refresh(nolock=True)
+        finally:
+            if not nolock:
+                cls._lock.release()
+
+    @classmethod
+    def set_lock(cls, lock):
+        """Set the global lock."""
+        cls._lock = lock
+
+    @classmethod
+    def get_lock(cls):
+        """Get the global lock. Construct it if it does not exist."""
+        if not hasattr(cls, '_lock'):
+            cls._lock = TqdmDefaultWriteLock()
+        return cls._lock
+
+    @classmethod
+    def pandas(cls, **tqdm_kwargs):
+        """
+        Registers the current `tqdm` class with
+            pandas.core.
+            ( frame.DataFrame
+            | series.Series
+            | groupby.(generic.)DataFrameGroupBy
+            | groupby.(generic.)SeriesGroupBy
+            ).progress_apply
+
+        A new instance will be created every time `progress_apply` is called,
+        and each instance will automatically `close()` upon completion.
+
+        Parameters
+        ----------
+        tqdm_kwargs  : arguments for the tqdm instance
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>> from tqdm import tqdm
+        >>> from tqdm.gui import tqdm as tqdm_gui
+        >>>
+        >>> df = pd.DataFrame(np.random.randint(0, 100, (100000, 6)))
+        >>> tqdm.pandas(ncols=50)  # can use tqdm_gui, optional kwargs, etc
+        >>> # Now you can use `progress_apply` instead of `apply`
+        >>> df.groupby(0).progress_apply(lambda x: x**2)
+
+        References
+        ----------
+        <https://stackoverflow.com/questions/18603270/\
+        progress-indicator-during-pandas-operations-python>
+        """
+        from warnings import catch_warnings, simplefilter
+
+        from pandas.core.frame import DataFrame
+        from pandas.core.series import Series
+        try:
+            with catch_warnings():
+                simplefilter("ignore", category=FutureWarning)
+                from pandas import Panel
+        except ImportError:  # pandas>=1.2.0
+            Panel = None
+        Rolling, Expanding = None, None
+        try:  # pandas>=1.0.0
+            from pandas.core.window.rolling import _Rolling_and_Expanding
+        except ImportError:
+            try:  # pandas>=0.18.0
+                from pandas.core.window import _Rolling_and_Expanding
+            except ImportError:  # pandas>=1.2.0
+                try:  # pandas>=1.2.0
+                    from pandas.core.window.expanding import Expanding
+                    from pandas.core.window.rolling import Rolling
+                    _Rolling_and_Expanding = Rolling, Expanding
+                except ImportError:  # pragma: no cover
+                    _Rolling_and_Expanding = None
+        try:  # pandas>=0.25.0
+            from pandas.core.groupby.generic import SeriesGroupBy  # , NDFrameGroupBy
+            from pandas.core.groupby.generic import DataFrameGroupBy
+        except ImportError:  # pragma: no cover
+            try:  # pandas>=0.23.0
+                from pandas.core.groupby.groupby import DataFrameGroupBy, SeriesGroupBy
+            except ImportError:
+                from pandas.core.groupby import DataFrameGroupBy, SeriesGroupBy
+        try:  # pandas>=0.23.0
+            from pandas.core.groupby.groupby import GroupBy
+        except ImportError:  # pragma: no cover
+            from pandas.core.groupby import GroupBy
+
+        try:  # pandas>=0.23.0
+            from pandas.core.groupby.groupby import PanelGroupBy
+        except ImportError:
+            try:
+                from pandas.core.groupby import PanelGroupBy
+            except ImportError:  # pandas>=0.25.0
+                PanelGroupBy = None
+
+        tqdm_kwargs = tqdm_kwargs.copy()
+        deprecated_t = [tqdm_kwargs.pop('deprecated_t', None)]
+
+        def inner_generator(df_function='apply'):
+            def inner(df, func, *args, **kwargs):
+                """
+                Parameters
+                ----------
+                df  : (DataFrame|Series)[GroupBy]
+                    Data (may be grouped).
+                func  : function
+                    To be applied on the (grouped) data.
+                **kwargs  : optional
+                    Transmitted to `df.apply()`.
+                """
+
+                # Precompute total iterations
+                total = tqdm_kwargs.pop("total", getattr(df, 'ngroups', None))
+                if total is None:  # not grouped
+                    if df_function == 'applymap':
+                        total = df.size
+                    elif isinstance(df, Series):
+                        total = len(df)
+                    elif (_Rolling_and_Expanding is None or
+                          not isinstance(df, _Rolling_and_Expanding)):
+                        # DataFrame or Panel
+                        axis = kwargs.get('axis', 0)
+                        if axis == 'index':
+                            axis = 0
+                        elif axis == 'columns':
+                            axis = 1
+                        # when axis=0, total is shape[axis1]
+                        total = df.size // df.shape[axis]
+
+                # Init bar
+                if deprecated_t[0] is not None:
+                    t = deprecated_t[0]
+                    deprecated_t[0] = None
+                else:
+                    t = cls(total=total, **tqdm_kwargs)
+
+                if len(args) > 0:
+                    # *args intentionally not supported (see #244, #299)
+                    TqdmDeprecationWarning(
+                        "Except func, normal arguments are intentionally" +
+                        " not supported by" +
+                        " `(DataFrame|Series|GroupBy).progress_apply`." +
+                        " Use keyword arguments instead.",
+                        fp_write=getattr(t.fp, 'write', sys.stderr.write))
+
+                try:  # pandas>=1.3.0
+                    from pandas.core.common import is_builtin_func
+                except ImportError:
+                    is_builtin_func = df._is_builtin_func
+                try:
+                    func = is_builtin_func(func)
+                except TypeError:
+                    pass
+
+                # Define bar updating wrapper
+                def wrapper(*args, **kwargs):
+                    # update tbar correctly
+                    # it seems `pandas apply` calls `func` twice
+                    # on the first column/row to decide whether it can
+                    # take a fast or slow code path; so stop when t.total==t.n
+                    t.update(n=1 if not t.total or t.n < t.total else 0)
+                    return func(*args, **kwargs)
+
+                # Apply the provided function (in **kwargs)
+                # on the df using our wrapper (which provides bar updating)
+                try:
+                    return getattr(df, df_function)(wrapper, **kwargs)
+                finally:
+                    t.close()
+
+            return inner
+
+        # Monkeypatch pandas to provide easy methods
+        # Enable custom tqdm progress in pandas!
+        Series.progress_apply = inner_generator()
+        SeriesGroupBy.progress_apply = inner_generator()
+        Series.progress_map = inner_generator('map')
+        SeriesGroupBy.progress_map = inner_generator('map')
+
+        DataFrame.progress_apply = inner_generator()
+        DataFrameGroupBy.progress_apply = inner_generator()
+        DataFrame.progress_applymap = inner_generator('applymap')
+        DataFrame.progress_map = inner_generator('map')
+        DataFrameGroupBy.progress_map = inner_generator('map')
+
+        if Panel is not None:
+            Panel.progress_apply = inner_generator()
+        if PanelGroupBy is not None:
+            PanelGroupBy.progress_apply = inner_generator()
+
+        GroupBy.progress_apply = inner_generator()
+        GroupBy.progress_aggregate = inner_generator('aggregate')
+        GroupBy.progress_transform = inner_generator('transform')
+
+        if Rolling is not None and Expanding is not None:
+            Rolling.progress_apply = inner_generator()
+            Expanding.progress_apply = inner_generator()
+        elif _Rolling_and_Expanding is not None:
+            _Rolling_and_Expanding.progress_apply = inner_generator()
+
+    # override defaults via env vars
+    @envwrap("TQDM_", is_method=True, types={'total': float, 'ncols': int, 'miniters': float,
+                                             'position': int, 'nrows': int})
+    def __init__(self, iterable=None, desc=None, total=None, leave=True, file=None,
+                 ncols=None, mininterval=0.1, maxinterval=10.0, miniters=None,
+                 ascii=None, disable=False, unit='it', unit_scale=False,
+                 dynamic_ncols=False, smoothing=0.3, bar_format=None, initial=0,
+                 position=None, postfix=None, unit_divisor=1000, write_bytes=False,
+                 lock_args=None, nrows=None, colour=None, delay=0.0, gui=False,
+                 **kwargs):
+        """see tqdm.tqdm for arguments"""
+        if file is None:
+            file = sys.stderr
+
+        if write_bytes:
+            # Despite coercing unicode into bytes, py2 sys.std* streams
+            # should have bytes written to them.
+            file = SimpleTextIOWrapper(
+                file, encoding=getattr(file, 'encoding', None) or 'utf-8')
+
+        file = DisableOnWriteError(file, tqdm_instance=self)
+
+        if disable is None and hasattr(file, "isatty") and not file.isatty():
+            disable = True
+
+        if total is None and iterable is not None:
+            try:
+                total = len(iterable)
+            except (TypeError, AttributeError):
+                total = None
+        if total == float("inf"):
+            # Infinite iterations, behave same as unknown
+            total = None
+
+        if disable:
+            self.iterable = iterable
+            self.disable = disable
+            with self._lock:
+                self.pos = self._get_free_pos(self)
+                self._instances.remove(self)
+            self.n = initial
+            self.total = total
+            self.leave = leave
+            return
+
+        if kwargs:
+            self.disable = True
+            with self._lock:
+                self.pos = self._get_free_pos(self)
+                self._instances.remove(self)
+            raise (
+                TqdmDeprecationWarning(
+                    "`nested` is deprecated and automated.\n"
+                    "Use `position` instead for manual control.\n",
+                    fp_write=getattr(file, 'write', sys.stderr.write))
+                if "nested" in kwargs else
+                TqdmKeyError("Unknown argument(s): " + str(kwargs)))
+
+        # Preprocess the arguments
+        if (
+            (ncols is None or nrows is None) and (file in (sys.stderr, sys.stdout))
+        ) or dynamic_ncols:  # pragma: no cover
+            if dynamic_ncols:
+                dynamic_ncols = _screen_shape_wrapper()
+                if dynamic_ncols:
+                    ncols, nrows = dynamic_ncols(file)
+            else:
+                _dynamic_ncols = _screen_shape_wrapper()
+                if _dynamic_ncols:
+                    _ncols, _nrows = _dynamic_ncols(file)
+                    if ncols is None:
+                        ncols = _ncols
+                    if nrows is None:
+                        nrows = _nrows
+
+        if miniters is None:
+            miniters = 0
+            dynamic_miniters = True
+        else:
+            dynamic_miniters = False
+
+        if mininterval is None:
+            mininterval = 0
+
+        if maxinterval is None:
+            maxinterval = 0
+
+        if ascii is None:
+            ascii = not _supports_unicode(file)
+
+        if bar_format and ascii is not True and not _is_ascii(ascii):
+            # Convert bar format into unicode since terminal uses unicode
+            bar_format = str(bar_format)
+
+        if smoothing is None:
+            smoothing = 0
+
+        # Store the arguments
+        self.iterable = iterable
+        self.desc = desc or ''
+        self.total = total
+        self.leave = leave
+        self.fp = file
+        self.ncols = ncols
+        self.nrows = nrows
+        self.mininterval = mininterval
+        self.maxinterval = maxinterval
+        self.miniters = miniters
+        self.dynamic_miniters = dynamic_miniters
+        self.ascii = ascii
+        self.disable = disable
+        self.unit = unit
+        self.unit_scale = unit_scale
+        self.unit_divisor = unit_divisor
+        self.initial = initial
+        self.lock_args = lock_args
+        self.delay = delay
+        self.gui = gui
+        self.dynamic_ncols = dynamic_ncols
+        self.smoothing = smoothing
+        self._ema_dn = EMA(smoothing)
+        self._ema_dt = EMA(smoothing)
+        self._ema_miniters = EMA(smoothing)
+        self.bar_format = bar_format
+        self.postfix = None
+        self.colour = colour
+        self._time = time
+        if postfix:
+            try:
+                self.set_postfix(refresh=False, **postfix)
+            except TypeError:
+                self.postfix = postfix
+
+        # Init the iterations counters
+        self.last_print_n = initial
+        self.n = initial
+
+        # if nested, at initial sp() call we replace '\r' by '\n' to
+        # not overwrite the outer progress bar
+        with self._lock:
+            # mark fixed positions as negative
+            self.pos = self._get_free_pos(self) if position is None else -position
+
+        if not gui:
+            # Initialize the screen printer
+            self.sp = self.status_printer(self.fp)
+            if delay <= 0:
+                self.refresh(lock_args=self.lock_args)
+
+        # Init the time counter
+        self.last_print_t = self._time()
+        # NB: Avoid race conditions by setting start_t at the very end of init
+        self.start_t = self.last_print_t
+
+    def __bool__(self):
+        if self.total is not None:
+            return self.total > 0
+        if self.iterable is None:
+            raise TypeError('bool() undefined when iterable == total == None')
+        return bool(self.iterable)
+
+    def __len__(self):
+        return (
+            self.total if self.iterable is None
+            else self.iterable.shape[0] if hasattr(self.iterable, "shape")
+            else len(self.iterable) if hasattr(self.iterable, "__len__")
+            else self.iterable.__length_hint__() if hasattr(self.iterable, "__length_hint__")
+            else getattr(self, "total", None))
+
+    def __reversed__(self):
+        try:
+            orig = self.iterable
+        except AttributeError:
+            raise TypeError("'tqdm' object is not reversible")
+        else:
+            self.iterable = reversed(self.iterable)
+            return self.__iter__()
+        finally:
+            self.iterable = orig
+
+    def __contains__(self, item):
+        contains = getattr(self.iterable, '__contains__', None)
+        return contains(item) if contains is not None else item in self.__iter__()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        try:
+            self.close()
+        except AttributeError:
+            # maybe eager thread cleanup upon external error
+            if (exc_type, exc_value, traceback) == (None, None, None):
+                raise
+            warn("AttributeError ignored", TqdmWarning, stacklevel=2)
+
+    def __del__(self):
+        self.close()
+
+    def __str__(self):
+        return self.format_meter(**self.format_dict)
+
+    @property
+    def _comparable(self):
+        return abs(getattr(self, "pos", 1 << 31))
+
+    def __hash__(self):
+        return id(self)
+
+    def __iter__(self):
+        """Backward-compatibility to use: for x in tqdm(iterable)"""
+
+        # Inlining instance variables as locals (speed optimisation)
+        iterable = self.iterable
+
+        # If the bar is disabled, then just walk the iterable
+        # (note: keep this check outside the loop for performance)
+        if self.disable:
+            for obj in iterable:
+                yield obj
+            return
+
+        mininterval = self.mininterval
+        last_print_t = self.last_print_t
+        last_print_n = self.last_print_n
+        min_start_t = self.start_t + self.delay
+        n = self.n
+        time = self._time
+
+        try:
+            for obj in iterable:
+                yield obj
+                # Update and possibly print the progressbar.
+                # Note: does not call self.update(1) for speed optimisation.
+                n += 1
+
+                if n - last_print_n >= self.miniters:
+                    cur_t = time()
+                    dt = cur_t - last_print_t
+                    if dt >= mininterval and cur_t >= min_start_t:
+                        self.update(n - last_print_n)
+                        last_print_n = self.last_print_n
+                        last_print_t = self.last_print_t
+        finally:
+            self.n = n
+            self.close()
+
+    def update(self, n=1):
+        """
+        Manually update the progress bar, useful for streams
+        such as reading files.
+        E.g.:
+        >>> t = tqdm(total=filesize) # Initialise
+        >>> for current_buffer in stream:
+        ...    ...
+        ...    t.update(len(current_buffer))
+        >>> t.close()
+        The last line is highly recommended, but possibly not necessary if
+        `t.update()` will be called in such a way that `filesize` will be
+        exactly reached and printed.
+
+        Parameters
+        ----------
+        n  : int or float, optional
+            Increment to add to the internal counter of iterations
+            [default: 1]. If using float, consider specifying `{n:.3f}`
+            or similar in `bar_format`, or specifying `unit_scale`.
+
+        Returns
+        -------
+        out  : bool or None
+            True if a `display()` was triggered.
+        """
+        if self.disable:
+            return
+
+        if n < 0:
+            self.last_print_n += n  # for auto-refresh logic to work
+        self.n += n
+
+        # check counter first to reduce calls to time()
+        if self.n - self.last_print_n >= self.miniters:
+            cur_t = self._time()
+            dt = cur_t - self.last_print_t
+            if dt >= self.mininterval and cur_t >= self.start_t + self.delay:
+                cur_t = self._time()
+                dn = self.n - self.last_print_n  # >= n
+                if self.smoothing and dt and dn:
+                    # EMA (not just overall average)
+                    self._ema_dn(dn)
+                    self._ema_dt(dt)
+                self.refresh(lock_args=self.lock_args)
+                if self.dynamic_miniters:
+                    # If no `miniters` was specified, adjust automatically to the
+                    # maximum iteration rate seen so far between two prints.
+                    # e.g.: After running `tqdm.update(5)`, subsequent
+                    # calls to `tqdm.update()` will only cause an update after
+                    # at least 5 more iterations.
+                    if self.maxinterval and dt >= self.maxinterval:
+                        self.miniters = dn * (self.mininterval or self.maxinterval) / dt
+                    elif self.smoothing:
+                        # EMA miniters update
+                        self.miniters = self._ema_miniters(
+                            dn * (self.mininterval / dt if self.mininterval and dt
+                                  else 1))
+                    else:
+                        # max iters between two prints
+                        self.miniters = max(self.miniters, dn)
+
+                # Store old values for next call
+                self.last_print_n = self.n
+                self.last_print_t = cur_t
+                return True
+
+    def close(self):
+        """Cleanup and (if leave=False) close the progressbar."""
+        if self.disable:
+            return
+
+        # Prevent multiple closures
+        self.disable = True
+
+        # decrement instance pos and remove from internal set
+        pos = abs(self.pos)
+        self._decr_instances(self)
+
+        if self.last_print_t < self.start_t + self.delay:
+            # haven't ever displayed; nothing to clear
+            return
+
+        # GUI mode
+        if getattr(self, 'sp', None) is None:
+            return
+
+        # annoyingly, _supports_unicode isn't good enough
+        def fp_write(s):
+            self.fp.write(str(s))
+
+        try:
+            fp_write('')
+        except ValueError as e:
+            if 'closed' in str(e):
+                return
+            raise  # pragma: no cover
+
+        leave = pos == 0 if self.leave is None else self.leave
+
+        with self._lock:
+            if leave:
+                # stats for overall rate (no weighted average)
+                self._ema_dt = lambda: None
+                self.display(pos=0)
+                fp_write('\n')
+            else:
+                # clear previous display
+                if self.display(msg='', pos=pos) and not pos:
+                    fp_write('\r')
+
+    def clear(self, nolock=False):
+        """Clear current bar display."""
+        if self.disable:
+            return
+
+        if not nolock:
+            self._lock.acquire()
+        pos = abs(self.pos)
+        if pos < (self.nrows or 20):
+            self.moveto(pos)
+            self.sp('')
+            self.fp.write('\r')  # place cursor back at the beginning of line
+            self.moveto(-pos)
+        if not nolock:
+            self._lock.release()
+
+    def refresh(self, nolock=False, lock_args=None):
+        """
+        Force refresh the display of this bar.
+
+        Parameters
+        ----------
+        nolock  : bool, optional
+            If `True`, does not lock.
+            If [default: `False`]: calls `acquire()` on internal lock.
+        lock_args  : tuple, optional
+            Passed to internal lock's `acquire()`.
+            If specified, will only `display()` if `acquire()` returns `True`.
+        """
+        if self.disable:
+            return
+
+        if not nolock:
+            if lock_args:
+                if not self._lock.acquire(*lock_args):
+                    return False
+            else:
+                self._lock.acquire()
+        self.display()
+        if not nolock:
+            self._lock.release()
+        return True
+
+    def unpause(self):
+        """Restart tqdm timer from last print time."""
+        if self.disable:
+            return
+        cur_t = self._time()
+        self.start_t += cur_t - self.last_print_t
+        self.last_print_t = cur_t
+
+    def reset(self, total=None):
+        """
+        Resets to 0 iterations for repeated use.
+
+        Consider combining with `leave=True`.
+
+        Parameters
+        ----------
+        total  : int or float, optional. Total to use for the new bar.
+        """
+        self.n = 0
+        if total is not None:
+            self.total = total
+        if self.disable:
+            return
+        self.last_print_n = 0
+        self.last_print_t = self.start_t = self._time()
+        self._ema_dn = EMA(self.smoothing)
+        self._ema_dt = EMA(self.smoothing)
+        self._ema_miniters = EMA(self.smoothing)
+        self.refresh()
+
+    def set_description(self, desc=None, refresh=True):
+        """
+        Set/modify description of the progress bar.
+
+        Parameters
+        ----------
+        desc  : str, optional
+        refresh  : bool, optional
+            Forces refresh [default: True].
+        """
+        self.desc = desc + ': ' if desc else ''
+        if refresh:
+            self.refresh()
+
+    def set_description_str(self, desc=None, refresh=True):
+        """Set/modify description without ': ' appended."""
+        self.desc = desc or ''
+        if refresh:
+            self.refresh()
+
+    def set_postfix(self, ordered_dict=None, refresh=True, **kwargs):
+        """
+        Set/modify postfix (additional stats)
+        with automatic formatting based on datatype.
+
+        Parameters
+        ----------
+        ordered_dict  : dict or OrderedDict, optional
+        refresh  : bool, optional
+            Forces refresh [default: True].
+        kwargs  : dict, optional
+        """
+        # Sort in alphabetical order to be more deterministic
+        postfix = OrderedDict([] if ordered_dict is None else ordered_dict)
+        for key in sorted(kwargs.keys()):
+            postfix[key] = kwargs[key]
+        # Preprocess stats according to datatype
+        for key in postfix.keys():
+            # Number: limit the length of the string
+            if isinstance(postfix[key], Number):
+                postfix[key] = self.format_num(postfix[key])
+            # Else for any other type, try to get the string conversion
+            elif not isinstance(postfix[key], str):
+                postfix[key] = str(postfix[key])
+            # Else if it's a string, don't need to preprocess anything
+        # Stitch together to get the final postfix
+        self.postfix = ', '.join(key + '=' + postfix[key].strip()
+                                 for key in postfix.keys())
+        if refresh:
+            self.refresh()
+
+    def set_postfix_str(self, s='', refresh=True):
+        """
+        Postfix without dictionary expansion, similar to prefix handling.
+        """
+        self.postfix = str(s)
+        if refresh:
+            self.refresh()
+
+    def moveto(self, n):
+        # TODO: private method
+        self.fp.write('\n' * n + _term_move_up() * -n)
+        getattr(self.fp, 'flush', lambda: None)()
+
+    @property
+    def format_dict(self):
+        """Public API for read-only member access."""
+        if self.disable and not hasattr(self, 'unit'):
+            return defaultdict(lambda: None, {
+                'n': self.n, 'total': self.total, 'elapsed': 0, 'unit': 'it'})
+        if self.dynamic_ncols:
+            self.ncols, self.nrows = self.dynamic_ncols(self.fp)
+        return {
+            'n': self.n, 'total': self.total,
+            'elapsed': self._time() - self.start_t if hasattr(self, 'start_t') else 0,
+            'ncols': self.ncols, 'nrows': self.nrows, 'prefix': self.desc,
+            'ascii': self.ascii, 'unit': self.unit, 'unit_scale': self.unit_scale,
+            'rate': self._ema_dn() / self._ema_dt() if self._ema_dt() else None,
+            'bar_format': self.bar_format, 'postfix': self.postfix,
+            'unit_divisor': self.unit_divisor, 'initial': self.initial,
+            'colour': self.colour}
+
+    def display(self, msg=None, pos=None):
+        """
+        Use `self.sp` to display `msg` in the specified `pos`.
+
+        Consider overloading this function when inheriting to use e.g.:
+        `self.some_frontend(**self.format_dict)` instead of `self.sp`.
+
+        Parameters
+        ----------
+        msg  : str, optional. What to display (default: `repr(self)`).
+        pos  : int, optional. Position to `moveto`
+          (default: `abs(self.pos)`).
+        """
+        if pos is None:
+            pos = abs(self.pos)
+
+        nrows = self.nrows or 20
+        if pos >= nrows - 1:
+            if pos >= nrows:
+                return False
+            if msg or msg is None:  # override at `nrows - 1`
+                msg = " ... (more hidden) ..."
+
+        if not hasattr(self, "sp"):
+            raise TqdmDeprecationWarning(
+                "Please use `tqdm.gui.tqdm(...)`"
+                " instead of `tqdm(..., gui=True)`\n",
+                fp_write=getattr(self.fp, 'write', sys.stderr.write))
+
+        if pos:
+            self.moveto(pos)
+        self.sp(self.__str__() if msg is None else msg)
+        if pos:
+            self.moveto(-pos)
+        return True
+
+    @classmethod
+    @contextmanager
+    def wrapattr(cls, stream, method, total=None, bytes=True, **tqdm_kwargs):
+        """
+        stream  : file-like object.
+        method  : str, "read" or "write". The result of `read()` and
+            the first argument of `write()` should have a `len()`.
+
+        >>> with tqdm.wrapattr(file_obj, "read", total=file_obj.size) as fobj:
+        ...     while True:
+        ...         chunk = fobj.read(chunk_size)
+        ...         if not chunk:
+        ...             break
+        """
+        with cls(total=total, **tqdm_kwargs) as t:
+            if bytes:
+                t.unit = "B"
+                t.unit_scale = True
+                t.unit_divisor = 1024
+            yield CallbackIOWrapper(t.update, stream, method)
+
+
+def trange(*args, **kwargs):
+    """Shortcut for tqdm(range(*args), **kwargs)."""
+    return tqdm(range(*args), **kwargs)

vllm/lib/python3.10/site-packages/tqdm/tqdm.1

@@ -0,0 +1,314 @@
+.\" Automatically generated by Pandoc 1.19.2
+.\"
+.TH "TQDM" "1" "2015\-2021" "tqdm User Manuals" ""
+.hy
+.SH NAME
+.PP
+tqdm \- fast, extensible progress bar for Python and CLI
+.SH SYNOPSIS
+.PP
+tqdm [\f[I]options\f[]]
+.SH DESCRIPTION
+.PP
+See <https://github.com/tqdm/tqdm>.
+Can be used as a pipe:
+.IP
+.nf
+\f[C]
+$\ #\ count\ lines\ of\ code
+$\ cat\ *.py\ |\ tqdm\ |\ wc\ \-l
+327it\ [00:00,\ 981773.38it/s]
+327
+
+$\ #\ find\ all\ files
+$\ find\ .\ \-name\ "*.py"\ |\ tqdm\ |\ wc\ \-l
+432it\ [00:00,\ 833842.30it/s]
+432
+
+#\ ...\ and\ more\ info
+$\ find\ .\ \-name\ \[aq]*.py\[aq]\ \-exec\ wc\ \-l\ \\{}\ \\;\ \\
+\ \ |\ tqdm\ \-\-total\ 432\ \-\-unit\ files\ \-\-desc\ counting\ \\
+\ \ |\ awk\ \[aq]{\ sum\ +=\ $1\ };\ END\ {\ print\ sum\ }\[aq]
+counting:\ 100%|█████████|\ 432/432\ [00:00<00:00,\ 794361.83files/s]
+131998
+\f[]
+.fi
+.SH OPTIONS
+.TP
+.B \-h, \-\-help
+Print this help and exit.
+.RS
+.RE
+.TP
+.B \-v, \-\-version
+Print version and exit.
+.RS
+.RE
+.TP
+.B \-\-desc=\f[I]desc\f[]
+str, optional.
+Prefix for the progressbar.
+.RS
+.RE
+.TP
+.B \-\-total=\f[I]total\f[]
+int or float, optional.
+The number of expected iterations.
+If unspecified, len(iterable) is used if possible.
+If float("inf") or as a last resort, only basic progress statistics are
+displayed (no ETA, no progressbar).
+If \f[C]gui\f[] is True and this parameter needs subsequent updating,
+specify an initial arbitrary large positive number, e.g.
+9e9.
+.RS
+.RE
+.TP
+.B \-\-leave
+bool, optional.
+If [default: True], keeps all traces of the progressbar upon termination
+of iteration.
+If \f[C]None\f[], will leave only if \f[C]position\f[] is \f[C]0\f[].
+.RS
+.RE
+.TP
+.B \-\-ncols=\f[I]ncols\f[]
+int, optional.
+The width of the entire output message.
+If specified, dynamically resizes the progressbar to stay within this
+bound.
+If unspecified, attempts to use environment width.
+The fallback is a meter width of 10 and no limit for the counter and
+statistics.
+If 0, will not print any meter (only stats).
+.RS
+.RE
+.TP
+.B \-\-mininterval=\f[I]mininterval\f[]
+float, optional.
+Minimum progress display update interval [default: 0.1] seconds.
+.RS
+.RE
+.TP
+.B \-\-maxinterval=\f[I]maxinterval\f[]
+float, optional.
+Maximum progress display update interval [default: 10] seconds.
+Automatically adjusts \f[C]miniters\f[] to correspond to
+\f[C]mininterval\f[] after long display update lag.
+Only works if \f[C]dynamic_miniters\f[] or monitor thread is enabled.
+.RS
+.RE
+.TP
+.B \-\-miniters=\f[I]miniters\f[]
+int or float, optional.
+Minimum progress display update interval, in iterations.
+If 0 and \f[C]dynamic_miniters\f[], will automatically adjust to equal
+\f[C]mininterval\f[] (more CPU efficient, good for tight loops).
+If > 0, will skip display of specified number of iterations.
+Tweak this and \f[C]mininterval\f[] to get very efficient loops.
+If your progress is erratic with both fast and slow iterations (network,
+skipping items, etc) you should set miniters=1.
+.RS
+.RE
+.TP
+.B \-\-ascii=\f[I]ascii\f[]
+bool or str, optional.
+If unspecified or False, use unicode (smooth blocks) to fill the meter.
+The fallback is to use ASCII characters " 123456789#".
+.RS
+.RE
+.TP
+.B \-\-disable
+bool, optional.
+Whether to disable the entire progressbar wrapper [default: False].
+If set to None, disable on non\-TTY.
+.RS
+.RE
+.TP
+.B \-\-unit=\f[I]unit\f[]
+str, optional.
+String that will be used to define the unit of each iteration [default:
+it].
+.RS
+.RE
+.TP
+.B \-\-unit\-scale=\f[I]unit_scale\f[]
+bool or int or float, optional.
+If 1 or True, the number of iterations will be reduced/scaled
+automatically and a metric prefix following the International System of
+Units standard will be added (kilo, mega, etc.) [default: False].
+If any other non\-zero number, will scale \f[C]total\f[] and \f[C]n\f[].
+.RS
+.RE
+.TP
+.B \-\-dynamic\-ncols
+bool, optional.
+If set, constantly alters \f[C]ncols\f[] and \f[C]nrows\f[] to the
+environment (allowing for window resizes) [default: False].
+.RS
+.RE
+.TP
+.B \-\-smoothing=\f[I]smoothing\f[]
+float, optional.
+Exponential moving average smoothing factor for speed estimates (ignored
+in GUI mode).
+Ranges from 0 (average speed) to 1 (current/instantaneous speed)
+[default: 0.3].
+.RS
+.RE
+.TP
+.B \-\-bar\-format=\f[I]bar_format\f[]
+str, optional.
+Specify a custom bar string formatting.
+May impact performance.
+[default: \[aq]{l_bar}{bar}{r_bar}\[aq]], where l_bar=\[aq]{desc}:
+{percentage:3.0f}%|\[aq] and r_bar=\[aq]| {n_fmt}/{total_fmt}
+[{elapsed}<{remaining}, \[aq] \[aq]{rate_fmt}{postfix}]\[aq] Possible
+vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt, percentage,
+elapsed, elapsed_s, ncols, nrows, desc, unit, rate, rate_fmt,
+rate_noinv, rate_noinv_fmt, rate_inv, rate_inv_fmt, postfix,
+unit_divisor, remaining, remaining_s, eta.
+Note that a trailing ": " is automatically removed after {desc} if the
+latter is empty.
+.RS
+.RE
+.TP
+.B \-\-initial=\f[I]initial\f[]
+int or float, optional.
+The initial counter value.
+Useful when restarting a progress bar [default: 0].
+If using float, consider specifying \f[C]{n:.3f}\f[] or similar in
+\f[C]bar_format\f[], or specifying \f[C]unit_scale\f[].
+.RS
+.RE
+.TP
+.B \-\-position=\f[I]position\f[]
+int, optional.
+Specify the line offset to print this bar (starting from 0) Automatic if
+unspecified.
+Useful to manage multiple bars at once (eg, from threads).
+.RS
+.RE
+.TP
+.B \-\-postfix=\f[I]postfix\f[]
+dict or *, optional.
+Specify additional stats to display at the end of the bar.
+Calls \f[C]set_postfix(**postfix)\f[] if possible (dict).
+.RS
+.RE
+.TP
+.B \-\-unit\-divisor=\f[I]unit_divisor\f[]
+float, optional.
+[default: 1000], ignored unless \f[C]unit_scale\f[] is True.
+.RS
+.RE
+.TP
+.B \-\-write\-bytes
+bool, optional.
+Whether to write bytes.
+If (default: False) will write unicode.
+.RS
+.RE
+.TP
+.B \-\-lock\-args=\f[I]lock_args\f[]
+tuple, optional.
+Passed to \f[C]refresh\f[] for intermediate output (initialisation,
+iterating, and updating).
+.RS
+.RE
+.TP
+.B \-\-nrows=\f[I]nrows\f[]
+int, optional.
+The screen height.
+If specified, hides nested bars outside this bound.
+If unspecified, attempts to use environment height.
+The fallback is 20.
+.RS
+.RE
+.TP
+.B \-\-colour=\f[I]colour\f[]
+str, optional.
+Bar colour (e.g.
+\[aq]green\[aq], \[aq]#00ff00\[aq]).
+.RS
+.RE
+.TP
+.B \-\-delay=\f[I]delay\f[]
+float, optional.
+Don\[aq]t display until [default: 0] seconds have elapsed.
+.RS
+.RE
+.TP
+.B \-\-delim=\f[I]delim\f[]
+chr, optional.
+Delimiting character [default: \[aq]\\n\[aq]].
+Use \[aq]\\0\[aq] for null.
+N.B.: on Windows systems, Python converts \[aq]\\n\[aq] to
+\[aq]\\r\\n\[aq].
+.RS
+.RE
+.TP
+.B \-\-buf\-size=\f[I]buf_size\f[]
+int, optional.
+String buffer size in bytes [default: 256] used when \f[C]delim\f[] is
+specified.
+.RS
+.RE
+.TP
+.B \-\-bytes
+bool, optional.
+If true, will count bytes, ignore \f[C]delim\f[], and default
+\f[C]unit_scale\f[] to True, \f[C]unit_divisor\f[] to 1024, and
+\f[C]unit\f[] to \[aq]B\[aq].
+.RS
+.RE
+.TP
+.B \-\-tee
+bool, optional.
+If true, passes \f[C]stdin\f[] to both \f[C]stderr\f[] and
+\f[C]stdout\f[].
+.RS
+.RE
+.TP
+.B \-\-update
+bool, optional.
+If true, will treat input as newly elapsed iterations, i.e.
+numbers to pass to \f[C]update()\f[].
+Note that this is slow (~2e5 it/s) since every input must be decoded as
+a number.
+.RS
+.RE
+.TP
+.B \-\-update\-to
+bool, optional.
+If true, will treat input as total elapsed iterations, i.e.
+numbers to assign to \f[C]self.n\f[].
+Note that this is slow (~2e5 it/s) since every input must be decoded as
+a number.
+.RS
+.RE
+.TP
+.B \-\-null
+bool, optional.
+If true, will discard input (no stdout).
+.RS
+.RE
+.TP
+.B \-\-manpath=\f[I]manpath\f[]
+str, optional.
+Directory in which to install tqdm man pages.
+.RS
+.RE
+.TP
+.B \-\-comppath=\f[I]comppath\f[]
+str, optional.
+Directory in which to place tqdm completion.
+.RS
+.RE
+.TP
+.B \-\-log=\f[I]log\f[]
+str, optional.
+CRITICAL|FATAL|ERROR|WARN(ING)|[default: \[aq]INFO\[aq]]|DEBUG|NOTSET.
+.RS
+.RE
+.SH AUTHORS
+tqdm developers <https://github.com/tqdm>.

vllm/lib/python3.10/site-packages/wandb/cli/beta.py

@@ -0,0 +1,181 @@
+"""Beta versions of wandb CLI commands.
+
+These commands are experimental and may change or be removed in future versions.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import sys
+
+import click
+
+import wandb
+from wandb.errors import UsageError, WandbCoreNotAvailableError
+from wandb.sdk.wandb_sync import _sync
+from wandb.util import get_core_path
+
+
+@click.group()
+def beta():
+    """Beta versions of wandb CLI commands. Requires wandb-core."""
+    # this is the future that requires wandb-core!
+    import wandb.env
+
+    wandb._sentry.configure_scope(process_context="wandb_beta")
+
+    if wandb.env.is_require_legacy_service():
+        raise UsageError(
+            "wandb beta commands can only be used with wandb-core. "
+            f"Please make sure that `{wandb.env._REQUIRE_LEGACY_SERVICE}` is not set."
+        )
+
+    try:
+        get_core_path()
+    except WandbCoreNotAvailableError as e:
+        wandb._sentry.exception(f"using `wandb beta`. failed with {e}")
+        click.secho(
+            (e),
+            fg="red",
+            err=True,
+        )
+
+
+@beta.command(
+    name="sync",
+    context_settings={"default_map": {}},
+    help="Upload a training run to W&B",
+)
+@click.pass_context
+@click.argument("wandb_dir", nargs=1, type=click.Path(exists=True))
+@click.option("--id", "run_id", help="The run you want to upload to.")
+@click.option("--project", "-p", help="The project you want to upload to.")
+@click.option("--entity", "-e", help="The entity to scope to.")
+@click.option("--skip-console", is_flag=True, default=False, help="Skip console logs")
+@click.option("--append", is_flag=True, default=False, help="Append run")
+@click.option(
+    "--include",
+    "-i",
+    help="Glob to include. Can be used multiple times.",
+    multiple=True,
+)
+@click.option(
+    "--exclude",
+    "-e",
+    help="Glob to exclude. Can be used multiple times.",
+    multiple=True,
+)
+@click.option(
+    "--mark-synced/--no-mark-synced",
+    is_flag=True,
+    default=True,
+    help="Mark runs as synced",
+)
+@click.option(
+    "--skip-synced/--no-skip-synced",
+    is_flag=True,
+    default=True,
+    help="Skip synced runs",
+)
+@click.option(
+    "--dry-run", is_flag=True, help="Perform a dry run without uploading anything."
+)
+def sync_beta(  # noqa: C901
+    ctx,
+    wandb_dir=None,
+    run_id: str | None = None,
+    project: str | None = None,
+    entity: str | None = None,
+    skip_console: bool = False,
+    append: bool = False,
+    include: str | None = None,
+    exclude: str | None = None,
+    skip_synced: bool = True,
+    mark_synced: bool = True,
+    dry_run: bool = False,
+) -> None:
+    import concurrent.futures
+    from multiprocessing import cpu_count
+
+    paths = set()
+
+    # TODO: test file discovery logic
+    # include and exclude globs are evaluated relative to the provided base_path
+    if include:
+        for pattern in include:
+            matching_dirs = list(pathlib.Path(wandb_dir).glob(pattern))
+            for d in matching_dirs:
+                if not d.is_dir():
+                    continue
+                wandb_files = [p for p in d.glob("*.wandb") if p.is_file()]
+                if len(wandb_files) > 1:
+                    wandb.termwarn(
+                        f"Multiple wandb files found in directory {d}, skipping"
+                    )
+                elif len(wandb_files) == 1:
+                    paths.add(d)
+    else:
+        paths.update({p.parent for p in pathlib.Path(wandb_dir).glob("**/*.wandb")})
+
+    for pattern in exclude:
+        matching_dirs = list(pathlib.Path(wandb_dir).glob(pattern))
+        for d in matching_dirs:
+            if not d.is_dir():
+                continue
+            if d in paths:
+                paths.remove(d)
+
+    # remove paths that are already synced, if requested
+    if skip_synced:
+        synced_paths = set()
+        for path in paths:
+            wandb_synced_files = [p for p in path.glob("*.wandb.synced") if p.is_file()]
+            if len(wandb_synced_files) > 1:
+                wandb.termwarn(
+                    f"Multiple wandb.synced files found in directory {path}, skipping"
+                )
+            elif len(wandb_synced_files) == 1:
+                synced_paths.add(path)
+        paths -= synced_paths
+
+    if run_id and len(paths) > 1:
+        # TODO: handle this more gracefully
+        click.echo("id can only be set for a single run.", err=True)
+        sys.exit(1)
+
+    if not paths:
+        click.echo("No runs to sync.")
+        return
+
+    click.echo("Found runs:")
+    for path in paths:
+        click.echo(f"  {path}")
+
+    if dry_run:
+        return
+
+    wandb.setup()
+
+    # TODO: make it thread-safe in the Rust code
+    with concurrent.futures.ProcessPoolExecutor(
+        max_workers=min(len(paths), cpu_count())
+    ) as executor:
+        futures = []
+        for path in paths:
+            # we already know there is only one wandb file in the directory
+            wandb_file = [p for p in path.glob("*.wandb") if p.is_file()][0]
+            future = executor.submit(
+                _sync,
+                wandb_file,
+                run_id=run_id,
+                project=project,
+                entity=entity,
+                skip_console=skip_console,
+                append=append,
+                mark_synced=mark_synced,
+            )
+            futures.append(future)
+
+        # Wait for tasks to complete
+        for _ in concurrent.futures.as_completed(futures):
+            pass

vllm/lib/python3.10/site-packages/wandb/cli/cli.py

@@ -0,0 +1,2810 @@
+import asyncio
+import configparser
+import datetime
+import getpass
+import json
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+import textwrap
+import time
+import traceback
+from functools import wraps
+from typing import Any, Dict, Optional
+
+import click
+import yaml
+from click.exceptions import ClickException
+
+# pycreds has a find_executable that works in windows
+from dockerpycreds.utils import find_executable
+
+import wandb
+import wandb.env
+import wandb.errors
+import wandb.sdk.verify.verify as wandb_verify
+from wandb import Config, Error, env, util, wandb_agent, wandb_sdk
+from wandb.apis import InternalApi, PublicApi
+from wandb.apis.public import RunQueue
+from wandb.errors.links import url_registry
+from wandb.sdk.artifacts._validators import is_artifact_registry_project
+from wandb.sdk.artifacts.artifact_file_cache import get_artifact_file_cache
+from wandb.sdk.internal.internal_api import Api as SDKInternalApi
+from wandb.sdk.launch import utils as launch_utils
+from wandb.sdk.launch._launch_add import _launch_add
+from wandb.sdk.launch.errors import ExecutionError, LaunchError
+from wandb.sdk.launch.sweeps import utils as sweep_utils
+from wandb.sdk.launch.sweeps.scheduler import Scheduler
+from wandb.sdk.lib import filesystem
+from wandb.sync import SyncManager, get_run_from_path, get_runs
+
+from .beta import beta
+
+# Send cli logs to wandb/debug-cli.<username>.log by default and fallback to a temp dir.
+_wandb_dir = wandb.old.core.wandb_dir(env.get_dir())
+if not os.path.exists(_wandb_dir):
+    _wandb_dir = tempfile.gettempdir()
+
+try:
+    _username = getpass.getuser()
+except KeyError:
+    # getuser() could raise KeyError in restricted environments like
+    # chroot jails or docker containers. Return user id in these cases.
+    _username = str(os.getuid())
+
+_wandb_log_path = os.path.join(_wandb_dir, f"debug-cli.{_username}.log")
+
+logging.basicConfig(
+    filename=_wandb_log_path,
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+logger = logging.getLogger("wandb")
+
+# Click Contexts
+CONTEXT = {"default_map": {}}
+RUN_CONTEXT = {
+    "default_map": {},
+    "allow_extra_args": True,
+    "ignore_unknown_options": True,
+}
+
+
+def cli_unsupported(argument):
+    wandb.termerror(f"Unsupported argument `{argument}`")
+    sys.exit(1)
+
+
+class ClickWandbException(ClickException):
+    def format_message(self):
+        # log_file = util.get_log_file_path()
+        log_file = ""
+        orig_type = f"{self.orig_type.__module__}.{self.orig_type.__name__}"
+        if issubclass(self.orig_type, Error):
+            return click.style(str(self.message), fg="red")
+        else:
+            return (
+                f"An Exception was raised, see {log_file} for full traceback.\n"
+                f"{orig_type}: {self.message}"
+            )
+
+
+def display_error(func):
+    """Function decorator for catching common errors and re-raising as wandb.Error."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except wandb.Error as e:
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
+            logger.error("".join(lines))
+            wandb.termerror(f"Find detailed error logs at: {_wandb_log_path}")
+            click_exc = ClickWandbException(e)
+            click_exc.orig_type = exc_type
+            raise click_exc.with_traceback(sys.exc_info()[2])
+
+    return wrapper
+
+
+_api = None  # caching api instance allows patching from unit tests
+
+
+def _get_cling_api(reset=None):
+    """Get a reference to the internal api with cling settings."""
+    # TODO: move CLI to wandb-core backend
+    wandb.require("legacy-service")
+
+    global _api
+    if reset:
+        _api = None
+        wandb.teardown()
+    if _api is None:
+        # TODO(jhr): make a settings object that is better for non runs.
+        # only override the necessary setting
+        wandb.setup(settings=wandb.Settings(x_cli_only_mode=True))
+        _api = InternalApi()
+    return _api
+
+
+def prompt_for_project(ctx, entity):
+    """Ask the user for a project, creating one if necessary."""
+    result = ctx.invoke(projects, entity=entity, display=False)
+    api = _get_cling_api()
+    try:
+        if len(result) == 0:
+            project = click.prompt("Enter a name for your first project")
+            # description = editor()
+            project = api.upsert_project(project, entity=entity)["name"]
+        else:
+            project_names = [project["name"] for project in result] + ["Create New"]
+            wandb.termlog("Which project should we use?")
+            result = util.prompt_choices(project_names)
+            if result:
+                project = result
+            else:
+                project = "Create New"
+            # TODO: check with the server if the project exists
+            if project == "Create New":
+                project = click.prompt(
+                    "Enter a name for your new project", value_proc=api.format_project
+                )
+                # description = editor()
+                project = api.upsert_project(project, entity=entity)["name"]
+
+    except wandb.errors.CommError as e:
+        raise ClickException(str(e))
+
+    return project
+
+
+class RunGroup(click.Group):
+    @display_error
+    def get_command(self, ctx, cmd_name):
+        # TODO: check if cmd_name is a file in the current dir and not require `run`?
+        rv = click.Group.get_command(self, ctx, cmd_name)
+        if rv is not None:
+            return rv
+        return None
+
+
+@click.command(cls=RunGroup, invoke_without_command=True)
+@click.version_option(version=wandb.__version__)
+@click.pass_context
+def cli(ctx):
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@cli.command(context_settings=CONTEXT, help="List projects", hidden=True)
+@click.option(
+    "--entity",
+    "-e",
+    default=None,
+    envvar=env.ENTITY,
+    help="The entity to scope the listing to.",
+)
+@display_error
+def projects(entity, display=True):
+    api = _get_cling_api()
+    projects = api.list_projects(entity=entity)
+    if len(projects) == 0:
+        message = "No projects found for {}".format(entity)
+    else:
+        message = 'Latest projects for "{}"'.format(entity)
+    if display:
+        click.echo(click.style(message, bold=True))
+        for project in projects:
+            click.echo(
+                "".join(
+                    (
+                        click.style(project["name"], fg="blue", bold=True),
+                        " - ",
+                        str(project["description"] or "").split("\n")[0],
+                    )
+                )
+            )
+    return projects
+
+
+@cli.command(context_settings=CONTEXT, help="Login to Weights & Biases")
+@click.argument("key", nargs=-1)
+@click.option("--cloud", is_flag=True, help="Login to the cloud instead of local")
+@click.option("--host", default=None, help="Login to a specific instance of W&B")
+@click.option(
+    "--relogin", default=None, is_flag=True, help="Force relogin if already logged in."
+)
+@click.option("--anonymously", default=False, is_flag=True, help="Log in anonymously")
+@click.option("--verify", default=False, is_flag=True, help="Verify login credentials")
+@display_error
+def login(key, host, cloud, relogin, anonymously, verify, no_offline=False):
+    # TODO: move CLI to wandb-core backend
+    wandb.require("legacy-service")
+
+    # TODO: handle no_offline
+    anon_mode = "must" if anonymously else "never"
+
+    wandb_sdk.wandb_login._handle_host_wandb_setting(host, cloud)
+    # A change in click or the test harness means key can be none...
+    key = key[0] if key is not None and len(key) > 0 else None
+    if key:
+        relogin = True
+
+    login_settings = dict(
+        x_cli_only_mode=True,
+        x_disable_viewer=relogin and not verify,
+        anonymous=anon_mode,
+        base_url=host,
+    )
+
+    try:
+        wandb.setup(
+            settings=wandb.Settings(
+                **{k: v for k, v in login_settings.items() if v is not None}
+            )
+        )
+    except TypeError as e:
+        wandb.termerror(str(e))
+        sys.exit(1)
+
+    wandb.login(
+        relogin=relogin,
+        key=key,
+        anonymous=anon_mode,
+        host=host,
+        force=True,
+        verify=verify,
+    )
+
+
+@cli.command(
+    context_settings=CONTEXT, help="Run a wandb service", name="service", hidden=True
+)
+@click.option(
+    "--sock-port", default=None, type=int, help="The host port to bind socket service."
+)
+@click.option("--port-filename", default=None, help="Save allocated port to file.")
+@click.option("--address", default=None, help="The address to bind service.")
+@click.option("--pid", default=None, type=int, help="The parent process id to monitor.")
+@click.option("--debug", is_flag=True, help="log debug info")
+@display_error
+def service(
+    sock_port=None,
+    port_filename=None,
+    address=None,
+    pid=None,
+    debug=False,
+):
+    from wandb.sdk.service.server import WandbServer
+
+    server = WandbServer(
+        sock_port=sock_port,
+        port_fname=port_filename,
+        address=address,
+        pid=pid,
+        debug=debug,
+    )
+    server.serve()
+
+
+@cli.command(
+    context_settings=CONTEXT, help="Configure a directory with Weights & Biases"
+)
+@click.option("--project", "-p", help="The project to use.")
+@click.option("--entity", "-e", help="The entity to scope the project to.")
+# TODO(jhr): Enable these with settings rework
+# @click.option("--setting", "-s", help="enable an arbitrary setting.", multiple=True)
+# @click.option('--show', is_flag=True, help="Show settings")
+@click.option("--reset", is_flag=True, help="Reset settings")
+@click.option(
+    "--mode",
+    "-m",
+    help=' Can be "online", "offline" or "disabled". Defaults to online.',
+)
+@click.pass_context
+@display_error
+def init(ctx, project, entity, reset, mode):
+    from wandb.old.core import __stage_dir__, _set_stage_dir, wandb_dir
+
+    if __stage_dir__ is None:
+        _set_stage_dir("wandb")
+
+    # non-interactive init
+    if reset or project or entity or mode:
+        api = InternalApi()
+        if reset:
+            api.clear_setting("entity", persist=True)
+            api.clear_setting("project", persist=True)
+            api.clear_setting("mode", persist=True)
+            # TODO(jhr): clear more settings?
+        if entity:
+            api.set_setting("entity", entity, persist=True)
+        if project:
+            api.set_setting("project", project, persist=True)
+        if mode:
+            api.set_setting("mode", mode, persist=True)
+        return
+
+    if os.path.isdir(wandb_dir()) and os.path.exists(
+        os.path.join(wandb_dir(), "settings")
+    ):
+        click.confirm(
+            click.style(
+                "This directory has been configured previously, should we re-configure it?",
+                bold=True,
+            ),
+            abort=True,
+        )
+    else:
+        click.echo(
+            click.style("Let's setup this directory for W&B!", fg="green", bold=True)
+        )
+    api = _get_cling_api()
+    if api.api_key is None:
+        ctx.invoke(login)
+        api = _get_cling_api(reset=True)
+
+    viewer = api.viewer()
+
+    # Viewer can be `None` in case your API information became invalid, or
+    # in testing if you switch hosts.
+    if not viewer:
+        click.echo(
+            click.style(
+                "Your login information seems to be invalid: can you log in again please?",
+                fg="red",
+                bold=True,
+            )
+        )
+        ctx.invoke(login)
+        api = _get_cling_api(reset=True)
+
+    # This shouldn't happen.
+    viewer = api.viewer()
+    if not viewer:
+        click.echo(
+            click.style(
+                "We're sorry, there was a problem logging you in. "
+                "Please send us a note at support@wandb.com and tell us how this happened.",
+                fg="red",
+                bold=True,
+            )
+        )
+        sys.exit(1)
+
+    # At this point we should be logged in successfully.
+    if len(viewer["teams"]["edges"]) > 1:
+        team_names = [e["node"]["name"] for e in viewer["teams"]["edges"]] + [
+            "Manual entry"
+        ]
+        wandb.termlog(
+            "Which team should we use?",
+        )
+        result = util.prompt_choices(team_names)
+        # result can be empty on click
+        if result:
+            entity = result
+        else:
+            entity = "Manual Entry"
+        if entity == "Manual Entry":
+            entity = click.prompt("Enter the name of the team you want to use")
+    else:
+        entity = viewer.get("entity") or click.prompt(
+            "What username or team should we use?"
+        )
+
+    # TODO: this error handling sucks and the output isn't pretty
+    try:
+        project = prompt_for_project(ctx, entity)
+    except ClickWandbException:
+        raise ClickException(f"Could not find team: {entity}")
+
+    api.set_setting("entity", entity, persist=True)
+    api.set_setting("project", project, persist=True)
+    api.set_setting("base_url", api.settings().get("base_url"), persist=True)
+
+    filesystem.mkdir_exists_ok(wandb_dir())
+    with open(os.path.join(wandb_dir(), ".gitignore"), "w") as file:
+        file.write("*\n!settings")
+
+    click.echo(
+        click.style("This directory is configured!  Next, track a run:\n", fg="green")
+        + textwrap.dedent(
+            """\
+        * In your training script:
+            {code1}
+            {code2}
+        * then `{run}`.
+        """
+        ).format(
+            code1=click.style("import wandb", bold=True),
+            code2=click.style('wandb.init(project="{}")'.format(project), bold=True),
+            run=click.style("python <train.py>", bold=True),
+        )
+    )
+
+
+@cli.command(
+    context_settings=CONTEXT, help="Upload an offline training directory to W&B"
+)
+@click.pass_context
+@click.argument("path", nargs=-1, type=click.Path(exists=True))
+@click.option("--view", is_flag=True, default=False, help="View runs", hidden=True)
+@click.option("--verbose", is_flag=True, default=False, help="Verbose", hidden=True)
+@click.option("--id", "run_id", help="The run you want to upload to.")
+@click.option("--project", "-p", help="The project you want to upload to.")
+@click.option("--entity", "-e", help="The entity to scope to.")
+@click.option(
+    "--job_type",
+    "job_type",
+    help="Specifies the type of run for grouping related runs together.",
+)
+@click.option(
+    "--sync-tensorboard/--no-sync-tensorboard",
+    is_flag=True,
+    default=None,
+    help="Stream tfevent files to wandb.",
+)
+@click.option("--include-globs", help="Comma separated list of globs to include.")
+@click.option("--exclude-globs", help="Comma separated list of globs to exclude.")
+@click.option(
+    "--include-online/--no-include-online",
+    is_flag=True,
+    default=None,
+    help="Include online runs",
+)
+@click.option(
+    "--include-offline/--no-include-offline",
+    is_flag=True,
+    default=None,
+    help="Include offline runs",
+)
+@click.option(
+    "--include-synced/--no-include-synced",
+    is_flag=True,
+    default=None,
+    help="Include synced runs",
+)
+@click.option(
+    "--mark-synced/--no-mark-synced",
+    is_flag=True,
+    default=True,
+    help="Mark runs as synced",
+)
+@click.option("--sync-all", is_flag=True, default=False, help="Sync all runs")
+@click.option("--clean", is_flag=True, default=False, help="Delete synced runs")
+@click.option(
+    "--clean-old-hours",
+    default=24,
+    help="Delete runs created before this many hours. To be used alongside --clean flag.",
+    type=int,
+)
+@click.option(
+    "--clean-force",
+    is_flag=True,
+    default=False,
+    help="Clean without confirmation prompt.",
+)
+@click.option("--ignore", hidden=True)
+@click.option("--show", default=5, help="Number of runs to show")
+@click.option("--append", is_flag=True, default=False, help="Append run")
+@click.option("--skip-console", is_flag=True, default=False, help="Skip console logs")
+@display_error
+def sync(
+    ctx,
+    path=None,
+    view=None,
+    verbose=None,
+    run_id=None,
+    project=None,
+    entity=None,
+    job_type=None,  # trace this back to SyncManager
+    sync_tensorboard=None,
+    include_globs=None,
+    exclude_globs=None,
+    include_online=None,
+    include_offline=None,
+    include_synced=None,
+    mark_synced=None,
+    sync_all=None,
+    ignore=None,
+    show=None,
+    clean=None,
+    clean_old_hours=24,
+    clean_force=None,
+    append=None,
+    skip_console=None,
+):
+    api = _get_cling_api()
+    if not api.is_authenticated:
+        wandb.termlog("Login to W&B to sync offline runs")
+        ctx.invoke(login, no_offline=True)
+        api = _get_cling_api(reset=True)
+
+    if ignore:
+        exclude_globs = ignore
+    if include_globs:
+        include_globs = include_globs.split(",")
+    if exclude_globs:
+        exclude_globs = exclude_globs.split(",")
+
+    def _summary():
+        all_items = get_runs(
+            include_online=True,
+            include_offline=True,
+            include_synced=True,
+            include_unsynced=True,
+        )
+        sync_items = get_runs(
+            include_online=include_online if include_online is not None else True,
+            include_offline=include_offline if include_offline is not None else True,
+            include_synced=include_synced if include_synced is not None else False,
+            include_unsynced=True,
+            exclude_globs=exclude_globs,
+            include_globs=include_globs,
+        )
+        synced = []
+        unsynced = []
+        for item in all_items:
+            (synced if item.synced else unsynced).append(item)
+        if sync_items:
+            wandb.termlog(f"Number of runs to be synced: {len(sync_items)}")
+            if show and show < len(sync_items):
+                wandb.termlog(f"Showing {show} runs to be synced:")
+            for item in sync_items[: (show or len(sync_items))]:
+                wandb.termlog(f"  {item}")
+        else:
+            wandb.termlog("No runs to be synced.")
+        if synced:
+            clean_cmd = click.style("wandb sync --clean", fg="yellow")
+            wandb.termlog(
+                f"NOTE: use {clean_cmd} to delete {len(synced)} synced runs from local directory."
+            )
+        if unsynced:
+            sync_cmd = click.style("wandb sync --sync-all", fg="yellow")
+            wandb.termlog(
+                f"NOTE: use {sync_cmd} to sync {len(unsynced)} unsynced runs from local directory."
+            )
+
+    def _sync_path(_path, _sync_tensorboard):
+        if run_id and len(_path) > 1:
+            wandb.termerror("id can only be set for a single run.")
+            sys.exit(1)
+        sm = SyncManager(
+            project=project,
+            entity=entity,
+            run_id=run_id,
+            job_type=job_type,
+            mark_synced=mark_synced,
+            app_url=api.app_url,
+            view=view,
+            verbose=verbose,
+            sync_tensorboard=_sync_tensorboard,
+            log_path=_wandb_log_path,
+            append=append,
+            skip_console=skip_console,
+        )
+        for p in _path:
+            sm.add(p)
+        sm.start()
+        while not sm.is_done():
+            _ = sm.poll()
+
+    def _sync_all():
+        sync_items = get_runs(
+            include_online=include_online if include_online is not None else True,
+            include_offline=include_offline if include_offline is not None else True,
+            include_synced=include_synced if include_synced is not None else False,
+            include_unsynced=True,
+            exclude_globs=exclude_globs,
+            include_globs=include_globs,
+        )
+        if not sync_items:
+            wandb.termerror("Nothing to sync.")
+        else:
+            # When syncing run directories, default to not syncing tensorboard
+            sync_tb = sync_tensorboard if sync_tensorboard is not None else False
+            _sync_path(sync_items, sync_tb)
+
+    def _clean():
+        if path:
+            runs = list(map(get_run_from_path, path))
+            if not clean_force:
+                click.confirm(
+                    click.style(
+                        f"Are you sure you want to remove {len(runs)} runs?",
+                        bold=True,
+                    ),
+                    abort=True,
+                )
+            for run in runs:
+                shutil.rmtree(run.path)
+            click.echo(click.style("Success!", fg="green"))
+            return
+        runs = get_runs(
+            include_online=include_online if include_online is not None else True,
+            include_offline=include_offline if include_offline is not None else True,
+            include_synced=include_synced if include_synced is not None else True,
+            include_unsynced=False,
+            exclude_globs=exclude_globs,
+            include_globs=include_globs,
+        )
+        since = datetime.datetime.now() - datetime.timedelta(hours=clean_old_hours)
+        old_runs = [run for run in runs if run.datetime < since]
+        old_runs.sort(key=lambda _run: _run.datetime)
+        if old_runs:
+            click.echo(
+                f"Found {len(runs)} runs, {len(old_runs)} are older than {clean_old_hours} hours"
+            )
+            for run in old_runs:
+                click.echo(run.path)
+            if not clean_force:
+                click.confirm(
+                    click.style(
+                        f"Are you sure you want to remove {len(old_runs)} runs?",
+                        bold=True,
+                    ),
+                    abort=True,
+                )
+            for run in old_runs:
+                shutil.rmtree(run.path)
+            click.echo(click.style("Success!", fg="green"))
+        else:
+            click.echo(
+                click.style(
+                    f"No runs older than {clean_old_hours} hours found", fg="red"
+                )
+            )
+
+    if sync_all:
+        _sync_all()
+    elif clean:
+        _clean()
+    elif path:
+        # When syncing a specific path, default to syncing tensorboard
+        sync_tb = sync_tensorboard if sync_tensorboard is not None else True
+        _sync_path(path, sync_tb)
+    else:
+        _summary()
+
+
+@cli.command(
+    context_settings=CONTEXT,
+    help="Initialize a hyperparameter sweep. Search for hyperparameters that optimizes a cost function of a machine learning model by testing various combinations.",
+)
+@click.option(
+    "--project",
+    "-p",
+    default=None,
+    help="""The name of the project where W&B runs created from the sweep are sent to. If the project is not specified, the run is sent to a project labeled Uncategorized.""",
+)
+@click.option(
+    "--entity",
+    "-e",
+    default=None,
+    help="""The username or team name where you want to send W&B runs created by the sweep to. Ensure that the entity you specify already exists. If you don't specify an entity, the run will be sent to your default entity, which is usually your username.""",
+)
+@click.option("--controller", is_flag=True, default=False, help="Run local controller")
+@click.option("--verbose", is_flag=True, default=False, help="Display verbose output")
+@click.option(
+    "--name",
+    default=None,
+    help="The name of the sweep. The sweep ID is used if no name is specified.",
+)
+@click.option("--program", default=None, help="Set sweep program")
+@click.option("--settings", default=None, help="Set sweep settings", hidden=True)
+@click.option("--update", default=None, help="Update pending sweep")
+@click.option(
+    "--stop",
+    is_flag=True,
+    default=False,
+    help="Finish a sweep to stop running new runs and let currently running runs finish.",
+)
+@click.option(
+    "--cancel",
+    is_flag=True,
+    default=False,
+    help="Cancel a sweep to kill all running runs and stop running new runs.",
+)
+@click.option(
+    "--pause",
+    is_flag=True,
+    default=False,
+    help="Pause a sweep to temporarily stop running new runs.",
+)
+@click.option(
+    "--resume",
+    is_flag=True,
+    default=False,
+    help="Resume a sweep to continue running new runs.",
+)
+@click.option(
+    "--prior_run",
+    "-R",
+    "prior_runs",
+    multiple=True,
+    default=None,
+    help="ID of an existing run to add to this sweep",
+)
+@click.argument("config_yaml_or_sweep_id")
+@click.pass_context
+@display_error
+def sweep(
+    ctx,
+    project,
+    entity,
+    controller,
+    verbose,
+    name,
+    program,
+    settings,
+    update,
+    stop,
+    cancel,
+    pause,
+    resume,
+    prior_runs,
+    config_yaml_or_sweep_id,
+):
+    state_args = "stop", "cancel", "pause", "resume"
+    lcls = locals()
+    is_state_change_command = sum(lcls[k] for k in state_args)
+    if is_state_change_command > 1:
+        raise Exception("Only one state flag (stop/cancel/pause/resume) is allowed.")
+    elif is_state_change_command == 1:
+        sweep_id = config_yaml_or_sweep_id
+        api = _get_cling_api()
+        if not api.is_authenticated:
+            wandb.termlog("Login to W&B to use the sweep feature")
+            ctx.invoke(login, no_offline=True)
+            api = _get_cling_api(reset=True)
+        parts = dict(entity=entity, project=project, name=sweep_id)
+        err = sweep_utils.parse_sweep_id(parts)
+        if err:
+            wandb.termerror(err)
+            return
+        entity = parts.get("entity") or entity
+        project = parts.get("project") or project
+        sweep_id = parts.get("name") or sweep_id
+        state = [s for s in state_args if lcls[s]][0]
+        ings = {
+            "stop": "Stopping",
+            "cancel": "Cancelling",
+            "pause": "Pausing",
+            "resume": "Resuming",
+        }
+        wandb.termlog(f"{ings[state]} sweep {entity}/{project}/{sweep_id}")
+        getattr(api, "{}_sweep".format(state))(sweep_id, entity=entity, project=project)
+        wandb.termlog("Done.")
+        return
+    else:
+        config_yaml = config_yaml_or_sweep_id
+
+    def _parse_settings(settings):
+        """Parse settings from json or comma separated assignments."""
+        ret = {}
+        # TODO(jhr): merge with magic:_parse_magic
+        if settings.find("=") > 0:
+            for item in settings.split(","):
+                kv = item.split("=")
+                if len(kv) != 2:
+                    wandb.termwarn(
+                        "Unable to parse sweep settings key value pair", repeat=False
+                    )
+                ret.update(dict([kv]))
+            return ret
+        wandb.termwarn("Unable to parse settings parameter", repeat=False)
+        return ret
+
+    api = _get_cling_api()
+    if not api.is_authenticated:
+        wandb.termlog("Login to W&B to use the sweep feature")
+        ctx.invoke(login, no_offline=True)
+        api = _get_cling_api(reset=True)
+
+    sweep_obj_id = None
+    if update:
+        parts = dict(entity=entity, project=project, name=update)
+        err = sweep_utils.parse_sweep_id(parts)
+        if err:
+            wandb.termerror(err)
+            return
+        entity = parts.get("entity") or entity
+        project = parts.get("project") or project
+        sweep_id = parts.get("name") or update
+
+        has_project = (project or api.settings("project")) is not None
+        has_entity = (entity or api.settings("entity")) is not None
+
+        termerror_msg = (
+            "Sweep lookup requires a valid %s, and none was specified. \n"
+            "Either set a default %s in wandb/settings, or, if invoking \n`wandb sweep` "
+            "from the command line, specify the full sweep path via: \n\n"
+            "    wandb sweep {username}/{projectname}/{sweepid}\n\n"
+        )
+
+        if not has_entity:
+            wandb.termerror(termerror_msg % (("entity",) * 2))
+            return
+
+        if not has_project:
+            wandb.termerror(termerror_msg % (("project",) * 2))
+            return
+
+        found = api.sweep(sweep_id, "{}", entity=entity, project=project)
+        if not found:
+            wandb.termerror(f"Could not find sweep {entity}/{project}/{sweep_id}")
+            return
+        sweep_obj_id = found["id"]
+
+    action = "Updating" if sweep_obj_id else "Creating"
+    wandb.termlog(f"{action} sweep from: {config_yaml}")
+    config = sweep_utils.load_sweep_config(config_yaml)
+
+    # Set or override parameters
+    if name:
+        config["name"] = name
+    if program:
+        config["program"] = program
+    if settings:
+        settings = _parse_settings(settings)
+        if settings:
+            config.setdefault("settings", {})
+            config["settings"].update(settings)
+    if controller:
+        config.setdefault("controller", {})
+        config["controller"]["type"] = "local"
+
+    is_local = config.get("controller", {}).get("type") == "local"
+    if is_local:
+        from wandb import controller as wandb_controller
+
+        tuner = wandb_controller()
+        err = tuner._validate(config)
+        if err:
+            wandb.termerror(f"Error in sweep file: {err}")
+            return
+
+    env = os.environ
+    entity = (
+        entity
+        or env.get("WANDB_ENTITY")
+        or config.get("entity")
+        or api.settings("entity")
+    )
+    project = (
+        project
+        or env.get("WANDB_PROJECT")
+        or config.get("project")
+        or api.settings("project")
+        or util.auto_project_name(config.get("program"))
+    )
+
+    sweep_id, warnings = api.upsert_sweep(
+        config,
+        project=project,
+        entity=entity,
+        obj_id=sweep_obj_id,
+        prior_runs=prior_runs,
+    )
+    sweep_utils.handle_sweep_config_violations(warnings)
+
+    # Log nicely formatted sweep information
+    styled_id = click.style(sweep_id, fg="yellow")
+    wandb.termlog(f"{action} sweep with ID: {styled_id}")
+
+    sweep_url = wandb_sdk.wandb_sweep._get_sweep_url(api, sweep_id)
+    if sweep_url:
+        styled_url = click.style(sweep_url, underline=True, fg="blue")
+        wandb.termlog(f"View sweep at: {styled_url}")
+
+    # re-probe entity and project if it was auto-detected by upsert_sweep
+    entity = entity or env.get("WANDB_ENTITY")
+    project = project or env.get("WANDB_PROJECT")
+
+    if entity and project:
+        sweep_path = f"{entity}/{project}/{sweep_id}"
+    elif project:
+        sweep_path = f"{project}/{sweep_id}"
+    else:
+        sweep_path = sweep_id
+
+    if sweep_path.find(" ") >= 0:
+        sweep_path = f"{sweep_path!r}"
+
+    styled_path = click.style(f"wandb agent {sweep_path}", fg="yellow")
+    wandb.termlog(f"Run sweep agent with: {styled_path}")
+    if controller:
+        wandb.termlog("Starting wandb controller...")
+        from wandb import controller as wandb_controller
+
+        tuner = wandb_controller(sweep_id)
+        tuner.run(verbose=verbose)
+
+
+@cli.command(
+    context_settings=CONTEXT,
+    no_args_is_help=True,
+    help="Run a W&B launch sweep (Experimental).",
+)
+@click.option(
+    "--queue",
+    "-q",
+    default=None,
+    help="The name of a queue to push the sweep to",
+)
+@click.option(
+    "--project",
+    "-p",
+    default=None,
+    help="Name of the project which the agent will watch. "
+    "If passed in, will override the project value passed in using a config file",
+)
+@click.option(
+    "--entity",
+    "-e",
+    default=None,
+    help="The entity to use. Defaults to current logged-in user",
+)
+@click.option(
+    "--resume_id",
+    "-r",
+    default=None,
+    help="Resume a launch sweep by passing an 8-char sweep id. Queue required",
+)
+@click.option(
+    "--prior_run",
+    "-R",
+    "prior_runs",
+    multiple=True,
+    default=None,
+    help="ID of an existing run to add to this sweep",
+)
+@click.argument("config", required=False, type=click.Path(exists=True))
+@click.pass_context
+@display_error
+def launch_sweep(
+    ctx,
+    project,
+    entity,
+    queue,
+    config,
+    resume_id,
+    prior_runs,
+):
+    api = _get_cling_api()
+    env = os.environ
+    if not api.is_authenticated:
+        wandb.termlog("Login to W&B to use the sweep feature")
+        ctx.invoke(login, no_offline=True)
+        api = _get_cling_api(reset=True)
+
+    entity = entity or env.get("WANDB_ENTITY") or api.settings("entity")
+    if entity is None:
+        wandb.termerror("Must specify entity when using launch")
+        return
+
+    project = project or env.get("WANDB_PROJECT") or api.settings("project")
+    if project is None:
+        wandb.termerror("A project must be configured when using launch")
+        return
+
+    # get personal username, not team name or service account, default to entity
+    author = api.viewer().get("username") or entity
+
+    # if not sweep_config XOR resume_id
+    if not (config or resume_id):
+        wandb.termerror("'config' and/or 'resume_id' required")
+        return
+
+    parsed_user_config = sweep_utils.load_launch_sweep_config(config)
+    # Rip special keys out of config, store in scheduler run_config
+    launch_args: Dict[str, Any] = parsed_user_config.pop("launch", {})
+    scheduler_args: Dict[str, Any] = parsed_user_config.pop("scheduler", {})
+    settings: Dict[str, Any] = scheduler_args.pop("settings", {})
+
+    scheduler_job: Optional[str] = scheduler_args.get("job")
+    if scheduler_job:
+        wandb.termwarn(
+            "Using a scheduler job for launch sweeps is *experimental* and may change without warning"
+        )
+    queue: Optional[str] = queue or launch_args.get("queue")
+
+    sweep_config, sweep_obj_id = None, None
+    if not resume_id:
+        sweep_config = parsed_user_config
+
+        # check method
+        method = sweep_config.get("method")
+        if scheduler_job and not method:
+            sweep_config["method"] = "custom"
+        elif scheduler_job and method != "custom":
+            # TODO(gst): Check if using Anaconda2
+            wandb.termwarn(
+                "Use 'method': 'custom' in the sweep config when using scheduler jobs, "
+                "or omit it entirely. For jobs using the wandb optimization engine (WandbScheduler), "
+                "set the method in the sweep config under scheduler.settings.method "
+            )
+            settings["method"] = method
+
+        if settings.get("method"):
+            # assume WandbScheduler, and user is using this right
+            sweep_config["method"] = settings["method"]
+
+    else:  # Resuming an existing sweep
+        found = api.sweep(resume_id, "{}", entity=entity, project=project)
+        if not found:
+            wandb.termerror(f"Could not find sweep {entity}/{project}/{resume_id}")
+            return
+
+        if found.get("state") == "RUNNING":
+            wandb.termerror(
+                f"Cannot resume sweep {entity}/{project}/{resume_id}, it is already running"
+            )
+            return
+
+        sweep_obj_id = found["id"]
+        sweep_config = yaml.safe_load(found["config"])
+        wandb.termlog(f"Resuming from existing sweep {entity}/{project}/{resume_id}")
+        if len(parsed_user_config.keys()) > 0:
+            wandb.termwarn(
+                "Sweep parameters loaded from resumed sweep, ignoring provided config"
+            )
+
+        prev_scheduler = json.loads(found.get("scheduler") or "{}")
+        run_spec = json.loads(prev_scheduler.get("run_spec", "{}"))
+        if (
+            scheduler_job
+            and run_spec.get("job")
+            and run_spec.get("job") != scheduler_job
+        ):
+            wandb.termerror(
+                f"Resuming a launch sweep with a different scheduler job is not supported. Job loaded from sweep: {run_spec.get('job')}, job in config: {scheduler_job}"
+            )
+            return
+
+        prev_scheduler_args, prev_settings = sweep_utils.get_previous_args(run_spec)
+        # Passed in scheduler_args and settings override previous
+        scheduler_args.update(prev_scheduler_args)
+        settings.update(prev_settings)
+    if not queue:
+        wandb.termerror(
+            "Launch-sweeps require setting a 'queue', use --queue option or a 'queue' key in the 'launch' section in the config"
+        )
+        return
+
+    entrypoint = Scheduler.ENTRYPOINT if not scheduler_job else None
+    args = sweep_utils.construct_scheduler_args(
+        return_job=scheduler_job is not None,
+        sweep_config=sweep_config,
+        queue=queue,
+        project=project,
+        author=author,
+    )
+    if not args:
+        return
+
+    # validate training job existence
+    if not sweep_utils.check_job_exists(PublicApi(), sweep_config.get("job")):
+        return False
+
+    # validate scheduler job existence, if present
+    if not sweep_utils.check_job_exists(PublicApi(), scheduler_job):
+        return False
+
+    # Set run overrides for the Scheduler
+    overrides = {"run_config": {}}
+    if launch_args:
+        overrides["run_config"]["launch"] = launch_args
+    if scheduler_args:
+        overrides["run_config"]["scheduler"] = scheduler_args
+    if settings:
+        overrides["run_config"]["settings"] = settings
+
+    if scheduler_job:
+        overrides["run_config"]["sweep_args"] = args
+    else:
+        overrides["args"] = args
+
+    # configure scheduler job resource
+    resource = scheduler_args.get("resource")
+    if resource:
+        if resource == "local-process" and scheduler_job:
+            wandb.termerror(
+                "Scheduler jobs cannot be run with the 'local-process' resource"
+            )
+            return
+        if resource == "local-process" and scheduler_args.get("docker_image"):
+            wandb.termerror(
+                "Scheduler jobs cannot be run with the 'local-process' resource and a docker image"
+            )
+            return
+    else:  # no resource set, default local-process if not scheduler job, else container
+        resource = "local-process" if not scheduler_job else "local-container"
+
+    # Launch job spec for the Scheduler
+    launch_scheduler_spec = launch_utils.construct_launch_spec(
+        uri=Scheduler.PLACEHOLDER_URI,
+        api=api,
+        name="Scheduler.WANDB_SWEEP_ID",
+        project=project,
+        entity=entity,
+        docker_image=scheduler_args.get("docker_image"),
+        resource=resource,
+        entry_point=entrypoint,
+        resource_args=scheduler_args.get("resource_args", {}),
+        repository=launch_args.get("registry", {}).get("url", None),
+        job=scheduler_job,
+        version=None,
+        launch_config={"overrides": overrides},
+        run_id="WANDB_SWEEP_ID",  # scheduler inits run with sweep_id=run_id
+        author=None,  # author gets passed into scheduler override args
+    )
+    launch_scheduler_with_queue = json.dumps(
+        {
+            "queue": queue,
+            "run_queue_project": launch_utils.LAUNCH_DEFAULT_PROJECT,
+            "run_spec": json.dumps(launch_scheduler_spec),
+        }
+    )
+
+    sweep_id, warnings = api.upsert_sweep(
+        sweep_config,
+        project=project,
+        entity=entity,
+        obj_id=sweep_obj_id,  # if resuming
+        launch_scheduler=launch_scheduler_with_queue,
+        state="PENDING",
+        prior_runs=prior_runs,
+        template_variable_values=scheduler_args.get("template_variables", None),
+    )
+    sweep_utils.handle_sweep_config_violations(warnings)
+    # Log nicely formatted sweep information
+    styled_id = click.style(sweep_id, fg="yellow")
+    wandb.termlog(f"{'Resumed' if resume_id else 'Created'} sweep with ID: {styled_id}")
+    sweep_url = wandb_sdk.wandb_sweep._get_sweep_url(api, sweep_id)
+    if sweep_url:
+        styled_url = click.style(sweep_url, underline=True, fg="blue")
+        wandb.termlog(f"View sweep at: {styled_url}")
+    wandb.termlog(f"Scheduler added to launch queue ({queue})")
+
+
+@cli.command(help=f"Launch or queue a W&B Job. See {url_registry.url('wandb-launch')}")
+@click.option(
+    "--uri",
+    "-u",
+    metavar="(str)",
+    default=None,
+    help="Local path or git repo uri to launch. If provided this command will "
+    "create a job from the specified uri.",
+)
+@click.option(
+    "--job",
+    "-j",
+    metavar="(str)",
+    default=None,
+    help="Name of the job to launch. If passed in, launch does not require a uri.",
+)
+@click.option(
+    "--entry-point",
+    "-E",
+    metavar="NAME",
+    default=None,
+    help="""Entry point within project. [default: main]. If the entry point is not found,
+    attempts to run the project file with the specified name as a script,
+    using 'python' to run .py files and the default shell (specified by
+    environment variable $SHELL) to run .sh files. If passed in, will override the entrypoint value passed in using a config file.""",
+)
+@click.option(
+    "--git-version",
+    "-g",
+    metavar="GIT-VERSION",
+    hidden=True,
+    help="Version of the project to run, as a Git commit reference for Git projects.",
+)
+@click.option(
+    "--build-context",
+    metavar="(str)",
+    help="Path to the build context within the source code. Defaults to the "
+    "root of the source code. Compatible only with -u.",
+)
+@click.option(
+    "--job-name",
+    "-J",
+    metavar="(str)",
+    default=None,
+    hidden=True,
+    help="Name for the job created if the -u,--uri flag is passed in.",
+)
+@click.option(
+    "--name",
+    envvar="WANDB_NAME",
+    help="""Name of the run under which to launch the run. If not
+    specified, a random run name will be used to launch run. If passed in, will override the name passed in using a config file.""",
+)
+@click.option(
+    "--entity",
+    "-e",
+    metavar="(str)",
+    default=None,
+    help="""Name of the target entity which the new run will be sent to. Defaults to using the entity set by local wandb/settings folder.
+    If passed in, will override the entity value passed in using a config file.""",
+)
+@click.option(
+    "--project",
+    "-p",
+    metavar="(str)",
+    default=None,
+    help="""Name of the target project which the new run will be sent to. Defaults to using the project name given by the source uri
+    or for github runs, the git repo name. If passed in, will override the project value passed in using a config file.""",
+)
+@click.option(
+    "--resource",
+    "-r",
+    metavar="BACKEND",
+    default=None,
+    help="""Execution resource to use for run. Supported values: 'local-process', 'local-container', 'kubernetes', 'sagemaker', 'gcp-vertex'.
+    This is now a required parameter if pushing to a queue with no resource configuration.
+    If passed in, will override the resource value passed in using a config file.""",
+)
+@click.option(
+    "--docker-image",
+    "-d",
+    default=None,
+    metavar="DOCKER IMAGE",
+    help="""Specific docker image you'd like to use. In the form name:tag.
+    If passed in, will override the docker image value passed in using a config file.""",
+)
+@click.option(
+    "--base-image",
+    "-B",
+    default=None,
+    metavar="BASE IMAGE",
+    help="""Docker image to run job code in. Incompatible with --docker-image.""",
+)
+@click.option(
+    "--config",
+    "-c",
+    metavar="FILE",
+    help="""Path to JSON file (must end in '.json') or JSON string which will be passed
+    as a launch config. Dictation how the launched run will be configured.""",
+)
+@click.option(
+    "--set-var",
+    "-v",
+    "cli_template_vars",
+    default=None,
+    multiple=True,
+    help="""Set template variable values for queues with allow listing enabled,
+    as key-value pairs e.g. `--set-var key1=value1 --set-var key2=value2`""",
+)
+@click.option(
+    "--queue",
+    "-q",
+    is_flag=False,
+    flag_value="default",
+    default=None,
+    help="""Name of run queue to push to. If none, launches single run directly. If supplied without
+    an argument (`--queue`), defaults to queue 'default'. Else, if name supplied, specified run queue must exist under the
+    project and entity supplied.""",
+)
+@click.option(
+    "--async",
+    "run_async",
+    is_flag=True,
+    help="""Flag to run the job asynchronously. Defaults to false, i.e. unless --async is set, wandb launch will wait for
+    the job to finish. This option is incompatible with --queue; asynchronous options when running with an agent should be
+    set on wandb launch-agent.""",
+)
+@click.option(
+    "--resource-args",
+    "-R",
+    metavar="FILE",
+    help="""Path to JSON file (must end in '.json') or JSON string which will be passed
+    as resource args to the compute resource. The exact content which should be
+    provided is different for each execution backend. See documentation for layout of this file.""",
+)
+@click.option(
+    "--build",
+    "-b",
+    is_flag=True,
+    hidden=True,
+    help="Flag to build an associated job and push to queue as an image job.",
+)
+@click.option(
+    "--repository",
+    "-rg",
+    is_flag=False,
+    default=None,
+    hidden=True,
+    help="Name of a remote repository. Will be used to push a built image to.",
+)
+# TODO: this is only included for back compat. But we should remove this in the future
+@click.option(
+    "--project-queue",
+    "-pq",
+    default=None,
+    hidden=True,
+    help="Name of the project containing the queue to push to. If none, defaults to entity level queues.",
+)
+@click.option(
+    "--dockerfile",
+    "-D",
+    default=None,
+    help="Path to the Dockerfile used to build the job, relative to the job's root",
+)
+@click.option(
+    "--priority",
+    "-P",
+    default=None,
+    type=click.Choice(["critical", "high", "medium", "low"]),
+    help="""When --queue is passed, set the priority of the job. Launch jobs with higher priority
+    are served first.  The order, from highest to lowest priority, is: critical, high, medium, low""",
+)
+@display_error
+def launch(
+    uri,
+    job,
+    entry_point,
+    git_version,
+    build_context,
+    name,
+    resource,
+    entity,
+    project,
+    docker_image,
+    base_image,
+    config,
+    cli_template_vars,
+    queue,
+    run_async,
+    resource_args,
+    build,
+    repository,
+    project_queue,
+    dockerfile,
+    priority,
+    job_name,
+):
+    """Start a W&B run from the given URI.
+
+    The URI can bea wandb URI, a GitHub repo uri, or a local path). In the case of a
+    wandb URI the arguments used in the original run will be used by default. These
+    arguments can be overridden using the args option, or specifying those arguments in
+    the config's 'overrides' key, 'args' field as a list of strings.
+
+    Running `wandb launch [URI]` will launch the run directly. To add the run to a
+    queue, run `wandb launch [URI] --queue [optional queuename]`.
+    """
+    logger.info(
+        f"=== Launch called with kwargs {locals()} CLI Version: {wandb.__version__}==="
+    )
+    from wandb.sdk.launch._launch import _launch
+    from wandb.sdk.launch.create_job import _create_job
+    from wandb.sdk.launch.utils import _is_git_uri
+
+    api = _get_cling_api()
+    wandb._sentry.configure_scope(process_context="launch_cli")
+
+    if run_async and queue is not None:
+        raise LaunchError(
+            "Cannot use both --async and --queue with wandb launch, see help for details."
+        )
+
+    if queue and docker_image and not project:
+        raise LaunchError(
+            "Cannot use --queue and --docker together without a project. Please specify a project with --project or -p."
+        )
+
+    if priority is not None and queue is None:
+        raise LaunchError("--priority flag requires --queue to be set")
+
+    if resource_args is not None:
+        resource_args = util.load_json_yaml_dict(resource_args)
+        if resource_args is None:
+            raise LaunchError("Invalid format for resource-args")
+    else:
+        resource_args = {}
+
+    if entry_point is not None:
+        entry_point = shlex.split(entry_point)
+
+    if config is not None:
+        config = util.load_json_yaml_dict(config)
+        if config is None:
+            raise LaunchError("Invalid format for config")
+    else:
+        config = {}
+
+    resource = resource or config.get("resource")
+
+    if build and queue is None:
+        raise LaunchError("Build flag requires a queue to be set")
+
+    try:
+        launch_utils.check_logged_in(api)
+    except Exception:
+        wandb.termerror(f"Error running job: {traceback.format_exc()}")
+
+    run_id = config.get("run_id")
+
+    # If URI was provided, we need to create a job from it.
+    if uri:
+        if entry_point is None:
+            raise LaunchError(
+                "Cannot provide a uri without an entry point. Please provide an "
+                "entry point with --entry-point or -E."
+            )
+        if job is not None:
+            raise LaunchError("Cannot provide both a uri and a job name.")
+        job_type = (
+            "git" if _is_git_uri(uri) else "code"
+        )  # TODO: Add support for local URIs with git.
+        if entity is None:
+            entity = launch_utils.get_default_entity(api, config)
+        artifact, _, _ = _create_job(
+            api,
+            job_type,
+            uri,
+            entrypoint=" ".join(entry_point),
+            git_hash=git_version,
+            name=job_name,
+            project=project,
+            base_image=base_image,
+            build_context=build_context,
+            dockerfile=dockerfile,
+            entity=entity,
+        )
+        if artifact is None:
+            raise LaunchError(f"Failed to create job from uri: {uri}")
+        job = f"{entity}/{project}/{artifact.name}"
+
+    if dockerfile:
+        if "overrides" in config:
+            config["overrides"]["dockerfile"] = dockerfile
+        else:
+            config["overrides"] = {"dockerfile": dockerfile}
+
+    if priority is not None:
+        priority_map = {
+            "critical": 0,
+            "high": 1,
+            "medium": 2,
+            "low": 3,
+        }
+        priority = priority_map[priority.lower()]
+
+    template_variables = None
+    if cli_template_vars:
+        if queue is None:
+            raise LaunchError("'--set-var' flag requires queue to be set")
+        if entity is None:
+            entity = launch_utils.get_default_entity(api, config)
+        public_api = PublicApi()
+        runqueue = RunQueue(client=public_api.client, name=queue, entity=entity)
+        template_variables = launch_utils.fetch_and_validate_template_variables(
+            runqueue, cli_template_vars
+        )
+
+    if queue is None:
+        # direct launch
+        try:
+            run = asyncio.run(
+                _launch(
+                    api,
+                    job,
+                    project=project,
+                    entity=entity,
+                    docker_image=docker_image,
+                    name=name,
+                    entry_point=entry_point,
+                    version=git_version,
+                    resource=resource,
+                    resource_args=resource_args,
+                    launch_config=config,
+                    synchronous=(not run_async),
+                    run_id=run_id,
+                    repository=repository,
+                )
+            )
+            if asyncio.run(run.get_status()).state in [
+                "failed",
+                "stopped",
+                "preempted",
+            ]:
+                wandb.termerror("Launched run exited with non-zero status")
+                sys.exit(1)
+        except LaunchError as e:
+            logger.error("=== %s ===", e)
+            wandb._sentry.exception(e)
+            sys.exit(e)
+        except ExecutionError as e:
+            logger.error("=== %s ===", e)
+            wandb._sentry.exception(e)
+            sys.exit(e)
+        except asyncio.CancelledError:
+            sys.exit(0)
+    else:
+        try:
+            _launch_add(
+                api,
+                job,
+                config,
+                template_variables,
+                project,
+                entity,
+                queue,
+                resource,
+                entry_point,
+                name,
+                git_version,
+                docker_image,
+                project_queue,
+                resource_args,
+                build=build,
+                run_id=run_id,
+                repository=repository,
+                priority=priority,
+            )
+
+        except Exception as e:
+            wandb._sentry.exception(e)
+            raise e
+
+
+@cli.command(
+    context_settings=CONTEXT,
+    help="Run a W&B launch agent.",
+)
+@click.pass_context
+@click.option(
+    "--queue",
+    "-q",
+    "queues",
+    default=None,
+    multiple=True,
+    help="The name of a queue for the agent to watch. Multiple -q flags supported.",
+)
+@click.option(
+    "--entity",
+    "-e",
+    default=None,
+    help="The entity to use. Defaults to current logged-in user",
+)
+@click.option(
+    "--log-file",
+    "-l",
+    default=None,
+    help=(
+        "Destination for internal agent logs. Use - for stdout. "
+        "By default all agents logs will go to debug.log in your wandb/ "
+        "subdirectory or WANDB_DIR if set."
+    ),
+)
+@click.option(
+    "--max-jobs",
+    "-j",
+    default=None,
+    help="The maximum number of launch jobs this agent can run in parallel. Defaults to 1. Set to -1 for no upper limit",
+)
+@click.option(
+    "--config", "-c", default=None, help="path to the agent config yaml to use"
+)
+@click.option(
+    "--url",
+    "-u",
+    default=None,
+    hidden=True,
+    help="a wandb client registration URL, this is generated in the UI",
+)
+@click.option("--verbose", "-v", count=True, help="Display verbose output")
+@display_error
+def launch_agent(
+    ctx,
+    entity=None,
+    queues=None,
+    max_jobs=None,
+    config=None,
+    url=None,
+    log_file=None,
+    verbose=0,
+):
+    logger.info(
+        f"=== Launch-agent called with kwargs {locals()}  CLI Version: {wandb.__version__} ==="
+    )
+    if url is not None:
+        raise LaunchError(
+            "--url is not supported in this version, upgrade with: pip install -u wandb"
+        )
+
+    import wandb.sdk.launch._launch as _launch
+
+    if log_file is not None:
+        _launch.set_launch_logfile(log_file)
+
+    api = _get_cling_api()
+    wandb._sentry.configure_scope(process_context="launch_agent")
+    agent_config, api = _launch.resolve_agent_config(
+        entity, max_jobs, queues, config, verbose
+    )
+
+    if len(agent_config.get("queues")) == 0:
+        raise LaunchError(
+            "To launch an agent please specify a queue or a list of queues in the configuration file or cli."
+        )
+
+    launch_utils.check_logged_in(api)
+
+    wandb.termlog("Starting launch agent ✨")
+    try:
+        _launch.create_and_run_agent(api, agent_config)
+    except Exception as e:
+        wandb._sentry.exception(e)
+        raise e
+
+
+@cli.command(context_settings=CONTEXT, help="Run the W&B agent")
+@click.pass_context
+@click.option(
+    "--project",
+    "-p",
+    default=None,
+    help="""The name of the project where W&B runs created from the sweep are sent to. If the project is not specified, the run is sent to a project labeled 'Uncategorized'.""",
+)
+@click.option(
+    "--entity",
+    "-e",
+    default=None,
+    help="""The username or team name where you want to send W&B runs created by the sweep to. Ensure that the entity you specify already exists. If you don't specify an entity, the run will be sent to your default entity, which is usually your username.""",
+)
+@click.option(
+    "--count", default=None, type=int, help="The max number of runs for this agent."
+)
+@click.argument("sweep_id")
+@display_error
+def agent(ctx, project, entity, count, sweep_id):
+    api = _get_cling_api()
+    if not api.is_authenticated:
+        wandb.termlog("Login to W&B to use the sweep agent feature")
+        ctx.invoke(login, no_offline=True)
+        api = _get_cling_api(reset=True)
+
+    wandb.termlog("Starting wandb agent 🕵️")
+    wandb_agent.agent(sweep_id, entity=entity, project=project, count=count)
+
+    # you can send local commands like so:
+    # agent_api.command({'type': 'run', 'program': 'train.py',
+    #                'args': ['--max_epochs=10']})
+
+
+@cli.command(
+    context_settings=RUN_CONTEXT, help="Run a W&B launch sweep scheduler (Experimental)"
+)
+@click.pass_context
+@click.argument("sweep_id")
+@display_error
+def scheduler(
+    ctx,
+    sweep_id,
+):
+    api = InternalApi()
+    if not api.is_authenticated:
+        wandb.termlog("Login to W&B to use the sweep scheduler feature")
+        ctx.invoke(login, no_offline=True)
+        api = InternalApi(reset=True)
+
+    wandb._sentry.configure_scope(process_context="sweep_scheduler")
+    wandb.termlog("Starting a Launch Scheduler 🚀")
+    from wandb.sdk.launch.sweeps import load_scheduler
+
+    # TODO(gst): remove this monstrosity
+    # Future-proofing hack to pull any kwargs that get passed in through the CLI
+    kwargs = {}
+    for i, _arg in enumerate(ctx.args):
+        if isinstance(_arg, str) and _arg.startswith("--"):
+            # convert input kwargs from hyphens to underscores
+            _key = _arg[2:].replace("-", "_")
+            _args = ctx.args[i + 1]
+            if str.isdigit(_args):
+                _args = int(_args)
+            kwargs[_key] = _args
+    try:
+        sweep_type = kwargs.get("sweep_type", "wandb")
+        _scheduler = load_scheduler(scheduler_type=sweep_type)(
+            api,
+            sweep_id=sweep_id,
+            **kwargs,
+        )
+        _scheduler.start()
+    except Exception as e:
+        wandb._sentry.exception(e)
+        raise e
+
+
+@cli.group(help="Commands for managing and viewing W&B jobs")
+def job() -> None:
+    pass
+
+
+@job.command("list", help="List jobs in a project")
+@click.option(
+    "--project",
+    "-p",
+    envvar=env.PROJECT,
+    help="The project you want to list jobs from.",
+)
+@click.option(
+    "--entity",
+    "-e",
+    default="models",
+    envvar=env.ENTITY,
+    help="The entity the jobs belong to",
+)
+def _list(project, entity):
+    wandb.termlog(f"Listing jobs in {entity}/{project}")
+    public_api = PublicApi()
+    try:
+        jobs = public_api.list_jobs(entity=entity, project=project)
+    except wandb.errors.CommError as e:
+        wandb.termerror(f"{e}")
+        return
+
+    if len(jobs) == 0:
+        wandb.termlog("No jobs found")
+        return
+
+    for job in jobs:
+        aliases = []
+        if len(job["edges"]) == 0:
+            # deleted?
+            continue
+
+        name = job["edges"][0]["node"]["artifactSequence"]["name"]
+        for version in job["edges"]:
+            aliases += [x["alias"] for x in version["node"]["aliases"]]
+
+        # only list the most recent 10 job versions
+        aliases_str = ",".join(aliases[::-1])
+        wandb.termlog(f"{name} -- versions ({len(aliases)}): {aliases_str}")
+
+
+@job.command(
+    help="Describe a launch job. Provide the launch job in the form of: entity/project/job-name:alias-or-version"
+)
+@click.argument("job")
+def describe(job):
+    public_api = PublicApi()
+    try:
+        job = public_api.job(name=job)
+    except wandb.errors.CommError as e:
+        wandb.termerror(f"{e}")
+        return
+
+    for key in job._job_info:
+        if key.startswith("_"):
+            continue
+        wandb.termlog(f"{key}: {job._job_info[key]}")
+
+
+@job.command(
+    no_args_is_help=True,
+)
+@click.option(
+    "--project",
+    "-p",
+    envvar=env.PROJECT,
+    help="The project you want to list jobs from.",
+)
+@click.option(
+    "--entity",
+    "-e",
+    envvar=env.ENTITY,
+    help="The entity the jobs belong to",
+)
+@click.option(
+    "--name",
+    "-n",
+    help="Name for the job",
+)
+@click.option(
+    "--description",
+    "-d",
+    help="Description for the job",
+)
+@click.option(
+    "--alias",
+    "-a",
+    "aliases",
+    help="Alias for the job",
+    multiple=True,
+    default=tuple(),
+)
+@click.option(
+    "--entry-point",
+    "-E",
+    "entrypoint",
+    help="Entrypoint to the script, including an executable and an entrypoint "
+    "file. Required for code or repo jobs. If --build-context is provided, "
+    "paths in the entrypoint command will be relative to the build context.",
+)
+@click.option(
+    "--git-hash",
+    "-g",
+    "git_hash",
+    type=str,
+    help="Commit reference to use as the source for git jobs",
+)
+@click.option(
+    "--runtime",
+    "-r",
+    type=str,
+    help="Python runtime to execute the job",
+)
+@click.option(
+    "--build-context",
+    "-b",
+    type=str,
+    help="Path to the build context from the root of the job source code. If "
+    "provided, this is used as the base path for the Dockerfile and entrypoint.",
+)
+@click.option(
+    "--base-image",
+    "-B",
+    type=str,
+    help="Base image to use for the job. Incompatible with image jobs.",
+)
+@click.option(
+    "--dockerfile",
+    "-D",
+    type=str,
+    help="Path to the Dockerfile for the job. If --build-context is provided, "
+    "the Dockerfile path will be relative to the build context.",
+)
+@click.argument(
+    "job_type",
+    type=click.Choice(("git", "code", "image")),
+)
+@click.argument("path")
+def create(
+    path,
+    project,
+    entity,
+    name,
+    job_type,
+    description,
+    aliases,
+    entrypoint,
+    git_hash,
+    runtime,
+    build_context,
+    base_image,
+    dockerfile,
+):
+    """Create a job from a source, without a wandb run.
+
+    Jobs can be of three types, git, code, or image.
+
+    git: A git source, with an entrypoint either in the path or provided explicitly pointing to the main python executable.
+    code: A code path, containing a requirements.txt file.
+    image: A docker image.
+    """
+    from wandb.sdk.launch.create_job import _create_job
+
+    api = _get_cling_api()
+    wandb._sentry.configure_scope(process_context="job_create")
+
+    entity = entity or os.getenv("WANDB_ENTITY") or api.default_entity
+    if not entity:
+        wandb.termerror("No entity provided, use --entity or set WANDB_ENTITY")
+        return
+
+    project = project or os.getenv("WANDB_PROJECT")
+    if not project:
+        wandb.termerror("No project provided, use --project or set WANDB_PROJECT")
+        return
+
+    if entrypoint is None and job_type in ["git", "code"]:
+        wandb.termwarn(
+            f"No entrypoint provided for {job_type} job, defaulting to main.py"
+        )
+        entrypoint = "main.py"
+
+    if job_type == "image" and base_image:
+        wandb.termerror("Cannot provide --base-image/-B for an `image` job")
+        return
+
+    artifact, action, aliases = _create_job(
+        api=api,
+        path=path,
+        entity=entity,
+        project=project,
+        name=name,
+        job_type=job_type,
+        description=description,
+        aliases=list(aliases),
+        entrypoint=entrypoint,
+        git_hash=git_hash,
+        runtime=runtime,
+        build_context=build_context,
+        base_image=base_image,
+        dockerfile=dockerfile,
+    )
+    if not artifact:
+        wandb.termerror("Job creation failed")
+        return
+
+    artifact_path = f"{entity}/{project}/{artifact.name}"
+    msg = f"{action} job: {click.style(artifact_path, fg='yellow')}"
+    if len(aliases) == 1:
+        alias_str = click.style(aliases[0], fg="yellow")
+        msg += f", with alias: {alias_str}"
+    elif len(aliases) > 1:
+        alias_str = click.style(", ".join(aliases), fg="yellow")
+        msg += f", with aliases: {alias_str}"
+
+    wandb.termlog(msg)
+    web_url = util.app_url(api.settings().get("base_url"))
+    url = click.style(f"{web_url}/{entity}/{project}/jobs", underline=True)
+    wandb.termlog(f"View all jobs in project '{project}' here: {url}\n")
+
+
+@cli.command(context_settings=CONTEXT, help="Run the W&B local sweep controller")
+@click.option("--verbose", is_flag=True, default=False, help="Display verbose output")
+@click.argument("sweep_id")
+@display_error
+def controller(verbose, sweep_id):
+    click.echo("Starting wandb controller...")
+    from wandb import controller as wandb_controller
+
+    tuner = wandb_controller(sweep_id)
+    tuner.run(verbose=verbose)
+
+
+@cli.command(context_settings=RUN_CONTEXT, name="docker-run")
+@click.pass_context
+@click.argument("docker_run_args", nargs=-1)
+def docker_run(ctx, docker_run_args):
+    """Wrap `docker run` and adds WANDB_API_KEY and WANDB_DOCKER environment variables.
+
+    This will also set the runtime to nvidia if the nvidia-docker executable is present
+    on the system and --runtime wasn't set.
+
+    See `docker run --help` for more details.
+    """
+    api = InternalApi()
+    args = list(docker_run_args)
+    if len(args) > 0 and args[0] == "run":
+        args.pop(0)
+    if len([a for a in args if a.startswith("--runtime")]) == 0 and find_executable(
+        "nvidia-docker"
+    ):
+        args = ["--runtime", "nvidia"] + args
+    #  TODO: image_from_docker_args uses heuristics to find the docker image arg, there are likely cases
+    #  where this won't work
+    image = util.image_from_docker_args(args)
+    resolved_image = None
+    if image:
+        resolved_image = wandb.docker.image_id(image)
+    if resolved_image:
+        args = ["-e", "WANDB_DOCKER={}".format(resolved_image)] + args
+    else:
+        wandb.termlog(
+            "Couldn't detect image argument, running command without the WANDB_DOCKER env variable"
+        )
+    if api.api_key:
+        args = ["-e", "WANDB_API_KEY={}".format(api.api_key)] + args
+    else:
+        wandb.termlog(
+            "Not logged in, run `wandb login` from the host machine to enable result logging"
+        )
+    subprocess.call(["docker", "run"] + args)
+
+
+@cli.command(context_settings=RUN_CONTEXT)
+@click.pass_context
+@click.argument("docker_run_args", nargs=-1)
+@click.argument("docker_image", required=False)
+@click.option(
+    "--nvidia/--no-nvidia",
+    default=find_executable("nvidia-docker") is not None,
+    help="Use the nvidia runtime, defaults to nvidia if nvidia-docker is present",
+)
+@click.option(
+    "--digest", is_flag=True, default=False, help="Output the image digest and exit"
+)
+@click.option(
+    "--jupyter/--no-jupyter", default=False, help="Run jupyter lab in the container"
+)
+@click.option(
+    "--dir", default="/app", help="Which directory to mount the code in the container"
+)
+@click.option("--no-dir", is_flag=True, help="Don't mount the current directory")
+@click.option(
+    "--shell", default="/bin/bash", help="The shell to start the container with"
+)
+@click.option("--port", default="8888", help="The host port to bind jupyter on")
+@click.option("--cmd", help="The command to run in the container")
+@click.option(
+    "--no-tty", is_flag=True, default=False, help="Run the command without a tty"
+)
+@display_error
+def docker(
+    ctx,
+    docker_run_args,
+    docker_image,
+    nvidia,
+    digest,
+    jupyter,
+    dir,
+    no_dir,
+    shell,
+    port,
+    cmd,
+    no_tty,
+):
+    """Run your code in a docker container.
+
+    W&B docker lets you run your code in a docker image ensuring wandb is configured. It
+    adds the WANDB_DOCKER and WANDB_API_KEY environment variables to your container and
+    mounts the current directory in /app by default.  You can pass additional args which
+    will be added to `docker run` before the image name is declared, we'll choose a
+    default image for you if one isn't passed:
+
+    ```sh
+    wandb docker -v /mnt/dataset:/app/data
+    wandb docker gcr.io/kubeflow-images-public/tensorflow-1.12.0-notebook-cpu:v0.4.0 --jupyter
+    wandb docker wandb/deepo:keras-gpu --no-tty --cmd "python train.py --epochs=5"
+    ```
+
+    By default, we override the entrypoint to check for the existence of wandb and
+    install it if not present.  If you pass the --jupyter flag we will ensure jupyter is
+    installed and start jupyter lab on port 8888.  If we detect nvidia-docker on your
+    system we will use the nvidia runtime.  If you just want wandb to set environment
+    variable to an existing docker run command, see the wandb docker-run command.
+    """
+    api = InternalApi()
+    if not find_executable("docker"):
+        raise ClickException("Docker not installed, install it from https://docker.com")
+    args = list(docker_run_args)
+    image = docker_image or ""
+    # remove run for users used to nvidia-docker
+    if len(args) > 0 and args[0] == "run":
+        args.pop(0)
+    if image == "" and len(args) > 0:
+        image = args.pop(0)
+    # If the user adds docker args without specifying an image (should be rare)
+    if not util.docker_image_regex(image.split("@")[0]):
+        if image:
+            args = args + [image]
+        image = wandb.docker.default_image(gpu=nvidia)
+        subprocess.call(["docker", "pull", image])
+    _, repo_name, tag = wandb.docker.parse(image)
+
+    resolved_image = wandb.docker.image_id(image)
+    if resolved_image is None:
+        raise ClickException(
+            "Couldn't find image locally or in a registry, try running `docker pull {}`".format(
+                image
+            )
+        )
+    if digest:
+        sys.stdout.write(resolved_image)
+        exit(0)
+
+    existing = wandb.docker.shell(
+        ["ps", "-f", "ancestor={}".format(resolved_image), "-q"]
+    )
+    if existing:
+        if click.confirm(
+            "Found running container with the same image, do you want to attach?"
+        ):
+            subprocess.call(["docker", "attach", existing.split("\n")[0]])
+            exit(0)
+    cwd = os.getcwd()
+    command = [
+        "docker",
+        "run",
+        "-e",
+        "LANG=C.UTF-8",
+        "-e",
+        "WANDB_DOCKER={}".format(resolved_image),
+        "--ipc=host",
+        "-v",
+        wandb.docker.entrypoint + ":/wandb-entrypoint.sh",
+        "--entrypoint",
+        "/wandb-entrypoint.sh",
+    ]
+    if nvidia:
+        command.extend(["--runtime", "nvidia"])
+    if not no_dir:
+        #  TODO: We should default to the working directory if defined
+        command.extend(["-v", cwd + ":" + dir, "-w", dir])
+    if api.api_key:
+        command.extend(["-e", "WANDB_API_KEY={}".format(api.api_key)])
+    else:
+        wandb.termlog(
+            "Couldn't find WANDB_API_KEY, run `wandb login` to enable streaming metrics"
+        )
+    if jupyter:
+        command.extend(["-e", "WANDB_ENSURE_JUPYTER=1", "-p", port + ":8888"])
+        no_tty = True
+        cmd = "jupyter lab --no-browser --ip=0.0.0.0 --allow-root --NotebookApp.token= --notebook-dir {}".format(
+            dir
+        )
+    command.extend(args)
+    if no_tty:
+        command.extend([image, shell, "-c", cmd])
+    else:
+        if cmd:
+            command.extend(["-e", "WANDB_COMMAND={}".format(cmd)])
+        command.extend(["-it", image, shell])
+        wandb.termlog("Launching docker container \U0001f6a2")
+    subprocess.call(command)
+
+
+@cli.command(
+    context_settings=RUN_CONTEXT,
+    help="Start a local W&B container (deprecated, see wandb server --help)",
+    hidden=True,
+)
+@click.pass_context
+@click.option("--port", "-p", default="8080", help="The host port to bind W&B local on")
+@click.option(
+    "--env", "-e", default=[], multiple=True, help="Env vars to pass to wandb/local"
+)
+@click.option(
+    "--daemon/--no-daemon", default=True, help="Run or don't run in daemon mode"
+)
+@click.option(
+    "--upgrade", is_flag=True, default=False, help="Upgrade to the most recent version"
+)
+@click.option(
+    "--edge", is_flag=True, default=False, help="Run the bleeding edge", hidden=True
+)
+@display_error
+def local(ctx, *args, **kwargs):
+    wandb.termwarn("`wandb local` has been replaced with `wandb server start`.")
+    ctx.invoke(start, *args, **kwargs)
+
+
+@cli.group(help="Commands for operating a local W&B server")
+def server():
+    pass
+
+
+@server.command(context_settings=RUN_CONTEXT, help="Start a local W&B server")
+@click.pass_context
+@click.option(
+    "--port", "-p", default="8080", help="The host port to bind W&B server on"
+)
+@click.option(
+    "--env", "-e", default=[], multiple=True, help="Env vars to pass to wandb/local"
+)
+@click.option(
+    "--daemon/--no-daemon", default=True, help="Run or don't run in daemon mode"
+)
+@click.option(
+    "--upgrade",
+    is_flag=True,
+    default=False,
+    help="Upgrade to the most recent version",
+    hidden=True,
+)
+@click.option(
+    "--edge", is_flag=True, default=False, help="Run the bleeding edge", hidden=True
+)
+@display_error
+def start(ctx, port, env, daemon, upgrade, edge):
+    api = InternalApi()
+    if not find_executable("docker"):
+        raise ClickException("Docker not installed, install it from https://docker.com")
+    local_image_sha = wandb.docker.image_id("wandb/local").split("wandb/local")[-1]
+    registry_image_sha = wandb.docker.image_id_from_registry("wandb/local").split(
+        "wandb/local"
+    )[-1]
+    if local_image_sha != registry_image_sha:
+        if upgrade:
+            subprocess.call(["docker", "pull", "wandb/local"])
+        else:
+            wandb.termlog(
+                "A new version of the W&B server is available, upgrade by calling `wandb server start --upgrade`"
+            )
+    running = subprocess.check_output(
+        ["docker", "ps", "--filter", "name=wandb-local", "--format", "{{.ID}}"]
+    )
+    if running != b"":
+        if upgrade:
+            subprocess.call(["docker", "stop", "wandb-local"])
+        else:
+            wandb.termerror(
+                "A container named wandb-local is already running, run `docker stop wandb-local` if you want to start a new instance"
+            )
+            exit(1)
+    image = "docker.pkg.github.com/wandb/core/local" if edge else "wandb/local"
+    username = getpass.getuser()
+    env_vars = ["-e", "LOCAL_USERNAME={}".format(username)]
+    for e in env:
+        env_vars.append("-e")
+        env_vars.append(e)
+    command = [
+        "docker",
+        "run",
+        "--rm",
+        "-v",
+        "wandb:/vol",
+        "-p",
+        port + ":8080",
+        "--name",
+        "wandb-local",
+    ] + env_vars
+    host = f"http://localhost:{port}"
+    api.set_setting("base_url", host, globally=True, persist=True)
+    if daemon:
+        command += ["-d"]
+    command += [image]
+
+    # DEVNULL is only in py3
+    try:
+        from subprocess import DEVNULL
+    except ImportError:
+        DEVNULL = open(os.devnull, "wb")  # noqa: N806
+    code = subprocess.call(command, stdout=DEVNULL)
+    if daemon:
+        if code != 0:
+            wandb.termerror(
+                "Failed to launch the W&B server container, see the above error."
+            )
+            exit(1)
+        else:
+            wandb.termlog(
+                "W&B server started at http://localhost:{} \U0001f680".format(port)
+            )
+            wandb.termlog("You can stop the server by running `wandb server stop`")
+            if not api.api_key:
+                # Let the server start before potentially launching a browser
+                time.sleep(2)
+                ctx.invoke(login, host=host)
+
+
+@server.command(context_settings=RUN_CONTEXT, help="Stop a local W&B server")
+def stop():
+    if not find_executable("docker"):
+        raise ClickException("Docker not installed, install it from https://docker.com")
+    subprocess.call(["docker", "stop", "wandb-local"])
+
+
+@cli.group(help="Commands for interacting with artifacts")
+def artifact():
+    pass
+
+
+@artifact.command(context_settings=CONTEXT, help="Upload an artifact to wandb")
+@click.argument("path")
+@click.option(
+    "--name", "-n", help="The name of the artifact to push: project/artifact_name"
+)
+@click.option("--description", "-d", help="A description of this artifact")
+@click.option("--type", "-t", default="dataset", help="The type of the artifact")
+@click.option(
+    "--alias",
+    "-a",
+    default=["latest"],
+    multiple=True,
+    help="An alias to apply to this artifact",
+)
+@click.option("--id", "run_id", help="The run you want to upload to.")
+@click.option(
+    "--resume",
+    is_flag=True,
+    default=None,
+    help="Resume the last run from your current directory.",
+)
+@click.option(
+    "--skip_cache",
+    is_flag=True,
+    default=False,
+    help="Skip caching while uploading artifact files.",
+)
+@click.option(
+    "--policy",
+    default="mutable",
+    type=click.Choice(["mutable", "immutable"]),
+    help="Set the storage policy while uploading artifact files.",
+)
+@display_error
+def put(
+    path,
+    name,
+    description,
+    type,
+    alias,
+    run_id,
+    resume,
+    skip_cache,
+    policy,
+):
+    if name is None:
+        name = os.path.basename(path)
+    public_api = PublicApi()
+    entity, project, artifact_name = public_api._parse_artifact_path(name)
+    if project is None:
+        project = click.prompt("Enter the name of the project you want to use")
+    # TODO: settings nightmare...
+    api = InternalApi()
+    api.set_setting("entity", entity)
+    api.set_setting("project", project)
+    artifact = wandb.Artifact(name=artifact_name, type=type, description=description)
+    artifact_path = f"{entity}/{project}/{artifact_name}:{alias[0]}"
+    if os.path.isdir(path):
+        wandb.termlog(f'Uploading directory {path} to: "{artifact_path}" ({type})')
+        artifact.add_dir(path, skip_cache=skip_cache, policy=policy)
+    elif os.path.isfile(path):
+        wandb.termlog(f'Uploading file {path} to: "{artifact_path}" ({type})')
+        artifact.add_file(path, skip_cache=skip_cache, policy=policy)
+    elif "://" in path:
+        wandb.termlog(
+            f'Logging reference artifact from {path} to: "{artifact_path}" ({type})'
+        )
+        artifact.add_reference(path)
+    else:
+        raise ClickException("Path argument must be a file or directory")
+
+    with wandb.init(
+        entity=entity,
+        project=project,
+        config={"path": path},
+        job_type="cli_put",
+        id=run_id,
+        resume=resume,
+    ) as run:
+        run.log_artifact(artifact, aliases=alias)
+    artifact.wait()
+
+    wandb.termlog(
+        "Artifact uploaded, use this artifact in a run by adding:\n", prefix=False
+    )
+    wandb.termlog(
+        f'    artifact = run.use_artifact("{artifact.source_qualified_name}")\n',
+        prefix=False,
+    )
+
+
+@artifact.command(context_settings=CONTEXT, help="Download an artifact from wandb")
+@click.argument("path")
+@click.option("--root", help="The directory you want to download the artifact to")
+@click.option("--type", help="The type of artifact you are downloading")
+@display_error
+def get(path, root, type):
+    public_api = PublicApi()
+    entity, project, artifact_name = public_api._parse_artifact_path(path)
+    if project is None:
+        project = click.prompt("Enter the name of the project you want to use")
+
+    try:
+        artifact_parts = artifact_name.split(":")
+        if len(artifact_parts) > 1:
+            version = artifact_parts[1]
+            artifact_name = artifact_parts[0]
+        else:
+            version = "latest"
+        if is_artifact_registry_project(project):
+            organization = path.split("/")[0] if path.count("/") == 2 else ""
+            # set entity to match the settings since in above code it was potentially set to an org
+            settings_entity = public_api.settings["entity"] or public_api.default_entity
+            # Registry artifacts are under the org entity. Because we offer a shorthand and alias for this path,
+            # we need to fetch the org entity to for the user behind the scenes.
+            entity = SDKInternalApi()._resolve_org_entity_name(
+                entity=settings_entity, organization=organization
+            )
+        full_path = f"{entity}/{project}/{artifact_name}:{version}"
+        wandb.termlog(
+            "Downloading {type} artifact {full_path}".format(
+                type=type or "dataset", full_path=full_path
+            )
+        )
+        artifact = public_api.artifact(full_path, type=type)
+        path = artifact.download(root=root)
+        wandb.termlog("Artifact downloaded to {}".format(path))
+    except ValueError:
+        raise ClickException("Unable to download artifact")
+
+
+@artifact.command(
+    context_settings=CONTEXT, help="List all artifacts in a wandb project"
+)
+@click.argument("path")
+@click.option("--type", "-t", help="The type of artifacts to list")
+@display_error
+def ls(path, type):
+    public_api = PublicApi()
+    if type is not None:
+        types = [public_api.artifact_type(type, path)]
+    else:
+        types = public_api.artifact_types(path)
+
+    for kind in types:
+        for collection in kind.collections():
+            versions = public_api.artifact_versions(
+                kind.type,
+                "/".join([kind.entity, kind.project, collection.name]),
+                per_page=1,
+            )
+            latest = next(versions)
+            wandb.termlog(
+                "{:<15s}{:<15s}{:>15s} {:<20s}".format(
+                    kind.type,
+                    latest.updated_at,
+                    util.to_human_size(latest.size),
+                    latest.name,
+                )
+            )
+
+
+@artifact.group(help="Commands for interacting with the artifact cache")
+def cache():
+    pass
+
+
+@cache.command(
+    context_settings=CONTEXT,
+    help="Clean up less frequently used files from the artifacts cache",
+)
+@click.argument("target_size")
+@click.option("--remove-temp/--no-remove-temp", default=False, help="Remove temp files")
+@display_error
+def cleanup(target_size, remove_temp):
+    target_size = util.from_human_size(target_size)
+    cache = get_artifact_file_cache()
+    reclaimed_bytes = cache.cleanup(target_size, remove_temp)
+    wandb.termlog(f"Reclaimed {util.to_human_size(reclaimed_bytes)} of space")
+
+
+@cli.command(context_settings=CONTEXT, help="Pull files from Weights & Biases")
+@click.argument("run", envvar=env.RUN_ID)
+@click.option(
+    "--project", "-p", envvar=env.PROJECT, help="The project you want to download."
+)
+@click.option(
+    "--entity",
+    "-e",
+    default="models",
+    envvar=env.ENTITY,
+    help="The entity to scope the listing to.",
+)
+@display_error
+def pull(run, project, entity):
+    api = InternalApi()
+    project, run = api.parse_slug(run, project=project)
+    urls = api.download_urls(project, run=run, entity=entity)
+    if len(urls) == 0:
+        raise ClickException("Run has no files")
+    click.echo(f"Downloading: {click.style(project, bold=True)}/{run}")
+
+    for name in urls:
+        if api.file_current(name, urls[name]["md5"]):
+            click.echo("File {} is up to date".format(name))
+        else:
+            length, response = api.download_file(urls[name]["url"])
+            # TODO: I had to add this because some versions in CI broke click.progressbar
+            sys.stdout.write("File {}\r".format(name))
+            dirname = os.path.dirname(name)
+            if dirname != "":
+                filesystem.mkdir_exists_ok(dirname)
+            with click.progressbar(
+                length=length,
+                label="File {}".format(name),
+                fill_char=click.style("&", fg="green"),
+            ) as bar:
+                with open(name, "wb") as f:
+                    for data in response.iter_content(chunk_size=4096):
+                        f.write(data)
+                        bar.update(len(data))
+
+
+@cli.command(
+    context_settings=CONTEXT, help="Restore code, config and docker state for a run"
+)
+@click.pass_context
+@click.argument("run", envvar=env.RUN_ID)
+@click.option("--no-git", is_flag=True, default=False, help="Don't restore git state")
+@click.option(
+    "--branch/--no-branch",
+    default=True,
+    help="Whether to create a branch or checkout detached",
+)
+@click.option(
+    "--project", "-p", envvar=env.PROJECT, help="The project you wish to upload to."
+)
+@click.option(
+    "--entity", "-e", envvar=env.ENTITY, help="The entity to scope the listing to."
+)
+@display_error
+def restore(ctx, run, no_git, branch, project, entity):
+    from wandb.old.core import wandb_dir
+
+    api = _get_cling_api()
+    if ":" in run:
+        if "/" in run:
+            entity, rest = run.split("/", 1)
+        else:
+            rest = run
+        project, run = rest.split(":", 1)
+    elif run.count("/") > 1:
+        entity, run = run.split("/", 1)
+
+    project, run = api.parse_slug(run, project=project)
+    commit, json_config, patch_content, metadata = api.run_config(
+        project, run=run, entity=entity
+    )
+    repo = metadata.get("git", {}).get("repo")
+    image = metadata.get("docker")
+    restore_message = """`wandb restore` needs to be run from the same git repository as the original run.
+Run `git clone {}` and restore from there or pass the --no-git flag.""".format(repo)
+    if no_git:
+        commit = None
+    elif not api.git.enabled:
+        if repo:
+            raise ClickException(restore_message)
+        elif image:
+            wandb.termlog(
+                "Original run has no git history.  Just restoring config and docker"
+            )
+
+    if commit and api.git.enabled:
+        wandb.termlog(f"Fetching origin and finding commit: {commit}")
+        subprocess.check_call(["git", "fetch", "--all"])
+        try:
+            api.git.repo.commit(commit)
+        except ValueError:
+            wandb.termlog(f"Couldn't find original commit: {commit}")
+            commit = None
+            files = api.download_urls(project, run=run, entity=entity)
+            for filename in files:
+                if filename.startswith("upstream_diff_") and filename.endswith(
+                    ".patch"
+                ):
+                    commit = filename[len("upstream_diff_") : -len(".patch")]
+                    try:
+                        api.git.repo.commit(commit)
+                    except ValueError:
+                        commit = None
+                    else:
+                        break
+
+            if commit:
+                wandb.termlog(f"Falling back to upstream commit: {commit}")
+                patch_path, _ = api.download_write_file(files[filename])
+            else:
+                raise ClickException(restore_message)
+        else:
+            if patch_content:
+                patch_path = os.path.join(wandb_dir(), "diff.patch")
+                with open(patch_path, "w") as f:
+                    f.write(patch_content)
+            else:
+                patch_path = None
+
+        branch_name = "wandb/{}".format(run)
+        if branch and branch_name not in api.git.repo.branches:
+            api.git.repo.git.checkout(commit, b=branch_name)
+            wandb.termlog(
+                "Created branch {}".format(click.style(branch_name, bold=True))
+            )
+        elif branch:
+            wandb.termlog(
+                "Using existing branch, run `git branch -D {}` from master for a clean checkout".format(
+                    branch_name
+                )
+            )
+            api.git.repo.git.checkout(branch_name)
+        else:
+            wandb.termlog("Checking out {} in detached mode".format(commit))
+            api.git.repo.git.checkout(commit)
+
+        if patch_path:
+            # we apply the patch from the repository root so git doesn't exclude
+            # things outside the current directory
+            root = api.git.root
+            patch_rel_path = os.path.relpath(patch_path, start=root)
+            # --reject is necessary or else this fails any time a binary file
+            # occurs in the diff
+            exit_code = subprocess.call(
+                ["git", "apply", "--reject", patch_rel_path], cwd=root
+            )
+            if exit_code == 0:
+                wandb.termlog("Applied patch")
+            else:
+                wandb.termerror(
+                    "Failed to apply patch, try un-staging any un-committed changes"
+                )
+
+    filesystem.mkdir_exists_ok(wandb_dir())
+    config_path = os.path.join(wandb_dir(), "config.yaml")
+    config = Config()
+    for k, v in json_config.items():
+        if k not in ("_wandb", "wandb_version"):
+            config[k] = v
+    s = b"wandb_version: 1"
+    s += b"\n\n" + yaml.dump(
+        config._as_dict(),
+        Dumper=yaml.SafeDumper,
+        default_flow_style=False,
+        allow_unicode=True,
+        encoding="utf-8",
+    )
+    s = s.decode("utf-8")
+    with open(config_path, "w") as f:
+        f.write(s)
+
+    wandb.termlog("Restored config variables to {}".format(config_path))
+    if image:
+        if not metadata["program"].startswith("<") and metadata.get("args") is not None:
+            # TODO: we may not want to default to python here.
+            runner = util.find_runner(metadata["program"]) or ["python"]
+            command = runner + [metadata["program"]] + metadata["args"]
+            cmd = " ".join(command)
+        else:
+            wandb.termlog("Couldn't find original command, just restoring environment")
+            cmd = None
+        wandb.termlog("Docker image found, attempting to start")
+        ctx.invoke(docker, docker_run_args=[image], cmd=cmd)
+
+    return commit, json_config, patch_content, repo, metadata
+
+
+@cli.command("online", help="Enable W&B sync")
+@display_error
+def online():
+    api = InternalApi()
+    try:
+        api.clear_setting("mode", persist=True)
+    except configparser.Error:
+        pass
+    click.echo(
+        "W&B online. Running your script from this directory will now sync to the cloud."
+    )
+
+
+@cli.command("offline", help="Disable W&B sync")
+@display_error
+def offline():
+    api = InternalApi()
+    try:
+        api.set_setting("mode", "offline", persist=True)
+        click.echo(
+            "W&B offline. Running your script from this directory will only write metadata locally. Use wandb disabled to completely turn off W&B."
+        )
+    except configparser.Error:
+        click.echo(
+            "Unable to write config, copy and paste the following in your terminal to turn off W&B:\nexport WANDB_MODE=offline"
+        )
+
+
+@cli.command("on", hidden=True)
+@click.pass_context
+@display_error
+def on(ctx):
+    ctx.invoke(online)
+
+
+@cli.command("off", hidden=True)
+@click.pass_context
+@display_error
+def off(ctx):
+    ctx.invoke(offline)
+
+
+@cli.command("status", help="Show configuration settings")
+@click.option(
+    "--settings/--no-settings", help="Show the current settings", default=True
+)
+def status(settings):
+    api = _get_cling_api()
+    if settings:
+        click.echo(click.style("Current Settings", bold=True))
+        settings = api.settings()
+        click.echo(
+            json.dumps(settings, sort_keys=True, indent=2, separators=(",", ": "))
+        )
+
+
+@cli.command("disabled", help="Disable W&B.")
+@click.option(
+    "--service",
+    is_flag=True,
+    show_default=True,
+    default=True,
+    help="Disable W&B service",
+)
+def disabled(service):
+    api = InternalApi()
+    try:
+        api.set_setting("mode", "disabled", persist=True)
+        click.echo("W&B disabled.")
+    except configparser.Error:
+        click.echo(
+            "Unable to write config, copy and paste the following in your terminal to turn off W&B:\nexport WANDB_MODE=disabled"
+        )
+
+
+@cli.command("enabled", help="Enable W&B.")
+@click.option(
+    "--service",
+    is_flag=True,
+    show_default=True,
+    default=True,
+    help="Enable W&B service",
+)
+def enabled(service):
+    api = InternalApi()
+    try:
+        api.set_setting("mode", "online", persist=True)
+        click.echo("W&B enabled.")
+    except configparser.Error:
+        click.echo(
+            "Unable to write config, copy and paste the following in your terminal to turn on W&B:\nexport WANDB_MODE=online"
+        )
+
+
+@cli.command(context_settings=CONTEXT, help="Verify your local instance")
+@click.option("--host", default=None, help="Test a specific instance of W&B")
+def verify(host):
+    # TODO: (kdg) Build this all into a WandbVerify object, and clean this up.
+    os.environ["WANDB_SILENT"] = "true"
+    os.environ["WANDB_PROJECT"] = "verify"
+    api = _get_cling_api()
+    reinit = False
+    if host is None:
+        host = api.settings("base_url")
+        wandb.termlog(f"Default host selected: {host}")
+    # if the given host does not match the default host, re-run init
+    elif host != api.settings("base_url"):
+        reinit = True
+
+    tmp_dir = tempfile.mkdtemp()
+    wandb.termlog(
+        "Find detailed logs for this test at: {}".format(os.path.join(tmp_dir, "wandb"))
+    )
+    os.chdir(tmp_dir)
+    os.environ["WANDB_BASE_URL"] = host
+    wandb.login(host=host)
+    if reinit:
+        api = _get_cling_api(reset=True)
+    if not wandb_verify.check_host(host):
+        sys.exit(1)
+    if not wandb_verify.check_logged_in(api, host):
+        sys.exit(1)
+    url_success, url = wandb_verify.check_graphql_put(api, host)
+    large_post_success = wandb_verify.check_large_post()
+    wandb_verify.check_secure_requests(
+        api.settings("base_url"),
+        "Checking requests to base url",
+        "Connections are not made over https. SSL required for secure communications.",
+    )
+    if url:
+        wandb_verify.check_secure_requests(
+            url,
+            "Checking requests made over signed URLs",
+            "Signed URL requests not made over https. SSL is required for secure communications.",
+        )
+        wandb_verify.check_cors_configuration(url, host)
+    wandb_verify.check_wandb_version(api)
+    check_run_success = wandb_verify.check_run(api)
+    check_artifacts_success = wandb_verify.check_artifacts()
+    if not (
+        check_artifacts_success
+        and check_run_success
+        and large_post_success
+        and url_success
+    ):
+        sys.exit(1)
+
+
+cli.add_command(beta)

vllm/lib/python3.10/site-packages/wandb/old/core.py

@@ -0,0 +1,53 @@
+"""Core variables, functions, and classes that we want in the wandb
+module but are also used in modules that import the wandb module.
+
+The purpose of this module is to break circular imports.
+"""
+
+import os
+import tempfile
+import time
+
+import wandb
+from wandb import env
+
+# We use the hidden version if it already exists, otherwise non-hidden.
+if os.path.exists(os.path.join(env.get_dir(os.getcwd()), ".wandb")):
+    __stage_dir__ = ".wandb" + os.sep
+elif os.path.exists(os.path.join(env.get_dir(os.getcwd()), "wandb")):
+    __stage_dir__ = "wandb" + os.sep
+else:
+    __stage_dir__ = None
+
+wandb.START_TIME = time.time()
+
+
+def wandb_dir(root_dir=None):
+    if root_dir is None or root_dir == "":
+        try:
+            cwd = os.getcwd()
+        except OSError:
+            wandb.termwarn("os.getcwd() no longer exists, using system temp directory")
+            cwd = tempfile.gettempdir()
+        root_dir = env.get_dir(cwd)
+    path = os.path.join(root_dir, __stage_dir__ or ("wandb" + os.sep))
+    if not os.access(root_dir, os.W_OK):
+        wandb.termwarn(
+            f"Path {path} wasn't writable, using system temp directory", repeat=False
+        )
+        path = os.path.join(tempfile.gettempdir(), __stage_dir__ or ("wandb" + os.sep))
+    return path
+
+
+def _set_stage_dir(stage_dir):
+    # Used when initing a new project with "wandb init"
+    global __stage_dir__
+    __stage_dir__ = stage_dir
+
+
+__all__ = [
+    "__stage_dir__",
+    "START_TIME",
+    "wandb_dir",
+    "_set_stage_dir",
+]

vllm/lib/python3.10/site-packages/wandb/old/settings.py

@@ -0,0 +1,173 @@
+import configparser
+import getpass
+import os
+import tempfile
+from typing import Any, Optional
+
+from wandb import env
+from wandb.old import core
+from wandb.sdk.lib import filesystem
+from wandb.sdk.lib.runid import generate_id
+
+
+class Settings:
+    """Global W&B settings stored under $WANDB_CONFIG_DIR/settings."""
+
+    DEFAULT_SECTION = "default"
+
+    _UNSET = object()
+
+    def __init__(
+        self, load_settings: bool = True, root_dir: Optional[str] = None
+    ) -> None:
+        self._global_settings = Settings._settings()
+        self._local_settings = Settings._settings()
+        self.root_dir = root_dir
+
+        if load_settings:
+            global_path = Settings._global_path()
+            if global_path is not None:
+                self._global_settings.read([global_path])
+            # Only attempt to read if there is a directory existing
+            if os.path.isdir(core.wandb_dir(self.root_dir)):
+                self._local_settings.read([Settings._local_path(self.root_dir)])
+
+    def get(self, section: str, key: str, fallback: Any = _UNSET) -> Any:
+        # Try the local settings first. If we can't find the key, then try the global settings.
+        # If a fallback is provided, return it if we can't find the key in either the local or global
+        # settings.
+        try:
+            return self._local_settings.get(section, key)
+        except configparser.NoOptionError:
+            try:
+                return self._global_settings.get(section, key)
+            except configparser.NoOptionError:
+                if fallback is not Settings._UNSET:
+                    return fallback
+                else:
+                    raise
+
+    def _persist_settings(self, settings, settings_path) -> None:
+        # write a temp file and then move it to the settings path
+        target_dir = os.path.dirname(settings_path)
+        with tempfile.NamedTemporaryFile(
+            "w+", suffix=".tmp", delete=False, dir=target_dir
+        ) as fp:
+            path = os.path.abspath(fp.name)
+            with open(path, "w+") as f:
+                settings.write(f)
+        try:
+            os.replace(path, settings_path)
+        except AttributeError:
+            os.rename(path, settings_path)
+
+    def set(self, section, key, value, globally=False, persist=False) -> None:
+        """Persist settings to disk if persist = True"""
+
+        def write_setting(settings, settings_path, persist):
+            if not settings.has_section(section):
+                Settings._safe_add_section(settings, Settings.DEFAULT_SECTION)
+            settings.set(section, key, str(value))
+
+            if persist:
+                self._persist_settings(settings, settings_path)
+
+        if globally:
+            global_path = Settings._global_path()
+            if global_path is not None:
+                write_setting(self._global_settings, global_path, persist)
+        else:
+            write_setting(
+                self._local_settings, Settings._local_path(self.root_dir), persist
+            )
+
+    def clear(self, section, key, globally=False, persist=False) -> None:
+        def clear_setting(settings, settings_path, persist):
+            settings.remove_option(section, key)
+            if persist:
+                self._persist_settings(settings, settings_path)
+
+        if globally:
+            global_path = Settings._global_path()
+            if global_path is not None:
+                clear_setting(self._global_settings, global_path, persist)
+        else:
+            clear_setting(
+                self._local_settings, Settings._local_path(self.root_dir), persist
+            )
+
+    def items(self, section=None):
+        section = section if section is not None else Settings.DEFAULT_SECTION
+
+        result = {"section": section}
+
+        try:
+            if section in self._global_settings.sections():
+                for option in self._global_settings.options(section):
+                    result[option] = self._global_settings.get(section, option)
+            if section in self._local_settings.sections():
+                for option in self._local_settings.options(section):
+                    result[option] = self._local_settings.get(section, option)
+        except configparser.InterpolationSyntaxError:
+            core.termwarn("Unable to parse settings file")
+
+        return result
+
+    @staticmethod
+    def _safe_add_section(settings, section):
+        if not settings.has_section(section):
+            settings.add_section(section)
+
+    @staticmethod
+    def _settings(default_settings={}):
+        settings = configparser.ConfigParser()
+        Settings._safe_add_section(settings, Settings.DEFAULT_SECTION)
+        for key, value in default_settings.items():
+            settings.set(Settings.DEFAULT_SECTION, key, str(value))
+        return settings
+
+    @staticmethod
+    def _global_path() -> Optional[str]:
+        def try_create_dir(path) -> bool:
+            try:
+                os.makedirs(path, exist_ok=True)
+                if os.access(path, os.W_OK):
+                    return True
+            except OSError:
+                pass
+            return False
+
+        def get_username() -> str:
+            try:
+                return getpass.getuser()
+            except (ImportError, KeyError):
+                return generate_id()
+
+        try:
+            home_config_dir = os.path.join(os.path.expanduser("~"), ".config", "wandb")
+
+            if not try_create_dir(home_config_dir):
+                temp_config_dir = os.path.join(
+                    tempfile.gettempdir(), ".config", "wandb"
+                )
+
+                if not try_create_dir(temp_config_dir):
+                    username = get_username()
+                    config_dir = os.path.join(
+                        tempfile.gettempdir(), username, ".config", "wandb"
+                    )
+                    try_create_dir(config_dir)
+                else:
+                    config_dir = temp_config_dir
+            else:
+                config_dir = home_config_dir
+
+            config_dir = os.environ.get(env.CONFIG_DIR, config_dir)
+            return os.path.join(config_dir, "settings")
+        except Exception:
+            return None
+
+    @staticmethod
+    def _local_path(root_dir=None):
+        filesystem.mkdir_exists_ok(core.wandb_dir(root_dir))
+        return os.path.join(core.wandb_dir(root_dir), "settings")

vllm/lib/python3.10/site-packages/wandb/old/summary.py

@@ -0,0 +1,440 @@
+import json
+import os
+import time
+
+from wandb_gql import gql
+
+import wandb
+from wandb import util
+from wandb.apis.internal import Api
+from wandb.sdk import lib as wandb_lib
+from wandb.sdk.data_types.utils import val_to_json
+
+DEEP_SUMMARY_FNAME = "wandb.h5"
+H5_TYPES = ("numpy.ndarray", "tensorflow.Tensor", "torch.Tensor")
+h5py = util.get_module("h5py")
+np = util.get_module("numpy")
+
+
+class SummarySubDict:
+    """Nested dict-like object that proxies read and write operations through a root object.
+
+    This lets us do synchronous serialization and lazy loading of large values.
+    """
+
+    def __init__(self, root=None, path=()):
+        self._path = tuple(path)
+        if root is None:
+            self._root = self
+            self._json_dict = {}
+        else:
+            self._root = root
+            json_dict = root._json_dict
+            for k in path:
+                json_dict = json_dict.get(k, {})
+
+            self._json_dict = json_dict
+        self._dict = {}
+
+        # We use this to track which keys the user has set explicitly
+        # so that we don't automatically overwrite them when we update
+        # the summary from the history.
+        self._locked_keys = set()
+
+    def __setattr__(self, k, v):
+        k = k.strip()
+        if k.startswith("_"):
+            object.__setattr__(self, k, v)
+        else:
+            self[k] = v
+
+    def __getattr__(self, k):
+        k = k.strip()
+        if k.startswith("_"):
+            return object.__getattribute__(self, k)
+        else:
+            return self[k]
+
+    def _root_get(self, path, child_dict):
+        """Load a value at a particular path from the root.
+
+        This should only be implemented by the "_root" child class.
+
+        We pass the child_dict so the item can be set on it or not as
+        appropriate. Returning None for a nonexistent path wouldn't be
+        distinguishable from that path being set to the value None.
+        """
+        raise NotImplementedError
+
+    def _root_set(self, path, new_keys_values):
+        """Set a value at a particular path in the root.
+
+        This should only be implemented by the "_root" child class.
+        """
+        raise NotImplementedError
+
+    def _root_del(self, path):
+        """Delete a value at a particular path in the root.
+
+        This should only be implemented by the "_root" child class.
+        """
+        raise NotImplementedError
+
+    def _write(self, commit=False):
+        # should only be implemented on the root summary
+        raise NotImplementedError
+
+    def keys(self):
+        # _json_dict has the full set of keys, including those for h5 objects
+        # that may not have been loaded yet
+        return self._json_dict.keys()
+
+    def get(self, k, default=None):
+        if isinstance(k, str):
+            k = k.strip()
+        if k not in self._dict:
+            self._root._root_get(self._path + (k,), self._dict)
+        return self._dict.get(k, default)
+
+    def items(self):
+        # not all items may be loaded into self._dict, so we
+        # have to build the sequence of items from scratch
+        for k in self.keys():
+            yield k, self[k]
+
+    def __getitem__(self, k):
+        if isinstance(k, str):
+            k = k.strip()
+
+        self.get(k)  # load the value into _dict if it should be there
+        res = self._dict[k]
+
+        return res
+
+    def __contains__(self, k):
+        if isinstance(k, str):
+            k = k.strip()
+
+        return k in self._json_dict
+
+    def __setitem__(self, k, v):
+        if isinstance(k, str):
+            k = k.strip()
+
+        path = self._path
+
+        if isinstance(v, dict):
+            self._dict[k] = SummarySubDict(self._root, path + (k,))
+            self._root._root_set(path, [(k, {})])
+            self._dict[k].update(v)
+        else:
+            self._dict[k] = v
+            self._root._root_set(path, [(k, v)])
+
+        self._locked_keys.add(k)
+
+        self._root._write()
+
+        return v
+
+    def __delitem__(self, k):
+        k = k.strip()
+        del self._dict[k]
+        self._root._root_del(self._path + (k,))
+
+        self._root._write()
+
+    def __repr__(self):
+        # use a copy of _dict, except add placeholders for h5 objects, etc.
+        # that haven't been loaded yet
+        repr_dict = dict(self._dict)
+        for k in self._json_dict:
+            v = self._json_dict[k]
+            if (
+                k not in repr_dict
+                and isinstance(v, dict)
+                and v.get("_type") in H5_TYPES
+            ):
+                # unloaded h5 objects may be very large. use a placeholder for them
+                # if we haven't already loaded them
+                repr_dict[k] = "..."
+            else:
+                repr_dict[k] = self[k]
+
+        return repr(repr_dict)
+
+    def update(self, key_vals=None, overwrite=True):
+        """Locked keys will be overwritten unless overwrite=False.
+
+        Otherwise, written keys will be added to the "locked" list.
+        """
+        if key_vals:
+            write_items = self._update(key_vals, overwrite)
+            self._root._root_set(self._path, write_items)
+        self._root._write(commit=True)
+
+    def _update(self, key_vals, overwrite):
+        if not key_vals:
+            return
+        key_vals = {k.strip(): v for k, v in key_vals.items()}
+        if overwrite:
+            write_items = list(key_vals.items())
+            self._locked_keys.update(key_vals.keys())
+        else:
+            write_keys = set(key_vals.keys()) - self._locked_keys
+            write_items = [(k, key_vals[k]) for k in write_keys]
+
+        for key, value in write_items:
+            if isinstance(value, dict):
+                self._dict[key] = SummarySubDict(self._root, self._path + (key,))
+                self._dict[key]._update(value, overwrite)
+            else:
+                self._dict[key] = value
+
+        return write_items
+
+
+class Summary(SummarySubDict):
+    """Store summary metrics (eg. accuracy) during and after a run.
+
+    You can manipulate this as if it's a Python dictionary but the keys
+    get mangled. .strip() is called on them, so spaces at the beginning
+    and end are removed.
+    """
+
+    def __init__(self, run, summary=None):
+        super().__init__()
+        self._run = run
+        self._h5_path = os.path.join(self._run.dir, DEEP_SUMMARY_FNAME)
+        # Lazy load the h5 file
+        self._h5 = None
+
+        # Mirrored version of self._dict with versions of values that get written
+        # to JSON kept up to date by self._root_set() and self._root_del().
+        self._json_dict = {}
+
+        if summary is not None:
+            self._json_dict = summary
+
+    def _json_get(self, path):
+        pass
+
+    def _root_get(self, path, child_dict):
+        json_dict = self._json_dict
+        for key in path[:-1]:
+            json_dict = json_dict[key]
+
+        key = path[-1]
+        if key in json_dict:
+            child_dict[key] = self._decode(path, json_dict[key])
+
+    def _root_del(self, path):
+        json_dict = self._json_dict
+        for key in path[:-1]:
+            json_dict = json_dict[key]
+
+        val = json_dict[path[-1]]
+        del json_dict[path[-1]]
+        if isinstance(val, dict) and val.get("_type") in H5_TYPES:
+            if not h5py:
+                wandb.termerror("Deleting tensors in summary requires h5py")
+            else:
+                self.open_h5()
+                h5_key = "summary/" + ".".join(path)
+                del self._h5[h5_key]
+                self._h5.flush()
+
+    def _root_set(self, path, new_keys_values):
+        json_dict = self._json_dict
+        for key in path:
+            json_dict = json_dict[key]
+
+        for new_key, new_value in new_keys_values:
+            json_dict[new_key] = self._encode(new_value, path + (new_key,))
+
+    def write_h5(self, path, val):
+        # ensure the file is open
+        self.open_h5()
+
+        if not self._h5:
+            wandb.termerror("Storing tensors in summary requires h5py")
+        else:
+            try:
+                del self._h5["summary/" + ".".join(path)]
+            except KeyError:
+                pass
+            self._h5["summary/" + ".".join(path)] = val
+            self._h5.flush()
+
+    def read_h5(self, path, val=None):
+        # ensure the file is open
+        self.open_h5()
+
+        if not self._h5:
+            wandb.termerror("Reading tensors from summary requires h5py")
+        else:
+            return self._h5.get("summary/" + ".".join(path), val)
+
+    def open_h5(self):
+        if not self._h5 and h5py:
+            self._h5 = h5py.File(self._h5_path, "a", libver="latest")
+
+    def _decode(self, path, json_value):
+        """Decode a `dict` encoded by `Summary._encode()`, loading h5 objects.
+
+        h5 objects may be very large, so we won't have loaded them automatically.
+        """
+        if isinstance(json_value, dict):
+            if json_value.get("_type") in H5_TYPES:
+                return self.read_h5(path, json_value)
+            elif json_value.get("_type") == "data-frame":
+                wandb.termerror(
+                    "This data frame was saved via the wandb data API. Contact support@wandb.com for help."
+                )
+                return None
+            # TODO: transform wandb objects and plots
+            else:
+                return SummarySubDict(self, path)
+        else:
+            return json_value
+
+    def _encode(self, value, path_from_root):
+        """Normalize, compress, and encode sub-objects for backend storage.
+
+        value: Object to encode.
+        path_from_root: `tuple` of key strings from the top-level summary to the
+            current `value`.
+
+        Returns:
+            A new tree of dict's with large objects replaced with dictionaries
+            with "_type" entries that say which type the original data was.
+        """
+
+        # Constructs a new `dict` tree in `json_value` that discards and/or
+        # encodes objects that aren't JSON serializable.
+
+        if isinstance(value, dict):
+            json_value = {}
+            for key, value in value.items():
+                json_value[key] = self._encode(value, path_from_root + (key,))
+            return json_value
+        else:
+            path = ".".join(path_from_root)
+            friendly_value, converted = util.json_friendly(
+                val_to_json(self._run, path, value, namespace="summary")
+            )
+            json_value, compressed = util.maybe_compress_summary(
+                friendly_value, util.get_h5_typename(value)
+            )
+            if compressed:
+                self.write_h5(path_from_root, friendly_value)
+
+            return json_value
+
+
+def download_h5(run_id, entity=None, project=None, out_dir=None):
+    api = Api()
+    meta = api.download_url(
+        project or api.settings("project"),
+        DEEP_SUMMARY_FNAME,
+        entity=entity or api.settings("entity"),
+        run=run_id,
+    )
+    if meta and "md5" in meta and meta["md5"] is not None:
+        # TODO: make this non-blocking
+        wandb.termlog("Downloading summary data...")
+        path, res = api.download_write_file(meta, out_dir=out_dir)
+        return path
+
+
+def upload_h5(file, run_id, entity=None, project=None):
+    api = Api()
+    wandb.termlog("Uploading summary data...")
+    with open(file, "rb") as f:
+        api.push(
+            {os.path.basename(file): f}, run=run_id, project=project, entity=entity
+        )
+
+
+class FileSummary(Summary):
+    def __init__(self, run):
+        super().__init__(run)
+        self._fname = os.path.join(run.dir, wandb_lib.filenames.SUMMARY_FNAME)
+        self.load()
+
+    def load(self):
+        try:
+            with open(self._fname) as f:
+                self._json_dict = json.load(f)
+        except (OSError, ValueError):
+            self._json_dict = {}
+
+    def _write(self, commit=False):
+        # TODO: we just ignore commit to ensure backward capability
+        with open(self._fname, "w") as f:
+            f.write(util.json_dumps_safer(self._json_dict))
+            f.write("\n")
+            f.flush()
+            os.fsync(f.fileno())
+        if self._h5:
+            self._h5.close()
+            self._h5 = None
+        if wandb.run and wandb.run._jupyter_agent:
+            wandb.run._jupyter_agent.start()
+
+
+class HTTPSummary(Summary):
+    def __init__(self, run, client, summary=None):
+        super().__init__(run, summary=summary)
+        self._run = run
+        self._client = client
+        self._started = time.time()
+
+    def __delitem__(self, key):
+        if key not in self._json_dict:
+            raise KeyError(key)
+        del self._json_dict[key]
+
+    def load(self):
+        pass
+
+    def open_h5(self):
+        if not self._h5 and h5py:
+            download_h5(
+                self._run.id,
+                entity=self._run.entity,
+                project=self._run.project,
+                out_dir=self._run.dir,
+            )
+        super().open_h5()
+
+    def _write(self, commit=False):
+        mutation = gql(
+            """
+        mutation UpsertBucket( $id: String, $summaryMetrics: JSONString) {
+            upsertBucket(input: { id: $id, summaryMetrics: $summaryMetrics}) {
+                bucket { id }
+            }
+        }
+        """
+        )
+        if commit:
+            if self._h5:
+                self._h5.close()
+                self._h5 = None
+            res = self._client.execute(
+                mutation,
+                variable_values={
+                    "id": self._run.storage_id,
+                    "summaryMetrics": util.json_dumps_safer(self._json_dict),
+                },
+            )
+            assert res["upsertBucket"]["bucket"]["id"]
+            entity, project, run = self._run.path
+            if (
+                os.path.exists(self._h5_path)
+                and os.path.getmtime(self._h5_path) >= self._started
+            ):
+                upload_h5(self._h5_path, run, entity=entity, project=project)
+        else:
+            return False

vllm/lib/python3.10/site-packages/wandb/plot/__init__.py

@@ -0,0 +1,28 @@
+"""Chart Visualization Utilities
+
+This module offers a collection of predefined chart types, along with functionality
+for creating custom charts, enabling flexible visualization of your data beyond the
+built-in options.
+"""
+
+__all__ = [
+    "line",
+    "histogram",
+    "scatter",
+    "bar",
+    "roc_curve",
+    "pr_curve",
+    "confusion_matrix",
+    "line_series",
+]
+
+from wandb.plot.bar import bar
+from wandb.plot.confusion_matrix import confusion_matrix
+from wandb.plot.custom_chart import CustomChart, plot_table
+from wandb.plot.histogram import histogram
+from wandb.plot.line import line
+from wandb.plot.line_series import line_series
+from wandb.plot.pr_curve import pr_curve
+from wandb.plot.roc_curve import roc_curve
+from wandb.plot.scatter import scatter
+from wandb.plot.viz import Visualize, visualize