Add files using upload-large-folder tool

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sqrt_cpu_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API at::Tensor sqrt(const at::Tensor & self);
+TORCH_API at::Tensor & sqrt_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & sqrt_outf(const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor & sqrt_(at::Tensor & self);
+
+} // namespace cpu
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sum_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor sum(const at::Tensor & self, c10::optional<at::ScalarType> dtype=c10::nullopt);
+TORCH_API at::Tensor & sum_out(at::Tensor & out, const at::Tensor & self, c10::optional<at::ScalarType> dtype=c10::nullopt);
+TORCH_API at::Tensor & sum_outf(const at::Tensor & self, c10::optional<at::ScalarType> dtype, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

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

@@ -0,0 +1,30 @@
+"""
+The gpustat module.
+"""
+
+# isort: skip_file
+try:
+    from ._version import version as __version__
+    from ._version import version_tuple as __version_tuple__
+except (ImportError, AttributeError) as ex:
+    raise ImportError(
+        "Unable to find `gpustat.__version__` string. "
+        "Please try reinstalling gpustat; or if you are on a development "
+        "version, then run `pip install -e .` and try again."
+    ) from ex
+
+from .core import GPUStat, GPUStatCollection
+from .core import new_query, gpu_count, is_available
+from .cli import print_gpustat, main
+
+
+__all__ = (
+    '__version__',
+    'GPUStat',
+    'GPUStatCollection',
+    'new_query',
+    'gpu_count',
+    'is_available',
+    'print_gpustat',
+    'main',
+)

vllm/lib/python3.10/site-packages/gpustat/__main__.py

@@ -0,0 +1,9 @@
+"""
+gpustat.__main__ module (to support python -m gpustat)
+"""
+
+from .cli import main
+
+
+if __name__ == '__main__':
+    main()

vllm/lib/python3.10/site-packages/gpustat/_shtab.py

@@ -0,0 +1,8 @@
+FILE = None
+DIRECTORY = DIR = None
+
+
+def add_argument_to(parser, *args, **kwargs):
+    from argparse import Action
+    Action.complete = None
+    return parser

vllm/lib/python3.10/site-packages/gpustat/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '1.1.1'
+__version_tuple__ = version_tuple = (1, 1, 1)

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

@@ -0,0 +1,221 @@
+import os
+import sys
+import time
+from contextlib import suppress
+
+from blessed import Terminal
+
+from gpustat import __version__
+from gpustat.core import GPUStatCollection
+
+
+SHTAB_PREAMBLE = {
+    'zsh': '''\
+# % gpustat -i <TAB>
+# float
+# % gpustat -i -<TAB>
+# option
+# -a                   Display all gpu properties above
+# ...
+_complete_for_one_or_zero() {
+  if [[ ${words[CURRENT]} == -* ]]; then
+    # override the original options
+    _shtab_gpustat_options=(${words[CURRENT - 1]} $_shtab_gpustat_options)
+    _arguments -C $_shtab_gpustat_options
+  else
+    eval "${@[-1]}"
+  fi
+}
+'''
+}
+
+
+def zsh_choices_to_complete(choices, tag='', description=''):
+    '''Change choices to complete for zsh.
+
+    https://github.com/zsh-users/zsh/blob/master/Etc/completion-style-guide#L224
+    '''
+    complete = 'compadd - ' + ' '.join(filter(len, choices))
+    if description == '':
+        description = tag
+    if tag != '':
+        complete = '_wanted ' + tag + ' expl ' + description + ' ' + complete
+    return complete
+
+
+def get_complete_for_one_or_zero(input):
+    '''Get shell complete for nargs='?'. Now only support zsh.'''
+    output = {}
+    for sh, complete in input.items():
+        if sh == 'zsh':
+            output[sh] = "_complete_for_one_or_zero '" + complete + "'"
+    return output
+
+
+def print_gpustat(*, id=None, json=False, debug=False, **kwargs):
+    '''Display the GPU query results into standard output.'''
+    try:
+        gpu_stats = GPUStatCollection.new_query(debug=debug, id=id)
+    except Exception as e:
+        sys.stderr.write('Error on querying NVIDIA devices. '
+                         'Use --debug flag to see more details.\n')
+        term = Terminal(stream=sys.stderr)
+        sys.stderr.write(term.red(str(e)) + '\n')
+
+        if debug:
+            sys.stderr.write('\n')
+            try:
+                import traceback
+                traceback.print_exc(file=sys.stderr)
+            except Exception:
+                # NVMLError can't be processed by traceback:
+                #   https://bugs.python.org/issue28603
+                # as a workaround, simply re-throw the exception
+                raise e
+
+        sys.stderr.flush()
+        sys.exit(1)
+
+    if json:
+        gpu_stats.print_json(sys.stdout)
+    else:
+        gpu_stats.print_formatted(sys.stdout, **kwargs)
+
+
+def loop_gpustat(interval=1.0, **kwargs):
+    term = Terminal()
+
+    with term.fullscreen():
+        while 1:
+            try:
+                query_start = time.time()
+
+                # Move cursor to (0, 0) but do not restore original cursor loc
+                print(term.move(0, 0), end='')
+                print_gpustat(eol_char=term.clear_eol + os.linesep, **kwargs)
+                print(term.clear_eos, end='')
+
+                query_duration = time.time() - query_start
+                sleep_duration = interval - query_duration
+                if sleep_duration > 0:
+                    time.sleep(sleep_duration)
+            except KeyboardInterrupt:
+                return 0
+
+
+def main(*argv):
+    if not argv:
+        argv = list(sys.argv)
+
+    # attach SIGPIPE handler to properly handle broken pipe
+    try:  # sigpipe not available under windows. just ignore in this case
+        import signal
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+    except Exception as e:
+        pass
+    # arguments to gpustat
+    import argparse
+    try:
+        import shtab
+    except ImportError:
+        from . import _shtab as shtab
+    parser = argparse.ArgumentParser('gpustat')
+    shtab.add_argument_to(parser, preamble=SHTAB_PREAMBLE)
+
+    def nonnegative_int(value):
+        value = int(value)
+        if value < 0:
+            raise argparse.ArgumentTypeError(
+                "Only non-negative integers are allowed.")
+        return value
+
+    parser_color = parser.add_mutually_exclusive_group()
+    parser_color.add_argument('--force-color', '--color', action='store_true',
+                              help='Force to output with colors')
+    parser_color.add_argument('--no-color', action='store_true',
+                              help='Suppress colored output')
+    parser.add_argument('--id', help='Target a specific GPU (index).')
+    parser.add_argument('-a', '--show-all', action='store_true',
+                        help='Display all gpu properties above')
+    parser.add_argument('-c', '--show-cmd', action='store_true',
+                        help='Display cmd name of running process')
+    parser.add_argument(
+        '-f', '--show-full-cmd', action='store_true', default=False,
+        help='Display full command and cpu stats of running process'
+    )
+    parser.add_argument('-u', '--show-user', action='store_true',
+                        help='Display username of running process')
+    parser.add_argument('-p', '--show-pid', action='store_true',
+                        help='Display PID of running process')
+    parser.add_argument('-F', '--show-fan-speed', '--show-fan',
+                        action='store_true', help='Display GPU fan speed')
+    codec_choices = ['', 'enc', 'dec', 'enc,dec']
+    parser.add_argument(
+        '-e', '--show-codec', nargs='?', const='enc,dec', default='',
+        choices=codec_choices,
+        help='Show encoder/decoder utilization'
+    ).complete = get_complete_for_one_or_zero(  # type: ignore
+        {'zsh': zsh_choices_to_complete(codec_choices, 'codec')}
+    )
+    power_choices = ['', 'draw', 'limit', 'draw,limit', 'limit,draw']
+    parser.add_argument(
+        '-P', '--show-power', nargs='?', const='draw,limit',
+        choices=power_choices,
+        help='Show GPU power usage or draw (and/or limit)'
+    ).complete = get_complete_for_one_or_zero(  # type: ignore
+        {'zsh': zsh_choices_to_complete(power_choices, 'power')}
+    )
+    parser.add_argument('--json', action='store_true', default=False,
+                        help='Print all the information in JSON format')
+    parser.add_argument(
+        '-i', '--interval', '--watch', nargs='?', type=float, default=0,
+        help='Use watch mode if given; seconds to wait between updates'
+    ).complete = get_complete_for_one_or_zero({'zsh': '_numbers float'})  # type: ignore
+    parser.add_argument(
+        '--no-header', dest='show_header', action='store_false', default=True,
+        help='Suppress header message'
+    )
+    parser.add_argument(
+        '--gpuname-width', type=nonnegative_int, default=None,
+        help='The width at which GPU names will be displayed.'
+    )
+    parser.add_argument(
+        '--debug', action='store_true', default=False,
+        help='Allow to print additional informations for debugging.'
+    )
+    parser.add_argument(
+        '--no-processes', dest='no_processes', action='store_true',
+        help='Do not display running process information (memory, user, etc.)'
+    )
+    parser.add_argument('-v', '--version', action='version',
+                        version=('gpustat %s' % __version__))
+    args = parser.parse_args(argv[1:])
+    # TypeError: GPUStatCollection.print_formatted() got an unexpected keyword argument 'print_completion'
+    with suppress(AttributeError):
+        del args.print_completion  # type: ignore
+    if args.show_all:
+        args.show_cmd = True
+        args.show_user = True
+        args.show_pid = True
+        args.show_fan_speed = True
+        args.show_codec = 'enc,dec'
+        args.show_power = 'draw,limit'
+    del args.show_all
+
+    if args.interval is None:  # with default value
+        args.interval = 1.0
+    if args.interval > 0:
+        args.interval = max(0.1, args.interval)
+        if args.json:
+            sys.stderr.write("Error: --json and --interval/-i "
+                             "can't be used together.\n")
+            sys.exit(1)
+
+        loop_gpustat(**vars(args))
+    else:
+        del args.interval
+        print_gpustat(**vars(args))
+
+
+if __name__ == '__main__':
+    main(*sys.argv)

vllm/lib/python3.10/site-packages/gpustat/core.py

@@ -0,0 +1,764 @@
+#!/usr/bin/env python
+
+"""
+Implementation of gpustat
+
+@author Jongwook Choi
+@url https://github.com/wookayin/gpustat
+"""
+
+from typing import Sequence
+import json
+import locale
+import os.path
+import platform
+import sys
+import time
+from datetime import datetime
+from io import StringIO
+
+import psutil
+from blessed import Terminal
+
+import gpustat.util as util
+from gpustat.nvml import pynvml as N
+
+
+NOT_SUPPORTED = 'Not Supported'
+MB = 1024 * 1024
+
+DEFAULT_GPUNAME_WIDTH = 16
+
+IS_WINDOWS = 'windows' in platform.platform().lower()
+
+
+class GPUStat(object):
+
+    def __init__(self, entry):
+        if not isinstance(entry, dict):
+            raise TypeError(
+                'entry should be a dict, {} given'.format(type(entry))
+            )
+        self.entry = entry
+
+    def __repr__(self):
+        return self.print_to(StringIO()).getvalue()
+
+    def keys(self):
+        return self.entry.keys()
+
+    def __getitem__(self, key):
+        return self.entry[key]
+
+    @property
+    def available(self):
+        return True
+
+    @property
+    def index(self):
+        """
+        Returns the index of GPU (as in nvidia-smi).
+        """
+        return self.entry['index']
+
+    @property
+    def uuid(self):
+        """
+        Returns the uuid returned by nvidia-smi,
+        e.g. GPU-12345678-abcd-abcd-uuid-123456abcdef
+        """
+        return self.entry['uuid']
+
+    @property
+    def name(self):
+        """
+        Returns the name of GPU card (e.g. Geforce Titan X)
+        """
+        return self.entry['name']
+
+    @property
+    def memory_total(self):
+        """
+        Returns the total memory (in MB) as an integer.
+        """
+        return int(self.entry['memory.total'])
+
+    @property
+    def memory_used(self):
+        """
+        Returns the occupied memory (in MB) as an integer.
+        """
+        return int(self.entry['memory.used'])
+
+    @property
+    def memory_free(self):
+        """
+        Returns the free (available) memory (in MB) as an integer.
+        """
+        v = self.memory_total - self.memory_used
+        return max(v, 0)
+
+    @property
+    def memory_available(self):
+        """
+        Returns the available memory (in MB) as an integer.
+        Alias of memory_free.
+        """
+        return self.memory_free
+
+    @property
+    def temperature(self):
+        """
+        Returns the temperature (in celcius) of GPU as an integer,
+        or None if the information is not available.
+        """
+        v = self.entry['temperature.gpu']
+        return int(v) if v is not None else None
+
+    @property
+    def fan_speed(self):
+        """
+        Returns the fan speed percentage (0-100) of maximum intended speed
+        as an integer, or None if the information is not available.
+        """
+        v = self.entry['fan.speed']
+        return int(v) if v is not None else None
+
+    @property
+    def utilization(self):
+        """
+        Returns the GPU utilization (in percentile),
+        or None if the information is not available.
+        """
+        v = self.entry['utilization.gpu']
+        return int(v) if v is not None else None
+
+    @property
+    def utilization_enc(self):
+        """
+        Returns the GPU encoder utilization (in percentile),
+        or None if the information is not available.
+        """
+        v = self.entry['utilization.enc']
+        return int(v) if v is not None else None
+
+    @property
+    def utilization_dec(self):
+        """
+        Returns the GPU decoder utilization (in percentile),
+        or None if the information is not available.
+        """
+        v = self.entry['utilization.dec']
+        return int(v) if v is not None else None
+
+    @property
+    def power_draw(self):
+        """
+        Returns the GPU power usage in Watts,
+        or None if the information is not available.
+        """
+        v = self.entry['power.draw']
+        return int(v) if v is not None else None
+
+    @property
+    def power_limit(self):
+        """
+        Returns the (enforced) GPU power limit in Watts,
+        or None if the information is not available.
+        """
+        v = self.entry['enforced.power.limit']
+        return int(v) if v is not None else None
+
+    @property
+    def processes(self):
+        """
+        Get the list of running processes on the GPU.
+        """
+        return self.entry['processes']
+
+    def print_to(self, fp, *,
+                 with_colors=True,    # deprecated arg
+                 show_cmd=False,
+                 show_full_cmd=False,
+                 no_processes=False,
+                 show_user=False,
+                 show_pid=False,
+                 show_fan_speed=None,
+                 show_codec="",
+                 show_power=None,
+                 gpuname_width=None,
+                 eol_char=os.linesep,
+                 term=None,
+                 ):
+        if term is None:
+            term = Terminal(stream=sys.stdout)
+
+        # color settings
+        colors = {}
+
+        def _conditional(cond_fn, true_value, false_value,
+                         error_value=term.bold_black):
+            try:
+                return cond_fn() and true_value or false_value
+            except Exception:
+                return error_value
+
+        _ENC_THRESHOLD = 50
+
+        colors['C0'] = term.normal
+        colors['C1'] = term.cyan
+        colors['CBold'] = term.bold
+        colors['CName'] = _conditional(lambda: self.available,
+                                       term.blue, term.red)
+        colors['CTemp'] = _conditional(lambda: self.temperature < 50,
+                                       term.red, term.bold_red)
+        colors['FSpeed'] = _conditional(lambda: self.fan_speed < 30,
+                                        term.cyan, term.bold_cyan)
+        colors['CMemU'] = _conditional(lambda: self.available,
+                                       term.bold_yellow, term.bold_black)
+        colors['CMemT'] = _conditional(lambda: self.available,
+                                       term.yellow, term.bold_black)
+        colors['CMemP'] = term.yellow
+        colors['CCPUMemU'] = term.yellow
+        colors['CUser'] = term.bold_black   # gray
+        colors['CUtil'] = _conditional(lambda: self.utilization < 30,
+                                       term.green, term.bold_green)
+        colors['CUtilEnc'] = _conditional(
+            lambda: self.utilization_enc < _ENC_THRESHOLD,
+            term.green, term.bold_green)
+        colors['CUtilDec'] = _conditional(
+            lambda: self.utilization_dec < _ENC_THRESHOLD,
+            term.green, term.bold_green)
+        colors['CCPUUtil'] = term.green
+        colors['CPowU'] = _conditional(
+            lambda: (self.power_limit is not None and
+                     float(self.power_draw) / self.power_limit < 0.4),
+            term.magenta, term.bold_magenta
+        )
+        colors['CPowL'] = term.magenta
+        colors['CCmd'] = term.color(24)   # a bit dark
+
+        if not with_colors:
+            for k in list(colors.keys()):
+                colors[k] = ''
+
+        def _repr(v, none_value='??'):
+            return none_value if v is None else v
+
+        # build one-line display information
+        # we want power use optional, but if deserves being grouped with
+        # temperature and utilization
+        reps = u"%(C1)s[{entry[index]}]%(C0)s "
+        if gpuname_width is None or gpuname_width != 0:
+            reps += u"%(CName)s{entry_name:{gpuname_width}}%(C0)s |"
+        reps += u"%(CTemp)s{entry[temperature.gpu]:>3}°C%(C0)s, "
+
+        if show_fan_speed:
+            reps += "%(FSpeed)s{entry[fan.speed]:>3} %%%(C0)s, "
+
+        reps += "%(CUtil)s{entry[utilization.gpu]:>3} %%%(C0)s"
+
+        if show_codec:
+            codec_info = []
+            if "enc" in show_codec:
+                codec_info.append(
+                    "%(CBold)sE: %(C0)s"
+                    "%(CUtilEnc)s{entry[utilization.enc]:>3} %%%(C0)s")
+            if "dec" in show_codec:
+                codec_info.append(
+                    "%(CBold)sD: %(C0)s"
+                    "%(CUtilDec)s{entry[utilization.dec]:>3} %%%(C0)s")
+            reps += " ({})".format("  ".join(codec_info))
+
+        if show_power:
+            reps += ",  %(CPowU)s{entry[power.draw]:>3}%(C0)s "
+            if show_power is True or 'limit' in show_power:
+                reps += "/ %(CPowL)s{entry[enforced.power.limit]:>3}%(C0)s "
+                reps += "%(CPowL)sW%(C0)s"
+            else:
+                reps += "%(CPowU)sW%(C0)s"
+
+        reps += " | %(C1)s%(CMemU)s{entry[memory.used]:>5}%(C0)s " \
+            "/ %(CMemT)s{entry[memory.total]:>5}%(C0)s MB"
+        reps = (reps) % colors
+
+        class entry_repr_accessor:
+            def __init__(self, entry):
+                self.entry = entry
+            def __getitem__(self, key):
+                return _repr(self.entry[key])
+
+        reps = reps.format(
+            entry=entry_repr_accessor(self.entry),
+            entry_name=util.shorten_left(
+                self.entry["name"], width=gpuname_width, placeholder='…'),
+            gpuname_width=gpuname_width or DEFAULT_GPUNAME_WIDTH
+        )
+
+        # Add " |" only if processes information is to be added.
+        if not no_processes:
+            reps += " |"
+
+        def process_repr(p):
+            r = ''
+            if not show_cmd or show_user:
+                r += "{CUser}{}{C0}".format(
+                    _repr(p['username'], '--'), **colors
+                )
+            if show_cmd:
+                if r:
+                    r += ':'
+                r += "{C1}{}{C0}".format(
+                    _repr(p.get('command', p['pid']), '--'), **colors
+                )
+
+            if show_pid:
+                r += ("/%s" % _repr(p['pid'], '--'))
+            r += '({CMemP}{}M{C0})'.format(
+                _repr(p['gpu_memory_usage'], '?'), **colors
+            )
+            return r
+
+        def full_process_info(p):
+            r = "{C0} ├─ {:>6} ".format(
+                    _repr(p['pid'], '--'), **colors
+                )
+            r += "{C0}({CCPUUtil}{:4.0f}%{C0}, {CCPUMemU}{:>6}{C0})".format(
+                    _repr(p['cpu_percent'], '--'),
+                    util.bytes2human(_repr(p['cpu_memory_usage'], 0)), **colors
+                )
+            full_command_pretty = util.prettify_commandline(
+                p['full_command'], colors['C1'], colors['CCmd'])
+            r += "{C0}: {CCmd}{}{C0}".format(
+                _repr(full_command_pretty, '?'),
+                **colors
+            )
+            return r
+
+        processes = self.entry['processes']
+        full_processes = []
+        if processes is None and not no_processes:
+            # None (not available)
+            reps += ' ({})'.format(NOT_SUPPORTED)
+        elif not no_processes:
+            for p in processes:
+                reps += ' ' + process_repr(p)
+                if show_full_cmd:
+                    full_processes.append(eol_char + full_process_info(p))
+        if show_full_cmd and full_processes:
+            full_processes[-1] = full_processes[-1].replace('├', '└', 1)
+            reps += ''.join(full_processes)
+        fp.write(reps)
+        return fp
+
+    def jsonify(self):
+        o = self.entry.copy()
+        if self.entry['processes'] is not None:
+            o['processes'] = [{k: v for (k, v) in p.items() if k != 'gpu_uuid'}
+                              for p in self.entry['processes']]
+        return o
+
+
+class InvalidGPU(GPUStat):
+    class FallbackDict(dict):
+        def __missing__(self, key):
+            return "?"
+
+    def __init__(self, gpu_index, message, ex):
+        super().__init__(self.FallbackDict(
+            index=gpu_index,
+            name=message,
+            processes=None
+        ))
+        self.exception = ex
+
+    @property
+    def available(self):
+        return False
+
+
+class GPUStatCollection(Sequence[GPUStat]):
+
+    global_processes = {}
+
+    def __init__(self, gpu_list, driver_version=None):
+        self.gpus = gpu_list
+
+        # attach additional system information
+        self.hostname = platform.node()
+        self.query_time = datetime.now()
+        self.driver_version = driver_version
+
+    @staticmethod
+    def clean_processes():
+        for pid in list(GPUStatCollection.global_processes.keys()):
+            if not psutil.pid_exists(pid):
+                del GPUStatCollection.global_processes[pid]
+
+    @staticmethod
+    def new_query(debug=False, id=None) -> 'GPUStatCollection':
+        """Query the information of all the GPUs on local machine"""
+
+        N.nvmlInit()
+        log = util.DebugHelper()
+
+        def _decode(b):
+            if isinstance(b, bytes):
+                return b.decode('utf-8')    # for python3, to unicode
+            return b
+
+        def get_gpu_info(handle):
+            """Get one GPU information specified by nvml handle"""
+
+            def safepcall(fn, error_value):
+                # Ignore the exception from psutil when the process is gone
+                # at the moment of querying. See #144.
+                return util.safecall(
+                    fn, error_value=error_value,
+                    exc_types=(psutil.AccessDenied, psutil.NoSuchProcess,
+                               FileNotFoundError))
+
+            def get_process_info(nv_process):
+                """Get the process information of specific pid"""
+                process = {}
+                if nv_process.pid not in GPUStatCollection.global_processes:
+                    GPUStatCollection.global_processes[nv_process.pid] = \
+                        psutil.Process(pid=nv_process.pid)
+                ps_process: psutil.Process = GPUStatCollection.global_processes[nv_process.pid]
+
+                # TODO: ps_process is being cached, but the dict below is not.
+                process['username'] = safepcall(ps_process.username, '?')
+                # cmdline returns full path;
+                # as in `ps -o comm`, get short cmdnames.
+                _cmdline = safepcall(ps_process.cmdline, [])
+                if not _cmdline:
+                    # sometimes, zombie or unknown (e.g. [kworker/8:2H])
+                    process['command'] = '?'
+                    process['full_command'] = ['?']
+                else:
+                    process['command'] = os.path.basename(_cmdline[0])
+                    process['full_command'] = _cmdline
+                # Bytes to MBytes
+                # if drivers are not TTC this will be None.
+                usedmem = nv_process.usedGpuMemory // MB if \
+                          nv_process.usedGpuMemory else None
+                process['gpu_memory_usage'] = usedmem
+
+                process['cpu_percent'] = safepcall(ps_process.cpu_percent, 0.0)
+                process['cpu_memory_usage'] = safepcall(
+                    lambda: round((ps_process.memory_percent() / 100.0) *
+                                  psutil.virtual_memory().total),
+                    0.0)
+
+                process['pid'] = nv_process.pid
+                return process
+
+            name = _decode(N.nvmlDeviceGetName(handle))
+            uuid = _decode(N.nvmlDeviceGetUUID(handle))
+
+            try:
+                temperature = N.nvmlDeviceGetTemperature(
+                    handle, N.NVML_TEMPERATURE_GPU
+                )
+            except N.NVMLError as e:
+                log.add_exception("temperature", e)
+                temperature = None  # Not supported
+
+            try:
+                fan_speed = N.nvmlDeviceGetFanSpeed(handle)
+            except N.NVMLError as e:
+                log.add_exception("fan_speed", e)
+                fan_speed = None  # Not supported
+
+            try:
+                # memory: in Bytes
+                # Note that this is a compat-patched API (see gpustat.nvml)
+                memory = N.nvmlDeviceGetMemoryInfo(handle)
+            except N.NVMLError as e:
+                log.add_exception("memory", e)
+                memory = None  # Not supported
+
+            try:
+                utilization = N.nvmlDeviceGetUtilizationRates(handle)
+            except N.NVMLError as e:
+                log.add_exception("utilization", e)
+                utilization = None  # Not supported
+
+            try:
+                utilization_enc = N.nvmlDeviceGetEncoderUtilization(handle)
+            except N.NVMLError as e:
+                log.add_exception("utilization_enc", e)
+                utilization_enc = None  # Not supported
+
+            try:
+                utilization_dec = N.nvmlDeviceGetDecoderUtilization(handle)
+            except N.NVMLError as e:
+                log.add_exception("utilization_dec", e)
+                utilization_dec = None  # Not supported
+
+            try:
+                power = N.nvmlDeviceGetPowerUsage(handle)
+            except N.NVMLError as e:
+                log.add_exception("power", e)
+                power = None
+
+            try:
+                power_limit = N.nvmlDeviceGetEnforcedPowerLimit(handle)
+            except N.NVMLError as e:
+                log.add_exception("power_limit", e)
+                power_limit = None
+
+            try:
+                nv_comp_processes = \
+                    N.nvmlDeviceGetComputeRunningProcesses(handle)
+            except N.NVMLError as e:
+                log.add_exception("compute_processes", e)
+                nv_comp_processes = None  # Not supported
+            try:
+                nv_graphics_processes = \
+                    N.nvmlDeviceGetGraphicsRunningProcesses(handle)
+            except N.NVMLError as e:
+                log.add_exception("graphics_processes", e)
+                nv_graphics_processes = None  # Not supported
+
+            if nv_comp_processes is None and nv_graphics_processes is None:
+                processes = None
+            else:
+                processes = []
+                nv_comp_processes = nv_comp_processes or []
+                nv_graphics_processes = nv_graphics_processes or []
+                # A single process might run in both of graphics and compute mode,
+                # However we will display the process only once
+                seen_pids = set()
+                for nv_process in nv_comp_processes + nv_graphics_processes:
+                    if nv_process.pid in seen_pids:
+                        continue
+                    seen_pids.add(nv_process.pid)
+                    try:
+                        process = get_process_info(nv_process)
+                        processes.append(process)
+                    except psutil.NoSuchProcess:
+                        # TODO: add some reminder for NVML broken context
+                        # e.g. nvidia-smi reset  or  reboot the system
+                        pass
+                    except psutil.AccessDenied:
+                        pass
+                    except FileNotFoundError:
+                        # Ignore the exception which probably has occured
+                        # from psutil, due to a non-existent PID (see #95).
+                        # The exception should have been translated, but
+                        # there appears to be a bug of psutil. It is unlikely
+                        # FileNotFoundError is thrown in different situations.
+                        pass
+
+                # TODO: Do not block if full process info is not requested
+                time.sleep(0.1)
+                for process in processes:
+                    pid = process['pid']
+                    cache_process: psutil.Process = GPUStatCollection.global_processes[pid]
+                    process['cpu_percent'] = safepcall(cache_process.cpu_percent, 0)
+
+            index = N.nvmlDeviceGetIndex(handle)
+
+            # GPU Info.
+            # We use the same key/spec as per `nvidia-smi --query-help-gpu`
+            gpu_info = {
+                'index': index,
+                'uuid': uuid,
+                'name': name,
+                'temperature.gpu': temperature,
+                'fan.speed': fan_speed,
+                'utilization.gpu': utilization.gpu if utilization else None,
+                'utilization.enc':
+                    utilization_enc[0] if utilization_enc else None,
+                'utilization.dec':
+                    utilization_dec[0] if utilization_dec else None,
+                'power.draw': power // 1000 if power is not None else None,
+                'enforced.power.limit': power_limit // 1000
+                if power_limit is not None else None,
+                # Convert bytes into MBytes
+                'memory.used': memory.used // MB if memory else None,
+                'memory.total': memory.total // MB if memory else None,
+                'processes': processes,
+            }
+            GPUStatCollection.clean_processes()
+            return gpu_info
+
+        # 1. get the list of gpu and status
+        gpu_list = []
+        device_count = N.nvmlDeviceGetCount()
+
+        if id is None:
+            gpus_to_query = range(device_count)
+        elif isinstance(id, str):
+            gpus_to_query = [int(i) for i in id.split(',')]
+        elif isinstance(id, Sequence):
+            gpus_to_query = [int(i) for i in id]
+        else:
+            raise TypeError(f"Unknown id: {id}")
+
+        for index in gpus_to_query:
+            try:
+                handle = N.nvmlDeviceGetHandleByIndex(index)
+                gpu_info = get_gpu_info(handle)
+                gpu_stat = GPUStat(gpu_info)
+            except N.NVMLError_Unknown as e:
+                gpu_stat = InvalidGPU(index, "((Unknown Error))", e)
+            except N.NVMLError_GpuIsLost as e:
+                gpu_stat = InvalidGPU(index, "((GPU is lost))", e)
+
+            if isinstance(gpu_stat, InvalidGPU):
+                log.add_exception("GPU %d" % index, gpu_stat.exception)
+            gpu_list.append(gpu_stat)
+
+        # 2. additional info (driver version, etc).
+        try:
+            driver_version = _decode(N.nvmlSystemGetDriverVersion())
+        except N.NVMLError as e:
+            log.add_exception("driver_version", e)
+            driver_version = None    # N/A
+
+        if debug:
+            log.report_summary()
+
+        N.nvmlShutdown()
+        return GPUStatCollection(gpu_list, driver_version=driver_version)
+
+    def __len__(self):
+        return len(self.gpus)
+
+    def __iter__(self):
+        return iter(self.gpus)
+
+    def __getitem__(self, index):
+        return self.gpus[index]
+
+    def __repr__(self):
+        s = 'GPUStatCollection(host=%s, [\n' % self.hostname
+        s += '\n'.join('  ' + str(g) for g in self.gpus)
+        s += '\n])'
+        return s
+
+    # --- Printing Functions ---
+
+    def print_formatted(self, fp=sys.stdout, *,
+                        force_color=False, no_color=False,
+                        show_cmd=False, show_full_cmd=False, show_user=False,
+                        show_pid=False, show_fan_speed=None,
+                        show_codec="", show_power=None,
+                        gpuname_width=None, show_header=True,
+                        no_processes=False,
+                        eol_char=os.linesep,
+                        ):
+        # ANSI color configuration
+        if force_color and no_color:
+            raise ValueError("--color and --no_color can't"
+                             " be used at the same time")
+
+        if force_color:
+            TERM = os.getenv('TERM') or 'xterm-256color'
+            t_color = Terminal(kind=TERM, force_styling=True)
+
+            # workaround of issue #32 (watch doesn't recognize sgr0 characters)
+            t_color._normal = u'\x1b[0;10m'
+        elif no_color:
+            t_color = Terminal(force_styling=None)
+        else:
+            t_color = Terminal()   # auto, depending on isatty
+
+        # appearance settings
+        if gpuname_width is None:
+            gpuname_width = max([len(g.entry['name']) for g in self] + [0])
+
+        # header
+        if show_header:
+            if IS_WINDOWS:
+                # no localization is available; just use a reasonable default
+                # same as str(timestr) but without ms
+                timestr = self.query_time.strftime('%Y-%m-%d %H:%M:%S')
+            else:
+                time_format = locale.nl_langinfo(locale.D_T_FMT)
+                timestr = self.query_time.strftime(time_format)
+            header_template = '{t.bold_white}{hostname:{width}}{t.normal}  '
+            header_template += '{timestr}  '
+            header_template += '{t.bold_black}{driver_version}{t.normal}'
+
+            header_msg = header_template.format(
+                    hostname=self.hostname,
+                    width=(gpuname_width or DEFAULT_GPUNAME_WIDTH) + 3,  # len("[?]")
+                    timestr=timestr,
+                    driver_version=self.driver_version,
+                    t=t_color,
+                )
+
+            fp.write(header_msg.strip())
+            fp.write(eol_char)
+
+        # body
+        for g in self:
+            g.print_to(fp,
+                       show_cmd=show_cmd,
+                       show_full_cmd=show_full_cmd,
+                       no_processes=no_processes,
+                       show_user=show_user,
+                       show_pid=show_pid,
+                       show_fan_speed=show_fan_speed,
+                       show_codec=show_codec,
+                       show_power=show_power,
+                       gpuname_width=gpuname_width,
+                       eol_char=eol_char,
+                       term=t_color)
+            fp.write(eol_char)
+
+        if len(self.gpus) == 0:
+            print(t_color.yellow("(No GPUs are available)"))
+
+        fp.flush()
+
+    def jsonify(self):
+        return {
+            'hostname': self.hostname,
+            'driver_version': self.driver_version,
+            'query_time': self.query_time,
+            "gpus": [g.jsonify() for g in self]
+        }
+
+    def print_json(self, fp=sys.stdout):
+        def date_handler(obj):
+            if hasattr(obj, 'isoformat'):
+                return obj.isoformat()
+            else:
+                raise TypeError(type(obj))
+
+        o = self.jsonify()
+        json.dump(o, fp, indent=4, separators=(',', ': '),
+                  default=date_handler)
+        fp.write(os.linesep)
+        fp.flush()
+
+
+def new_query() -> GPUStatCollection:
+    '''
+    Obtain a new GPUStatCollection instance by querying nvidia-smi
+    to get the list of GPUs and running process information.
+    '''
+    return GPUStatCollection.new_query()
+
+
+def gpu_count() -> int:
+    '''Return the number of available GPUs in the system.'''
+    try:
+        N.nvmlInit()
+        return N.nvmlDeviceGetCount()
+    except N.NVMLError:
+        return 0  # fallback
+    finally:
+        try:
+            N.nvmlShutdown()
+        except N.NVMLError:
+            pass
+
+
+def is_available() -> bool:
+    '''Return True if the NVML library and GPU devices are available.'''
+    return gpu_count() > 0

vllm/lib/python3.10/site-packages/gpustat/nvml.py

@@ -0,0 +1,160 @@
+"""Imports pynvml with sanity checks and custom patches."""
+
+import warnings
+import functools
+import os
+import sys
+import textwrap
+
+# If this environment variable is set, we will bypass pynvml version validation
+# so that legacy pynvml (nvidia-ml-py3) can be used. This would be useful
+# in a case where there are conflicts on pynvml dependencies.
+# However, beware that pynvml might produce wrong results (see #107).
+ALLOW_LEGACY_PYNVML = os.getenv("ALLOW_LEGACY_PYNVML", "")
+ALLOW_LEGACY_PYNVML = ALLOW_LEGACY_PYNVML.lower() not in ('false', '0', '')
+
+
+try:
+    # Check pynvml version: we require 11.450.129 or newer.
+    # https://github.com/wookayin/gpustat/pull/107
+    import pynvml
+    if not (
+        # Requires nvidia-ml-py >= 11.460.79
+        hasattr(pynvml, 'NVML_BRAND_NVIDIA_RTX') or
+        # Requires nvidia-ml-py >= 11.450.129, < 11.510.69
+        hasattr(pynvml, 'nvmlDeviceGetComputeRunningProcesses_v2')
+    ) and not ALLOW_LEGACY_PYNVML:
+        raise ImportError("pynvml library is outdated.")
+
+    if not hasattr(pynvml, '_nvmlGetFunctionPointer'):
+        # Unofficial pynvml from @gpuopenanalytics/pynvml, see #153
+        import pynvml.nvml as pynvml
+
+except (ImportError, SyntaxError, RuntimeError) as e:
+    _pynvml = sys.modules.get('pynvml', None)
+
+    raise ImportError(textwrap.dedent(
+        """\
+        pynvml is missing or an outdated version is installed.
+
+        We require nvidia-ml-py>=11.450.129, and the official NVIDIA python bindings
+        should be used; neither nvidia-ml-py3 nor gpuopenanalytics/pynvml.
+        For more details, please refer to: https://github.com/wookayin/gpustat/issues/107
+
+        The root cause: """ + str(e) +
+        """
+
+        Your pynvml installation: """ + repr(_pynvml) +
+        """
+
+        -----------------------------------------------------------
+        Please reinstall `gpustat`:
+
+        $ pip install --force-reinstall gpustat
+
+        If it still does not fix the problem, please uninstall pynvml packages and reinstall nvidia-ml-py manually:
+
+        $ pip uninstall nvidia-ml-py3 pynvml
+        $ pip install --force-reinstall --ignore-installed 'nvidia-ml-py'
+        """)) from e
+
+
+# Monkey-patch nvml due to breaking changes in pynvml.
+# See #107, #141, and test_gpustat.py for more details.
+
+_original_nvmlGetFunctionPointer = pynvml._nvmlGetFunctionPointer
+_original_nvmlDeviceGetMemoryInfo = pynvml.nvmlDeviceGetMemoryInfo
+
+
+class pynvml_monkeypatch:
+
+    @staticmethod  # Note: must be defined as a staticmethod to allow mocking.
+    def original_nvmlGetFunctionPointer(name):
+        return _original_nvmlGetFunctionPointer(name)
+
+    FUNCTION_FALLBACKS = {
+        # for pynvml._nvmlGetFunctionPointer
+        'nvmlDeviceGetComputeRunningProcesses_v3': 'nvmlDeviceGetComputeRunningProcesses_v2',
+        'nvmlDeviceGetGraphicsRunningProcesses_v3': 'nvmlDeviceGetGraphicsRunningProcesses_v2',
+    }
+
+    @staticmethod
+    @functools.wraps(pynvml._nvmlGetFunctionPointer)
+    def _nvmlGetFunctionPointer(name):
+        """Our monkey-patched pynvml._nvmlGetFunctionPointer().
+
+        See also:
+            test_gpustat::NvidiaDriverMock for test scenarios. See #107.
+        """
+        M = pynvml_monkeypatch
+
+        try:
+            ret = M.original_nvmlGetFunctionPointer(name)
+            return ret
+        except pynvml.NVMLError_FunctionNotFound:  # type: ignore
+            if name in M.FUNCTION_FALLBACKS:
+                # Lack of ...Processes_v3 APIs happens for
+                # OLD drivers < 510.39.01 && pynvml >= 11.510, where
+                # we fallback to v2 APIs. (see #107 for more details)
+
+                ret = M.original_nvmlGetFunctionPointer(
+                    M.FUNCTION_FALLBACKS[name]
+                )
+                # populate the cache, so this handler won't get executed again
+                pynvml._nvmlGetFunctionPointer_cache[name] = ret
+
+            else:
+                # Unknown case, cannot handle. re-raise again
+                raise
+
+        return ret
+
+    @staticmethod  # Note: must be defined as a staticmethod to allow mocking.
+    def original_nvmlDeviceGetMemoryInfo(*args, **kwargs):
+        return _original_nvmlDeviceGetMemoryInfo(*args, **kwargs)
+
+    has_memoryinfo_v2 = None
+
+    @staticmethod
+    @functools.wraps(pynvml.nvmlDeviceGetMemoryInfo)
+    def nvmlDeviceGetMemoryInfo(handle):
+        """A patched version of nvmlDeviceGetMemoryInfo.
+
+        This tries `version=N.nvmlMemory_v2` if the nvmlDeviceGetMemoryInfo_v2
+        function is available (for driver >= 515), or fallback to the legacy
+        v1 API for (driver < 515) to yield a correct result. See #141.
+        """
+        M = pynvml_monkeypatch
+
+        if M.has_memoryinfo_v2 is None:
+            try:
+                pynvml._nvmlGetFunctionPointer("nvmlDeviceGetMemoryInfo_v2")
+                M.has_memoryinfo_v2 = True
+            except pynvml.NVMLError_FunctionNotFound:  # type: ignore
+                M.has_memoryinfo_v2 = False
+
+        if hasattr(pynvml, 'nvmlMemory_v2'):  # pynvml >= 11.510.69
+            try:
+                memory = M.original_nvmlDeviceGetMemoryInfo(
+                    handle, version=pynvml.nvmlMemory_v2)
+            except pynvml.NVMLError_FunctionNotFound:  # type: ignore
+                # pynvml >= 11.510 but driver is old (<515.39)
+                memory = M.original_nvmlDeviceGetMemoryInfo(handle)
+        else:
+            if M.has_memoryinfo_v2:
+                warnings.warn(
+                    "Your NVIDIA driver requires a compatible version of "
+                    "pynvml (>= 11.510.69) installed to display the correct "
+                    "memory usage information (See #141 for more details). "
+                    "Please try `pip install --upgrade nvidia-ml-py`.",
+                    category=UserWarning)
+            memory = M.original_nvmlDeviceGetMemoryInfo(handle)
+
+        return memory
+
+
+setattr(pynvml, '_nvmlGetFunctionPointer', pynvml_monkeypatch._nvmlGetFunctionPointer)
+setattr(pynvml, 'nvmlDeviceGetMemoryInfo', pynvml_monkeypatch.nvmlDeviceGetMemoryInfo)
+
+
+__all__ = ['pynvml']

vllm/lib/python3.10/site-packages/gpustat/test_gpustat.py

@@ -0,0 +1,703 @@
+"""
+Unit or integration tests for gpustat
+"""
+# flake8: ignore=E501
+
+import ctypes
+import os
+import shlex
+import sys
+import types
+from collections import namedtuple
+from io import StringIO
+from typing import Any
+
+import psutil
+import pytest
+from mockito import ANY, mock, unstub, when, when2
+
+import gpustat
+from gpustat.nvml import pynvml, pynvml_monkeypatch
+
+MB = 1024 * 1024
+
+
+def remove_ansi_codes(s):
+    import re
+    s = re.compile(r'\x1b[^m]*m').sub('', s)
+    s = re.compile(r'\x0f').sub('', s)
+    return s
+
+# -----------------------------------------------------------------------------
+
+mock_gpu_handles = [types.SimpleNamespace(value='mock-handle-%d' % i, index=i)
+                    for i in range(3)]
+
+def _configure_mock(N=pynvml,
+                    _scenario_nonexistent_pid=False,  # GH-95
+                    _scenario_failing_one_gpu=None,   # GH-125, GH-81
+                    ):
+    """Define mock behaviour for pynvml and psutil.{Process,virtual_memory}."""
+
+    # without following patch, unhashable NVMLError makes unit test crash
+    N.NVMLError.__hash__ = lambda _: 0
+    assert issubclass(N.NVMLError, BaseException)
+
+    unstub(N)  # reset all the stubs
+
+    when(N).nvmlInit().thenReturn()
+    when(N).nvmlShutdown().thenReturn()
+    when(N).nvmlSystemGetDriverVersion().thenReturn('415.27.mock')
+
+    when(N)._nvmlGetFunctionPointer(...).thenCallOriginalImplementation()
+
+    NUM_GPUS = 3
+    when(N).nvmlDeviceGetCount().thenReturn(NUM_GPUS)
+
+    def _return_or_raise(v):
+        """Return a callable for thenAnswer() to let exceptions re-raised."""
+        def _callable(*args, **kwargs):
+            del args, kwargs
+            if isinstance(v, Exception):
+                raise v
+            return v
+        return _callable
+
+    for i in range(NUM_GPUS):
+        handle = mock_gpu_handles[i]
+        if _scenario_failing_one_gpu and i == 2:  # see #81, #125
+            assert (_scenario_failing_one_gpu is N.NVMLError_Unknown or
+                    _scenario_failing_one_gpu is N.NVMLError_GpuIsLost)
+            handle = _scenario_failing_one_gpu()  # see 81
+
+        when(N).nvmlDeviceGetHandleByIndex(i)\
+            .thenAnswer(_return_or_raise(handle))
+        when(N).nvmlDeviceGetIndex(handle)\
+            .thenReturn(i)
+        when(N).nvmlDeviceGetName(handle)\
+            .thenReturn({
+                0: 'GeForce GTX TITAN 0',
+                1: 'GeForce GTX TITAN 1',
+                2: 'GeForce RTX 2',
+            }[i].encode())
+        when(N).nvmlDeviceGetUUID(handle)\
+            .thenReturn({
+                0: b'GPU-10fb0fbd-2696-43f3-467f-d280d906a107',
+                1: b'GPU-d1df4664-bb44-189c-7ad0-ab86c8cb30e2',
+                2: b'GPU-50205d95-57b6-f541-2bcb-86c09afed564',
+            }[i])
+
+        when(N).nvmlDeviceGetTemperature(handle, N.NVML_TEMPERATURE_GPU)\
+            .thenReturn([80, 36, 71][i])
+        when(N).nvmlDeviceGetFanSpeed(handle)\
+            .thenReturn([16, 53, 100][i])
+        when(N).nvmlDeviceGetPowerUsage(handle)\
+            .thenAnswer(_return_or_raise({
+                0: 125000, 1: N.NVMLError_NotSupported(), 2: 250000
+            }[i]))
+        when(N).nvmlDeviceGetEnforcedPowerLimit(handle)\
+            .thenAnswer(_return_or_raise({
+                0: 250000, 1: 250000, 2: N.NVMLError_NotSupported()
+            }[i]))
+
+        # see also: NvidiaDriverMock
+        mock_memory_t = namedtuple("Memory_t", ['total', 'used'])  # c_nvmlMemory_t
+        when(N).nvmlDeviceGetMemoryInfo(handle)\
+            .thenAnswer(_return_or_raise({
+                0: mock_memory_t(total=12883853312, used=8000*MB),
+                1: mock_memory_t(total=12781551616, used=9000*MB),
+                2: mock_memory_t(total=12781551616, used=0),
+            }[i]))
+        # this mock function assumes <510.39 behavior (#141)
+        when(N, strict=False)\
+            .nvmlDeviceGetMemoryInfo(handle, version=ANY())\
+            .thenRaise(N.NVMLError_FunctionNotFound)
+
+        mock_utilization_t = namedtuple("Utilization_t", ['gpu', 'memory'])
+        when(N).nvmlDeviceGetUtilizationRates(handle)\
+            .thenAnswer(_return_or_raise({
+                0: mock_utilization_t(gpu=76, memory=0),
+                1: mock_utilization_t(gpu=0, memory=0),
+                2: N.NVMLError_NotSupported(),  # Not Supported
+            }[i]))
+
+        when(N).nvmlDeviceGetEncoderUtilization(handle)\
+            .thenAnswer(_return_or_raise({
+                0: [88, 167000],  # [value, sample_rate]
+                1: [0, 167000],   # [value, sample_rate]
+                2: N.NVMLError_NotSupported(),  # Not Supported
+            }[i]))
+        when(N).nvmlDeviceGetDecoderUtilization(handle)\
+            .thenAnswer(_return_or_raise({
+                0: [67, 167000],  # [value, sample_rate]
+                1: [0, 167000],   # [value, sample_rate]
+                2: N.NVMLError_NotSupported(),  # Not Supported
+            }[i]))
+
+        # running process information: a bit annoying...
+        mock_process_t = namedtuple("Process_t", ['pid', 'usedGpuMemory'])
+
+        if _scenario_nonexistent_pid:
+            mock_processes_gpu2_erratic = [
+                mock_process_t(99999, 9999*MB),
+                mock_process_t(99995, 9995*MB),   # see issue #95
+            ]
+        else:
+            mock_processes_gpu2_erratic = N.NVMLError_NotSupported()
+
+        # see NvidiaDriverMock as well
+        when(N).nvmlDeviceGetComputeRunningProcesses(handle)\
+            .thenAnswer(_return_or_raise({
+                0: [mock_process_t(48448, 4000*MB), mock_process_t(153223, 4000*MB)],
+                1: [mock_process_t(192453, 3000*MB), mock_process_t(194826, 6000*MB)],
+                2: mock_processes_gpu2_erratic,   # Not Supported or non-existent
+            }[i]))
+
+        when(N).nvmlDeviceGetGraphicsRunningProcesses(handle)\
+            .thenAnswer(_return_or_raise({
+                0: [mock_process_t(48448, 4000*MB)],
+                1: [],
+                2: N.NVMLError_NotSupported(),
+            }[i]))
+
+    # for psutil
+    mock_pid_map = {   # mock/stub information for psutil...
+        48448:  ('user1', 'python', 85.25, 3.1415),
+        154213: ('user1', 'caffe', 16.89, 100.00),
+        38310:  ('user3', 'python', 26.23, 99.9653),
+        153223: ('user2', 'python', 15.25, 0.0000),
+        194826: ('user3', 'caffe', 0.0, 12.5236),
+        192453: ('user1', 'torch', 123.2, 0.7312),
+    }
+    assert 99999 not in mock_pid_map, 'scenario_nonexistent_pid'
+    assert 99995 not in mock_pid_map, 'scenario_nonexistent_pid (#95)'
+
+    def _MockedProcess(pid):
+        if pid not in mock_pid_map:
+            if pid == 99995:
+                # simulate a bug reported in #95
+                raise FileNotFoundError("/proc/99995/stat")
+            else:
+                # for a process that does not exist, NoSuchProcess is the
+                # type of exceptions supposed to be raised by psutil
+                raise psutil.NoSuchProcess(pid=pid)
+        username, cmdline, cpuutil, memutil = mock_pid_map[pid]
+        p: Any = mock(strict=True)   # psutil.Process
+        p.username = lambda: username
+        p.cmdline = lambda: [cmdline]
+        p.cpu_percent = lambda: cpuutil
+        p.memory_percent = lambda: memutil
+        p.pid = pid
+        return p
+
+    when(psutil).Process(...)\
+        .thenAnswer(_MockedProcess)
+    when(psutil).virtual_memory()\
+        .thenReturn(mock_memory_t(total=8589934592, used=0))
+
+
+MOCK_EXPECTED_OUTPUT_DEFAULT = os.linesep.join("""\
+[0] GeForce GTX TITAN 0 | 80°C,  76 % |  8000 / 12287 MB | user1(4000M) user2(4000M)
+[1] GeForce GTX TITAN 1 | 36°C,   0 % |  9000 / 12189 MB | user1(3000M) user3(6000M)
+[2] GeForce RTX 2       | 71°C,  ?? % |     0 / 12189 MB | (Not Supported)
+""".splitlines())  # noqa: E501
+
+MOCK_EXPECTED_OUTPUT_FULL = os.linesep.join("""\
+[0] GeForce GTX TITAN 0 | 80°C,  16 %,  76 % (E:  88 %  D:  67 %),  125 / 250 W |  8000 / 12287 MB | user1:python/48448(4000M) user2:python/153223(4000M)
+[1] GeForce GTX TITAN 1 | 36°C,  53 %,   0 % (E:   0 %  D:   0 %),   ?? / 250 W |  9000 / 12189 MB | user1:torch/192453(3000M) user3:caffe/194826(6000M)
+[2] GeForce RTX 2       | 71°C, 100 %,  ?? % (E:  ?? %  D:  ?? %),  250 /  ?? W |     0 / 12189 MB | (Not Supported)
+""".splitlines())  # noqa: E501
+
+MOCK_EXPECTED_OUTPUT_FULL_PROCESS = os.linesep.join("""\
+[0] GeForce GTX TITAN 0 | 80°C,  16 %,  76 % (E:  88 %  D:  67 %),  125 / 250 W |  8000 / 12287 MB | user1:python/48448(4000M) user2:python/153223(4000M)
+ ├─  48448 (  85%,  257MB): python
+ └─ 153223 (  15%,     0B): python
+[1] GeForce GTX TITAN 1 | 36°C,  53 %,   0 % (E:   0 %  D:   0 %),   ?? / 250 W |  9000 / 12189 MB | user1:torch/192453(3000M) user3:caffe/194826(6000M)
+ ├─ 192453 ( 123%,   59MB): torch
+ └─ 194826 (   0%, 1025MB): caffe
+[2] GeForce RTX 2       | 71°C, 100 %,  ?? % (E:  ?? %  D:  ?? %),  250 /  ?? W |     0 / 12189 MB | (Not Supported)
+""".splitlines())  # noqa: E501
+
+MOCK_EXPECTED_OUTPUT_NO_PROCESSES = os.linesep.join("""\
+[0] GeForce GTX TITAN 0 | 80°C,  76 % |  8000 / 12287 MB
+[1] GeForce GTX TITAN 1 | 36°C,   0 % |  9000 / 12189 MB
+[2] GeForce RTX 2       | 71°C,  ?? % |     0 / 12189 MB
+""".splitlines())  # noqa: E501
+
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture
+def scenario_basic():
+    _configure_mock()
+
+
+@pytest.fixture
+def scenario_nonexistent_pid():
+    _configure_mock(_scenario_nonexistent_pid=True)
+
+
+@pytest.fixture
+def scenario_failing_one_gpu(request: pytest.FixtureRequest):
+    # request.param should be either NVMLError_Unknown or NVMLError_GpuIsLost
+    _configure_mock(_scenario_failing_one_gpu=request.param)
+    return dict(expected_message={
+        pynvml.NVMLError_GpuIsLost: 'GPU is lost',
+        pynvml.NVMLError_Unknown: 'Unknown Error',
+    }[request.param])
+
+
+@pytest.fixture
+def nvidia_driver_version(request: pytest.FixtureRequest):
+    """See NvidiaDriverMock."""
+
+    nvidia_mock: NvidiaDriverMock = request.param
+    nvidia_mock(pynvml)
+
+    if nvidia_mock.name.startswith('430'):
+        # AssertionError: gpustat will print (Not Supported) in this case
+        request.node.add_marker(pytest.mark.xfail(
+            reason="nvmlDeviceGetComputeRunningProcesses_v2 does not exist"))
+
+    yield nvidia_mock
+
+
+class NvidiaDriverMock:
+    """Simulate the behavior of nvml's low-level functions according to a
+    specific nvidia driver versions, with backward compatibility in concern.
+    In all the scenarios, gpustat should work well with a compatible version
+    of pynvml installed.
+
+    For what has changed on the nvidia driver side (a non-exhaustive list), see
+    https://github.com/NVIDIA/nvidia-settings/blame/main/src/nvml.h
+    https://github.com/NVIDIA/nvidia-settings/blame/main/src/libXNVCtrlAttributes/NvCtrlAttributesPrivate.h
+
+    Noteworthy changes of nvml driviers:
+        450.66:    nvmlDeviceGetComputeRunningProcesses_v2
+        510.39.01: nvmlDeviceGetComputeRunningProcesses_v3  (_v2 removed)
+                   nvmlDeviceGetMemoryInfo_v2
+
+    Relevant github issues:
+        #107: nvmlDeviceGetComputeRunningProcesses_v2 added
+        #141: nvmlDeviceGetMemoryInfo (v1) broken for 510.39.01+
+    """
+    INSTANCES = []
+
+    def __init__(self, name, **kwargs):
+        self.name = name
+        self.feat = kwargs
+
+    def __call__(self, N):
+        self.mock_processes(N)
+        self.mock_memoryinfo(N)
+
+    def mock_processes(self, N):
+        when(N).nvmlDeviceGetComputeRunningProcesses(...).thenCallOriginalImplementation()
+        when(N).nvmlDeviceGetGraphicsRunningProcesses(...).thenCallOriginalImplementation()
+        when(N).nvmlSystemGetDriverVersion().thenReturn(self.name)
+
+        def process_t(pid, usedGpuMemory):
+            return pynvml.c_nvmlProcessInfo_t(
+                pid=ctypes.c_uint(pid),
+                usedGpuMemory=ctypes.c_ulonglong(usedGpuMemory),
+            )
+
+        # more low-level mocking for
+        # nvmlDeviceGetComputeRunningProcesses_{v2, v3} & c_nvmlProcessInfo_t
+        def _nvmlDeviceGetComputeRunningProcesses_v2(handle, c_count, c_procs):
+            # handle: SimpleNamespace (see _configure_mock)
+            if c_count._obj.value == 0:
+                return pynvml.NVML_ERROR_INSUFFICIENT_SIZE
+            else:
+                c_count._obj.value = 2
+                if handle.index == 0:
+                    c = process_t(pid=48448, usedGpuMemory=4000*MB); c_procs[0] = c
+                    c = process_t(pid=153223, usedGpuMemory=4000*MB); c_procs[1] = c
+                elif handle.index == 1:
+                    c = process_t(pid=192453, usedGpuMemory=3000*MB); c_procs[0] = c
+                    c = process_t(pid=194826, usedGpuMemory=6000*MB); c_procs[1] = c
+                else:
+                    return pynvml.NVML_ERROR_NOT_SUPPORTED
+            return pynvml.NVML_SUCCESS
+
+        def _nvmlDeviceGetGraphicsRunningProcesses_v2(handle, c_count, c_procs):
+            if c_count._obj.value == 0:
+                return pynvml.NVML_ERROR_INSUFFICIENT_SIZE
+            else:
+                if handle.index == 0:
+                    c_count._obj.value = 1
+                    c = process_t(pid=48448, usedGpuMemory=4000*MB); c_procs[0] = c
+                elif handle.index == 1:
+                    c_count._obj.value = 0
+                else:
+                    return pynvml.NVML_ERROR_NOT_SUPPORTED
+            return pynvml.NVML_SUCCESS
+
+        # Note: N._nvmlGetFunctionPointer might have been monkey-patched,
+        # so this mock should decorate the underlying, unwrapped raw function,
+        # NOT a monkey-patched version of pynvml._nvmlGetFunctionPointer.
+        for v in [1, 2, 3]:
+            _v = f'_v{v}' if v != 1 else ''   # backward compatible v3 -> v2
+            stub = when2(pynvml_monkeypatch.original_nvmlGetFunctionPointer,
+                         f'nvmlDeviceGetComputeRunningProcesses{_v}')
+            if v <= self.nvmlDeviceGetComputeRunningProcesses_v:
+                stub.thenReturn(_nvmlDeviceGetComputeRunningProcesses_v2)
+            else:
+                stub.thenRaise(pynvml.NVMLError(pynvml.NVML_ERROR_FUNCTION_NOT_FOUND))
+
+            stub = when2(pynvml_monkeypatch.original_nvmlGetFunctionPointer,
+                         f'nvmlDeviceGetGraphicsRunningProcesses{_v}')
+            if v <= self.nvmlDeviceGetComputeRunningProcesses_v:
+                stub.thenReturn(_nvmlDeviceGetGraphicsRunningProcesses_v2)
+            else:
+                stub.thenRaise(pynvml.NVMLError(pynvml.NVML_ERROR_FUNCTION_NOT_FOUND))
+
+    def mock_memoryinfo(self, N):
+        nvmlMemory_v2 = 0x02000028
+        if self.nvmlDeviceGetMemoryInfo_v == 1:
+            mock_memory_t = namedtuple(
+                "c_nvmlMemory_t",
+                ['total', 'used'],
+            )
+        elif self.nvmlDeviceGetMemoryInfo_v == 2:
+            mock_memory_t = namedtuple(
+                "c_nvmlMemory_v2_t",
+                ['version', 'total', 'reserved', 'free', 'used'],
+            )
+            mock_memory_t.__new__.__defaults__ = (nvmlMemory_v2, 0, 0, 0, 0)
+        else:
+            raise NotImplementedError
+
+        # simulates drivers >= 510.39, where memoryinfo v2 is introduced
+        if self.nvmlDeviceGetMemoryInfo_v == 2:
+            for handle in mock_gpu_handles:
+                # a correct API requires version=... parameter
+                # this assumes nvidia driver is also recent enough.
+                when(pynvml_monkeypatch, strict=False)\
+                    .original_nvmlDeviceGetMemoryInfo(handle, version=nvmlMemory_v2)\
+                    .thenReturn({
+                        0: mock_memory_t(total=12883853312, used=8000*MB),
+                        1: mock_memory_t(total=12781551616, used=9000*MB),
+                        2: mock_memory_t(total=12781551616, used=0),
+                    }[handle.index])
+                # simulate #141: without the v2 parameter, gives wrong result
+                when(pynvml_monkeypatch)\
+                    .original_nvmlDeviceGetMemoryInfo(handle)\
+                    .thenReturn({
+                        0: mock_memory_t(total=12883853312, used=8099*MB),
+                        1: mock_memory_t(total=12781551616, used=9099*MB),
+                        2: mock_memory_t(total=12781551616, used=99*MB),
+                    }[handle.index])
+
+        else:  # old drivers < 510.39
+            for handle in mock_gpu_handles:
+                # when pynvml>=11.510, v2 API can be called but can't be used
+                when(N, strict=False)\
+                    .nvmlDeviceGetMemoryInfo(handle, version=ANY())\
+                    .thenRaise(N.NVMLError_FunctionNotFound)
+                # The v1 API will give a correct result for the v1 API
+                when(N).nvmlDeviceGetMemoryInfo(handle)\
+                    .thenReturn({
+                        0: mock_memory_t(total=12883853312, used=8000*MB),
+                        1: mock_memory_t(total=12781551616, used=9000*MB),
+                        2: mock_memory_t(total=12781551616, used=0),
+                    }[handle.index])
+
+    def __getattr__(self, k):
+        return self.feat[k]
+
+    @property
+    def __name__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.__name__
+
+
+NvidiaDriverMock.INSTANCES = [
+    NvidiaDriverMock('430.xx.xx',
+                     nvmlDeviceGetComputeRunningProcesses_v=1,
+                     nvmlDeviceGetMemoryInfo_v=1,
+                     ),
+    NvidiaDriverMock('450.66',
+                     nvmlDeviceGetComputeRunningProcesses_v=2,
+                     nvmlDeviceGetMemoryInfo_v=1,
+                     ),
+    NvidiaDriverMock('510.39.01',
+                     nvmlDeviceGetComputeRunningProcesses_v=3,
+                     nvmlDeviceGetMemoryInfo_v=2,
+                     ),
+]
+
+
+# -----------------------------------------------------------------------------
+
+
+class TestGPUStat(object):
+    """A pytest class suite for gpustat."""
+
+    def setup_method(self):
+        print("")
+        self.maxDiff = 4096
+
+    def teardown_method(self):
+        unstub()
+
+    @staticmethod
+    def capture_output(*args):
+        f = StringIO()
+        import contextlib
+
+        with contextlib.redirect_stdout(f):  # requires python 3.4+
+            try:
+                gpustat.main(*args)
+            except SystemExit as e:
+                if e.code != 0:
+                    raise AssertionError(
+                        "Argparse failed (see above error message)")
+        return f.getvalue()
+
+    # -----------------------------------------------------------------------
+
+    @pytest.mark.parametrize("nvidia_driver_version",
+                             NvidiaDriverMock.INSTANCES, indirect=True)
+    def test_new_query_mocked_basic(self, scenario_basic, nvidia_driver_version):
+        """A basic functionality test, in a case where everything is normal."""
+
+        gpustats = gpustat.new_query()
+        fp = StringIO()
+        gpustats.print_formatted(
+            fp=fp, no_color=False, show_user=True,
+            show_cmd=True, show_full_cmd=True, show_pid=True,
+            show_fan_speed=True, show_codec="enc,dec", show_power=True,
+        )
+
+        result = fp.getvalue()
+        print(result)
+
+        unescaped = remove_ansi_codes(result)
+        # remove first line (header)
+        unescaped = os.linesep.join(unescaped.splitlines()[1:])
+
+        assert unescaped == MOCK_EXPECTED_OUTPUT_FULL_PROCESS
+
+        # verify gpustat results (not exhaustive yet)
+        assert gpustats.driver_version == nvidia_driver_version.name
+        g: gpustat.GPUStat = gpustats.gpus[0]
+        assert g.memory_used == 8000
+        assert g.power_draw == 125
+        assert g.utilization == 76
+        assert g.processes and g.processes[0]['pid'] == 48448
+
+    def test_new_query_mocked_nonexistent_pid(self, scenario_nonexistent_pid):
+        """
+        Test a case where nvidia query returns non-existent pids (see #16, #18)
+        for GPU index 2.
+        """
+        fp = StringIO()
+
+        gpustats = gpustat.new_query()
+        gpustats.print_formatted(fp=fp)
+
+        ret = fp.getvalue()
+        print(ret)
+
+        # gpu 2: should ignore process id
+        line = remove_ansi_codes(ret).split('\n')[3]
+        assert '[2] GeForce RTX 2' in line, str(line)
+        assert '99999' not in line
+        assert '(Not Supported)' not in line
+
+    @pytest.mark.parametrize("scenario_failing_one_gpu", [
+        pynvml.NVMLError_GpuIsLost,
+        pynvml.NVMLError_Unknown,
+    ], indirect=True)
+    def test_new_query_mocked_failing_one_gpu(self, scenario_failing_one_gpu):
+        """Test a case where one GPU is failing (see #125)."""
+        fp = StringIO()
+        gpustats = gpustat.new_query()
+        gpustats.print_formatted(fp=fp, show_header=False)
+        ret = fp.getvalue()
+        print(ret)
+
+        lines = remove_ansi_codes(ret).split('\n')
+        message = scenario_failing_one_gpu['expected_message']
+
+        # gpu 2: failing due to unknown error
+        line = lines[2]
+        assert '[2] ((' + message + '))' in line, str(line)
+        assert '99999' not in line
+        assert '?°C,   ? %' in line, str(line)
+        assert '? /     ? MB' in line, str(line)
+
+        # other gpus should be displayed normally
+        assert '[0] GeForce GTX TITAN 0' in lines[0]
+        assert '[1] GeForce GTX TITAN 1' in lines[1]
+
+    def test_attributes_and_items(self, scenario_basic):
+        """Test whether each property of `GPUStat` instance is well-defined."""
+
+        g = gpustat.new_query()[1]  # includes N/A
+        print("(keys) : %s" % str(g.keys()))
+        print(g)
+
+        assert g['name'] == g.entry['name']
+        assert g['uuid'] == g.uuid
+
+        with pytest.raises(KeyError):
+            g['unknown_key']
+
+        print("uuid : %s" % g.uuid)
+        print("name : %s" % g.name)
+        print("memory : used %d total %d avail %d" % (
+            g.memory_used, g.memory_total, g.memory_available))
+        print("temperature : %d" % (g.temperature))
+        print("utilization : %s" % (g.utilization))
+        print("utilization_enc : %s" % (g.utilization_enc))
+        print("utilization_dec : %s" % (g.utilization_dec))
+
+    def test_main(self, scenario_basic):
+        """Test whether gpustat.main() works well.
+        The behavior is mocked exactly as in test_new_query_mocked().
+        """
+        sys.argv = ['gpustat']
+        gpustat.main()
+
+    def test_args_commandline(self, scenario_basic):
+        """Tests the end gpustat CLI."""
+        capture_output = self.capture_output
+
+        def _remove_ansi_codes_and_header_line(s):
+            unescaped = remove_ansi_codes(s)
+            # remove first line (header)
+            unescaped = os.linesep.join(unescaped.splitlines()[1:])
+            return unescaped
+
+        s = capture_output('gpustat', )
+        assert _remove_ansi_codes_and_header_line(s) == MOCK_EXPECTED_OUTPUT_DEFAULT
+
+        s = capture_output('gpustat', '--version')
+        assert s.startswith('gpustat ')
+        print(s)
+
+        s = capture_output('gpustat', '--no-header')
+        assert "[0]" in s.splitlines()[0]
+
+        s = capture_output('gpustat', '-a')  # --show-all
+        assert _remove_ansi_codes_and_header_line(s) == MOCK_EXPECTED_OUTPUT_FULL
+
+        s = capture_output('gpustat', '--color')
+        assert '\x0f' not in s, "Extra \\x0f found (see issue #32)"
+        assert _remove_ansi_codes_and_header_line(s) == MOCK_EXPECTED_OUTPUT_DEFAULT
+
+        s = capture_output('gpustat', '--no-color')
+        unescaped = remove_ansi_codes(s)
+        assert s == unescaped   # should have no ansi code
+        assert _remove_ansi_codes_and_header_line(s) == MOCK_EXPECTED_OUTPUT_DEFAULT
+
+        s = capture_output('gpustat', '--no-processes')
+        assert _remove_ansi_codes_and_header_line(s) == MOCK_EXPECTED_OUTPUT_NO_PROCESSES
+
+        s = capture_output('gpustat', '--id', '1,2')
+        assert _remove_ansi_codes_and_header_line(s) == \
+            os.linesep.join(MOCK_EXPECTED_OUTPUT_DEFAULT.splitlines()[1:3])
+
+    def test_args_commandline_width(self, scenario_basic):
+        capture_output = self.capture_output
+
+        # see MOCK_EXPECTED_OUTPUT_DEFAULT
+        assert len("GeForce GTX TITAN 0") == 19
+
+        s = capture_output('gpustat', '--gpuname-width', '25')
+        print("- Should have width=25")
+        print(s)
+        assert 'GeForce GTX TITAN 0       |' in remove_ansi_codes(s)
+        assert 'GeForce RTX 2             |' in remove_ansi_codes(s)
+        #                         ^012345
+        #                        19
+
+        # See #47 (since v1.0)
+        print("- Should have width=10 (with truncation)")
+        s = capture_output('gpustat', '--gpuname-width', '10')
+        print(s)
+        assert '…X TITAN 0 |' in remove_ansi_codes(s)
+        assert '…rce RTX 2 |' in remove_ansi_codes(s)
+        #       1234567890
+
+        print("- Should have width=1 (too short)")
+        s = capture_output('gpustat', '--gpuname-width', '1')
+        print(s)
+        assert '… |' in remove_ansi_codes(s)
+
+        print("- Should have width=0: no name displayed.")
+        s = capture_output('gpustat', '--gpuname-width', '0')
+        print(s)
+        assert '[0]  80°C' in remove_ansi_codes(s)
+
+        print("- Invalid inputs")
+        with pytest.raises(AssertionError, match="Argparse failed"):
+            s = capture_output('gpustat', '--gpuname-width', '-1')
+        with pytest.raises(AssertionError, match="Argparse failed"):
+            s = capture_output('gpustat', '--gpuname-width', 'None')
+
+    def test_args_commandline_showoptions(self, scenario_basic):
+        """Tests gpustat CLI with a variety of --show-xxx options. """
+
+        capture_output = self.capture_output
+        print('')
+
+        TEST_OPTS = []
+        TEST_OPTS += ['-a', '-c', '-u', '-p', '-e', '-P', '-f']
+        TEST_OPTS += [('-e', ''), ('-P', '')]
+        TEST_OPTS += [('-e', 'enc,dec'), '-Plimit,draw']
+        TEST_OPTS += ['-cup', '-cpu', '-cufP']  # 'cpuePf'
+
+        for opt in TEST_OPTS:
+            if isinstance(opt, str):
+                opt = [opt]
+
+            print('\x1b[30m\x1b[43m',  # black_on_yellow
+                  '$ gpustat ' + ' '.join(shlex.quote(o) for o in opt),
+                  '\x1b(B\x1b[m', sep='')
+            s = capture_output('gpustat', *opt)
+
+            # TODO: Validate output without hardcoding expected outputs
+            print(s)
+
+        # Finally, unknown args
+        with pytest.raises(AssertionError):
+            capture_output('gpustat', '--unrecognized-args-in-test')
+
+    @pytest.mark.skipif(sys.platform == 'win32', reason="Do not run on Windows")
+    def test_no_TERM(self, scenario_basic, monkeypatch):
+        """--color should work well even when executed without TERM,
+        e.g. ssh localhost gpustat --color"""
+        monkeypatch.setenv("TERM", "")
+
+        s = self.capture_output('gpustat', '--color', '--no-header').rstrip()
+        print(s)
+        assert remove_ansi_codes(s) == MOCK_EXPECTED_OUTPUT_DEFAULT, \
+            "wrong gpustat output"
+
+        assert '\x1b[36m' in s, "should contain cyan color code"
+        assert '\x0f' not in s, "Extra \\x0f found (see issue #32)"
+
+    def test_json_mocked(self, scenario_basic):
+        gpustats = gpustat.new_query()
+
+        fp = StringIO()
+        gpustats.print_json(fp=fp)
+
+        import json
+        j = json.loads(fp.getvalue())
+
+        from pprint import pprint
+        pprint(j)
+
+        assert j['driver_version'] == '415.27.mock'
+        assert j['hostname']
+        assert j['gpus']
+
+
+if __name__ == '__main__':
+    pytest.main()

vllm/lib/python3.10/site-packages/gpustat/util.py

@@ -0,0 +1,103 @@
+""" Miscellaneous Utilities. """
+
+import collections
+import os.path
+import sys
+import traceback
+from typing import Callable, Tuple, Type, TypeVar, Union
+
+T = TypeVar('T')
+
+
+def bytes2human(in_bytes):
+    '''Convert bytes (int) to a human-readable string.'''
+    suffixes = ('B', 'KB', 'MB', 'GB', 'TB', 'PB')
+    suffix = 0
+    result = int(in_bytes)
+    while result > 9999 and suffix < len(suffixes):
+        result = result >> 10
+        suffix += 1
+
+    if suffix >= len(suffixes):
+        suffix -= 1
+    return "%d%s" % (result, suffixes[suffix])
+
+
+def prettify_commandline(cmdline, color_command='', color_text=''):
+    '''
+    Prettify and colorize a full command-line (given as list of strings),
+    where command (basename) is highlighted in a different color.
+    '''
+    # cmdline: Iterable[str]
+    if isinstance(cmdline, str):
+        return cmdline
+    assert cmdline
+
+    command_p, command_b = os.path.split(cmdline[0])
+    s = color_text + os.path.join(command_p,
+                                  color_command + command_b + color_text)
+
+    if len(cmdline) > 1:
+        s += ' '
+        s += ' '.join(cmdline[1:])
+    return s
+
+
+def shorten_left(text, width, placeholder="…"):
+    # text: str
+    if width is None:
+        return text
+    if text is None or len(text) <= width:
+        return text
+    if width < 0:
+        raise ValueError("width must be non-negative.")
+    if width == 0:
+        return ""
+
+    if width == len(placeholder):
+        return placeholder
+    elif width - len(placeholder) < 0:
+        return placeholder[:width]
+        # raise ValueError("width is smaller than the length of placeholder.")
+    return placeholder + text[-(width - len(placeholder)):]
+
+
+def safecall(fn: Callable[[], T],
+             *,
+             exc_types: Union[Type, Tuple[Type, ...]] = Exception,
+             error_value: T) -> T:
+    """A protected call that suppress certain types of exceptions."""
+    try:
+        return fn()
+    except exc_types:  # pylint: disable=broad-except
+        return error_value
+
+
+class DebugHelper:
+
+    def __init__(self):
+        self._reports = []
+
+    def add_exception(self, column, e=None):
+        msg = "> An error while retrieving `{column}`: {e}".format(
+            column=column, e=str(e))
+        self._reports.append((msg, e))
+
+    def _write(self, msg):
+        sys.stderr.write(msg)
+        sys.stderr.write('\n')
+
+    def report_summary(self, concise=True):
+        _seen_messages = collections.defaultdict(int)
+        for msg, e in self._reports:
+            if msg not in _seen_messages or not concise:
+                self._write(msg)
+                self._write(''.join(
+                    traceback.format_exception(None, e, e.__traceback__)))
+            _seen_messages[msg] += 1
+
+        if concise:
+            for msg, value in _seen_messages.items():
+                self._write("{msg} -> Total {value} occurrences.".format(
+                    msg=msg, value=value))
+            self._write('')

vllm/lib/python3.10/site-packages/gpustat/util_test.py

@@ -0,0 +1,29 @@
+import sys
+import pytest
+
+from gpustat import util
+
+
+def test_safecall():
+
+    def _success():
+        return 42
+
+    def _error():
+        raise FileNotFoundError("oops")
+
+    assert util.safecall(_success, error_value=None) == 42
+    assert util.safecall(_error, error_value=-1) == -1
+
+    with pytest.raises(FileNotFoundError):
+        # not catched because exc_types does not match
+        assert util.safecall(_error, exc_types=ValueError, error_value=-1)
+
+    assert util.safecall(_error, error_value=-1,
+                         exc_types=FileNotFoundError) == -1
+    assert util.safecall(_error, error_value=-1,
+                         exc_types=(FileNotFoundError, OSError)) == -1
+
+
+if __name__ == '__main__':
+    sys.exit(pytest.main(["-s", "-v"] + sys.argv))

vllm/lib/python3.10/site-packages/httptools-0.6.4.dist-info/INSTALLER

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

vllm/lib/python3.10/site-packages/httptools-0.6.4.dist-info/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 MagicStack Inc.  http://magic.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vllm/lib/python3.10/site-packages/httptools-0.6.4.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.1
+Name: httptools
+Version: 0.6.4
+Summary: A collection of framework independent HTTP protocol utils.
+Home-page: https://github.com/MagicStack/httptools
+Author: Yury Selivanov
+Author-email: yury@magic.io
+License: MIT
+Platform: macOS
+Platform: POSIX
+Platform: Windows
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Environment :: Web Environment
+Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.8.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: Cython>=0.29.24; extra == "test"
+
+![Tests](https://github.com/MagicStack/httptools/workflows/Tests/badge.svg)
+
+httptools is a Python binding for the nodejs HTTP parser.
+
+The package is available on PyPI: `pip install httptools`.
+
+
+# APIs
+
+httptools contains two classes `httptools.HttpRequestParser`,
+`httptools.HttpResponseParser` (fulfilled through
+[llhttp](https://github.com/nodejs/llhttp)) and a function for
+parsing URLs `httptools.parse_url` (through
+[http-parse](https://github.com/nodejs/http-parser) for now).
+See unittests for examples.
+
+
+```python
+
+class HttpRequestParser:
+
+    def __init__(self, protocol):
+        """HttpRequestParser
+
+        protocol -- a Python object with the following methods
+        (all optional):
+
+          - on_message_begin()
+          - on_url(url: bytes)
+          - on_header(name: bytes, value: bytes)
+          - on_headers_complete()
+          - on_body(body: bytes)
+          - on_message_complete()
+          - on_chunk_header()
+          - on_chunk_complete()
+          - on_status(status: bytes)
+        """
+
+    def get_http_version(self) -> str:
+        """Return an HTTP protocol version."""
+
+    def should_keep_alive(self) -> bool:
+        """Return ``True`` if keep-alive mode is preferred."""
+
+    def should_upgrade(self) -> bool:
+        """Return ``True`` if the parsed request is a valid Upgrade request.
+	The method exposes a flag set just before on_headers_complete.
+	Calling this method earlier will only yield `False`.
+	"""
+
+    def feed_data(self, data: bytes):
+        """Feed data to the parser.
+
+        Will eventually trigger callbacks on the ``protocol``
+        object.
+
+        On HTTP upgrade, this method will raise an
+        ``HttpParserUpgrade`` exception, with its sole argument
+        set to the offset of the non-HTTP data in ``data``.
+        """
+
+    def get_method(self) -> bytes:
+        """Return HTTP request method (GET, HEAD, etc)"""
+
+
+class HttpResponseParser:
+
+    """Has all methods except ``get_method()`` that
+    HttpRequestParser has."""
+
+    def get_status_code(self) -> int:
+        """Return the status code of the HTTP response"""
+
+
+def parse_url(url: bytes):
+    """Parse URL strings into a structured Python object.
+
+    Returns an instance of ``httptools.URL`` class with the
+    following attributes:
+
+      - schema: bytes
+      - host: bytes
+      - port: int
+      - path: bytes
+      - query: bytes
+      - fragment: bytes
+      - userinfo: bytes
+    """
+```
+
+
+# Development
+
+1. Clone this repository with
+   `git clone --recursive git@github.com:MagicStack/httptools.git`
+
+2. Create a virtual environment with Python 3:
+   `python3 -m venv envname`
+
+3. Activate the environment with `source envname/bin/activate`
+
+4. Install development requirements with `pip install -e .[test]`
+
+5. Run `make` and `make test`.
+
+
+# License
+
+MIT.

vllm/lib/python3.10/site-packages/httptools-0.6.4.dist-info/RECORD

@@ -0,0 +1,22 @@
+httptools-0.6.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+httptools-0.6.4.dist-info/LICENSE,sha256=9Fc-fLdnZ0X7W402-lSKqT45HPtoct2s1lEwxF6mqS0,1093
+httptools-0.6.4.dist-info/METADATA,sha256=U4VRvayKRJbdHp18Fagk4_L7RvIQJ4anhwtwS64rO9A,3583
+httptools-0.6.4.dist-info/RECORD,,
+httptools-0.6.4.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httptools-0.6.4.dist-info/WHEEL,sha256=2JiXcU0-Qfy9gwog3WAIw4e5slUs9ReZ9xqrxqqbExM,224
+httptools-0.6.4.dist-info/top_level.txt,sha256=APjJKTbZcj0OQ4fdgf2eTCk82nK1n2BFXOD7ky41MPY,10
+httptools/__init__.py,sha256=plt3MIbueJdco9Dy7zoH3ksLNeyirqWagat5rwRmAjo,147
+httptools/__pycache__/__init__.cpython-310.pyc,,
+httptools/__pycache__/_version.cpython-310.pyc,,
+httptools/_version.py,sha256=ASqOB8fLS7jwZsM551Lc49WxYPyjteqnz1iDWmka-KA,575
+httptools/parser/__init__.py,sha256=fWyconPEHZlJojzRwmBKSn4C85OGXmKEwiEcdjHqXO8,166
+httptools/parser/__pycache__/__init__.cpython-310.pyc,,
+httptools/parser/__pycache__/errors.cpython-310.pyc,,
+httptools/parser/cparser.pxd,sha256=4qBxnma83Vz86Z9sOZRxjqYj20A-aLSWVGXZgTVLJqE,4977
+httptools/parser/errors.py,sha256=ZVrtN1smPIb_opQ2Ud3uCbGlNLMlECYM2-6S7r5LnHs,566
+httptools/parser/parser.cpython-310-x86_64-linux-gnu.so,sha256=gUJVhgrfY6kfy5lOsa1_8lIFPtbRLot_obcQUnrfRuk,1028176
+httptools/parser/parser.pyx,sha256=x0BUY9EzHNKCDaw-U8bkZ1MaKGtrOQ8iVCm1IuOtEQI,15140
+httptools/parser/python.pxd,sha256=zWCdGZh34fyQNt3BUHIUjPqY8a5sodRUkfdABxqYHgQ,138
+httptools/parser/url_cparser.pxd,sha256=X5dDI8A7T0l5HL_Czt0mTs0l_d2lXnUDHx1TN8LeiCM,779
+httptools/parser/url_parser.cpython-310-x86_64-linux-gnu.so,sha256=rG1YT8DYa7kfGmsTITKzLi1H-ZJShJEkJWXnziUo0JU,426712
+httptools/parser/url_parser.pyx,sha256=ZJVUZqrIDdhzVodA7tTtoFb570av-SczIyh2oAZXKzM,3758

vllm/lib/python3.10/site-packages/httptools-0.6.4.dist-info/WHEEL

@@ -0,0 +1,8 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_5_x86_64
+Tag: cp310-cp310-manylinux1_x86_64
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

vllm/lib/python3.10/site-packages/httptools-0.6.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+httptools

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

@@ -0,0 +1,426 @@
+# -*- coding: utf-8 -*-
+"""
+    inflection
+    ~~~~~~~~~~~~
+
+    A port of Ruby on Rails' inflector to Python.
+
+    :copyright: (c) 2012-2020 by Janne Vanhala
+
+    :license: MIT, see LICENSE for more details.
+"""
+import re
+import unicodedata
+
+__version__ = '0.5.1'
+
+PLURALS = [
+    (r"(?i)(quiz)$", r'\1zes'),
+    (r"(?i)^(oxen)$", r'\1'),
+    (r"(?i)^(ox)$", r'\1en'),
+    (r"(?i)(m|l)ice$", r'\1ice'),
+    (r"(?i)(m|l)ouse$", r'\1ice'),
+    (r"(?i)(passer)s?by$", r'\1sby'),
+    (r"(?i)(matr|vert|ind)(?:ix|ex)$", r'\1ices'),
+    (r"(?i)(x|ch|ss|sh)$", r'\1es'),
+    (r"(?i)([^aeiouy]|qu)y$", r'\1ies'),
+    (r"(?i)(hive)$", r'\1s'),
+    (r"(?i)([lr])f$", r'\1ves'),
+    (r"(?i)([^f])fe$", r'\1ves'),
+    (r"(?i)sis$", 'ses'),
+    (r"(?i)([ti])a$", r'\1a'),
+    (r"(?i)([ti])um$", r'\1a'),
+    (r"(?i)(buffal|potat|tomat)o$", r'\1oes'),
+    (r"(?i)(bu)s$", r'\1ses'),
+    (r"(?i)(alias|status)$", r'\1es'),
+    (r"(?i)(octop|vir)i$", r'\1i'),
+    (r"(?i)(octop|vir)us$", r'\1i'),
+    (r"(?i)^(ax|test)is$", r'\1es'),
+    (r"(?i)s$", 's'),
+    (r"$", 's'),
+]
+
+SINGULARS = [
+    (r"(?i)(database)s$", r'\1'),
+    (r"(?i)(quiz)zes$", r'\1'),
+    (r"(?i)(matr)ices$", r'\1ix'),
+    (r"(?i)(vert|ind)ices$", r'\1ex'),
+    (r"(?i)(passer)sby$", r'\1by'),
+    (r"(?i)^(ox)en", r'\1'),
+    (r"(?i)(alias|status)(es)?$", r'\1'),
+    (r"(?i)(octop|vir)(us|i)$", r'\1us'),
+    (r"(?i)^(a)x[ie]s$", r'\1xis'),
+    (r"(?i)(cris|test)(is|es)$", r'\1is'),
+    (r"(?i)(shoe)s$", r'\1'),
+    (r"(?i)(o)es$", r'\1'),
+    (r"(?i)(bus)(es)?$", r'\1'),
+    (r"(?i)(m|l)ice$", r'\1ouse'),
+    (r"(?i)(x|ch|ss|sh)es$", r'\1'),
+    (r"(?i)(m)ovies$", r'\1ovie'),
+    (r"(?i)(s)eries$", r'\1eries'),
+    (r"(?i)([^aeiouy]|qu)ies$", r'\1y'),
+    (r"(?i)([lr])ves$", r'\1f'),
+    (r"(?i)(tive)s$", r'\1'),
+    (r"(?i)(hive)s$", r'\1'),
+    (r"(?i)([^f])ves$", r'\1fe'),
+    (r"(?i)(t)he(sis|ses)$", r"\1hesis"),
+    (r"(?i)(s)ynop(sis|ses)$", r"\1ynopsis"),
+    (r"(?i)(p)rogno(sis|ses)$", r"\1rognosis"),
+    (r"(?i)(p)arenthe(sis|ses)$", r"\1arenthesis"),
+    (r"(?i)(d)iagno(sis|ses)$", r"\1iagnosis"),
+    (r"(?i)(b)a(sis|ses)$", r"\1asis"),
+    (r"(?i)(a)naly(sis|ses)$", r"\1nalysis"),
+    (r"(?i)([ti])a$", r'\1um'),
+    (r"(?i)(n)ews$", r'\1ews'),
+    (r"(?i)(ss)$", r'\1'),
+    (r"(?i)s$", ''),
+]
+
+UNCOUNTABLES = {
+    'equipment',
+    'fish',
+    'information',
+    'jeans',
+    'money',
+    'rice',
+    'series',
+    'sheep',
+    'species'}
+
+
+def _irregular(singular: str, plural: str) -> None:
+    """
+    A convenience function to add appropriate rules to plurals and singular
+    for irregular words.
+
+    :param singular: irregular word in singular form
+    :param plural: irregular word in plural form
+    """
+    def caseinsensitive(string: str) -> str:
+        return ''.join('[' + char + char.upper() + ']' for char in string)
+
+    if singular[0].upper() == plural[0].upper():
+        PLURALS.insert(0, (
+            r"(?i)({}){}$".format(singular[0], singular[1:]),
+            r'\1' + plural[1:]
+        ))
+        PLURALS.insert(0, (
+            r"(?i)({}){}$".format(plural[0], plural[1:]),
+            r'\1' + plural[1:]
+        ))
+        SINGULARS.insert(0, (
+            r"(?i)({}){}$".format(plural[0], plural[1:]),
+            r'\1' + singular[1:]
+        ))
+    else:
+        PLURALS.insert(0, (
+            r"{}{}$".format(singular[0].upper(),
+                            caseinsensitive(singular[1:])),
+            plural[0].upper() + plural[1:]
+        ))
+        PLURALS.insert(0, (
+            r"{}{}$".format(singular[0].lower(),
+                            caseinsensitive(singular[1:])),
+            plural[0].lower() + plural[1:]
+        ))
+        PLURALS.insert(0, (
+            r"{}{}$".format(plural[0].upper(), caseinsensitive(plural[1:])),
+            plural[0].upper() + plural[1:]
+        ))
+        PLURALS.insert(0, (
+            r"{}{}$".format(plural[0].lower(), caseinsensitive(plural[1:])),
+            plural[0].lower() + plural[1:]
+        ))
+        SINGULARS.insert(0, (
+            r"{}{}$".format(plural[0].upper(), caseinsensitive(plural[1:])),
+            singular[0].upper() + singular[1:]
+        ))
+        SINGULARS.insert(0, (
+            r"{}{}$".format(plural[0].lower(), caseinsensitive(plural[1:])),
+            singular[0].lower() + singular[1:]
+        ))
+
+
+def camelize(string: str, uppercase_first_letter: bool = True) -> str:
+    """
+    Convert strings to CamelCase.
+
+    Examples::
+
+        >>> camelize("device_type")
+        'DeviceType'
+        >>> camelize("device_type", False)
+        'deviceType'
+
+    :func:`camelize` can be thought of as a inverse of :func:`underscore`,
+    although there are some cases where that does not hold::
+
+        >>> camelize(underscore("IOError"))
+        'IoError'
+
+    :param uppercase_first_letter: if set to `True` :func:`camelize` converts
+        strings to UpperCamelCase. If set to `False` :func:`camelize` produces
+        lowerCamelCase. Defaults to `True`.
+    """
+    if uppercase_first_letter:
+        return re.sub(r"(?:^|_)(.)", lambda m: m.group(1).upper(), string)
+    else:
+        return string[0].lower() + camelize(string)[1:]
+
+
+def dasherize(word: str) -> str:
+    """Replace underscores with dashes in the string.
+
+    Example::
+
+        >>> dasherize("puni_puni")
+        'puni-puni'
+
+    """
+    return word.replace('_', '-')
+
+
+def humanize(word: str) -> str:
+    """
+    Capitalize the first word and turn underscores into spaces and strip a
+    trailing ``"_id"``, if any. Like :func:`titleize`, this is meant for
+    creating pretty output.
+
+    Examples::
+
+        >>> humanize("employee_salary")
+        'Employee salary'
+        >>> humanize("author_id")
+        'Author'
+
+    """
+    word = re.sub(r"_id$", "", word)
+    word = word.replace('_', ' ')
+    word = re.sub(r"(?i)([a-z\d]*)", lambda m: m.group(1).lower(), word)
+    word = re.sub(r"^\w", lambda m: m.group(0).upper(), word)
+    return word
+
+
+def ordinal(number: int) -> str:
+    """
+    Return the suffix that should be added to a number to denote the position
+    in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+
+    Examples::
+
+        >>> ordinal(1)
+        'st'
+        >>> ordinal(2)
+        'nd'
+        >>> ordinal(1002)
+        'nd'
+        >>> ordinal(1003)
+        'rd'
+        >>> ordinal(-11)
+        'th'
+        >>> ordinal(-1021)
+        'st'
+
+    """
+    number = abs(int(number))
+    if number % 100 in (11, 12, 13):
+        return "th"
+    else:
+        return {
+            1: "st",
+            2: "nd",
+            3: "rd",
+        }.get(number % 10, "th")
+
+
+def ordinalize(number: int) -> str:
+    """
+    Turn a number into an ordinal string used to denote the position in an
+    ordered sequence such as 1st, 2nd, 3rd, 4th.
+
+    Examples::
+
+        >>> ordinalize(1)
+        '1st'
+        >>> ordinalize(2)
+        '2nd'
+        >>> ordinalize(1002)
+        '1002nd'
+        >>> ordinalize(1003)
+        '1003rd'
+        >>> ordinalize(-11)
+        '-11th'
+        >>> ordinalize(-1021)
+        '-1021st'
+
+    """
+    return "{}{}".format(number, ordinal(number))
+
+
+def parameterize(string: str, separator: str = '-') -> str:
+    """
+    Replace special characters in a string so that it may be used as part of a
+    'pretty' URL.
+
+    Example::
+
+        >>> parameterize(u"Donald E. Knuth")
+        'donald-e-knuth'
+
+    """
+    string = transliterate(string)
+    # Turn unwanted chars into the separator
+    string = re.sub(r"(?i)[^a-z0-9\-_]+", separator, string)
+    if separator:
+        re_sep = re.escape(separator)
+        # No more than one of the separator in a row.
+        string = re.sub(r'%s{2,}' % re_sep, separator, string)
+        # Remove leading/trailing separator.
+        string = re.sub(r"(?i)^{sep}|{sep}$".format(sep=re_sep), '', string)
+
+    return string.lower()
+
+
+def pluralize(word: str) -> str:
+    """
+    Return the plural form of a word.
+
+    Examples::
+
+        >>> pluralize("posts")
+        'posts'
+        >>> pluralize("octopus")
+        'octopi'
+        >>> pluralize("sheep")
+        'sheep'
+        >>> pluralize("CamelOctopus")
+        'CamelOctopi'
+
+    """
+    if not word or word.lower() in UNCOUNTABLES:
+        return word
+    else:
+        for rule, replacement in PLURALS:
+            if re.search(rule, word):
+                return re.sub(rule, replacement, word)
+        return word
+
+
+def singularize(word: str) -> str:
+    """
+    Return the singular form of a word, the reverse of :func:`pluralize`.
+
+    Examples::
+
+        >>> singularize("posts")
+        'post'
+        >>> singularize("octopi")
+        'octopus'
+        >>> singularize("sheep")
+        'sheep'
+        >>> singularize("word")
+        'word'
+        >>> singularize("CamelOctopi")
+        'CamelOctopus'
+
+    """
+    for inflection in UNCOUNTABLES:
+        if re.search(r'(?i)\b(%s)\Z' % inflection, word):
+            return word
+
+    for rule, replacement in SINGULARS:
+        if re.search(rule, word):
+            return re.sub(rule, replacement, word)
+    return word
+
+
+def tableize(word: str) -> str:
+    """
+    Create the name of a table like Rails does for models to table names. This
+    method uses the :func:`pluralize` method on the last word in the string.
+
+    Examples::
+
+        >>> tableize('RawScaledScorer')
+        'raw_scaled_scorers'
+        >>> tableize('egg_and_ham')
+        'egg_and_hams'
+        >>> tableize('fancyCategory')
+        'fancy_categories'
+    """
+    return pluralize(underscore(word))
+
+
+def titleize(word: str) -> str:
+    """
+    Capitalize all the words and replace some characters in the string to
+    create a nicer looking title. :func:`titleize` is meant for creating pretty
+    output.
+
+    Examples::
+
+      >>> titleize("man from the boondocks")
+      'Man From The Boondocks'
+      >>> titleize("x-men: the last stand")
+      'X Men: The Last Stand'
+      >>> titleize("TheManWithoutAPast")
+      'The Man Without A Past'
+      >>> titleize("raiders_of_the_lost_ark")
+      'Raiders Of The Lost Ark'
+
+    """
+    return re.sub(
+        r"\b('?\w)",
+        lambda match: match.group(1).capitalize(),
+        humanize(underscore(word)).title()
+    )
+
+
+def transliterate(string: str) -> str:
+    """
+    Replace non-ASCII characters with an ASCII approximation. If no
+    approximation exists, the non-ASCII character is ignored. The string must
+    be ``unicode``.
+
+    Examples::
+
+        >>> transliterate('älämölö')
+        'alamolo'
+        >>> transliterate('Ærøskøbing')
+        'rskbing'
+
+    """
+    normalized = unicodedata.normalize('NFKD', string)
+    return normalized.encode('ascii', 'ignore').decode('ascii')
+
+
+def underscore(word: str) -> str:
+    """
+    Make an underscored, lowercase form from the expression in the string.
+
+    Example::
+
+        >>> underscore("DeviceType")
+        'device_type'
+
+    As a rule of thumb you can think of :func:`underscore` as the inverse of
+    :func:`camelize`, though there are cases where that does not hold::
+
+        >>> camelize(underscore("IOError"))
+        'IoError'
+
+    """
+    word = re.sub(r"([A-Z]+)([A-Z][a-z])", r'\1_\2', word)
+    word = re.sub(r"([a-z\d])([A-Z])", r'\1_\2', word)
+    word = word.replace("-", "_")
+    return word.lower()
+
+
+_irregular('person', 'people')
+_irregular('man', 'men')
+_irregular('human', 'humans')
+_irregular('child', 'children')
+_irregular('sex', 'sexes')
+_irregular('move', 'moves')
+_irregular('cow', 'kine')
+_irregular('zombie', 'zombies')