Upload MemGen code and data

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.venv/bin/python filter=lfs diff=lfs merge=lfs -text
+.venv/bin/python3 filter=lfs diff=lfs merge=lfs -text
+.venv/bin/python3.10 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.10/site-packages/psutil/_psutil_linux.abi3.so filter=lfs diff=lfs merge=lfs -text
+assets/memgen.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,17 @@
+test_output/
+# data/*
+**.pyc
+**.pyo
+**.pyd
+**.pyw
+**.pyz
+**.pywz
+**.pyzw
+**.pyzwz
+**.pyzwzw
+**.pyzwzwzw
+
+model/
+results/
+dataset/
+.env

.venv/.gitignore

@@ -0,0 +1 @@
+*

.venv/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

.venv/bin/activate

@@ -0,0 +1,130 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# 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.
+
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+if ! [ -z "${SCRIPT_PATH+_}" ] ; then
+    _OLD_SCRIPT_PATH="$SCRIPT_PATH"
+fi
+
+# Get script path (only used if environment is relocatable).
+if [ -n "${BASH_VERSION:+x}" ] ; then
+    SCRIPT_PATH="${BASH_SOURCE[0]}"
+    if [ "$SCRIPT_PATH" = "$0" ]; then
+        # Only bash has a reasonably robust check for source'dness.
+        echo "You must source this script: \$ source $0" >&2
+        exit 33
+    fi
+elif [ -n "${ZSH_VERSION:+x}" ] ; then
+    SCRIPT_PATH="${(%):-%x}"
+elif [ -n "${KSH_VERSION:+x}" ] ; then
+    SCRIPT_PATH="${.sh.file}"
+fi
+
+deactivate () {
+    unset -f pydoc >/dev/null 2>&1 || true
+
+    # reset old environment variables
+    # ! [ -z ${VAR+_} ] returns true if VAR is declared at all
+    if ! [ -z "${_OLD_VIRTUAL_PATH:+_}" ] ; then
+        PATH="$_OLD_VIRTUAL_PATH"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if ! [ -z "${_OLD_VIRTUAL_PYTHONHOME+_}" ] ; then
+        PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # The hash command must be called to get it to forget past
+    # commands. Without forgetting past commands the $PATH changes
+    # we made may not be respected
+    hash -r 2>/dev/null
+
+    if ! [ -z "${_OLD_VIRTUAL_PS1+_}" ] ; then
+        PS1="$_OLD_VIRTUAL_PS1"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV='/root/CVPR/MemGen/.venv'
+if ([ "$OSTYPE" = "cygwin" ] || [ "$OSTYPE" = "msys" ]) && $(command -v cygpath &> /dev/null) ; then
+    VIRTUAL_ENV=$(cygpath -u "$VIRTUAL_ENV")
+fi
+export VIRTUAL_ENV
+
+# Unset the `SCRIPT_PATH` variable, now that the `VIRTUAL_ENV` variable
+# has been set. This is important for relocatable environments.
+if ! [ -z "${_OLD_SCRIPT_PATH+_}" ] ; then
+    SCRIPT_PATH="$_OLD_SCRIPT_PATH"
+    export SCRIPT_PATH
+    unset _OLD_SCRIPT_PATH
+else
+    unset SCRIPT_PATH
+fi
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+if [ "xMemGen" != x ] ; then
+    VIRTUAL_ENV_PROMPT="MemGen"
+else
+    VIRTUAL_ENV_PROMPT=$(basename "$VIRTUAL_ENV")
+fi
+export VIRTUAL_ENV_PROMPT
+
+# unset PYTHONHOME if set
+if ! [ -z "${PYTHONHOME+_}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1-}"
+    PS1="(${VIRTUAL_ENV_PROMPT}) ${PS1-}"
+    export PS1
+fi
+
+# Make sure to unalias pydoc if it's already there
+alias pydoc 2>/dev/null >/dev/null && unalias pydoc || true
+
+pydoc () {
+    python -m pydoc "$@"
+}
+
+# The hash command must be called to get it to forget past
+# commands. Without forgetting past commands the $PATH changes
+# we made may not be respected
+hash -r 2>/dev/null || true

.venv/bin/activate.bat

@@ -0,0 +1,71 @@
+@REM Copyright (c) 2020-202x The virtualenv developers
+@REM
+@REM Permission is hereby granted, free of charge, to any person obtaining
+@REM a copy of this software and associated documentation files (the
+@REM "Software"), to deal in the Software without restriction, including
+@REM without limitation the rights to use, copy, modify, merge, publish,
+@REM distribute, sublicense, and/or sell copies of the Software, and to
+@REM permit persons to whom the Software is furnished to do so, subject to
+@REM the following conditions:
+@REM
+@REM The above copyright notice and this permission notice shall be
+@REM included in all copies or substantial portions of the Software.
+@REM
+@REM THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+@REM EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+@REM MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+@REM NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+@REM LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+@REM OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+@REM WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+@REM This file is UTF-8 encoded, so we need to update the current code page while executing it
+@for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do @set _OLD_CODEPAGE=%%a
+
+@if defined _OLD_CODEPAGE (
+    "%SystemRoot%\System32\chcp.com" 65001 > nul
+)
+
+@for %%i in ("/root/CVPR/MemGen/.venv") do @set "VIRTUAL_ENV=%%~fi"
+
+@set "VIRTUAL_ENV_PROMPT=MemGen"
+@if NOT DEFINED VIRTUAL_ENV_PROMPT (
+    @for %%d in ("%VIRTUAL_ENV%") do @set "VIRTUAL_ENV_PROMPT=%%~nxd"
+)
+
+@if defined _OLD_VIRTUAL_PROMPT (
+    @set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+) else (
+    @if not defined PROMPT (
+        @set "PROMPT=$P$G"
+    )
+    @if not defined VIRTUAL_ENV_DISABLE_PROMPT (
+        @set "_OLD_VIRTUAL_PROMPT=%PROMPT%"
+    )
+)
+@if not defined VIRTUAL_ENV_DISABLE_PROMPT (
+    @set "PROMPT=(%VIRTUAL_ENV_PROMPT%) %PROMPT%"
+)
+
+@REM Don't use () to avoid problems with them in %PATH%
+@if defined _OLD_VIRTUAL_PYTHONHOME @goto ENDIFVHOME
+    @set "_OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%"
+:ENDIFVHOME
+
+@set PYTHONHOME=
+
+@REM if defined _OLD_VIRTUAL_PATH (
+@if not defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH1
+    @set "PATH=%_OLD_VIRTUAL_PATH%"
+:ENDIFVPATH1
+@REM ) else (
+@if defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH2
+    @set "_OLD_VIRTUAL_PATH=%PATH%"
+:ENDIFVPATH2
+
+@set "PATH=%VIRTUAL_ENV%\bin;%PATH%"
+
+@if defined _OLD_CODEPAGE (
+    "%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul
+    @set _OLD_CODEPAGE=
+)

.venv/bin/activate.csh

@@ -0,0 +1,76 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# 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.
+
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <[email protected]>.
+
+set newline='\
+'
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH:q" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT:q" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate && unalias pydoc'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV '/root/CVPR/MemGen/.venv'
+
+set _OLD_VIRTUAL_PATH="$PATH:q"
+setenv PATH "$VIRTUAL_ENV:q/bin:$PATH:q"
+
+
+
+if ('MemGen' != "") then
+    setenv VIRTUAL_ENV_PROMPT 'MemGen'
+else
+    setenv VIRTUAL_ENV_PROMPT "$VIRTUAL_ENV:t:q"
+endif
+
+if ( $?VIRTUAL_ENV_DISABLE_PROMPT ) then
+    if ( $VIRTUAL_ENV_DISABLE_PROMPT == "" ) then
+        set do_prompt = "1"
+    else
+        set do_prompt = "0"
+    endif
+else
+    set do_prompt = "1"
+endif
+
+if ( $do_prompt == "1" ) then
+    # Could be in a non-interactive environment,
+    # in which case, $prompt is undefined and we wouldn't
+    # care about the prompt anyway.
+    if ( $?prompt ) then
+        set _OLD_VIRTUAL_PROMPT="$prompt:q"
+        if ( "$prompt:q" =~ *"$newline:q"* ) then
+            :
+        else
+            set prompt = '('"$VIRTUAL_ENV_PROMPT:q"') '"$prompt:q"
+        endif
+    endif
+endif
+
+unset env_name
+unset do_prompt
+
+alias pydoc python -m pydoc
+
+rehash

.venv/bin/activate.fish

@@ -0,0 +1,124 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# 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.
+
+# This file must be used using `source bin/activate.fish` *within a running fish ( http://fishshell.com ) session*.
+# Do not run it directly.
+
+function _bashify_path -d "Converts a fish path to something bash can recognize"
+    set fishy_path $argv
+    set bashy_path $fishy_path[1]
+    for path_part in $fishy_path[2..-1]
+        set bashy_path "$bashy_path:$path_part"
+    end
+    echo $bashy_path
+end
+
+function _fishify_path -d "Converts a bash path to something fish can recognize"
+    echo $argv | tr ':' '\n'
+end
+
+function deactivate -d 'Exit virtualenv mode and return to the normal environment.'
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        # https://github.com/fish-shell/fish-shell/issues/436 altered PATH handling
+        if test (string sub -s 1 -l 1 $FISH_VERSION) -lt 3
+            set -gx PATH (_fishify_path "$_OLD_VIRTUAL_PATH")
+        else
+            set -gx PATH $_OLD_VIRTUAL_PATH
+        end
+        set -e _OLD_VIRTUAL_PATH
+    end
+
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME "$_OLD_VIRTUAL_PYTHONHOME"
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+       and functions -q _old_fish_prompt
+        # Set an empty local `$fish_function_path` to allow the removal of `fish_prompt` using `functions -e`.
+        set -l fish_function_path
+
+        # Erase virtualenv's `fish_prompt` and restore the original.
+        functions -e fish_prompt
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+
+    if test "$argv[1]" != 'nondestructive'
+        # Self-destruct!
+        functions -e pydoc
+        functions -e deactivate
+        functions -e _bashify_path
+        functions -e _fishify_path
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV '/root/CVPR/MemGen/.venv'
+
+# https://github.com/fish-shell/fish-shell/issues/436 altered PATH handling
+if test (string sub -s 1 -l 1 $FISH_VERSION) -lt 3
+    set -gx _OLD_VIRTUAL_PATH (_bashify_path $PATH)
+else
+    set -gx _OLD_VIRTUAL_PATH $PATH
+end
+set -gx PATH "$VIRTUAL_ENV"'/bin' $PATH
+
+# Prompt override provided?
+# If not, just use the environment name.
+if test -n 'MemGen'
+    set -gx VIRTUAL_ENV_PROMPT 'MemGen'
+else
+    set -gx VIRTUAL_ENV_PROMPT (basename "$VIRTUAL_ENV")
+end
+
+# Unset `$PYTHONHOME` if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+function pydoc
+    python -m pydoc $argv
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # Copy the current `fish_prompt` function as `_old_fish_prompt`.
+    functions -c fish_prompt _old_fish_prompt
+
+    function fish_prompt
+        # Run the user's prompt first; it might depend on (pipe)status.
+        set -l prompt (_old_fish_prompt)
+
+        printf '(%s) ' $VIRTUAL_ENV_PROMPT
+
+        string join -- \n $prompt # handle multi-line prompts
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end

.venv/bin/activate.nu

@@ -0,0 +1,102 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# 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.
+
+# virtualenv activation module:
+# - Activate with `overlay use activate.nu`
+# - Deactivate with `deactivate`, as usual
+#
+# To customize the overlay name, you can call `overlay use activate.nu as foo`, but then simply `deactivate` won't work
+# because it is just an alias to hide the "activate" overlay. You'd need to call `overlay hide foo` manually.
+
+module warning {
+    export-env {
+        const file = path self
+        error make -u {
+            msg: $"`($file | path basename)` is meant to be used with `overlay use`, not `source`"
+        }
+    }
+
+}
+
+use warning
+
+export-env {
+
+    let nu_ver = (version | get version | split row '.' | take 2 | each { into int })
+        if $nu_ver.0 == 0 and $nu_ver.1 < 106 {
+            error make {
+                msg: 'virtualenv Nushell activation requires Nushell 0.106 or greater.'
+            }
+    }
+
+    def is-string [x] {
+        ($x | describe) == 'string'
+    }
+
+    def has-env [...names] {
+        $names | each {|n| $n in $env } | all {|i| $i }
+    }
+
+    def is-env-true [name: string] {
+        if (has-env $name) {
+            let val = ($env | get --optional $name)
+            if ($val | describe) == 'bool' {
+                $val
+            } else {
+                not ($val | is-empty)
+            }
+        } else {
+            false
+        }
+    }
+
+    let virtual_env = '/root/CVPR/MemGen/.venv'
+    let bin = 'bin'
+    let path_name = if (has-env 'Path') { 'Path' } else { 'PATH' }
+    let venv_path = ([$virtual_env $bin] | path join)
+    let new_path = ($env | get $path_name | prepend $venv_path)
+    let virtual_env_prompt = if ('MemGen' | is-empty) {
+        ($virtual_env | path basename)
+    } else {
+        'MemGen'
+    }
+    let new_env = { $path_name: $new_path VIRTUAL_ENV: $virtual_env VIRTUAL_ENV_PROMPT: $virtual_env_prompt }
+    let old_prompt_command = if (has-env 'PROMPT_COMMAND') { $env.PROMPT_COMMAND } else { '' }
+    let new_env = if (is-env-true 'VIRTUAL_ENV_DISABLE_PROMPT') {
+        $new_env
+    } else {
+        let virtual_prefix = $'(char lparen)($virtual_env_prompt)(char rparen) '
+        let new_prompt = if (has-env 'PROMPT_COMMAND') {
+            if ('closure' in ($old_prompt_command | describe)) {
+                {|| $'($virtual_prefix)(do $old_prompt_command)' }
+            } else {
+                {|| $'($virtual_prefix)($old_prompt_command)' }
+            }
+        } else {
+            {|| $'($virtual_prefix)' }
+        }
+        $new_env | merge { PROMPT_COMMAND: $new_prompt VIRTUAL_PREFIX: $virtual_prefix }
+    }
+    load-env $new_env
+}
+
+export alias pydoc = python -m pydoc
+export alias deactivate = overlay hide activate

.venv/bin/activate.ps1

@@ -0,0 +1,82 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# 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.
+
+$script:THIS_PATH = $myinvocation.mycommand.path
+$script:BASE_DIR = Split-Path (Resolve-Path "$THIS_PATH/..") -Parent
+
+function global:deactivate([switch] $NonDestructive) {
+    if (Test-Path variable:_OLD_VIRTUAL_PATH) {
+        $env:PATH = $variable:_OLD_VIRTUAL_PATH
+        Remove-Variable "_OLD_VIRTUAL_PATH" -Scope global
+    }
+
+    if (Test-Path function:_old_virtual_prompt) {
+        $function:prompt = $function:_old_virtual_prompt
+        Remove-Item function:\_old_virtual_prompt
+    }
+
+    if ($env:VIRTUAL_ENV) {
+        Remove-Item env:VIRTUAL_ENV -ErrorAction SilentlyContinue
+    }
+
+    if ($env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item env:VIRTUAL_ENV_PROMPT -ErrorAction SilentlyContinue
+    }
+
+    if (!$NonDestructive) {
+        # Self destruct!
+        Remove-Item function:deactivate
+        Remove-Item function:pydoc
+    }
+}
+
+function global:pydoc {
+    python -m pydoc $args
+}
+
+# unset irrelevant variables
+deactivate -nondestructive
+
+$VIRTUAL_ENV = $BASE_DIR
+$env:VIRTUAL_ENV = $VIRTUAL_ENV
+
+if ("MemGen" -ne "") {
+    $env:VIRTUAL_ENV_PROMPT = "MemGen"
+}
+else {
+    $env:VIRTUAL_ENV_PROMPT = $( Split-Path $env:VIRTUAL_ENV -Leaf )
+}
+
+New-Variable -Scope global -Name _OLD_VIRTUAL_PATH -Value $env:PATH
+
+$env:PATH = "$env:VIRTUAL_ENV/bin:" + $env:PATH
+if (!$env:VIRTUAL_ENV_DISABLE_PROMPT) {
+    function global:_old_virtual_prompt {
+        ""
+    }
+    $function:_old_virtual_prompt = $function:prompt
+
+    function global:prompt {
+        # Add the custom prefix to the existing prompt
+        $previous_prompt_value = & $function:_old_virtual_prompt
+        ("(" + $env:VIRTUAL_ENV_PROMPT + ") " + $previous_prompt_value)
+    }
+}

.venv/bin/activate_this.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# 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.
+
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("bin") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = "MemGen" or os.path.basename(base)  # noqa: SIM222
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "../lib/python3.10/site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

.venv/bin/deactivate.bat

@@ -0,0 +1,39 @@
+@REM Copyright (c) 2020-202x The virtualenv developers
+@REM
+@REM Permission is hereby granted, free of charge, to any person obtaining
+@REM a copy of this software and associated documentation files (the
+@REM "Software"), to deal in the Software without restriction, including
+@REM without limitation the rights to use, copy, modify, merge, publish,
+@REM distribute, sublicense, and/or sell copies of the Software, and to
+@REM permit persons to whom the Software is furnished to do so, subject to
+@REM the following conditions:
+@REM
+@REM The above copyright notice and this permission notice shall be
+@REM included in all copies or substantial portions of the Software.
+@REM
+@REM THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+@REM EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+@REM MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+@REM NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+@REM LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+@REM OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+@REM WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+@set VIRTUAL_ENV=
+@set VIRTUAL_ENV_PROMPT=
+
+@REM Don't use () to avoid problems with them in %PATH%
+@if not defined _OLD_VIRTUAL_PROMPT @goto ENDIFVPROMPT
+    @set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+    @set _OLD_VIRTUAL_PROMPT=
+:ENDIFVPROMPT
+
+@if not defined _OLD_VIRTUAL_PYTHONHOME @goto ENDIFVHOME
+    @set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%"
+    @set _OLD_VIRTUAL_PYTHONHOME=
+:ENDIFVHOME
+
+@if not defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH
+    @set "PATH=%_OLD_VIRTUAL_PATH%"
+    @set _OLD_VIRTUAL_PATH=
+:ENDIFVPATH

.venv/bin/nvisel

@@ -0,0 +1,10 @@
+#!/root/CVPR/MemGen/.venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from nvitop.select import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

.venv/bin/nvitop

@@ -0,0 +1,10 @@
+#!/root/CVPR/MemGen/.venv/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from nvitop.cli import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

.venv/bin/pydoc.bat

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

.venv/bin/python

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfcd193db9dc7318c3c0a6bd743aac2d92d5b2c1677b0c55031376b193327402
+size 17250880

.venv/bin/python3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfcd193db9dc7318c3c0a6bd743aac2d92d5b2c1677b0c55031376b193327402
+size 17250880

.venv/bin/python3.10

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfcd193db9dc7318c3c0a6bd743aac2d92d5b2c1677b0c55031376b193327402
+size 17250880

.venv/lib/python3.10/site-packages/_virtualenv.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69ac3d8f27e679c81b94ab30b3b56e9cd138219b1ba94a1fa3606d5a76a1433d
+size 18

.venv/lib/python3.10/site-packages/_virtualenv.py

@@ -0,0 +1,101 @@
+"""Patches that are applied at runtime to the virtual environment."""
+
+import os
+import sys
+
+VIRTUALENV_PATCH_FILE = os.path.join(__file__)
+
+
+def patch_dist(dist):
+    """
+    Distutils allows user to configure some arguments via a configuration file:
+    https://docs.python.org/3.11/install/index.html#distutils-configuration-files.
+
+    Some of this arguments though don't make sense in context of the virtual environment files, let's fix them up.
+    """  # noqa: D205
+    # we cannot allow some install config as that would get packages installed outside of the virtual environment
+    old_parse_config_files = dist.Distribution.parse_config_files
+
+    def parse_config_files(self, *args, **kwargs):
+        result = old_parse_config_files(self, *args, **kwargs)
+        install = self.get_option_dict("install")
+
+        if "prefix" in install:  # the prefix governs where to install the libraries
+            install["prefix"] = VIRTUALENV_PATCH_FILE, os.path.abspath(sys.prefix)
+        for base in ("purelib", "platlib", "headers", "scripts", "data"):
+            key = f"install_{base}"
+            if key in install:  # do not allow global configs to hijack venv paths
+                install.pop(key, None)
+        return result
+
+    dist.Distribution.parse_config_files = parse_config_files
+
+
+# Import hook that patches some modules to ignore configuration values that break package installation in case
+# of virtual environments.
+_DISTUTILS_PATCH = "distutils.dist", "setuptools.dist"
+# https://docs.python.org/3/library/importlib.html#setting-up-an-importer
+
+
+class _Finder:
+    """A meta path finder that allows patching the imported distutils modules."""
+
+    fullname = None
+
+    # lock[0] is threading.Lock(), but initialized lazily to avoid importing threading very early at startup,
+    # because there are gevent-based applications that need to be first to import threading by themselves.
+    # See https://github.com/pypa/virtualenv/issues/1895 for details.
+    lock = []  # noqa: RUF012
+
+    def find_spec(self, fullname, path, target=None):  # noqa: ARG002
+        if fullname in _DISTUTILS_PATCH and self.fullname is None:
+            # initialize lock[0] lazily
+            if len(self.lock) == 0:
+                import threading
+
+                lock = threading.Lock()
+                # there is possibility that two threads T1 and T2 are simultaneously running into find_spec,
+                # observing .lock as empty, and further going into hereby initialization. However due to the GIL,
+                # list.append() operation is atomic and this way only one of the threads will "win" to put the lock
+                # - that every thread will use - into .lock[0].
+                # https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe
+                self.lock.append(lock)
+
+            from functools import partial
+            from importlib.util import find_spec
+
+            with self.lock[0]:
+                self.fullname = fullname
+                try:
+                    spec = find_spec(fullname, path)
+                    if spec is not None:
+                        # https://www.python.org/dev/peps/pep-0451/#how-loading-will-work
+                        is_new_api = hasattr(spec.loader, "exec_module")
+                        func_name = "exec_module" if is_new_api else "load_module"
+                        old = getattr(spec.loader, func_name)
+                        func = self.exec_module if is_new_api else self.load_module
+                        if old is not func:
+                            try:  # noqa: SIM105
+                                setattr(spec.loader, func_name, partial(func, old))
+                            except AttributeError:
+                                pass  # C-Extension loaders are r/o such as zipimporter with <3.7
+                        return spec
+                finally:
+                    self.fullname = None
+        return None
+
+    @staticmethod
+    def exec_module(old, module):
+        old(module)
+        if module.__name__ in _DISTUTILS_PATCH:
+            patch_dist(module)
+
+    @staticmethod
+    def load_module(old, name):
+        module = old(name)
+        if module.__name__ in _DISTUTILS_PATCH:
+            patch_dist(module)
+        return module
+
+
+sys.meta_path.insert(0, _Finder())

.venv/lib/python3.10/site-packages/example.py

@@ -0,0 +1,169 @@
+#################################################################################
+# Copyright (c) 2020, NVIDIA Corporation.  All rights reserved.                 #
+#                                                                               #
+# Redistribution and use in source and binary forms, with or without            #
+# modification, are permitted provided that the following conditions are met:   #
+#                                                                               #
+#    * Redistributions of source code must retain the above copyright notice,   #
+#      this list of conditions and the following disclaimer.                    #
+#    * Redistributions in binary form must reproduce the above copyright        #
+#      notice, this list of conditions and the following disclaimer in the      #
+#      documentation and/or other materials provided with the distribution.     #
+#    * Neither the name of the NVIDIA Corporation nor the names of its          #
+#      contributors may be used to endorse or promote products derived from     #
+#      this software without specific prior written permission.                 #
+#                                                                               #
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"   #
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     #
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    #
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE     #
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           #
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF          #
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS      #
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN       #
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)       #
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF        #
+# THE POSSIBILITY OF SUCH DAMAGE.                                               #
+#################################################################################
+
+#
+# Sample script to demonstrate the usage of NVML API python bindings
+#
+
+# To Run:
+# $ python ./example.py
+
+from pynvml import *
+
+#
+# Helper function
+#
+def StrVirt(mode):
+    if mode == NVML_GPU_VIRTUALIZATION_MODE_NONE:
+        return "None";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH:
+        return "Pass-Through";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_VGPU:
+        return "VGPU";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_HOST_VGPU:
+        return "Host VGPU";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA:
+        return "Host VSGA";
+    else:
+        return "Unknown";
+
+#
+# Converts errors into string messages
+#
+def handleError(err):
+    if (err.value == NVML_ERROR_NOT_SUPPORTED):
+        return "N/A"
+    else:
+        return err.__str__()
+
+#######
+def deviceQuery():
+
+    strResult = ''
+    try:
+        #
+        # Initialize NVML
+        #
+        nvmlInit()
+
+        strResult += '  <driver_version>' + str(nvmlSystemGetDriverVersion()) + '</driver_version>\n'
+
+        deviceCount = nvmlDeviceGetCount()
+        strResult += '  <attached_gpus>' + str(deviceCount) + '</attached_gpus>\n'
+
+        for i in range(0, deviceCount):
+            handle = nvmlDeviceGetHandleByIndex(i)
+
+            pciInfo = nvmlDeviceGetPciInfo(handle)
+
+            strResult += '  <gpu id="%s">\n' % pciInfo.busId
+
+            strResult += '    <product_name>' + nvmlDeviceGetName(handle) + '</product_name>\n'
+
+            brandNames = {NVML_BRAND_UNKNOWN             :  "Unknown",
+                          NVML_BRAND_QUADRO              :  "Quadro",
+                          NVML_BRAND_TESLA               :  "Tesla",
+                          NVML_BRAND_NVS                 :  "NVS",
+                          NVML_BRAND_GRID                :  "Grid",
+                          NVML_BRAND_TITAN               :  "Titan",
+                          NVML_BRAND_GEFORCE             :  "GeForce",
+                          NVML_BRAND_NVIDIA_VAPPS        :  "NVIDIA Virtual Applications",
+                          NVML_BRAND_NVIDIA_VPC          :  "NVIDIA Virtual PC",
+                          NVML_BRAND_NVIDIA_VCS          :  "NVIDIA Virtual Compute Server",
+                          NVML_BRAND_NVIDIA_VWS          :  "NVIDIA RTX Virtual Workstation",
+                          NVML_BRAND_NVIDIA_CLOUD_GAMING :  "NVIDIA Cloud Gaming",
+                          NVML_BRAND_QUADRO_RTX          :  "Quadro RTX",
+                          NVML_BRAND_NVIDIA_RTX          :  "NVIDIA RTX",
+                          NVML_BRAND_NVIDIA              :  "NVIDIA",
+                          NVML_BRAND_GEFORCE_RTX         :  "GeForce RTX",
+                          NVML_BRAND_TITAN_RTX           :  "TITAN RTX",
+
+            }
+
+            try:
+                # If nvmlDeviceGetBrand() succeeds it is guaranteed to be in the dictionary
+                brandName = brandNames[nvmlDeviceGetBrand(handle)]
+            except NVMLError as err:
+                brandName = handleError(err)
+
+            strResult += '    <product_brand>' + brandName + '</product_brand>\n'
+
+            try:
+                serial = nvmlDeviceGetSerial(handle)
+            except NVMLError as err:
+                serial = handleError(err)
+
+            strResult += '    <serial>' + serial + '</serial>\n'
+
+            try:
+                uuid = nvmlDeviceGetUUID(handle)
+            except NVMLError as err:
+                uuid = handleError(err)
+
+            strResult += '    <uuid>' + uuid + '</uuid>\n'
+
+            strResult += '    <gpu_virtualization_mode>\n'
+            try:
+                mode = StrVirt(nvmlDeviceGetVirtualizationMode(handle))
+            except NVMLError as err:
+                mode = handleError(err)
+            strResult += '      <virtualization_mode>' + mode + '</virtualization_mode>\n'
+            strResult += '    </gpu_virtualization_mode>\n'
+
+            try:
+                gridLicensableFeatures = nvmlDeviceGetGridLicensableFeatures(handle)
+                if gridLicensableFeatures.isGridLicenseSupported == 1:
+                    strResult += '    <vgpu_software_licensed_product>\n'
+                    for i in range(gridLicensableFeatures.licensableFeaturesCount):
+                        if gridLicensableFeatures.gridLicensableFeatures[i].featureState == 0:
+                            if nvmlDeviceGetVirtualizationMode(handle) == NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH:
+                                strResult += '        <licensed_product_name>' + 'NVIDIA Virtual Applications' + '</licensed_product_name>\n'
+                                strResult += '        <license_status>' + 'Licensed' + '</license_status>\n'
+                            else:
+                                strResult += '        <licensed_product_name>' + gridLicensableFeatures.gridLicensableFeatures[i].productName + '</licensed_product_name>\n'
+                                strResult += '        <license_status>' + 'Unlicensed' + '</license_status>\n'
+                        else:
+                            strResult += '        <licensed_product_name>' + gridLicensableFeatures.gridLicensableFeatures[i].productName + '</licensed_product_name>\n'
+                            strResult += '        <license_status>' + 'Licensed' + '</license_status>\n'
+                    strResult += '    </vgpu_software_licensed_product>\n'
+            except NVMLError as err:
+                gridLicensableFeatures = handleError(err)
+
+            strResult += '  </gpu>\n'
+
+    except NVMLError as err:
+        strResult += 'example.py: ' + err.__str__() + '\n'
+
+    nvmlShutdown()
+
+    return strResult
+
+# If this is not exectued when module is imported
+if __name__ == "__main__":
+    print(deviceQuery())
+

.venv/lib/python3.10/site-packages/nvidia_ml_py-13.580.82.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

.venv/lib/python3.10/site-packages/nvidia_ml_py-13.580.82.dist-info/METADATA

@@ -0,0 +1,284 @@
+Metadata-Version: 2.4
+Name: nvidia-ml-py
+Version: 13.580.82
+Summary: Python Bindings for the NVIDIA Management Library
+Home-page: https://forums.developer.nvidia.com
+Author: NVIDIA Corporation
+Author-email: [email protected]
+License: BSD
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Systems Administration
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: summary
+
+pyNVML
+======
+
+Python bindings to the NVIDIA Management Library
+------------------------------------------------
+
+Provides a Python interface to GPU management and monitoring functions.
+
+This is a wrapper around the NVML library.
+For information about the NVML library, see the NVML developer page
+http://developer.nvidia.com/nvidia-management-library-nvml
+
+Download the latest package from:
+http://pypi.python.org/pypi/nvidia-ml-py/
+
+Note this file can be run with 'python -m doctest -v README.txt'
+although the results are system dependent
+
+The nvml header file contains function documentation that is relevant
+to this wrapper. The header file is distributed with.
+https://developer.nvidia.com/gpu-deployment-kit
+
+The main difference is this library handles allocating structs and
+passing pointers to the functions, before returning the desired value.
+Non-success return codes are raised as exceptions as described in the
+section below.
+
+REQUIRES
+--------
+Python 2.5, or an earlier version with the ctypes module.
+
+INSTALLATION
+------------
+
+Pip Installation with python3:
+- `python3 -m pip install nvidia-ml-py`
+
+Manual Installation:
+```
+$ tar -xzf nvidia-ml-py-$major-$minor-$patch.tar.gz`
+$ cd nvidia-ml-py-$major-$minor-$patch
+$ sudo python setup.py install
+```
+
+USAGE
+-----
+```
+>>> from pynvml import *
+>>> nvmlInit()
+>>> print(f"Driver Version: {nvmlSystemGetDriverVersion()}")
+Driver Version: 11.515.48
+>>> deviceCount = nvmlDeviceGetCount()
+>>> for i in range(deviceCount):
+...     handle = nvmlDeviceGetHandleByIndex(i)
+...     print(f"Device {i} : {nvmlDeviceGetName(handle)}")
+...
+Device 0 : Tesla K40c
+
+>>> nvmlShutdown()
+```
+
+FUNCTIONS
+---------
+Python methods wrap NVML functions, implemented in a C shared library.
+Each function's use is the same with the following exceptions:
+
+- Instead of returning error codes, failing error codes are raised as Python exceptions.
+
+```
+>>> try:
+...     nvmlDeviceGetCount()
+... except NVMLError as error:
+...     print(error)
+...
+Uninitialized
+```
+
+- C function output parameters are returned from the corresponding Python function left to right.
+```
+nvmlReturn_t nvmlDeviceGetEccMode(nvmlDevice_t device,
+                                  nvmlEnableState_t *current,
+                                  nvmlEnableState_t *pending);
+
+>>> nvmlInit()
+>>> handle = nvmlDeviceGetHandleByIndex(0)
+>>> (current, pending) = nvmlDeviceGetEccMode(handle)
+```
+- C structs are converted into Python classes.
+
+```
+// C Function and typedef struct
+nvmlReturn_t DECLDIR nvmlDeviceGetMemoryInfo(nvmlDevice_t device,
+                                             nvmlMemory_t *memory);
+typedef struct nvmlMemory_st {
+    unsigned long long total;
+    unsigned long long free;
+    unsigned long long used;
+} nvmlMemory_t;
+
+
+# Python call to function and accessing members of ctype struct
+>>> info = nvmlDeviceGetMemoryInfo(handle)
+>>> print(f"Total memory: {info.total}")
+Total memory: 5636292608
+>>> print(f"Free memory:, {info.free}")
+Free memory: 5578420224
+>>> print(f"Used memory: {info.used}")
+Used memory: 57872384
+```
+
+- Python handles string buffer creation.
+
+```
+// C Function that needs character array and length
+nvmlReturn_t nvmlSystemGetDriverVersion(char* version,
+                                        unsigned int length);
+
+# Python function handles memory
+>>> version = nvmlSystemGetDriverVersion()
+>>> print(version)
+... 11.520.75
+>>> nvmlShutdown()
+```
+
+For usage information see the NVML documentation.
+
+VARIABLES
+---------
+All meaningful NVML constants and enums are exposed in Python.
+
+The NVML_VALUE_NOT_AVAILABLE constant is not used.  Instead None is mapped to the field.
+
+EXCEPTIONS
+----------
+Since the C library uses return codes and python prefers exception handling, the
+library converts all return codes to various exceptions. The exceptions are generated
+automatically via a function at run time instead of being defined manually.
+
+The list of exceptions can be found in NVMLError base class.
+
+The example seen above in the FUNCTIONS section:
+
+```
+>>> try:
+...     nvmlDeviceGetCount()
+... except NVMLError as error:
+...     print(error)
+...
+Uninitialized
+```
+
+Can be more accurately caught like this:
+
+```
+>>> try:
+...     nvmlDeviceGetCount()
+... except NVMLError_Uninitialized as error:
+...     print(error)
+...
+Uninitialized
+```
+
+The conversion from name to exception is like this for all exceptions:
+* `NVML_ERROR_UNINITIALIZED` => `NVMLError_Uninitialized`
+* `NVML_ERROR_LIBRARY_NOT_FOUND` => `NVMLError_LibraryNotFound`
+* `NVML_ERROR_ALREADY_INITIALIZED` => `NVMLError_AlreadyInitialized`
+
+RELEASE NOTES
+-------------
+Version 2.285.0
+- Added new functions for NVML 2.285.  See NVML documentation for more information.
+- Ported to support Python 3.0 and Python 2.0 syntax.
+- Added nvidia_smi.py tool as a sample app.
+
+Version 3.295.0
+- Added new functions for NVML 3.295.  See NVML documentation for more information.
+- Updated nvidia_smi.py tool
+- Includes additional error handling
+
+Version 4.304.0
+- Added new functions for NVML 4.304.  See NVML documentation for more information.
+- Updated nvidia_smi.py tool
+
+Version 4.304.3
+- Fixing nvmlUnitGetDeviceCount bug
+
+Version 5.319.0
+- Added new functions for NVML 5.319.  See NVML documentation for more information.
+
+Version 6.340.0
+- Added new functions for NVML 6.340.  See NVML documentation for more information.
+
+Version 7.346.0
+- Added new functions for NVML 7.346.  See NVML documentation for more information.
+
+Version 7.352.0
+- Added new functions for NVML 7.352.  See NVML documentation for more information.
+
+Version 10.418
+- Added new functions for NVML 10.418.  See NVML documentation for more information.
+- Fixed issues with using the bindings with Python 3.x
+- Replaced sample app nvidia_smi.py with example.py
+
+Version 11.515.48
+- Python3 support added
+- Updated API to add function new to NVML, bringing pynvml up to date with NVML
+- Added auto-version to handle byte and string conversion automatically for both structs and functions
+- Minor bug fixes
+- Added README.txt correctly in long_description for pypi.org
+
+Version 11.520
+- Updated Long Description to be actual markdown
+- Added new functions for NVML 11.520
+
+Version 11.525
+- Added new functions for NVML 11.525
+
+Version 12.535
+- Added new functions for NVML 12.535. See NVML documentation for more information.
+
+Version 12.550
+- Added new functions for NVML 12.550. See NVML documentation for more information.
+
+Version 12.555
+- Added new functions for NVML 12.555. See NVML documentation for more information.
+
+Version 12.560
+- Added new functions for NVML 12.560. See NVML documentation for more information.
+
+Version 12.565
+- Added new functions for NVML 12.565. See NVML documentation for more information.
+
+Version 12.575
+- Added new functions for NVML 12.575. See NVML documentation for more information.
+
+Version 13.580
+- Major version increased to 13.
+- Several APIs are now deprecated and will be removed in a future release. Please see NVML documentation for more information.
+- Added new functions for NVML 13.580. See NVML documentation for more information.
+
+COPYRIGHT
+---------
+Copyright (c) 2011-2025, NVIDIA Corporation.  All rights reserved.
+
+LICENSE
+-------
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+- Neither the name of the NVIDIA Corporation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

.venv/lib/python3.10/site-packages/nvidia_ml_py-13.580.82.dist-info/RECORD

@@ -0,0 +1,8 @@
+example.py,sha256=mDXwPVyEDuiKeMApEh53r_M36xuncmzMpFOGA3Q-_Kw,7968
+nvidia_ml_py-13.580.82.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+nvidia_ml_py-13.580.82.dist-info/METADATA,sha256=efN4BCMX6ch9fgSsWKVGrI5wmUikeXL62QUO3KutF8Y,9578
+nvidia_ml_py-13.580.82.dist-info/RECORD,,
+nvidia_ml_py-13.580.82.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia_ml_py-13.580.82.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_ml_py-13.580.82.dist-info/top_level.txt,sha256=wLINSA1WKnhsGgKsb_nuj51ZCQrXaN5qhioTL56g98A,15
+pynvml.py,sha256=QlFCnCXxYVpBZvOV08Cf4HMr-wI4ZMS38SgTNz5Wluo,264920

.venv/lib/python3.10/site-packages/nvidia_ml_py-13.580.82.dist-info/WHEEL

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

.venv/lib/python3.10/site-packages/nvidia_ml_py-13.580.82.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+example
+pynvml

.venv/lib/python3.10/site-packages/nvitop-1.5.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

.venv/lib/python3.10/site-packages/nvitop-1.5.3.dist-info/METADATA

@@ -0,0 +1,1563 @@
+Metadata-Version: 2.4
+Name: nvitop
+Version: 1.5.3
+Summary: An interactive NVIDIA-GPU process viewer and beyond, the one-stop solution for GPU process management.
+Author-email: Xuehai Pan <[email protected]>
+License: Apache-2.0 AND GPL-3.0-only
+Project-URL: Homepage, https://github.com/XuehaiPan/nvitop
+Project-URL: Repository, https://github.com/XuehaiPan/nvitop
+Project-URL: Documentation, https://nvitop.readthedocs.io
+Project-URL: Bug Report, https://github.com/XuehaiPan/nvitop/issues
+Keywords: nvidia,nvidia-smi,NVIDIA,NVML,CUDA,GPU,top,monitoring
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: GPU
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Environment :: Console
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: COPYING
+Requires-Dist: nvidia-ml-py<13.581.0a0,>=11.450.51
+Requires-Dist: psutil>=5.6.6
+Requires-Dist: colorama>=0.4.0; platform_system == "Windows"
+Requires-Dist: windows-curses>=2.2.0; platform_system == "Windows"
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Requires-Dist: pylint[spelling]; extra == "lint"
+Requires-Dist: xdoctest; extra == "lint"
+Requires-Dist: mypy; extra == "lint"
+Requires-Dist: typing-extensions; extra == "lint"
+Requires-Dist: pre-commit; extra == "lint"
+Provides-Extra: cuda10
+Requires-Dist: nvidia-ml-py==11.450.51; extra == "cuda10"
+Provides-Extra: cuda11
+Requires-Dist: nvidia-ml-py<=11.525.150,>=11.450.51; extra == "cuda11"
+Provides-Extra: cuda12
+Requires-Dist: nvidia-ml-py<=12.575.51,>=12.535.77; extra == "cuda12"
+Provides-Extra: cuda13
+Requires-Dist: nvidia-ml-py==13.580.65; extra == "cuda13"
+Dynamic: license-file
+Dynamic: provides-extra
+
+# nvitop
+
+<!-- markdownlint-disable html -->
+
+![Python 3.8+](https://img.shields.io/badge/Python-3.8%2B-brightgreen)
+[![PyPI](https://img.shields.io/pypi/v/nvitop?label=pypi&logo=pypi)](https://pypi.org/project/nvitop)
+[![conda-forge](https://img.shields.io/conda/vn/conda-forge/nvitop?label=conda&logo=condaforge)](https://anaconda.org/conda-forge/nvitop)
+[![Documentation Status](https://img.shields.io/readthedocs/nvitop?label=docs&logo=readthedocs)](https://nvitop.readthedocs.io)
+[![Downloads](https://static.pepy.tech/personalized-badge/nvitop?period=total&left_color=grey&right_color=blue&left_text=downloads)](https://pepy.tech/project/nvitop)
+[![GitHub Repo Stars](https://img.shields.io/github/stars/XuehaiPan/nvitop?label=stars&logo=github&color=brightgreen)](https://github.com/XuehaiPan/nvitop/stargazers)
+[![License](https://img.shields.io/github/license/XuehaiPan/nvitop?label=license&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjI0IiBoZWlnaHQ9IjI0IiBmaWxsPSIjZmZmZmZmIj48cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik0xMi43NSAyLjc1YS43NS43NSAwIDAwLTEuNSAwVjQuNUg5LjI3NmExLjc1IDEuNzUgMCAwMC0uOTg1LjMwM0w2LjU5NiA1Ljk1N0EuMjUuMjUgMCAwMTYuNDU1IDZIMi4zNTNhLjc1Ljc1IDAgMTAwIDEuNUgzLjkzTC41NjMgMTUuMThhLjc2Mi43NjIgMCAwMC4yMS44OGMuMDguMDY0LjE2MS4xMjUuMzA5LjIyMS4xODYuMTIxLjQ1Mi4yNzguNzkyLjQzMy42OC4zMTEgMS42NjIuNjIgMi44NzYuNjJhNi45MTkgNi45MTkgMCAwMDIuODc2LS42MmMuMzQtLjE1NS42MDYtLjMxMi43OTItLjQzMy4xNS0uMDk3LjIzLS4xNTguMzEtLjIyM2EuNzUuNzUgMCAwMC4yMDktLjg3OEw1LjU2OSA3LjVoLjg4NmMuMzUxIDAgLjY5NC0uMTA2Ljk4NC0uMzAzbDEuNjk2LTEuMTU0QS4yNS4yNSAwIDAxOS4yNzUgNmgxLjk3NXYxNC41SDYuNzYzYS43NS43NSAwIDAwMCAxLjVoMTAuNDc0YS43NS43NSAwIDAwMC0xLjVIMTIuNzVWNmgxLjk3NGMuMDUgMCAuMS4wMTUuMTQuMDQzbDEuNjk3IDEuMTU0Yy4yOS4xOTcuNjMzLjMwMy45ODQuMzAzaC44ODZsLTMuMzY4IDcuNjhhLjc1Ljc1IDAgMDAuMjMuODk2Yy4wMTIuMDA5IDAgMCAuMDAyIDBhMy4xNTQgMy4xNTQgMCAwMC4zMS4yMDZjLjE4NS4xMTIuNDUuMjU2Ljc5LjRhNy4zNDMgNy4zNDMgMCAwMDIuODU1LjU2OCA3LjM0MyA3LjM0MyAwIDAwMi44NTYtLjU2OWMuMzM4LS4xNDMuNjA0LS4yODcuNzktLjM5OWEzLjUgMy41IDAgMDAuMzEtLjIwNi43NS43NSAwIDAwLjIzLS44OTZMMjAuMDcgNy41aDEuNTc4YS43NS43NSAwIDAwMC0xLjVoLTQuMTAyYS4yNS4yNSAwIDAxLS4xNC0uMDQzbC0xLjY5Ny0xLjE1NGExLjc1IDEuNzUgMCAwMC0uOTg0LS4zMDNIMTIuNzVWMi43NXpNMi4xOTMgMTUuMTk4YTUuNDE4IDUuNDE4IDAgMDAyLjU1Ny42MzUgNS40MTggNS40MTggMCAwMDIuNTU3LS42MzVMNC43NSA5LjM2OGwtMi41NTcgNS44M3ptMTQuNTEtLjAyNGMuMDgyLjA0LjE3NC4wODMuMjc1LjEyNi41My4yMjMgMS4zMDUuNDUgMi4yNzIuNDVhNS44NDYgNS44NDYgMCAwMDIuNTQ3LS41NzZMMTkuMjUgOS4zNjdsLTIuNTQ3IDUuODA3eiI+PC9wYXRoPjwvc3ZnPgo=)](#license)
+
+An interactive NVIDIA-GPU process viewer and beyond, the one-stop solution for GPU process management. The full API references host at <https://nvitop.readthedocs.io>.
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/171005261-1aad126e-dc27-4ed3-a89b-7f9c1c998bf7.png" alt="Monitor">
+  <br/>
+  Monitor mode of <code>nvitop</code>.
+  <br/>
+  (TERM: GNOME Terminal / OS: Ubuntu 16.04 LTS (over SSH) / Locale: <code>en_US.UTF-8</code>)
+</p>
+
+<p align="center">
+  <a href="./nvitop-exporter">
+    <img width="100%" src="https://github.com/user-attachments/assets/e4867e64-2ca9-45bc-b524-929053f9673d" alt="Grafana Dashboard">
+  </a>
+  <br/>
+  A Grafana dashboard built on top of <code>nvitop-exporter</code>.
+</p>
+
+### Table of Contents  <!-- omit in toc --> <!-- markdownlint-disable heading-increment -->
+
+- [Features](#features)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Device and Process Status](#device-and-process-status)
+  - [Resource Monitor](#resource-monitor)
+    - [For Docker Users](#for-docker-users)
+    - [For SSH Users](#for-ssh-users)
+    - [Command Line Options and Environment Variables](#command-line-options-and-environment-variables)
+    - [Keybindings for Monitor Mode](#keybindings-for-monitor-mode)
+  - [CUDA Visible Devices Selection Tool](#cuda-visible-devices-selection-tool)
+  - [Callback Functions for Machine Learning Frameworks (DEPRECATED)](#callback-functions-for-machine-learning-frameworks-deprecated)
+    - [Callback for TensorFlow (Keras)](#callback-for-tensorflow-keras)
+    - [Callback for PyTorch Lightning](#callback-for-pytorch-lightning)
+    - [TensorBoard Integration](#tensorboard-integration)
+  - [More than a Monitor](#more-than-a-monitor)
+    - [Quick Start](#quick-start)
+    - [Status Snapshot](#status-snapshot)
+    - [Resource Metric Collector](#resource-metric-collector)
+    - [Low-level APIs](#low-level-apis)
+      - [Device](#device)
+      - [Process](#process)
+      - [Host (inherited from psutil)](#host-inherited-from-psutil)
+- [Screenshots](#screenshots)
+- [Changelog](#changelog)
+- [License](#license)
+  - [Copyright Notice](#copyright-notice)
+
+------
+
+`nvitop` is an interactive NVIDIA device and process monitoring tool. It has a colorful and informative interface that continuously updates the status of the devices and processes. As a resource monitor, it includes many features and options, such as tree-view, environment variable viewing, process filtering, process metrics monitoring, etc. Beyond that, the package also ships a [CUDA device selection tool `nvisel`](#cuda-visible-devices-selection-tool) for deep learning researchers. It also provides handy APIs that allow developers to write their own monitoring tools. Please refer to section [More than a Monitor](#more-than-a-monitor) and the full API references at <https://nvitop.readthedocs.io> for more information.
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/202362811-34f2c01d-97c8-49d2-b19b-0d7da648f2d5.png" alt="Filter">
+  <br/>
+  Process filtering and a more colorful interface.
+</p>
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/202362686-859bf4ad-6237-46ca-b2f7-f547d2f63213.png" alt="Comparison">
+  <br/>
+  Compare to <code>nvidia-smi</code>.
+</p>
+
+------
+
+## Features
+
+- **Informative and fancy output**: show more information than `nvidia-smi` with colorized fancy box drawing.
+- **Monitor mode**: can run as a resource monitor, rather than print the results only once.
+  - bar charts and history graphs
+  - process sorting
+  - process filtering
+  - send signals to processes with a keystroke
+  - tree-view screen for GPU processes and their parent processes
+  - environment variable screen
+  - help screen
+  - mouse support
+- **Interactive**: responsive for user input (from keyboard and/or mouse) in monitor mode. (vs. [gpustat](https://github.com/wookayin/gpustat) & [py3nvml](https://github.com/fbcotter/py3nvml))
+- **Efficient**:
+  - query device status using [*NVML Python bindings*](https://pypi.org/project/nvidia-ml-py) directly, instead of parsing the output of `nvidia-smi`. (vs. [nvidia-htop](https://github.com/peci1/nvidia-htop))
+  - support sparse query and cache results with `TTLCache` from [cachetools](https://github.com/tkem/cachetools). (vs. [gpustat](https://github.com/wookayin/gpustat))
+  - display information using the `curses` library rather than `print` with ANSI escape codes. (vs. [py3nvml](https://github.com/fbcotter/py3nvml))
+  - asynchronously gather information using multi-threading and correspond to user input much faster. (vs. [nvtop](https://github.com/Syllo/nvtop))
+- **Portable**: work on both Linux and Windows.
+  - get host process information using the cross-platform library [psutil](https://github.com/giampaolo/psutil) instead of calling `ps -p <pid>` in a subprocess. (vs. [nvidia-htop](https://github.com/peci1/nvidia-htop) & [py3nvml](https://github.com/fbcotter/py3nvml))
+  - written in pure Python, easy to install with `pip`. (vs. [nvtop](https://github.com/Syllo/nvtop))
+- **Integrable**: easy to integrate into other applications, more than monitoring. (vs. [nvidia-htop](https://github.com/peci1/nvidia-htop) & [nvtop](https://github.com/Syllo/nvtop))
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/129374533-fe06c01a-630d-4994-b54b-821cccd0d33c.png" alt="Windows">
+  <br/>
+  <code>nvitop</code> supports Windows!
+  <br/>
+  (SHELL: PowerShell / TERM: Windows Terminal / OS: Windows 10 / Locale: <code>en-US</code>)
+</p>
+
+------
+
+## Requirements
+
+- Python 3.8+
+- NVIDIA Management Library (NVML)
+- nvidia-ml-py
+- psutil
+- curses<sup>[*](#curses)</sup> (with `libncursesw`)
+
+**NOTE:** The [NVIDIA Management Library (*NVML*)](https://developer.nvidia.com/nvidia-management-library-nvml) is a C-based programmatic interface for monitoring and managing various states. The runtime version of the NVML library ships with the NVIDIA display driver (available at [Download Drivers | NVIDIA](https://www.nvidia.com/Download/index.aspx)), or can be downloaded as part of the NVIDIA CUDA Toolkit (available at [CUDA Toolkit | NVIDIA Developer](https://developer.nvidia.com/cuda-downloads)). The lists of OS platforms and NVIDIA-GPUs supported by the NVML library can be found in the [NVML API Reference](https://docs.nvidia.com/deploy/nvml-api/nvml-api-reference.html).
+
+This repository contains a Bash script to install/upgrade the NVIDIA drivers for Ubuntu Linux. For example:
+
+```bash
+git clone --depth=1 https://github.com/XuehaiPan/nvitop.git && cd nvitop
+
+# Change to tty3 console (required for desktop users with GUI (tty2))
+# Optional for SSH users
+sudo chvt 3  # or use keyboard shortcut: Ctrl-LeftAlt-F3
+
+bash install-nvidia-driver.sh --package=nvidia-driver-470  # install the R470 driver from ppa:graphics-drivers
+bash install-nvidia-driver.sh --latest                     # install the latest driver from ppa:graphics-drivers
+```
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/174480112-e9a35edc-8f42-438e-a103-1d0ce998b381.png" alt="install-nvidia-driver">
+  <br/>
+  NVIDIA driver installer for Ubuntu Linux.
+</p>
+
+Run `bash install-nvidia-driver.sh --help` for more information.
+
+<a name="curses">*</a> The `curses` library is a built-in module of Python on Unix-like systems, and it is supported by a third-party package called `windows-curses` on Windows using PDCurses. Inconsistent behavior of `nvitop` may occur on different terminal emulators on Windows, such as missing mouse support.
+
+------
+
+## Installation
+
+**It is highly recommended to install `nvitop` in an isolated virtual environment.** Simple installation and run via [`uvx`](https://docs.astral.sh/uv/guides/tools) (a.k.a. `uv tool run`) or [`pipx`](https://pypa.github.io/pipx):
+
+```bash
+uvx nvitop
+# or
+pipx run nvitop
+```
+
+You can also set this command as an alias in your shell startup file, e.g.:
+
+```bash
+# For Bash
+echo 'alias nvitop="uvx nvitop"' >> ~/.bashrc
+
+# For Zsh
+echo 'alias nvitop="uvx nvitop"' >> ~/.zshrc
+
+# For Fish
+mkdir -p ~/.config/fish
+echo 'alias nvitop="uvx nvitop"' >> ~/.config/fish/config.fish
+
+# For PowerShell
+New-Item -Path (Split-Path -Parent -Path $PROFILE.CurrentUserAllHosts) -ItemType Directory -Force
+'Function nvitop { uvx nvitop @Args }' >> $PROFILE.CurrentUserAllHosts
+```
+
+or
+
+```bash
+# For Bash
+echo 'alias nvitop="pipx run nvitop"' >> ~/.bashrc
+
+# For Zsh
+echo 'alias nvitop="pipx run nvitop"' >> ~/.zshrc
+
+# For Fish
+mkdir -p ~/.config/fish
+echo 'alias nvitop="pipx run nvitop"' >> ~/.config/fish/config.fish
+
+# For PowerShell
+New-Item -Path (Split-Path -Parent -Path $PROFILE.CurrentUserAllHosts) -ItemType Directory -Force
+'Function nvitop { pipx run nvitop @Args }' >> $PROFILE.CurrentUserAllHosts
+```
+
+Install from PyPI ([![PyPI](https://img.shields.io/pypi/v/nvitop?label=pypi&logo=pypi)](https://pypi.org/project/nvitop)):
+
+```bash
+pip3 install --upgrade nvitop
+```
+
+Install from conda-forge ([![conda-forge](https://img.shields.io/conda/v/conda-forge/nvitop?logo=condaforge)](https://anaconda.org/conda-forge/nvitop)):
+
+```bash
+conda install -c conda-forge nvitop
+```
+
+Install the latest version from GitHub (![Commit Count](https://img.shields.io/github/commits-since/XuehaiPan/nvitop/v1.5.3)):
+
+```bash
+pip3 install --upgrade pip setuptools
+pip3 install git+https://github.com/XuehaiPan/nvitop.git#egg=nvitop
+```
+
+Or, clone this repo and install manually:
+
+```bash
+git clone --depth=1 https://github.com/XuehaiPan/nvitop.git
+cd nvitop
+pip3 install .
+```
+
+**NOTE:** If you encounter the *"nvitop: command not found"* error after installation, please check whether you have added the Python console script path (e.g., `"${HOME}/.local/bin"`) to your `PATH` environment variable. Alternatively, you can use `python3 -m nvitop`.
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/178963038-a5cd4eb5-02a8-4456-966f-d5ff04eb44d8.png" alt="MIG Device Support">
+  <br/>
+  MIG Device Support.
+  <br/>
+</p>
+
+------
+
+## Usage
+
+### Device and Process Status
+
+Query the device and process status. The output is similar to `nvidia-smi`, but has been enriched and colorized.
+
+```bash
+# Query the status of all devices
+$ nvitop -1  # or use `python3 -m nvitop -1`
+
+# Specify query devices (by integer indices)
+$ nvitop -1 -o 0 1  # only show <GPU 0> and <GPU 1>
+
+# Only show devices in `CUDA_VISIBLE_DEVICES` (by integer indices or UUID strings)
+$ nvitop -1 -ov
+
+# Only show GPU processes with the compute context (type: 'C' or 'C+G')
+$ nvitop -1 -c
+```
+
+When the `-1` switch is on, the result will be displayed **ONLY ONCE** (same as the default behavior of `nvidia-smi`). This is much faster and has lower resource usage. See [Command Line Options](#command-line-options-and-environment-variables) for more command options.
+
+There is also a CLI tool called `nvisel` that ships with the `nvitop` PyPI package. See [CUDA Visible Devices Selection Tool](#cuda-visible-devices-selection-tool) for more information.
+
+### Resource Monitor
+
+Run as a resource monitor:
+
+```bash
+# Monitor mode (when the display mode is omitted, `NVITOP_MONITOR_MODE` will be used)
+$ nvitop  # or use `python3 -m nvitop`
+
+# Automatically configure the display mode according to the terminal size
+$ nvitop -m auto     # shortcut: `a` key
+
+# Arbitrarily display as `full` mode
+$ nvitop -m full     # shortcut: `f` key
+
+# Arbitrarily display as `compact` mode
+$ nvitop -m compact  # shortcut: `c` key
+
+# Specify query devices (by integer indices)
+$ nvitop -o 0 1  # only show <GPU 0> and <GPU 1>
+
+# Only show devices in `CUDA_VISIBLE_DEVICES` (by integer indices or UUID strings)
+$ nvitop -ov
+
+# Only show GPU processes with the compute context (type: 'C' or 'C+G')
+$ nvitop -c
+
+# Use ASCII characters only
+$ nvitop -U  # useful for terminals without Unicode support
+
+# For light terminals
+$ nvitop --light
+
+# For spectrum-like bar charts (requires the terminal supports 256-color)
+$ nvitop --colorful
+```
+
+You can configure the default monitor mode with the `NVITOP_MONITOR_MODE` environment variable (default `auto` if not set). See [Command Line Options and Environment Variables](#command-line-options-and-environment-variables) for more command options.
+
+In monitor mode, you can use <kbd>Ctrl-c</kbd> / <kbd>T</kbd> / <kbd>K</kbd> keys to interrupt / terminate / kill a process. And it's recommended to *terminate* or *kill* a process in the **tree-view screen** (shortcut: <kbd>t</kbd>). For normal users, `nvitop` will shallow other users' processes (in low-intensity colors). For **system administrators**, you can use `sudo nvitop` to terminate other users' processes.
+
+Also, to enter the process metrics screen, select a process and then press the <kbd>Enter</kbd> / <kbd>Return</kbd> key . `nvitop` dynamically displays the process metrics with live graphs.
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/192108815-37c03705-be44-47d4-9908-6d05175db230.png" alt="Process Metrics Screen">
+  <br/>
+  Watch metrics for a specific process (shortcut: <kbd>Enter</kbd> / <kbd>Return</kbd>).
+</p>
+
+Press <kbd>h</kbd> for help or <kbd>q</kbd> to return to the terminal. See [Keybindings for Monitor Mode](#keybindings-for-monitor-mode) for more shortcuts.
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/192108664-61f1983c-6f62-48e6-87c5-29633d9c409e.png" alt="Help Screen">
+  <br/>
+  <code>nvitop</code> comes with a help screen (shortcut: <kbd>h</kbd>).
+</p>
+
+#### For Docker Users
+
+Build and run the Docker image with [nvidia-container-toolkit](https://github.com/NVIDIA/nvidia-container-toolkit):
+
+```bash
+git clone --depth=1 https://github.com/XuehaiPan/nvitop.git && cd nvitop  # clone this repo first
+docker build --tag nvitop:latest .  # build the Docker image
+docker run -it --rm --runtime=nvidia --gpus=all --pid=host nvitop:latest  # run the Docker container
+```
+
+**NOTE:** Don't forget to add the `--pid=host` option when running the container.
+
+If you only need to set up the Grafana dashboard, you can start a dashboard at [`http://localhost:3000`](http://localhost:3000) with the following command:
+
+```bash
+docker compose --project-directory=nvitop-exporter/grafana up --build --detach
+```
+
+See [`nvitop-exporter`](./nvitop-exporter/README.md) for more details.
+
+#### For SSH Users
+
+Run `nvitop` directly on the SSH session instead of a login shell:
+
+```bash
+ssh user@host -t nvitop                 # installed by `sudo pip3 install ...`
+ssh user@host -t '~/.local/bin/nvitop'  # installed by `pip3 install --user ...`
+```
+
+**NOTE:** Users need to add the `-t` option to allocate a pseudo-terminal over the SSH session for monitor mode.
+
+#### Command Line Options and Environment Variables
+
+Type `nvitop --help` for more command options:
+
+```text
+usage: nvitop [--help] [--version] [--once | --monitor [{auto,full,compact}]]
+              [--interval SEC] [--ascii] [--colorful] [--force-color] [--light]
+              [--gpu-util-thresh th1 th2] [--mem-util-thresh th1 th2]
+              [--only INDEX [INDEX ...]] [--only-visible]
+              [--compute] [--only-compute] [--graphics] [--only-graphics]
+              [--user [USERNAME ...]] [--pid PID [PID ...]]
+
+An interactive NVIDIA-GPU process viewer.
+
+options:
+  --help, -h            Show this help message and exit.
+  --version, -V         Show nvitop's version number and exit.
+  --once, -1            Report query data only once.
+  --monitor [{auto,full,compact}], -m [{auto,full,compact}]
+                        Run as a resource monitor. Continuously report query data and handle user inputs.
+                        If the argument is omitted, the value from `NVITOP_MONITOR_MODE` will be used.
+                        (default fallback mode: auto)
+  --interval SEC        Process status update interval in seconds. (default: 2)
+  --ascii, --no-unicode, -U
+                        Use ASCII characters only, which is useful for terminals without Unicode support.
+
+coloring:
+  --colorful            Use gradient colors to get spectrum-like bar charts. This option is only available
+                        when the terminal supports 256 colors. You may need to set environment variable
+                        `TERM="xterm-256color"`. Note that the terminal multiplexer, such as `tmux`, may
+                        override the `TREM` variable.
+  --force-color         Force colorize even when `stdout` is not a TTY terminal.
+  --light               Tweak visual results for light theme terminals in monitor mode.
+                        Set variable `NVITOP_MONITOR_MODE="light"` on light terminals for convenience.
+  --gpu-util-thresh th1 th2
+                        Thresholds of GPU utilization to determine the load intensity.
+                        Coloring rules: light < th1 % <= moderate < th2 % <= heavy.
+                        ( 1 <= th1 < th2 <= 99, defaults: 10 75 )
+  --mem-util-thresh th1 th2
+                        Thresholds of GPU memory percent to determine the load intensity.
+                        Coloring rules: light < th1 % <= moderate < th2 % <= heavy.
+                        ( 1 <= th1 < th2 <= 99, defaults: 10 80 )
+
+device filtering:
+  --only INDEX [INDEX ...], -o INDEX [INDEX ...]
+                        Only show the specified devices, suppress option `--only-visible`.
+  --only-visible, -ov   Only show devices in the `CUDA_VISIBLE_DEVICES` environment variable.
+
+process filtering:
+  --compute, -c         Only show GPU processes with the compute context. (type: 'C' or 'C+G')
+  --only-compute, -C    Only show GPU processes exactly with the compute context. (type: 'C' only)
+  --graphics, -g        Only show GPU processes with the graphics context. (type: 'G' or 'C+G')
+  --only-graphics, -G   Only show GPU processes exactly with the graphics context. (type: 'G' only)
+  --user [USERNAME ...], -u [USERNAME ...]
+                        Only show processes of the given users (or `$USER` for no argument).
+  --pid PID [PID ...], -p PID [PID ...]
+                        Only show processes of the given PIDs.
+```
+
+`nvitop` can accept the following environment variables for monitor mode:
+
+| Name                                   | Description                                         | Valid Values                                                            | Default Value     |
+| -------------------------------------- | --------------------------------------------------- | ----------------------------------------------------------------------- | ----------------- |
+| `NVITOP_MONITOR_MODE`                  | The default display mode (a comma-separated string) | `auto` / `full` / `compact`<br>`plain` / `colorful`<br>`dark` / `light` | `auto,plain,dark` |
+| `NVITOP_GPU_UTILIZATION_THRESHOLDS`    | Thresholds of GPU utilization                       | `10,75` , `1,99`, ...                                                   | `10,75`           |
+| `NVITOP_MEMORY_UTILIZATION_THRESHOLDS` | Thresholds of GPU memory percent                    | `10,80` , `1,99`, ...                                                   | `10,80`           |
+| `LOGLEVEL`                             | Log level for log messages                          | `DEBUG` , `INFO`, `WARNING`, ...                                        | `WARNING`         |
+
+For example:
+
+```bash
+# Replace the following export statements if you are not using Bash / Zsh
+export NVITOP_MONITOR_MODE="full,light"
+
+# Full monitor mode with light terminal tweaks
+nvitop
+```
+
+For convenience, you can add these environment variables to your shell startup file, e.g.:
+
+```bash
+# For Bash
+echo 'export NVITOP_MONITOR_MODE="full"' >> ~/.bashrc
+
+# For Zsh
+echo 'export NVITOP_MONITOR_MODE="full"' >> ~/.zshrc
+
+# For Fish
+echo 'set -gx NVITOP_MONITOR_MODE "full"' >> ~/.config/fish/config.fish
+
+# For PowerShell
+'$Env:NVITOP_MONITOR_MODE = "full"' >> $PROFILE.CurrentUserAllHosts
+```
+
+#### Keybindings for Monitor Mode
+
+|                                                                        Key | Binding                                                                              |
+| -------------------------------------------------------------------------: | :----------------------------------------------------------------------------------- |
+|                                                                        `q` | Quit and return to the terminal.                                                     |
+|                                                                  `h` / `?` | Go to the help screen.                                                               |
+|                                                            `a` / `f` / `c` | Change the display mode to *auto* / *full* / *compact*.                              |
+|                                                     `r` / `<C-r>` / `<F5>` | Force refresh the window.                                                            |
+|                                                                            |                                                                                      |
+| `<Up>` / `<Down>`<br>`<A-k>` / `<A-j>`<br>`<Tab>` / `<S-Tab>`<br>`<Wheel>` | Select and highlight a process.                                                      |
+|                   `<Left>` / `<Right>`<br>`<A-h>` / `<A-l>`<br>`<S-Wheel>` | Scroll the host information of processes.                                            |
+|                                                                   `<Home>` | Select the first process.                                                            |
+|                                                                    `<End>` | Select the last process.                                                             |
+|                                                             `<C-a>`<br>`^` | Scroll left to the beginning of the process entry (i.e. beginning of line).          |
+|                                                             `<C-e>`<br>`$` | Scroll right to the end of the process entry (i.e. end of line).                     |
+|              `<PageUp>` / `<PageDown>`<br/> `<A-K>` / `<A-J>`<br>`[` / `]` | scroll entire screen (for large amounts of processes).                               |
+|                                                                            |                                                                                      |
+|                                                                  `<Space>` | Tag/untag current process.                                                           |
+|                                                                    `<Esc>` | Clear process selection.                                                             |
+|                                                             `<C-c>`<br>`I` | Send `signal.SIGINT` to the selected process (interrupt).                            |
+|                                                                        `T` | Send `signal.SIGTERM` to the selected process (terminate).                           |
+|                                                                        `K` | Send `signal.SIGKILL` to the selected process (kill).                                |
+|                                                                            |                                                                                      |
+|                                                                        `e` | Show process environment.                                                            |
+|                                                                        `t` | Toggle tree-view screen.                                                             |
+|                                                                  `<Enter>` | Show process metrics.                                                                |
+|                                                                            |                                                                                      |
+|                                                                  `,` / `.` | Select the sort column.                                                              |
+|                                                                        `/` | Reverse the sort order.                                                              |
+|                                                                `on` (`oN`) | Sort processes in the natural order, i.e., in ascending (descending) order of `GPU`. |
+|                                                                `ou` (`oU`) | Sort processes by `USER` in ascending (descending) order.                            |
+|                                                                `op` (`oP`) | Sort processes by `PID` in descending (ascending) order.                             |
+|                                                                `og` (`oG`) | Sort processes by `GPU-MEM` in descending (ascending) order.                         |
+|                                                                `os` (`oS`) | Sort processes by `%SM` in descending (ascending) order.                             |
+|                                                                `oc` (`oC`) | Sort processes by `%CPU` in descending (ascending) order.                            |
+|                                                                `om` (`oM`) | Sort processes by `%MEM` in descending (ascending) order.                            |
+|                                                                `ot` (`oT`) | Sort processes by `TIME` in descending (ascending) order.                            |
+
+**HINT:** It's recommended to terminate or kill a process in the tree-view screen (shortcut: <kbd>t</kbd>).
+
+------
+
+### CUDA Visible Devices Selection Tool
+
+Automatically select `CUDA_VISIBLE_DEVICES` from the given criteria. Example usage of the CLI tool:
+
+```console
+# All devices but sorted
+$ nvisel       # or use `python3 -m nvitop.select`
+6,5,4,3,2,1,0,7,8
+
+# A simple example to select 4 devices
+$ nvisel -n 4  # or use `python3 -m nvitop.select -n 4`
+6,5,4,3
+
+# Select available devices that satisfy the given constraints
+$ nvisel --min-count 2 --max-count 3 --min-free-memory 5GiB --max-gpu-utilization 60
+6,5,4
+
+# Set `CUDA_VISIBLE_DEVICES` environment variable using `nvisel`
+$ export CUDA_DEVICE_ORDER="PCI_BUS_ID" CUDA_VISIBLE_DEVICES="$(nvisel -c 1 -f 10GiB)"
+CUDA_VISIBLE_DEVICES="6,5,4,3,2,1,0"
+
+# Use UUID strings in `CUDA_VISIBLE_DEVICES` environment variable
+$ export CUDA_VISIBLE_DEVICES="$(nvisel -O uuid -c 2 -f 5000M)"
+CUDA_VISIBLE_DEVICES="GPU-849d5a8d-610e-eeea-1fd4-81ff44a23794,GPU-18ef14e9-dec6-1d7e-1284-3010c6ce98b1,GPU-96de99c9-d68f-84c8-424c-7c75e59cc0a0,GPU-2428d171-8684-5b64-830c-435cd972ec4a,GPU-6d2a57c9-7783-44bb-9f53-13f36282830a,GPU-f8e5a624-2c7e-417c-e647-b764d26d4733,GPU-f9ca790e-683e-3d56-00ba-8f654e977e02"
+
+# Pipe output to other shell utilities
+$ nvisel --newline -O uuid -C 6 -f 8GiB
+GPU-849d5a8d-610e-eeea-1fd4-81ff44a23794
+GPU-18ef14e9-dec6-1d7e-1284-3010c6ce98b1
+GPU-96de99c9-d68f-84c8-424c-7c75e59cc0a0
+GPU-2428d171-8684-5b64-830c-435cd972ec4a
+GPU-6d2a57c9-7783-44bb-9f53-13f36282830a
+GPU-f8e5a624-2c7e-417c-e647-b764d26d4733
+$ nvisel -0 -O uuid -c 2 -f 4GiB | xargs -0 -I {} nvidia-smi --id={} --query-gpu=index,memory.free --format=csv
+CUDA_VISIBLE_DEVICES="GPU-849d5a8d-610e-eeea-1fd4-81ff44a23794,GPU-18ef14e9-dec6-1d7e-1284-3010c6ce98b1,GPU-96de99c9-d68f-84c8-424c-7c75e59cc0a0,GPU-2428d171-8684-5b64-830c-435cd972ec4a,GPU-6d2a57c9-7783-44bb-9f53-13f36282830a,GPU-f8e5a624-2c7e-417c-e647-b764d26d4733,GPU-f9ca790e-683e-3d56-00ba-8f654e977e02"
+index, memory.free [MiB]
+6, 11018 MiB
+index, memory.free [MiB]
+5, 11018 MiB
+index, memory.free [MiB]
+4, 11018 MiB
+index, memory.free [MiB]
+3, 11018 MiB
+index, memory.free [MiB]
+2, 11018 MiB
+index, memory.free [MiB]
+1, 11018 MiB
+index, memory.free [MiB]
+0, 11018 MiB
+
+# Normalize the `CUDA_VISIBLE_DEVICES` environment variable (e.g. convert UUIDs to indices or get full UUIDs for an abbreviated form)
+$ nvisel -i "GPU-18ef14e9,GPU-849d5a8d" -S
+5,6
+$ nvisel -i "GPU-18ef14e9,GPU-849d5a8d" -S -O uuid --newline
+GPU-18ef14e9-dec6-1d7e-1284-3010c6ce98b1
+GPU-849d5a8d-610e-eeea-1fd4-81ff44a23794
+```
+
+You can also integrate `nvisel` into your training script like this:
+
+```python
+# Put this at the top of the Python script
+import os
+from nvitop import select_devices
+
+os.environ['CUDA_VISIBLE_DEVICES'] = ','.join(
+    select_devices(format='uuid', min_count=4, min_free_memory='8GiB')
+)
+```
+
+Type `nvisel --help` for more command options:
+
+```text
+usage: nvisel [--help] [--version]
+              [--inherit [CUDA_VISIBLE_DEVICES]] [--account-as-free [USERNAME ...]]
+              [--min-count N] [--max-count N] [--count N]
+              [--min-free-memory SIZE] [--min-total-memory SIZE]
+              [--max-gpu-utilization RATE] [--max-memory-utilization RATE]
+              [--tolerance TOL]
+              [--format FORMAT] [--sep SEP | --newline | --null] [--no-sort]
+
+CUDA visible devices selection tool.
+
+options:
+  --help, -h            Show this help message and exit.
+  --version, -V         Show nvisel's version number and exit.
+
+constraints:
+  --inherit [CUDA_VISIBLE_DEVICES], -i [CUDA_VISIBLE_DEVICES]
+                        Inherit the given `CUDA_VISIBLE_DEVICES`. If the argument is omitted, use the
+                        value from the environment. This means selecting a subset of the currently
+                        CUDA-visible devices.
+  --account-as-free [USERNAME ...]
+                        Account the used GPU memory of the given users as free memory.
+                        If this option is specified but without argument, `$USER` will be used.
+  --min-count N, -c N   Minimum number of devices to select. (default: 0)
+                        The tool will fail (exit non-zero) if the requested resource is not available.
+  --max-count N, -C N   Maximum number of devices to select. (default: all devices)
+  --count N, -n N       Overriding both `--min-count N` and `--max-count N`.
+  --min-free-memory SIZE, -f SIZE
+                        Minimum free memory of devices to select. (example value: 4GiB)
+                        If this constraint is given, check against all devices.
+  --min-total-memory SIZE, -t SIZE
+                        Minimum total memory of devices to select. (example value: 10GiB)
+                        If this constraint is given, check against all devices.
+  --max-gpu-utilization RATE, -G RATE
+                        Maximum GPU utilization rate of devices to select. (example value: 30)
+                        If this constraint is given, check against all devices.
+  --max-memory-utilization RATE, -M RATE
+                        Maximum memory bandwidth utilization rate of devices to select. (example value: 50)
+                        If this constraint is given, check against all devices.
+  --tolerance TOL, --tol TOL
+                        The constraints tolerance (in percentage). (default: 0, i.e., strict)
+                        This option can loose the constraints if the requested resource is not available.
+                        For example, set `--tolerance=20` will accept a device with only 4GiB of free
+                        memory when set `--min-free-memory=5GiB`.
+
+formatting:
+  --format FORMAT, -O FORMAT
+                        The output format of the selected device identifiers. (default: index)
+                        If any MIG device found, the output format will be fallback to `uuid`.
+  --sep SEP, --separator SEP, -s SEP
+                        Separator for the output. (default: ',')
+  --newline             Use newline character as separator for the output, equivalent to `--sep=$'\n'`.
+  --null, -0            Use null character ('\x00') as separator for the output. This option corresponds
+                        to the `-0` option of `xargs`.
+  --no-sort, -S         Do not sort the device by memory usage and GPU utilization.
+```
+
+------
+
+### Callback Functions for Machine Learning Frameworks (DEPRECATED)
+
+`nvitop` provides two builtin callbacks for [TensorFlow (Keras)](https://www.tensorflow.org) and [PyTorch Lightning](https://pytorchlightning.ai).
+
+#### Callback for [TensorFlow (Keras)](https://www.tensorflow.org)
+
+```python
+from tensorflow.python.keras.utils.multi_gpu_utils import multi_gpu_model
+from tensorflow.python.keras.callbacks import TensorBoard
+from nvitop.callbacks.keras import GpuStatsLogger
+gpus = ['/gpu:0', '/gpu:1']  # or `gpus = [0, 1]` or `gpus = 2`
+model = Xception(weights=None, ..)
+model = multi_gpu_model(model, gpus)  # optional
+model.compile(..)
+tb_callback = TensorBoard(log_dir='./logs')  # or `keras.callbacks.CSVLogger`
+gpu_stats = GpuStatsLogger(gpus)
+model.fit(.., callbacks=[gpu_stats, tb_callback])
+```
+
+**NOTE:** Users should assign a `keras.callbacks.TensorBoard` callback or a `keras.callbacks.CSVLogger` callback to the model. And the `GpuStatsLogger` callback should be placed before the `keras.callbacks.TensorBoard` / `keras.callbacks.CSVLogger` callback.
+
+#### Callback for [PyTorch Lightning](https://lightning.ai)
+
+```python
+from lightning.pytorch import Trainer
+from nvitop.callbacks.lightning import GpuStatsLogger
+gpu_stats = GpuStatsLogger()
+trainer = Trainer(gpus=[..], logger=True, callbacks=[gpu_stats])
+```
+
+**NOTE:** Users should assign a logger to the trainer.
+
+#### [TensorBoard](https://github.com/tensorflow/tensorboard) Integration
+
+Please refer to [Resource Metric Collector](#resource-metric-collector) for an example.
+
+------
+
+### More than a Monitor
+
+`nvitop` can be easily integrated into other applications. You can use `nvitop` to make your own monitoring tools. The full API references host at <https://nvitop.readthedocs.io>.
+
+#### Quick Start
+
+A minimal script to monitor the GPU devices based on APIs from `nvitop`:
+
+```python
+from nvitop import Device
+
+devices = Device.all()  # or `Device.cuda.all()` to use CUDA ordinal instead
+for device in devices:
+    processes = device.processes()  # type: Dict[int, GpuProcess]
+    sorted_pids = sorted(processes.keys())
+
+    print(device)
+    print(f'  - Fan speed:       {device.fan_speed()}%')
+    print(f'  - Temperature:     {device.temperature()}C')
+    print(f'  - GPU utilization: {device.gpu_utilization()}%')
+    print(f'  - Total memory:    {device.memory_total_human()}')
+    print(f'  - Used memory:     {device.memory_used_human()}')
+    print(f'  - Free memory:     {device.memory_free_human()}')
+    print(f'  - Processes ({len(processes)}): {sorted_pids}')
+    for pid in sorted_pids:
+        print(f'    - {processes[pid]}')
+    print('-' * 120)
+```
+
+Another more advanced approach with coloring:
+
+```python
+import time
+
+from nvitop import Device, GpuProcess, NA, colored
+
+print(colored(time.strftime('%a %b %d %H:%M:%S %Y'), color='red', attrs=('bold',)))
+
+devices = Device.cuda.all()  # or `Device.all()` to use NVML ordinal instead
+separator = False
+for device in devices:
+    processes = device.processes()  # type: Dict[int, GpuProcess]
+
+    print(colored(str(device), color='green', attrs=('bold',)))
+    print(colored('  - Fan speed:       ', color='blue', attrs=('bold',)) + f'{device.fan_speed()}%')
+    print(colored('  - Temperature:     ', color='blue', attrs=('bold',)) + f'{device.temperature()}C')
+    print(colored('  - GPU utilization: ', color='blue', attrs=('bold',)) + f'{device.gpu_utilization()}%')
+    print(colored('  - Total memory:    ', color='blue', attrs=('bold',)) + f'{device.memory_total_human()}')
+    print(colored('  - Used memory:     ', color='blue', attrs=('bold',)) + f'{device.memory_used_human()}')
+    print(colored('  - Free memory:     ', color='blue', attrs=('bold',)) + f'{device.memory_free_human()}')
+    if len(processes) > 0:
+        processes = GpuProcess.take_snapshots(processes.values(), failsafe=True)
+        processes.sort(key=lambda process: (process.username, process.pid))
+
+        print(colored(f'  - Processes ({len(processes)}):', color='blue', attrs=('bold',)))
+        fmt = '    {pid:<5}  {username:<8} {cpu:>5}  {host_memory:>8} {time:>8}  {gpu_memory:>8}  {sm:>3}  {command:<}'.format
+        print(colored(fmt(pid='PID', username='USERNAME',
+                          cpu='CPU%', host_memory='HOST-MEM', time='TIME',
+                          gpu_memory='GPU-MEM', sm='SM%',
+                          command='COMMAND'),
+                      attrs=('bold',)))
+        for snapshot in processes:
+            print(fmt(pid=snapshot.pid,
+                      username=snapshot.username[:7] + ('+' if len(snapshot.username) > 8 else snapshot.username[7:8]),
+                      cpu=snapshot.cpu_percent, host_memory=snapshot.host_memory_human,
+                      time=snapshot.running_time_human,
+                      gpu_memory=(snapshot.gpu_memory_human if snapshot.gpu_memory_human is not NA else 'WDDM:N/A'),
+                      sm=snapshot.gpu_sm_utilization,
+                      command=snapshot.command))
+    else:
+        print(colored('  - No Running Processes', attrs=('bold',)))
+
+    if separator:
+        print('-' * 120)
+    separator = True
+```
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/177041142-fe988d58-6a97-4559-84fd-b51204cf9231.png" alt="Demo">
+  <br/>
+  An example monitoring script built with APIs from <code>nvitop</code>.
+</p>
+
+------
+
+#### Status Snapshot
+
+`nvitop` provides a helper function [`take_snapshots`](https://nvitop.readthedocs.io/en/latest/api/collector.html#nvitop.take_snapshots) to retrieve the status of both GPU devices and GPU processes at once. You can type `help(nvitop.take_snapshots)` in Python REPL for detailed documentation.
+
+```python
+In [1]: from nvitop import take_snapshots, Device
+   ...: import os
+   ...: os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
+   ...: os.environ['CUDA_VISIBLE_DEVICES'] = '1,0'  # comma-separated integers or UUID strings
+
+In [2]: take_snapshots()  # equivalent to `take_snapshots(Device.all())`
+Out[2]:
+SnapshotResult(
+    devices=[
+        DeviceSnapshot(
+            real=Device(index=0, ...),
+            ...
+        ),
+        ...
+    ],
+    gpu_processes=[
+        GpuProcessSnapshot(
+            real=GpuProcess(pid=xxxxxx, device=Device(index=0, ...), ...),
+            ...
+        ),
+        ...
+    ]
+)
+
+In [3]: device_snapshots, gpu_process_snapshots = take_snapshots(Device.all())  # type: Tuple[List[DeviceSnapshot], List[GpuProcessSnapshot]]
+
+In [4]: device_snapshots, _ = take_snapshots(gpu_processes=False)  # ignore process snapshots
+
+In [5]: take_snapshots(Device.cuda.all())  # use CUDA device enumeration
+Out[5]:
+SnapshotResult(
+    devices=[
+        CudaDeviceSnapshot(
+            real=CudaDevice(cuda_index=0, nvml_index=1, ...),
+            ...
+        ),
+        CudaDeviceSnapshot(
+            real=CudaDevice(cuda_index=1, nvml_index=0, ...),
+            ...
+        ),
+    ],
+    gpu_processes=[
+        GpuProcessSnapshot(
+            real=GpuProcess(pid=xxxxxx, device=CudaDevice(cuda_index=0, ...), ...),
+            ...
+        ),
+        ...
+    ]
+)
+
+In [6]: take_snapshots(Device.cuda(1))  # <CUDA 1> only
+Out[6]:
+SnapshotResult(
+    devices=[
+        CudaDeviceSnapshot(
+            real=CudaDevice(cuda_index=1, nvml_index=0, ...),
+            ...
+        )
+    ],
+    gpu_processes=[
+        GpuProcessSnapshot(
+            real=GpuProcess(pid=xxxxxx, device=CudaDevice(cuda_index=1, ...), ...),
+            ...
+        ),
+        ...
+    ]
+)
+```
+
+Please refer to section [Low-level APIs](#low-level-apis) for more information.
+
+------
+
+#### Resource Metric Collector
+
+[`ResourceMetricCollector`](https://nvitop.readthedocs.io/en/latest/api/collector.html#nvitop.ResourceMetricCollector) is a class that collects resource metrics for host, GPUs and processes running on the GPUs. All metrics will be collected in an asynchronous manner. You can type `help(nvitop.ResourceMetricCollector)` in Python REPL for detailed documentation.
+
+```python
+In [1]: from nvitop import ResourceMetricCollector, Device
+   ...: import os
+   ...: os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
+   ...: os.environ['CUDA_VISIBLE_DEVICES'] = '3,2,1,0'  # comma-separated integers or UUID strings
+
+In [2]: collector = ResourceMetricCollector()                                   # log all devices and descendant processes of the current process on the GPUs
+In [3]: collector = ResourceMetricCollector(root_pids={1})                      # log all devices and all GPU processes
+In [4]: collector = ResourceMetricCollector(devices=Device(0), root_pids={1})   # log <GPU 0> and all GPU processes on <GPU 0>
+In [5]: collector = ResourceMetricCollector(devices=Device.cuda.all())          # use the CUDA ordinal
+
+In [6]: with collector(tag='<tag>'):
+   ...:     # Do something
+   ...:     collector.collect()  # -> Dict[str, float]
+# key -> '<tag>/<scope>/<metric (unit)>/<mean/min/max>'
+{
+    '<tag>/host/cpu_percent (%)/mean': 8.967849777683456,
+    '<tag>/host/cpu_percent (%)/min': 6.1,
+    '<tag>/host/cpu_percent (%)/max': 28.1,
+    ...,
+    '<tag>/host/memory_percent (%)/mean': 21.5,
+    '<tag>/host/swap_percent (%)/mean': 0.3,
+    '<tag>/host/memory_used (GiB)/mean': 91.0136418208109,
+    '<tag>/host/load_average (%) (1 min)/mean': 10.251427386878328,
+    '<tag>/host/load_average (%) (5 min)/mean': 10.072539414569503,
+    '<tag>/host/load_average (%) (15 min)/mean': 11.91126970422139,
+    ...,
+    '<tag>/cuda:0 (gpu:3)/memory_used (MiB)/mean': 3.875,
+    '<tag>/cuda:0 (gpu:3)/memory_free (MiB)/mean': 11015.562499999998,
+    '<tag>/cuda:0 (gpu:3)/memory_total (MiB)/mean': 11019.437500000002,
+    '<tag>/cuda:0 (gpu:3)/memory_percent (%)/mean': 0.0,
+    '<tag>/cuda:0 (gpu:3)/gpu_utilization (%)/mean': 0.0,
+    '<tag>/cuda:0 (gpu:3)/memory_utilization (%)/mean': 0.0,
+    '<tag>/cuda:0 (gpu:3)/fan_speed (%)/mean': 22.0,
+    '<tag>/cuda:0 (gpu:3)/temperature (C)/mean': 25.0,
+    '<tag>/cuda:0 (gpu:3)/power_usage (W)/mean': 19.11166264116916,
+    ...,
+    '<tag>/cuda:1 (gpu:2)/memory_used (MiB)/mean': 8878.875,
+    ...,
+    '<tag>/cuda:2 (gpu:1)/memory_used (MiB)/mean': 8182.875,
+    ...,
+    '<tag>/cuda:3 (gpu:0)/memory_used (MiB)/mean': 9286.875,
+    ...,
+    '<tag>/pid:12345/host/cpu_percent (%)/mean': 151.34342772112265,
+    '<tag>/pid:12345/host/host_memory (MiB)/mean': 44749.72373447514,
+    '<tag>/pid:12345/host/host_memory_percent (%)/mean': 8.675082352111717,
+    '<tag>/pid:12345/host/running_time (min)': 336.23803206741576,
+    '<tag>/pid:12345/cuda:1 (gpu:4)/gpu_memory (MiB)/mean': 8861.0,
+    '<tag>/pid:12345/cuda:1 (gpu:4)/gpu_memory_percent (%)/mean': 80.4,
+    '<tag>/pid:12345/cuda:1 (gpu:4)/gpu_memory_utilization (%)/mean': 6.711118172407917,
+    '<tag>/pid:12345/cuda:1 (gpu:4)/gpu_sm_utilization (%)/mean': 48.23283397736476,
+    ...,
+    '<tag>/duration (s)': 7.247399162035435,
+    '<tag>/timestamp': 1655909466.9981883
+}
+```
+
+The results can be easily logged into [TensorBoard](https://github.com/tensorflow/tensorboard) or a CSV file. For example:
+
+```python
+import os
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.tensorboard import SummaryWriter
+
+from nvitop import CudaDevice, ResourceMetricCollector
+from nvitop.callbacks.tensorboard import add_scalar_dict
+
+# Build networks and prepare datasets
+...
+
+# Logger and status collector
+writer = SummaryWriter()
+collector = ResourceMetricCollector(devices=CudaDevice.all(),  # log all visible CUDA devices and use the CUDA ordinal
+                                    root_pids={os.getpid()},   # only log the descendant processes of the current process
+                                    interval=1.0)              # snapshot interval for background daemon thread
+
+# Start training
+global_step = 0
+for epoch in range(num_epoch):
+    with collector(tag='train'):
+        for batch in train_dataset:
+            with collector(tag='batch'):
+                metrics = train(net, batch)
+                global_step += 1
+                add_scalar_dict(writer, 'train', metrics, global_step=global_step)
+                add_scalar_dict(writer, 'resources',      # tag='resources/train/batch/...'
+                                collector.collect(),
+                                global_step=global_step)
+
+        add_scalar_dict(writer, 'resources',              # tag='resources/train/...'
+                        collector.collect(),
+                        global_step=epoch)
+
+    with collector(tag='validate'):
+        metrics = validate(net, validation_dataset)
+        add_scalar_dict(writer, 'validate', metrics, global_step=epoch)
+        add_scalar_dict(writer, 'resources',              # tag='resources/validate/...'
+                        collector.collect(),
+                        global_step=epoch)
+```
+
+Another example for logging into a CSV file:
+
+```python
+import datetime
+import time
+
+import pandas as pd
+
+from nvitop import ResourceMetricCollector
+
+collector = ResourceMetricCollector(root_pids={1}, interval=2.0)  # log all devices and all GPU processes
+df = pd.DataFrame()
+
+with collector(tag='resources'):
+    for _ in range(60):
+        # Do something
+        time.sleep(60)
+
+        metrics = collector.collect()
+        df_metrics = pd.DataFrame.from_records(metrics, index=[len(df)])
+        df = pd.concat([df, df_metrics], ignore_index=True)
+        # Flush to CSV file ...
+
+df.insert(0, 'time', df['resources/timestamp'].map(datetime.datetime.fromtimestamp))
+df.to_csv('results.csv', index=False)
+```
+
+You can also daemonize the collector in the background using [`collect_in_background`](https://nvitop.readthedocs.io/en/latest/api/collector.html#nvitop.collect_in_background) or [`ResourceMetricCollector.daemonize`](https://nvitop.readthedocs.io/en/latest/api/collector.html#nvitop.ResourceMetricCollector.daemonize) with callback functions.
+
+```python
+from nvitop import Device, ResourceMetricCollector, collect_in_background
+
+logger = ...
+
+def on_collect(metrics):  # will be called periodically
+    if logger.is_closed():  # closed manually by user
+        return False
+    logger.log(metrics)
+    return True
+
+def on_stop(collector):  # will be called only once at stop
+    if not logger.is_closed():
+        logger.close()  # cleanup
+
+# Record metrics to the logger in the background every 5 seconds.
+# It will collect 5-second mean/min/max for each metric.
+collect_in_background(
+    on_collect,
+    ResourceMetricCollector(Device.cuda.all()),
+    interval=5.0,
+    on_stop=on_stop,
+)
+```
+
+or simply:
+
+```python
+ResourceMetricCollector(Device.cuda.all()).daemonize(
+    on_collect,
+    interval=5.0,
+    on_stop=on_stop,
+)
+```
+
+------
+
+#### Low-level APIs
+
+The full API references can be found at <https://nvitop.readthedocs.io>.
+
+##### Device
+
+The [device module](https://nvitop.readthedocs.io/en/latest/api/device.html) provides:
+
+<table class="autosummary longtable docutils align-default">
+  <colgroup>
+    <col style="width: 10%" />
+    <col style="width: 90%" />
+  </colgroup>
+  <tbody>
+    <tr class="row-odd">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/device.html#nvitop.Device" title="nvitop.Device"><code class="xref py py-obj docutils literal notranslate"><span class="pre">Device</span></code></a>([index, uuid, bus_id])</p></td>
+      <td><p>Live class of the GPU devices, different from the device snapshots.</p></td>
+    </tr>
+    <tr class="row-even">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/device.html#nvitop.PhysicalDevice" title="nvitop.PhysicalDevice"><code class="xref py py-obj docutils literal notranslate"><span class="pre">PhysicalDevice</span></code></a>([index, uuid, bus_id])</p></td>
+      <td><p>Class for physical devices.</p></td>
+    </tr>
+    <tr class="row-odd">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/device.html#nvitop.MigDevice" title="nvitop.MigDevice"><code class="xref py py-obj docutils literal notranslate"><span class="pre">MigDevice</span></code></a>([index, uuid, bus_id])</p></td>
+      <td><p>Class for MIG devices.</p></td>
+    </tr>
+    <tr class="row-even">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/device.html#nvitop.CudaDevice" title="nvitop.CudaDevice"><code class="xref py py-obj docutils literal notranslate"><span class="pre">CudaDevice</span></code></a>([cuda_index, nvml_index, uuid])</p></td>
+      <td><p>Class for devices enumerated over the CUDA ordinal.</p></td>
+    </tr>
+    <tr class="row-odd">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/device.html#nvitop.CudaMigDevice" title="nvitop.CudaMigDevice"><code class="xref py py-obj docutils literal notranslate"><span class="pre">CudaMigDevice</span></code></a>([cuda_index, nvml_index, uuid])</p></td>
+      <td><p>Class for CUDA devices that are MIG devices.</p></td>
+    </tr>
+    <tr class="row-even">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/device.html#nvitop.parse_cuda_visible_devices" title="nvitop.parse_cuda_visible_devices"><code class="xref py py-obj docutils literal notranslate"><span class="pre">parse_cuda_visible_devices</span></code></a>([...])</p></td>
+      <td><p>Parse the given <code class="docutils literal notranslate"><span class="pre">CUDA_VISIBLE_DEVICES</span></code> value into a list of NVML device indices.</p></td>
+    </tr>
+    <tr class="row-odd">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/device.html#nvitop.normalize_cuda_visible_devices" title="nvitop.normalize_cuda_visible_devices"><code class="xref py py-obj docutils literal notranslate"><span class="pre">normalize_cuda_visible_devices</span></code></a>([...])</p></td>
+      <td><p>Parse the given <code class="docutils literal notranslate"><span class="pre">CUDA_VISIBLE_DEVICES</span></code> value and convert it into a comma-separated string of UUIDs.</p></td>
+    </tr>
+  </tbody>
+</table>
+
+```python
+In [1]: from nvitop import (
+   ...:     host,
+   ...:     Device, PhysicalDevice, CudaDevice,
+   ...:     parse_cuda_visible_devices, normalize_cuda_visible_devices
+   ...:     HostProcess, GpuProcess,
+   ...:     NA,
+   ...: )
+   ...: import os
+   ...: os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
+   ...: os.environ['CUDA_VISIBLE_DEVICES'] = '9,8,7,6'  # comma-separated integers or UUID strings
+
+In [2]: Device.driver_version()
+Out[2]: '525.60.11'
+
+In [3]: Device.cuda_driver_version()  # the maximum CUDA version supported by the driver (can be different from the CUDA Runtime version)
+Out[3]: '12.0'
+
+In [4]: Device.cuda_runtime_version()  # the CUDA Runtime version
+Out[4]: '11.8'
+
+In [5]: Device.count()
+Out[5]: 10
+
+In [6]: CudaDevice.count()  # or `Device.cuda.count()`
+Out[6]: 4
+
+In [7]: all_devices      = Device.all()                 # all devices on board (physical device)
+   ...: nvidia0, nvidia1 = Device.from_indices([0, 1])  # from physical device indices
+   ...: all_devices
+Out[7]: [
+    PhysicalDevice(index=0, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=1, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=2, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=3, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=4, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=5, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=6, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=7, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=8, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    PhysicalDevice(index=9, name="GeForce RTX 2080 Ti", total_memory=11019MiB)
+]
+
+In [8]: # NOTE: The function results might be different between calls when the `CUDA_VISIBLE_DEVICES` environment variable has been modified
+   ...: cuda_visible_devices = Device.from_cuda_visible_devices()  # from the `CUDA_VISIBLE_DEVICES` environment variable
+   ...: cuda0, cuda1         = Device.from_cuda_indices([0, 1])    # from CUDA device indices (might be different from physical device indices if `CUDA_VISIBLE_DEVICES` is set)
+   ...: cuda_visible_devices = CudaDevice.all()                    # shortcut to `Device.from_cuda_visible_devices()`
+   ...: cuda_visible_devices = Device.cuda.all()                   # `Device.cuda` is aliased to `CudaDevice`
+   ...: cuda_visible_devices
+Out[8]: [
+    CudaDevice(cuda_index=0, nvml_index=9, name="NVIDIA GeForce RTX 2080 Ti", total_memory=11019MiB),
+    CudaDevice(cuda_index=1, nvml_index=8, name="NVIDIA GeForce RTX 2080 Ti", total_memory=11019MiB),
+    CudaDevice(cuda_index=2, nvml_index=7, name="NVIDIA GeForce RTX 2080 Ti", total_memory=11019MiB),
+    CudaDevice(cuda_index=3, nvml_index=6, name="NVIDIA GeForce RTX 2080 Ti", total_memory=11019MiB)
+]
+
+In [9]: nvidia0 = Device(0)  # from device index (or `Device(index=0)`)
+   ...: nvidia0
+Out[9]: PhysicalDevice(index=0, name="GeForce RTX 2080 Ti", total_memory=11019MiB)
+
+In [10]: nvidia1 = Device(uuid='GPU-01234567-89ab-cdef-0123-456789abcdef')  # from UUID string (or just `Device('GPU-xxxxxxxx-...')`)
+    ...: nvidia2 = Device(bus_id='00000000:06:00.0')                        # from PCI bus ID
+    ...: nvidia1
+Out[10]: PhysicalDevice(index=1, name="GeForce RTX 2080 Ti", total_memory=11019MiB)
+
+In [11]: cuda0 = CudaDevice(0)                        # from CUDA device index (equivalent to `CudaDevice(cuda_index=0)`)
+    ...: cuda1 = CudaDevice(nvml_index=8)             # from physical device index
+    ...: cuda3 = CudaDevice(uuid='GPU-xxxxxxxx-...')  # from UUID string
+    ...: cuda4 = Device.cuda(4)                       # `Device.cuda` is aliased to `CudaDevice`
+    ...: cuda0
+Out[11]:
+CudaDevice(cuda_index=0, nvml_index=9, name="NVIDIA GeForce RTX 2080 Ti", total_memory=11019MiB)
+
+In [12]: nvidia0.memory_used()  # in bytes
+Out[12]: 9293398016
+
+In [13]: nvidia0.memory_used_human()
+Out[13]: '8862MiB'
+
+In [14]: nvidia0.gpu_utilization()  # in percentage
+Out[14]: 5
+
+In [15]: nvidia0.processes()  # type: Dict[int, GpuProcess]
+Out[15]: {
+    52059: GpuProcess(pid=52059, gpu_memory=7885MiB, type=C, device=PhysicalDevice(index=0, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=52059, name='ipython3', status='sleeping', started='14:31:22')),
+    53002: GpuProcess(pid=53002, gpu_memory=967MiB, type=C, device=PhysicalDevice(index=0, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=53002, name='python', status='running', started='14:31:59'))
+}
+
+In [16]: nvidia1_snapshot = nvidia1.as_snapshot()
+    ...: nvidia1_snapshot
+Out[16]: PhysicalDeviceSnapshot(
+    real=PhysicalDevice(index=1, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    bus_id='00000000:05:00.0',
+    compute_mode='Default',
+    clock_infos=ClockInfos(graphics=1815, sm=1815, memory=6800, video=1680),  # in MHz
+    clock_speed_infos=ClockSpeedInfos(current=ClockInfos(graphics=1815, sm=1815, memory=6800, video=1680), max=ClockInfos(graphics=2100, sm=2100, memory=7000, video=1950)),  # in MHz
+    cuda_compute_capability=(7, 5),
+    current_driver_model='N/A',
+    decoder_utilization=0,              # in percentage
+    display_active='Disabled',
+    display_mode='Disabled',
+    encoder_utilization=0,              # in percentage
+    fan_speed=22,                       # in percentage
+    gpu_utilization=17,                 # in percentage (NOTE: this is the utilization rate of SMs, i.e. GPU percent)
+    index=1,
+    max_clock_infos=ClockInfos(graphics=2100, sm=2100, memory=7000, video=1950),  # in MHz
+    memory_clock=6800,                  # in MHz
+    memory_free=10462232576,            # in bytes
+    memory_free_human='9977MiB',
+    memory_info=MemoryInfo(total=11554717696, free=10462232576, used=1092485120)  # in bytes
+    memory_percent=9.5,                 # in percentage (NOTE: this is the percentage of used GPU memory)
+    memory_total=11554717696,           # in bytes
+    memory_total_human='11019MiB',
+    memory_usage='1041MiB / 11019MiB',
+    memory_used=1092485120,             # in bytes
+    memory_used_human='1041MiB',
+    memory_utilization=7,               # in percentage (NOTE: this is the utilization rate of GPU memory bandwidth)
+    mig_mode='N/A',
+    name='GeForce RTX 2080 Ti',
+    pcie_rx_throughput=1000,            # in KiB/s
+    pcie_rx_throughput_human='1000KiB/s',
+    pcie_throughput=ThroughputInfo(tx=1000, rx=1000),  # in KiB/s
+    pcie_tx_throughput=1000,            # in KiB/s
+    pcie_tx_throughput_human='1000KiB/s',
+    performance_state='P2',
+    persistence_mode='Disabled',
+    power_limit=250000,                 # in milliwatts (mW)
+    power_status='66W / 250W',          # in watts (W)
+    power_usage=66051,                  # in milliwatts (mW)
+    sm_clock=1815,                      # in MHz
+    temperature=39,                     # in Celsius
+    total_volatile_uncorrected_ecc_errors='N/A',
+    utilization_rates=UtilizationRates(gpu=17, memory=7, encoder=0, decoder=0),  # in percentage
+    uuid='GPU-01234567-89ab-cdef-0123-456789abcdef',
+)
+
+In [17]: nvidia1_snapshot.memory_percent  # snapshot uses properties instead of function calls
+Out[17]: 9.5
+
+In [18]: nvidia1_snapshot['memory_info']  # snapshot also supports `__getitem__` by string
+Out[18]: MemoryInfo(total=11554717696, free=10462232576, used=1092485120)
+
+In [19]: nvidia1_snapshot.bar1_memory_info  # snapshot will automatically retrieve not presented attributes from `real`
+Out[19]: MemoryInfo(total=268435456, free=257622016, used=10813440)
+```
+
+**NOTE:** Some entry values may be `'N/A'` (type: [`NaType`](https://nvitop.readthedocs.io/en/latest/index.html#nvitop.NaType), a subclass of `str`) when the corresponding resources are not applicable. The [`NA`](https://nvitop.readthedocs.io/en/latest/index.html#nvitop.NA) value supports arithmetic operations. It acts like `math.nan: float`.
+
+```python
+>>> from nvitop import NA
+>>> NA
+'N/A'
+
+>>> 'memory usage: {}'.format(NA)  # NA is an instance of `str`
+'memory usage: N/A'
+>>> NA.lower()                     # NA is an instance of `str`
+'n/a'
+>>> NA.ljust(5)                    # NA is an instance of `str`
+'N/A  '
+>>> NA + 'str'                     # string contamination if the operand is a string
+'N/Astr'
+
+>>> float(NA)                      # explicit conversion to float (`math.nan`)
+nan
+>>> NA + 1                         # auto-casting to float if the operand is a number
+nan
+>>> NA * 1024                      # auto-casting to float if the operand is a number
+nan
+>>> NA / (1024 * 1024)             # auto-casting to float if the operand is a number
+nan
+```
+
+You can use `entry != 'N/A'` conditions to avoid exceptions. It's safe to use `float(entry)` for numbers while `NaType` will be converted to `math.nan`. For example:
+
+```python
+memory_used: Union[int, NaType] = device.memory_used()            # memory usage in bytes or `'N/A'`
+memory_used_in_mib: float       = float(memory_used) / (1 << 20)  # memory usage in Mebibytes (MiB) or `math.nan`
+```
+
+It's safe to compare `NaType` with numbers, but `NaType` is always larger than any number:
+
+```python
+devices_by_used_memory = sorted(Device.all(), key=Device.memory_used, reverse=True)  # it's safe to compare `'N/A'` with numbers
+devices_by_free_memory = sorted(Device.all(), key=Device.memory_free, reverse=True)  # please add `memory_free != 'N/A'` checks if sort in descending order here
+```
+
+See [`nvitop.NaType`](https://nvitop.readthedocs.io/en/latest/apis/index.html#nvitop.NaType) documentation for more details.
+
+##### Process
+
+The [process module](https://nvitop.readthedocs.io/en/latest/api/process.html) provides:
+
+<table class="autosummary longtable docutils align-default">
+  <colgroup>
+    <col style="width: 10%" />
+    <col style="width: 90%" />
+  </colgroup>
+  <tbody>
+    <tr class="row-odd">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/process.html#nvitop.HostProcess" title="nvitop.HostProcess"><code class="xref py py-obj docutils literal notranslate"><span class="pre">HostProcess</span></code></a>([pid])</p></td>
+      <td><p>Represents an OS process with the given PID.</p></td>
+    </tr>
+    <tr class="row-even">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/process.html#nvitop.GpuProcess" title="nvitop.GpuProcess"><code class="xref py py-obj docutils literal notranslate"><span class="pre">GpuProcess</span></code></a>(pid, device[, gpu_memory, ...])</p></td>
+      <td><p>Represents a process with the given PID running on the given GPU device.</p></td>
+    </tr>
+    <tr class="row-odd">
+      <td><p><a href="https://nvitop.readthedocs.io/en/latest/api/process.html#nvitop.command_join" title="nvitop.command_join"><code class="xref py py-obj docutils literal notranslate"><span class="pre">command_join</span></code></a>(cmdline)</p></td>
+      <td><p>Returns a shell-escaped string from command line arguments.</p></td>
+    </tr>
+  </tbody>
+</table>
+
+```python
+In [20]: processes = nvidia1.processes()  # type: Dict[int, GpuProcess]
+    ...: processes
+Out[20]: {
+    23266: GpuProcess(pid=23266, gpu_memory=1031MiB, type=C, device=Device(index=1, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=23266, name='python3', status='running', started='2021-05-10 21:02:40'))
+}
+
+In [21]: process = processes[23266]
+    ...: process
+Out[21]: GpuProcess(pid=23266, gpu_memory=1031MiB, type=C, device=Device(index=1, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=23266, name='python3', status='running', started='2021-05-10 21:02:40'))
+
+In [22]: process.status()  # GpuProcess will automatically inherit attributes from GpuProcess.host
+Out[22]: 'running'
+
+In [23]: process.cmdline()  # type: List[str]
+Out[23]: ['python3', 'rllib_train.py']
+
+In [24]: process.command()  # type: str
+Out[24]: 'python3 rllib_train.py'
+
+In [25]: process.cwd()  # GpuProcess will automatically inherit attributes from GpuProcess.host
+Out[25]: '/home/xxxxxx/Projects/xxxxxx'
+
+In [26]: process.gpu_memory_human()
+Out[26]: '1031MiB'
+
+In [27]: process.as_snapshot()
+Out[27]: GpuProcessSnapshot(
+    real=GpuProcess(pid=23266, gpu_memory=1031MiB, type=C, device=PhysicalDevice(index=1, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=23266, name='python3', status='running', started='2021-05-10 21:02:40')),
+    cmdline=['python3', 'rllib_train.py'],
+    command='python3 rllib_train.py',
+    compute_instance_id='N/A',
+    cpu_percent=98.5,                       # in percentage
+    device=PhysicalDevice(index=1, name="GeForce RTX 2080 Ti", total_memory=11019MiB),
+    gpu_encoder_utilization=0,              # in percentage
+    gpu_decoder_utilization=0,              # in percentage
+    gpu_instance_id='N/A',
+    gpu_memory=1081081856,                  # in bytes
+    gpu_memory_human='1031MiB',
+    gpu_memory_percent=9.4,                 # in percentage (NOTE: this is the percentage of used GPU memory)
+    gpu_memory_utilization=5,               # in percentage (NOTE: this is the utilization rate of GPU memory bandwidth)
+    gpu_sm_utilization=0,                   # in percentage (NOTE: this is the utilization rate of SMs, i.e. GPU percent)
+    host=HostProcessSnapshot(
+        real=HostProcess(pid=23266, name='python3', status='running', started='2021-05-10 21:02:40'),
+        cmdline=['python3', 'rllib_train.py'],
+        command='python3 rllib_train.py',
+        cpu_percent=98.5,                   # in percentage
+        host_memory=9113627439,             # in bytes
+        host_memory_human='8691MiB',
+        is_running=True,
+        memory_percent=1.6849018430285683,  # in percentage
+        name='python3',
+        running_time=datetime.timedelta(days=1, seconds=80013, microseconds=470024),
+        running_time_human='46:13:33',
+        running_time_in_seconds=166413.470024,
+        status='running',
+        username='panxuehai',
+    ),
+    host_memory=9113627439,                 # in bytes
+    host_memory_human='8691MiB',
+    is_running=True,
+    memory_percent=1.6849018430285683,      # in percentage (NOTE: this is the percentage of used host memory)
+    name='python3',
+    pid=23266,
+    running_time=datetime.timedelta(days=1, seconds=80013, microseconds=470024),
+    running_time_human='46:13:33',
+    running_time_in_seconds=166413.470024,
+    status='running',
+    type='C',                               # 'C' for Compute / 'G' for Graphics / 'C+G' for Both
+    username='panxuehai',
+)
+
+In [28]: process.uids()  # GpuProcess will automatically inherit attributes from GpuProcess.host
+Out[28]: puids(real=1001, effective=1001, saved=1001)
+
+In [29]: process.kill()  # GpuProcess will automatically inherit attributes from GpuProcess.host
+
+In [30]: list(map(Device.processes, all_devices))  # all processes
+Out[30]: [
+    {
+        52059: GpuProcess(pid=52059, gpu_memory=7885MiB, type=C, device=PhysicalDevice(index=0, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=52059, name='ipython3', status='sleeping', started='14:31:22')),
+        53002: GpuProcess(pid=53002, gpu_memory=967MiB, type=C, device=PhysicalDevice(index=0, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=53002, name='python', status='running', started='14:31:59'))
+    },
+    {},
+    {},
+    {},
+    {},
+    {},
+    {},
+    {},
+    {
+        84748: GpuProcess(pid=84748, gpu_memory=8975MiB, type=C, device=PhysicalDevice(index=8, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=84748, name='python', status='running', started='11:13:38'))
+    },
+    {
+        84748: GpuProcess(pid=84748, gpu_memory=8341MiB, type=C, device=PhysicalDevice(index=9, name="GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=84748, name='python', status='running', started='11:13:38'))
+    }
+]
+
+In [31]: this = HostProcess(os.getpid())
+    ...: this
+Out[31]: HostProcess(pid=35783, name='python', status='running', started='19:19:00')
+
+In [32]: this.cmdline()  # type: List[str]
+Out[32]: ['python', '-c', 'import IPython; IPython.terminal.ipapp.launch_new_instance()']
+
+In [33]: this.command()  # not simply `' '.join(cmdline)` but quotes are added
+Out[33]: 'python -c "import IPython; IPython.terminal.ipapp.launch_new_instance()"'
+
+In [34]: this.memory_info()
+Out[34]: pmem(rss=83988480, vms=343543808, shared=12079104, text=8192, lib=0, data=297435136, dirty=0)
+
+In [35]: import cupy as cp
+    ...: x = cp.zeros((10000, 1000))
+    ...: this = GpuProcess(os.getpid(), cuda0)  # construct from `GpuProcess(pid, device)` explicitly rather than calling `device.processes()`
+    ...: this
+Out[35]: GpuProcess(pid=35783, gpu_memory=N/A, type=N/A, device=CudaDevice(cuda_index=0, nvml_index=9, name="NVIDIA GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=35783, name='python', status='running', started='19:19:00'))
+
+In [36]: this.update_gpu_status()  # update used GPU memory from new driver queries
+Out[36]: 267386880
+
+In [37]: this
+Out[37]: GpuProcess(pid=35783, gpu_memory=255MiB, type=C, device=CudaDevice(cuda_index=0, nvml_index=9, name="NVIDIA GeForce RTX 2080 Ti", total_memory=11019MiB), host=HostProcess(pid=35783, name='python', status='running', started='19:19:00'))
+
+In [38]: id(this) == id(GpuProcess(os.getpid(), cuda0))  # IMPORTANT: the instance will be reused while the process is running
+Out[38]: True
+```
+
+##### Host (inherited from [psutil](https://github.com/giampaolo/psutil))
+
+```python
+In [39]: host.cpu_count()
+Out[39]: 88
+
+In [40]: host.cpu_percent()
+Out[40]: 18.5
+
+In [41]: host.cpu_times()
+Out[41]: scputimes(user=2346377.62, nice=53321.44, system=579177.52, idle=10323719.85, iowait=28750.22, irq=0.0, softirq=11566.87, steal=0.0, guest=0.0, guest_nice=0.0)
+
+In [42]: host.load_average()
+Out[42]: (14.88, 17.8, 19.91)
+
+In [43]: host.virtual_memory()
+Out[43]: svmem(total=270352478208, available=192275968000, percent=28.9, used=53350518784, free=88924037120, active=125081112576, inactive=44803993600, buffers=37006450688, cached=91071471616, shared=23820632064, slab=8200687616)
+
+In [44]: host.memory_percent()
+Out[44]: 28.9
+
+In [45]: host.swap_memory()
+Out[45]: sswap(total=65534947328, used=475136, free=65534472192, percent=0.0, sin=2404139008, sout=4259434496)
+
+In [46]: host.swap_percent()
+Out[46]: 0.0
+```
+
+------
+
+## Screenshots
+
+![Screen Recording](https://user-images.githubusercontent.com/16078332/113173772-508dc380-927c-11eb-84c5-b6f496e54c08.gif)
+
+Example output of `nvitop -1`:
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/117765250-41793880-b260-11eb-8a1b-9c32868a46d4.png" alt="Screenshot">
+</p>
+
+Example output of `nvitop`:
+
+<table>
+  <tr valign="center" align="center">
+    <td>Full</td>
+    <td>Compact</td>
+  </tr>
+  <tr valign="top" align="center">
+    <td><img src="https://user-images.githubusercontent.com/16078332/117765260-4342fc00-b260-11eb-9198-7bcfdd1db113.png" alt="Full"></td>
+    <td><img src="https://user-images.githubusercontent.com/16078332/117765274-476f1980-b260-11eb-9afd-877cca54e0bc.png" alt="Compact"></td>
+  </tr>
+</table>
+
+Tree-view screen (shortcut: <kbd>t</kbd>) for GPU processes and their ancestors:
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/123914889-7b3e0400-d9b2-11eb-9b71-a48971617c2a.png" alt="Tree-view">
+</p>
+
+**NOTE:** The process tree is built in backward order (recursively back to the tree root). Only GPU processes along with their children and ancestors (parents and grandparents ...) will be shown. Not all running processes will be displayed.
+
+Environment variable screen (shortcut: <kbd>e</kbd>):
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/123914881-7a0cd700-d9b2-11eb-8da1-26f7a3a7c2b6.png" alt="Environment Screen">
+</p>
+
+Spectrum-like bar charts (with option <code>--colorful</code>):
+
+<p align="center">
+  <img width="100%" src="https://user-images.githubusercontent.com/16078332/182555606-8388e5a5-43a9-4990-90d4-46e45ac448a0.png" alt="Spectrum-like Bar Charts">
+  <br/>
+</p>
+
+------
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/XuehaiPan/nvitop/blob/HEAD/CHANGELOG.md).
+
+------
+
+## License
+
+The source code of `nvitop` is dual-licensed by the **Apache License, Version 2.0 (Apache-2.0)** and **GNU General Public License, Version 3 (GPL-3.0)**. The `nvitop` CLI is released under the **GPL-3.0** license while the remaining part of `nvitop` is released under the **Apache-2.0** license. The license files can be found at [LICENSE](https://github.com/XuehaiPan/nvitop/blob/HEAD/LICENSE) (Apache-2.0) and [COPYING](https://github.com/XuehaiPan/nvitop/blob/HEAD/COPYING) (GPL-3.0).
+
+The source code is organized as:
+
+```text
+nvitop           (GPL-3.0)
+├── __init__.py  (Apache-2.0)
+├── version.py   (Apache-2.0)
+├── api          (Apache-2.0)
+│   ├── LICENSE  (Apache-2.0)
+│   └── *        (Apache-2.0)
+├── callbacks    (Apache-2.0)
+│   ├── LICENSE  (Apache-2.0)
+│   └── *        (Apache-2.0)
+├── select.py    (Apache-2.0)
+├── __main__.py  (GPL-3.0)
+├── cli.py       (GPL-3.0)
+└── tui          (GPL-3.0)
+    ├── COPYING  (GPL-3.0)
+    └── *        (GPL-3.0)
+```
+
+### Copyright Notice
+
+Please feel free to use `nvitop` as a dependency for your own projects. The following Python import statements are permitted:
+
+```python
+import nvitop
+import nvitop as alias
+import nvitop.api as api
+import nvitop.device as device
+from nvitop import *
+from nvitop.api import *
+from nvitop import Device, ResourceMetricCollector
+```
+
+The public APIs from `nvitop` are released under the **Apache License, Version 2.0 (Apache-2.0)**. The original license files can be found at [LICENSE](https://github.com/XuehaiPan/nvitop/blob/HEAD/LICENSE), [nvitop/api/LICENSE](https://github.com/XuehaiPan/nvitop/blob/HEAD/nvitop/api/LICENSE), and [nvitop/callbacks/LICENSE](https://github.com/XuehaiPan/nvitop/blob/HEAD/nvitop/callbacks/LICENSE).
+
+The CLI of `nvitop` is released under the **GNU General Public License, Version 3 (GPL-3.0)**. The original license files can be found at [COPYING](https://github.com/XuehaiPan/nvitop/blob/HEAD/COPYING) and [nvitop/tui/COPYING](https://github.com/XuehaiPan/nvitop/blob/HEAD/nvitop/tui/COPYING). If you dynamically load the source code of `nvitop`'s CLI or TUI:
+
+```python
+from nvitop import cli
+from nvitop import tui
+import nvitop.cli
+import nvitop.tui
+```
+
+your source code should also be released under the GPL-3.0 License.
+
+If you want to add or modify some features of `nvitop`'s CLI, or copy some source code of `nvitop`'s CLI into your own code, the source code should also be released under the GPL-3.0 License (as `nvitop`  contains some modified source code from [ranger](https://github.com/ranger/ranger) under the GPL-3.0 License).

.venv/lib/python3.10/site-packages/nvitop-1.5.3.dist-info/RECORD

@@ -0,0 +1,60 @@
+../../../bin/nvisel,sha256=ijf-8eGUm2wgR1maKbrxzD5WVVw-VtMBnKCNVavcBTc,314
+../../../bin/nvitop,sha256=5tYRS4cLpLo36crEEXW-Llw8yoRcdbk6KzerjwKQrPM,311
+nvitop-1.5.3.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+nvitop-1.5.3.dist-info/METADATA,sha256=Fh-tBdjUVl1M04EPLULbh5lf4i8NuaNA6dgHSprVsjE,78404
+nvitop-1.5.3.dist-info/RECORD,,
+nvitop-1.5.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvitop-1.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvitop-1.5.3.dist-info/entry_points.txt,sha256=KapUQUNeukBIt7kA6TzIPYMZHco_zud1vK0lMXqX2Fo,71
+nvitop-1.5.3.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+nvitop-1.5.3.dist-info/licenses/LICENSE,sha256=SopLLKbMm5DzDYZ1wSDfYFuT1l0GObAHfOAUFqZ3bTg,11368
+nvitop-1.5.3.dist-info/top_level.txt,sha256=XdSN8bn0PccqPEltMgjbA9zh2r7CLNJjzL5bjZYUGgQ,7
+nvitop/__init__.py,sha256=Xl75rKpSQmZqq9err_QhlSQlg09I46D8Q2J4XgLfTwo,1668
+nvitop/__main__.py,sha256=ADFld7mUiHEQQDqxCyL8NP8_ZtVrddzeb-aVOCh7-bE,245
+nvitop/api/__init__.py,sha256=sJkqDqD60__dvuRIJ2bD2XsuAvNdh0HY8Ow_qLH7Gc4,2666
+nvitop/api/caching.py,sha256=avMtj8kDSuErcTAqP9m5jPl0aQHZVUg-1JyM0V6U1LE,10146
+nvitop/api/collector.py,sha256=7f6MH-BLPHk0zNx9lNgYHF5oncRtaHtSD-gRcU4VkPE,35465
+nvitop/api/device.py,sha256=pCt7U7w8s_AC59QxuGBfHeEhWiyn2pLGMNIjVG6tU4A,138669
+nvitop/api/host.py,sha256=YA69pvp-mMZ1hZ4Vyl54vrxY-kcPVxh9iUkiNFinTiA,4065
+nvitop/api/libcuda.py,sha256=aKt5hNOTFq9_BtOmjvu6UvVv2dbvtIFGD3O_DZBQMuc,38588
+nvitop/api/libcudart.py,sha256=z_sKG9BUQTHHDdytZE_UwC0KPWweHqoCuoum5rPdYpk,43834
+nvitop/api/libnvml.py,sha256=OJ_XGRGz9TsGXSe0Io15ezWjix6pt1YbuAYF3JGjYV4,43066
+nvitop/api/process.py,sha256=HxBzEAynpIhEih7yjEiXZxEyrpKnaexMAOuQ5jHOWkQ,40734
+nvitop/api/termcolor.py,sha256=s89ze2_E6EVVGPnN1nvYYfgOroXi8eATQ7nsotoNeIs,7856
+nvitop/api/utils.py,sha256=Ttm3wNvC2iIQoa0hNLK09zoCH3RVWoHlhLGHTImjrxM,24572
+nvitop/callbacks/__init__.py,sha256=HyQOo_3qgEq3Lpl5WvSo0ihsBFIhwzNOQH1QRaiuoLY,1051
+nvitop/callbacks/keras.py,sha256=SEOBEF2pFS-985Y1TgVgpNb6MbbusmOEM0fP9-HFNGY,7974
+nvitop/callbacks/lightning.py,sha256=1cVWo9XgYk-XN8B1E7w6TEwkfHhkk1zGay1LSjsQv1w,8202
+nvitop/callbacks/pytorch_lightning.py,sha256=Za2lllm5XkZtTYa8v3_t-Tm5bLsAn7-eIgJNAtGzvzI,8375
+nvitop/callbacks/tensorboard.py,sha256=-s5i0kW-SNihGhKNdMAvJj3dzNkFd7fJqFqRRA623cM,1863
+nvitop/callbacks/utils.py,sha256=dmTkZ53ux7CRPseTV7ApQ26LzZ0g2kTC_ruka2mWIaI,2604
+nvitop/cli.py,sha256=HQdfLQnXdwbKa4ddQA0AnYcHyKbRuP_6JnJVVhtz858,14586
+nvitop/select.py,sha256=Y7-p-Y_S9-ZGR8ffZJRElKnTdxO2e9ggATINCIDFap8,20542
+nvitop/tui/__init__.py,sha256=tOYq1itOiBwI7OIePpzkTwNxe8u-DNf3AsdyJBMk8CM,470
+nvitop/tui/library/__init__.py,sha256=u_RafwW2SESGgDRwimv1W9PDJeKuhBW7RW3EaDllnOQ,2057
+nvitop/tui/library/device.py,sha256=PwBf4IPEn7kjEJEWNC2IUZD4fQEnBXqbmQL8fZEo5C8,8221
+nvitop/tui/library/displayable.py,sha256=WnVaYT9lQqth6oaP0U_W3BZV-bpnPo0aBGaHMG91iME,9289
+nvitop/tui/library/history.py,sha256=pQx4o2SrM7gpGvdRtIovd3XwkYdkrSUIt5PaXULowIY,14235
+nvitop/tui/library/host.py,sha256=sVJMCKXM3_4ZSYQjDw3yUZfoZl7nkO0VdP6dBSHk7SA,2972
+nvitop/tui/library/keybinding.py,sha256=iPX23vOPcjoVl-m1qhJVPVJDeOBgpNB_sXNj9PWZE9E,13883
+nvitop/tui/library/libcurses.py,sha256=wxIo5lP_q30oyjBd1jYYGq07ZTsyBZKwDvcS9XnJ0WQ,10227
+nvitop/tui/library/messagebox.py,sha256=cOfAHmv56cSIr3zByWuuF1qw2ZFgsxEridqRFjdHOAQ,14732
+nvitop/tui/library/mouse.py,sha256=4BUXxFeZn1twmftJdNZuDFf7E_L6SnV_8QZmRsrJE3A,3872
+nvitop/tui/library/process.py,sha256=036Ta3d8uq-CyBV9pZVZaQ1HlIAvPmnJOGOrkYfpBEg,3950
+nvitop/tui/library/selection.py,sha256=QPDhg3v6-TVV8QWfUP9cY0vpBhQAb1HU4OZsA1dsOlQ,6030
+nvitop/tui/library/utils.py,sha256=UvOXUX23udEkO-msyhcDat6ttkMu6EMdHA71kfv42Tc,3334
+nvitop/tui/library/widestring.py,sha256=LycasKh39MulefL-BUFQWZmcIF46qPe-zM1jrHrlp4I,7818
+nvitop/tui/screens/__init__.py,sha256=2mIOd9IRjPNEXy1w-USy67Kb7jGVgyFpIfoEBi6Kf_8,677
+nvitop/tui/screens/base.py,sha256=L9IgtgA5uLMF3Cnl5hsjwWA-bTOU-okfscLJYbsGIJc,651
+nvitop/tui/screens/environ.py,sha256=E1bxcoQpMNpvrvS6QwKbXgaQbrfK32jwcWKS2e3T5qs,9404
+nvitop/tui/screens/help.py,sha256=jgEOGCQlGDmdbNUQ2hM62TcB9x7O245_jWBdJmn1VPM,4947
+nvitop/tui/screens/main/__init__.py,sha256=P0lYBIrb4yXsjpL-OXZBXN62UAycUaY8DQAZ7-AiodI,11586
+nvitop/tui/screens/main/panels/__init__.py,sha256=wmP_jqBsnagZc3wfuR1hpZ7bDHEQq8W9wpc6RAuidhQ,556
+nvitop/tui/screens/main/panels/base.py,sha256=WBpvCwC2rSazIW5YjGRY72aT4jMtA_EUo4MEkawFi6M,729
+nvitop/tui/screens/main/panels/device.py,sha256=dsayJsbM6GBZLYsZ9j5puOAj0N_KPuvIinWkwvQJ3bU,23123
+nvitop/tui/screens/main/panels/host.py,sha256=JPnqe_I7KNajmbsQe3H2J6vJuI7XhF2TEZZsg_I7dz4,17784
+nvitop/tui/screens/main/panels/process.py,sha256=aYbzN43Oi-2VwALDv8usyx5pW0NuEgFyDQLxBvwPKVs,28327
+nvitop/tui/screens/metrics.py,sha256=-bgTPqAjv00HJiq0mKCfSA2JrGigiuUbt7zvQ0j04U4,24082
+nvitop/tui/screens/treeview.py,sha256=Vr8cQGVbNU2JjJXr62Ma-LOb8U9OEW_7RqLzGZTYJdY,22552
+nvitop/tui/tui.py,sha256=xB68ceFNt9IGfEg-2ePyPIaBY-mjsQidjPNby-SNfbY,13849
+nvitop/version.py,sha256=qo2i0gZ5DfW1hp5HbF0U35Qp3Cg5ukCByIfO7xifCCg,4297

.venv/lib/python3.10/site-packages/nvitop-1.5.3.dist-info/WHEEL

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

.venv/lib/python3.10/site-packages/nvitop-1.5.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+nvisel = nvitop.select:main
+nvitop = nvitop.cli:main

.venv/lib/python3.10/site-packages/nvitop-1.5.3.dist-info/licenses/COPYING

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

.venv/lib/python3.10/site-packages/nvitop-1.5.3.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

.venv/lib/python3.10/site-packages/nvitop-1.5.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+nvitop

.venv/lib/python3.10/site-packages/nvitop/__init__.py

@@ -0,0 +1,60 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""An interactive NVIDIA-GPU process viewer and beyond, the one-stop solution for GPU process management."""
+
+import sys
+
+from nvitop import api
+from nvitop.api import *  # noqa: F403
+from nvitop.api import (
+    caching,
+    collector,
+    device,
+    host,
+    libcuda,
+    libcudart,
+    libnvml,
+    process,
+    termcolor,
+    utils,
+)
+from nvitop.select import select_devices
+from nvitop.version import __version__
+
+
+__all__ = [*api.__all__, 'select_devices']
+
+# Add submodules to the top-level namespace
+for submodule in (
+    caching,
+    collector,
+    device,
+    host,
+    libcuda,
+    libcudart,
+    libnvml,
+    process,
+    termcolor,
+    utils,
+):
+    sys.modules[f'{__name__}.{submodule.__name__.rpartition(".")[-1]}'] = submodule
+
+# Remove the nvitop.select module from sys.modules
+# Required for `python -m nvitop.select` to work properly
+sys.modules.pop(f'{__name__}.select', None)
+
+del sys

.venv/lib/python3.10/site-packages/nvitop/__main__.py

@@ -0,0 +1,12 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+# License: GNU GPL version 3.
+
+"""The interactive NVIDIA-GPU process viewer."""
+
+import sys
+
+from nvitop.cli import main
+
+
+if __name__ == '__main__':
+    sys.exit(main())

.venv/lib/python3.10/site-packages/nvitop/api/__init__.py

@@ -0,0 +1,114 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""The core APIs of nvitop."""
+
+from nvitop.api import (
+    caching,
+    collector,
+    device,
+    host,
+    libcuda,
+    libcudart,
+    libnvml,
+    process,
+    termcolor,
+    utils,
+)
+from nvitop.api.caching import ttl_cache
+from nvitop.api.collector import ResourceMetricCollector, collect_in_background, take_snapshots
+from nvitop.api.device import (
+    CudaDevice,
+    CudaMigDevice,
+    Device,
+    MigDevice,
+    PhysicalDevice,
+    normalize_cuda_visible_devices,
+    parse_cuda_visible_devices,
+)
+from nvitop.api.libnvml import NVMLError, nvmlCheckReturn
+from nvitop.api.process import GpuProcess, HostProcess, command_join
+from nvitop.api.utils import (  # explicitly export these to appease mypy
+    NA,
+    SIZE_UNITS,
+    UINT_MAX,
+    ULONGLONG_MAX,
+    GiB,
+    KiB,
+    MiB,
+    NaType,
+    NotApplicable,
+    NotApplicableType,
+    PiB,
+    Snapshot,
+    TiB,
+    boolify,
+    bytes2human,
+    colored,
+    human2bytes,
+    set_color,
+    timedelta2human,
+    utilization2string,
+)
+
+
+__all__ = [  # noqa: RUF022
+    'NVMLError',
+    'nvmlCheckReturn',
+    'libnvml',
+    'libcuda',
+    'libcudart',
+    # nvitop.api.device
+    'Device',
+    'PhysicalDevice',
+    'MigDevice',
+    'CudaDevice',
+    'CudaMigDevice',
+    'parse_cuda_visible_devices',
+    'normalize_cuda_visible_devices',
+    # nvitop.api.process
+    'host',
+    'HostProcess',
+    'GpuProcess',
+    'command_join',
+    # nvitop.api.collector
+    'take_snapshots',
+    'collect_in_background',
+    'ResourceMetricCollector',
+    # nvitop.api.caching
+    'ttl_cache',
+    # nvitop.api.utils
+    'NA',
+    'NaType',
+    'NotApplicable',
+    'NotApplicableType',
+    'UINT_MAX',
+    'ULONGLONG_MAX',
+    'KiB',
+    'MiB',
+    'GiB',
+    'TiB',
+    'PiB',
+    'SIZE_UNITS',
+    'bytes2human',
+    'human2bytes',
+    'timedelta2human',
+    'utilization2string',
+    'colored',
+    'set_color',
+    'boolify',
+    'Snapshot',
+]

.venv/lib/python3.10/site-packages/nvitop/api/caching.py

@@ -0,0 +1,279 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Caching utilities."""
+
+from __future__ import annotations
+
+import builtins
+import functools
+import time
+from dataclasses import dataclass
+from threading import RLock
+from typing import TYPE_CHECKING, Any, NamedTuple, overload
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Sized
+    from collections.abc import Set as AbstractSet
+    from typing import TypeVar
+    from typing_extensions import (
+        ParamSpec,  # Python 3.10+
+        Self,  # Python 3.11+
+    )
+
+    _P = ParamSpec('_P')
+    _T = TypeVar('_T')
+
+
+__all__ = ['ttl_cache']
+
+
+class _CacheInfo(NamedTuple):
+    """A named tuple representing the cache statistics."""
+
+    hits: int
+    misses: int
+    maxsize: int
+    currsize: int
+
+
+try:
+    from functools import _make_key
+except ImportError:
+
+    class _HashedSeq(list):
+        """This class guarantees that hash() will be called no more than once per element."""
+
+        __slots__ = ('__hashvalue',)
+
+        def __init__(
+            self,
+            seq: tuple[Any, ...],
+            hash: Callable[[Any], int] = builtins.hash,  # pylint: disable=redefined-builtin
+        ) -> None:
+            """Initialize the hashed sequence."""
+            self[:] = seq
+            self.__hashvalue = hash(seq)
+
+        def __hash__(self) -> int:  # type: ignore[override]
+            """Return the hash value of the hashed sequence."""
+            return self.__hashvalue
+
+    _KWD_MARK = object()
+
+    # pylint: disable-next=too-many-arguments
+    def _make_key(  # type: ignore[misc]
+        args: tuple[Hashable, ...],
+        kwds: dict[str, Hashable],
+        typed: bool,
+        *,
+        kwd_mark: tuple[object, ...] = (_KWD_MARK,),
+        fasttypes: AbstractSet[type] = frozenset({int, str}),
+        tuple: type[tuple] = builtins.tuple,  # pylint: disable=redefined-builtin
+        type: type[type] = builtins.type,  # pylint: disable=redefined-builtin
+        len: Callable[[Sized], int] = builtins.len,  # pylint: disable=redefined-builtin
+    ) -> Hashable:
+        """Make a cache key from optionally typed positional and keyword arguments."""
+        key = args
+        if kwds:
+            key += kwd_mark
+            for item in kwds.items():
+                key += item
+        if typed:
+            key += tuple(type(v) for v in args)
+            if kwds:
+                key += tuple(type(v) for v in kwds.values())
+        elif len(key) == 1 and type(key[0]) in fasttypes:
+            return key[0]
+        return _HashedSeq(key)
+
+
+@dataclass
+class _TTLCacheLink:  # pylint: disable=too-few-public-methods
+    __slots__ = ('expires', 'key', 'next', 'prev', 'value')
+
+    prev: Self
+    next: Self  # pylint: disable=redefined-builtin
+    key: Hashable
+    value: Any
+    expires: float
+
+
+@overload
+def ttl_cache(
+    maxsize: int | None = 128,
+    *,
+    ttl: float = 600.0,
+    timer: Callable[[], float] = time.monotonic,
+    typed: bool = False,
+) -> Callable[[Callable[_P, _T]], Callable[_P, _T]]: ...
+
+
+@overload
+def ttl_cache(
+    maxsize: Callable[_P, _T],
+    *,
+    ttl: float = 600.0,
+    timer: Callable[[], float] = time.monotonic,
+    typed: bool = False,
+) -> Callable[_P, _T]: ...
+
+
+# pylint: disable-next=too-many-statements
+def ttl_cache(
+    maxsize: int | Callable[_P, _T] | None = 128,
+    *,
+    ttl: float = 600.0,
+    timer: Callable[[], float] = time.monotonic,
+    typed: bool = False,
+) -> Callable[[Callable[_P, _T]], Callable[_P, _T]] | Callable[_P, _T]:
+    """Time aware cache decorator."""
+    if isinstance(maxsize, int):
+        # Negative maxsize is treated as 0
+        maxsize = max(0, maxsize)
+    elif callable(maxsize) and isinstance(typed, bool):
+        # The user_function was passed in directly via the maxsize argument
+        func, maxsize = maxsize, 128
+        return ttl_cache(maxsize, ttl=ttl, timer=timer, typed=typed)(func)
+    elif maxsize is not None:
+        raise TypeError('Expected first argument to be an integer, a callable, or None')
+
+    if ttl < 0.0:
+        raise ValueError('TTL must be a non-negative number')
+    if not callable(timer):
+        raise TypeError('Timer must be a callable')
+
+    if maxsize == 0 or maxsize is None:
+        return functools.lru_cache(maxsize=maxsize, typed=typed)  # type: ignore[return-value]
+
+    # pylint: disable-next=too-many-statements,too-many-locals
+    def wrapper(func: Callable[_P, _T], /) -> Callable[_P, _T]:
+        cache: dict[Any, _TTLCacheLink] = {}
+        cache_get = cache.get  # bound method to lookup a key or return None
+        cache_len = cache.__len__  # get cache size without calling len()
+        lock = RLock()  # because linked-list updates aren't thread-safe
+        # root of the circular doubly linked list
+        root = _TTLCacheLink(*((None,) * 5))  # type: ignore[arg-type]
+        root.prev = root.next = root  # initialize by pointing to self
+        hits = misses = 0
+        full = False
+
+        def unlink(link: _TTLCacheLink) -> _TTLCacheLink:
+            with lock:
+                link_prev, link_next = link.prev, link.next
+                link_next.prev, link_prev.next = link_prev, link_next
+            return link_next
+
+        def append(link: _TTLCacheLink) -> _TTLCacheLink:
+            with lock:
+                last = root.prev
+                last.next = root.prev = link
+                link.prev, link.next = last, root
+            return link
+
+        def move_to_end(link: _TTLCacheLink) -> _TTLCacheLink:
+            with lock:
+                unlink(link)
+                append(link)
+            return link
+
+        def expire() -> None:
+            nonlocal full
+
+            with lock:
+                now = timer()
+                front = root.next
+                while front is not root and front.expires < now:
+                    del cache[front.key]
+                    front = unlink(front)
+                full = cache_len() >= maxsize
+
+        @functools.wraps(func)
+        def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> _T:
+            # Size limited time aware caching
+            nonlocal root, hits, misses, full
+
+            key = _make_key(args, kwargs, typed)
+            with lock:
+                link = cache_get(key)
+                if link is not None:
+                    if timer() < link.expires:
+                        hits += 1
+                        return link.value
+                    expire()
+
+            misses += 1
+            result = func(*args, **kwargs)
+            expires = timer() + ttl
+            with lock:
+                if key in cache:
+                    # Getting here means that this same key was added to the cache while the lock
+                    # was released or the key was expired. Move the link to the front of the
+                    # circular queue.
+                    link = move_to_end(cache[key])
+                    # We need only update the expiration time.
+                    link.value = result
+                    link.expires = expires
+                else:
+                    if full:
+                        expire()
+                    if full:
+                        # Use the old root to store the new key and result.
+                        root.key = key
+                        root.value = result
+                        root.expires = expires
+                        # Empty the oldest link and make it the new root.
+                        # Keep a reference to the old key and old result to prevent their ref counts
+                        # from going to zero during the update. That will prevent potentially
+                        # arbitrary object clean-up code (i.e. __del__) from running while we're
+                        # still adjusting the links.
+                        front = root.next
+                        old_key = front.key
+                        front.key = front.value = front.expires = None  # type: ignore[assignment]
+                        # Now update the cache dictionary.
+                        del cache[old_key]
+                        # Save the potentially reentrant cache[key] assignment for last, after the
+                        # root and links have been put in a consistent state.
+                        cache[key], root = root, front
+                    else:
+                        # Put result in a new link at the front of the queue.
+                        cache[key] = append(_TTLCacheLink(None, None, key, result, expires))  # type: ignore[arg-type]
+                    full = cache_len() >= maxsize
+            return result
+
+        def cache_info() -> _CacheInfo:
+            """Report cache statistics."""
+            with lock:
+                expire()
+                return _CacheInfo(hits, misses, maxsize, cache_len())
+
+        def cache_clear() -> None:
+            """Clear the cache and cache statistics."""
+            nonlocal hits, misses, full
+            with lock:
+                cache.clear()
+                root.prev = root.next = root
+                root.key = root.value = root.expires = None  # type: ignore[assignment]
+                hits = misses = 0
+                full = False
+
+        wrapped.cache_info = cache_info  # type: ignore[attr-defined]
+        wrapped.cache_clear = cache_clear  # type: ignore[attr-defined]
+        wrapped.cache_parameters = lambda: {'maxsize': maxsize, 'typed': typed}  # type: ignore[attr-defined]
+        return wrapped
+
+    return wrapper

.venv/lib/python3.10/site-packages/nvitop/api/collector.py

@@ -0,0 +1,912 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Resource metrics collectors."""
+
+from __future__ import annotations
+
+import contextlib
+import itertools
+import math
+import os
+import threading
+import time
+from collections import OrderedDict, defaultdict
+from typing import TYPE_CHECKING, ClassVar, NamedTuple, TypeVar
+from weakref import WeakSet
+
+from nvitop.api import host
+from nvitop.api.device import CudaDevice, Device
+from nvitop.api.process import GpuProcess, HostProcess
+from nvitop.api.utils import GiB, MiB, Snapshot
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Iterable
+
+
+__all__ = ['ResourceMetricCollector', 'collect_in_background', 'take_snapshots']
+
+
+class SnapshotResult(NamedTuple):  # pylint: disable=missing-class-docstring
+    devices: list[Snapshot]
+    gpu_processes: list[Snapshot]
+
+
+timer = time.monotonic
+
+
+_T = TypeVar('_T')
+
+
+def _unique(iterable: Iterable[_T], /) -> list[_T]:
+    return list(OrderedDict.fromkeys(iterable).keys())
+
+
+# pylint: disable-next=too-many-branches
+def take_snapshots(
+    devices: Device | Iterable[Device] | None = None,
+    *,
+    gpu_processes: bool | GpuProcess | Iterable[GpuProcess] | None = None,
+) -> SnapshotResult:
+    """Retrieve status of demanded devices and GPU processes.
+
+    Args:
+        devices (Optional[Union[Device, Iterable[Device]]]):
+            Requested devices for snapshots. If not given, the devices will be determined from GPU
+            processes: **(1)** All devices (no GPU processes are given); **(2)** Devices that used
+            by given GPU processes.
+        gpu_processes (Optional[Union[bool, GpuProcess, Iterable[GpuProcess]]]):
+            Requested GPU processes snapshots. If not given, all GPU processes running on the
+            requested device will be returned. The GPU process snapshots can be suppressed by
+            specifying ``gpu_processes=False``.
+
+    Returns: SnapshotResult
+        A named tuple containing two lists of snapshots.
+
+    Note:
+        If not arguments are specified, all devices and all GPU processes will
+        be returned.
+
+    Examples:
+        >>> from nvitop import take_snapshots, Device
+        >>> import os
+        >>> os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
+        >>> os.environ['CUDA_VISIBLE_DEVICES'] = '1,0'
+
+        >>> take_snapshots()  # equivalent to `take_snapshots(Device.all())`
+        SnapshotResult(
+            devices=[
+                PhysicalDeviceSnapshot(
+                    real=PhysicalDevice(index=0, ...),
+                    ...
+                ),
+                ...
+            ],
+            gpu_processes=[
+                GpuProcessSnapshot(
+                    real=GpuProcess(pid=xxxxxx, device=PhysicalDevice(index=0, ...), ...),
+                    ...
+                ),
+                ...
+            ]
+        )
+
+        >>> device_snapshots, gpu_process_snapshots = take_snapshots(Device.all())  # type: Tuple[List[DeviceSnapshot], List[GpuProcessSnapshot]]
+
+        >>> device_snapshots, _ = take_snapshots(gpu_processes=False)  # ignore process snapshots
+
+        >>> take_snapshots(Device.cuda.all())  # use CUDA device enumeration
+        SnapshotResult(
+            devices=[
+                CudaDeviceSnapshot(
+                    real=CudaDevice(cuda_index=0, physical_index=1, ...),
+                    ...
+                ),
+                CudaDeviceSnapshot(
+                    real=CudaDevice(cuda_index=1, physical_index=0, ...),
+                    ...
+                ),
+            ],
+            gpu_processes=[
+                GpuProcessSnapshot(
+                    real=GpuProcess(pid=xxxxxx, device=CudaDevice(cuda_index=0, ...), ...),
+                    ...
+                ),
+                ...
+            ]
+        )
+
+        >>> take_snapshots(Device.cuda(1))  # <CUDA 1> only
+        SnapshotResult(
+            devices=[
+                CudaDeviceSnapshot(
+                    real=CudaDevice(cuda_index=1, physical_index=0, ...),
+                    ...
+                )
+            ],
+            gpu_processes=[
+                GpuProcessSnapshot(
+                    real=GpuProcess(pid=xxxxxx, device=CudaDevice(cuda_index=1, ...), ...),
+                    ...
+                ),
+                ...
+            ]
+        )
+    """  # pylint: disable=line-too-long
+    if isinstance(devices, Device):
+        devices = [devices]
+    if isinstance(gpu_processes, GpuProcess):
+        gpu_processes = [gpu_processes]
+
+    if gpu_processes is not None and gpu_processes is not True:
+        if gpu_processes:  # is a non-empty list/tuple
+            gpu_processes = list(gpu_processes)
+            process_devices = _unique(process.device for process in gpu_processes)
+            for device in process_devices:
+                device.processes()  # update GPU status for requested GPU processes
+            if devices is None:
+                devices = process_devices
+        else:
+            gpu_processes = []  # False or empty list/tuple
+            if devices is None:
+                devices = Device.all()
+    else:
+        if devices is None:
+            physical_devices = Device.all()
+            devices = []
+            leaf_devices: list[Device] = []
+            for physical_device in physical_devices:
+                devices.append(physical_device)
+                mig_devices = physical_device.mig_devices()
+                if len(mig_devices) > 0:
+                    devices.extend(mig_devices)
+                    leaf_devices.extend(mig_devices)
+                else:
+                    leaf_devices.append(physical_device)
+        else:
+            leaf_devices = devices = list(devices)
+        gpu_processes = list(
+            itertools.chain.from_iterable(device.processes().values() for device in leaf_devices),
+        )
+
+    devices = [device.as_snapshot() for device in devices]  # type: ignore[union-attr]
+    gpu_processes = GpuProcess.take_snapshots(gpu_processes, failsafe=True)
+
+    return SnapshotResult(devices, gpu_processes)
+
+
+# pylint: disable-next=too-many-arguments
+def collect_in_background(
+    on_collect: Callable[[dict[str, float]], bool],
+    collector: ResourceMetricCollector | None = None,
+    interval: float | None = None,
+    *,
+    on_start: Callable[[ResourceMetricCollector], None] | None = None,
+    on_stop: Callable[[ResourceMetricCollector], None] | None = None,
+    tag: str = 'metrics-daemon',
+    start: bool = True,
+) -> threading.Thread:
+    """Start a background daemon thread that collect and call the callback function periodically.
+
+    See also :func:`ResourceMetricCollector.daemonize`.
+
+    Args:
+        on_collect (Callable[[Dict[str, float]], bool]):
+            A callback function that will be called periodically. It takes a dictionary containing
+            the resource metrics and returns a boolean indicating whether to continue monitoring.
+        collector (Optional[ResourceMetricCollector]):
+            A :class:`ResourceMetricCollector` instance to collect metrics. If not given, it will
+            collect metrics for all GPUs and subprocess of the current process.
+        interval (Optional[float]):
+            The collect interval. If not given, use ``collector.interval``.
+        on_start (Optional[Callable[[ResourceMetricCollector], None]]):
+            A function to initialize the daemon thread and collector.
+        on_stop (Optional[Callable[[ResourceMetricCollector], None]]):
+            A function that do some necessary cleanup after the daemon thread is stopped.
+        tag (str):
+            The tag prefix used for metrics results.
+        start (bool):
+            Whether to start the daemon thread on return.
+
+    Returns: threading.Thread
+        A daemon thread object.
+
+    Examples:
+        .. code-block:: python
+
+            logger = ...
+
+            def on_collect(metrics):  # will be called periodically
+                if logger.is_closed():  # closed manually by user
+                    return False
+                logger.log(metrics)
+                return True
+
+            def on_stop(collector):  # will be called only once at stop
+                if not logger.is_closed():
+                    logger.close()  # cleanup
+
+            # Record metrics to the logger in the background every 5 seconds.
+            # It will collect 5-second mean/min/max for each metric.
+            collect_in_background(
+                on_collect,
+                ResourceMetricCollector(Device.cuda.all()),
+                interval=5.0,
+                on_stop=on_stop,
+            )
+    """
+    if collector is None:
+        collector = ResourceMetricCollector()
+    if isinstance(interval, (int, float)) and interval > 0:
+        interval = float(interval)
+    elif interval is None:
+        interval = collector.interval
+    else:
+        raise ValueError(f'Invalid argument interval={interval!r}')
+
+    def target() -> None:
+        if on_start is not None:
+            on_start(collector)
+        try:
+            with collector(tag):
+                try:
+                    next_snapshot = timer() + interval
+                    while on_collect(collector.collect()):
+                        time.sleep(max(0.0, next_snapshot - timer()))
+                        next_snapshot += interval
+                except KeyboardInterrupt:
+                    pass
+        finally:
+            if on_stop is not None:
+                on_stop(collector)
+
+    daemon = threading.Thread(target=target, name=tag, daemon=True)
+    daemon.collector = collector  # type: ignore[attr-defined]
+    if start:
+        daemon.start()
+    return daemon
+
+
+class ResourceMetricCollector:  # pylint: disable=too-many-instance-attributes
+    """A class for collecting resource metrics.
+
+    Args:
+        devices (Iterable[Device]):
+            Set of Device instances for logging. If not given, all physical devices on board will be
+            used.
+        root_pids (Set[int]):
+            A set of PIDs, only the status of the descendant processes on the GPUs will be collected.
+            If not given, the PID of the current process will be used.
+        interval (float):
+            The snapshot interval for background daemon thread.
+
+    Core methods:
+
+    .. code-block:: python
+
+        collector.activate(tag='<tag>')  # alias: start
+        collector.deactivate()           # alias: stop
+        collector.clear(tag='<tag>')
+        collector.collect()
+
+        with collector(tag='<tag>'):
+            ...
+
+        collector.daemonize(on_collect_fn)
+
+    Examples:
+        >>> import os
+        >>> os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
+        >>> os.environ['CUDA_VISIBLE_DEVICES'] = '3,2,1,0'
+
+        >>> from nvitop import ResourceMetricCollector, Device
+
+        >>> collector = ResourceMetricCollector()                           # log all devices and descendant processes of the current process on the GPUs
+        >>> collector = ResourceMetricCollector(root_pids={1})              # log all devices and all GPU processes
+        >>> collector = ResourceMetricCollector(devices=Device.cuda.all())  # use the CUDA ordinal
+
+        >>> with collector(tag='<tag>'):
+        ...     # Do something
+        ...     collector.collect()  # -> Dict[str, float]
+        # key -> '<tag>/<scope>/<metric (unit)>/<mean/min/max>'
+        {
+            '<tag>/host/cpu_percent (%)/mean': 8.967849777683456,
+            '<tag>/host/cpu_percent (%)/min': 6.1,
+            '<tag>/host/cpu_percent (%)/max': 28.1,
+            ...,
+            '<tag>/host/memory_percent (%)/mean': 21.5,
+            '<tag>/host/swap_percent (%)/mean': 0.3,
+            '<tag>/host/memory_used (GiB)/mean': 91.0136418208109,
+            '<tag>/host/load_average (%) (1 min)/mean': 10.251427386878328,
+            '<tag>/host/load_average (%) (5 min)/mean': 10.072539414569503,
+            '<tag>/host/load_average (%) (15 min)/mean': 11.91126970422139,
+            ...,
+            '<tag>/cuda:0 (gpu:3)/memory_used (MiB)/mean': 3.875,
+            '<tag>/cuda:0 (gpu:3)/memory_free (MiB)/mean': 11015.562499999998,
+            '<tag>/cuda:0 (gpu:3)/memory_total (MiB)/mean': 11019.437500000002,
+            '<tag>/cuda:0 (gpu:3)/memory_percent (%)/mean': 0.0,
+            '<tag>/cuda:0 (gpu:3)/gpu_utilization (%)/mean': 0.0,
+            '<tag>/cuda:0 (gpu:3)/memory_utilization (%)/mean': 0.0,
+            '<tag>/cuda:0 (gpu:3)/fan_speed (%)/mean': 22.0,
+            '<tag>/cuda:0 (gpu:3)/temperature (C)/mean': 25.0,
+            '<tag>/cuda:0 (gpu:3)/power_usage (W)/mean': 19.11166264116916,
+            ...,
+            '<tag>/cuda:1 (gpu:2)/memory_used (MiB)/mean': 8878.875,
+            ...,
+            '<tag>/cuda:2 (gpu:1)/memory_used (MiB)/mean': 8182.875,
+            ...,
+            '<tag>/cuda:3 (gpu:0)/memory_used (MiB)/mean': 9286.875,
+            ...,
+            '<tag>/pid:12345/host/cpu_percent (%)/mean': 151.34342772112265,
+            '<tag>/pid:12345/host/host_memory (MiB)/mean': 44749.72373447514,
+            '<tag>/pid:12345/host/host_memory_percent (%)/mean': 8.675082352111717,
+            '<tag>/pid:12345/host/running_time (min)': 336.23803206741576,
+            '<tag>/pid:12345/cuda:1 (gpu:4)/gpu_memory (MiB)/mean': 8861.0,
+            '<tag>/pid:12345/cuda:1 (gpu:4)/gpu_memory_percent (%)/mean': 80.4,
+            '<tag>/pid:12345/cuda:1 (gpu:4)/gpu_memory_utilization (%)/mean': 6.711118172407917,
+            '<tag>/pid:12345/cuda:1 (gpu:4)/gpu_sm_utilization (%)/mean': 48.23283397736476,
+            ...,
+            '<tag>/duration (s)': 7.247399162035435,
+            '<tag>/timestamp': 1655909466.9981883
+        }
+    """  # pylint: disable=line-too-long
+
+    DEVICE_METRICS: ClassVar[list[tuple[str, str, float | int]]] = [
+        # (<attribute>, <name>, <unit>)
+        # GPU memory metrics
+        ('memory_used', 'memory_used (MiB)', MiB),
+        ('memory_free', 'memory_free (MiB)', MiB),
+        ('memory_total', 'memory_total (MiB)', MiB),
+        ('memory_percent', 'memory_percent (%)', 1.0),
+        # GPU utilization metrics
+        ('gpu_utilization', 'gpu_utilization (%)', 1.0),
+        ('memory_utilization', 'memory_utilization (%)', 1.0),
+        # Miscellaneous
+        ('fan_speed', 'fan_speed (%)', 1.0),
+        ('temperature', 'temperature (C)', 1.0),
+        ('power_usage', 'power_usage (W)', 1000.0),
+    ]
+
+    PROCESS_METRICS: ClassVar[list[tuple[str, str | None, str, float | int]]] = [
+        # (<attribute>, <scope>, <name>, <unit>)
+        # Host resource metrics
+        ('cpu_percent', 'host', 'cpu_percent (%)', 1.0),
+        ('host_memory', 'host', 'host_memory (MiB)', MiB),
+        ('host_memory_percent', 'host', 'host_memory_percent (%)', 1.0),
+        ('running_time_in_seconds', 'host', 'running_time (min)', 60.0),
+        # GPU memory metrics
+        ('gpu_memory', None, 'gpu_memory (MiB)', MiB),
+        ('gpu_memory_percent', None, 'gpu_memory_percent (%)', 1.0),
+        ('gpu_memory_utilization', None, 'gpu_memory_utilization (%)', 1.0),
+        # GPU utilization metrics
+        ('gpu_sm_utilization', None, 'gpu_sm_utilization (%)', 1.0),
+    ]
+
+    def __init__(
+        self,
+        devices: Iterable[Device] | None = None,
+        *,
+        root_pids: Iterable[int] | None = None,
+        interval: float = 1.0,
+    ) -> None:
+        """Initialize the resource metric collector."""
+        if isinstance(interval, (int, float)) and interval > 0:
+            interval = float(interval)
+        else:
+            raise ValueError(f'Invalid argument interval={interval!r}')
+
+        if devices is None:
+            devices = Device.all()
+
+        root_pids: set[int] = {os.getpid()} if root_pids is None else set(root_pids)
+
+        self.interval: float = interval
+
+        self.devices: list[Device] = list(devices)
+        self.all_devices: list[Device] = []
+        self.leaf_devices: list[Device] = []
+        for device in self.devices:
+            self.all_devices.append(device)
+            mig_devices = device.mig_devices()
+            if len(mig_devices) > 0:
+                self.all_devices.extend(mig_devices)
+                self.leaf_devices.extend(mig_devices)
+            else:
+                self.leaf_devices.append(device)
+
+        self.root_pids: set[int] = root_pids
+        self._positive_processes: WeakSet[HostProcess] = WeakSet(
+            HostProcess(pid) for pid in self.root_pids
+        )
+        self._negative_processes: WeakSet[HostProcess] = WeakSet()
+
+        self._last_timestamp: float = timer() - 2.0 * self.interval
+        self._lock: threading.RLock = threading.RLock()
+        self._metric_buffer: _MetricBuffer | None = None
+        self._tags: set[str] = set()
+
+        self._daemon: threading.Thread = threading.Thread(
+            name='metrics-collector-daemon',
+            target=self._target,
+            daemon=True,
+        )
+        self._daemon_running: threading.Event = threading.Event()
+
+    def activate(self, tag: str) -> ResourceMetricCollector:
+        """Start a new metric collection with the given tag.
+
+        Args:
+            tag (str):
+                The name of the new metric collection. The tag will be used to identify the metric
+                collection. It must be a unique string.
+
+        Examples:
+            >>> collector = ResourceMetricCollector()
+
+            >>> collector.activate(tag='train')  # key prefix -> 'train'
+            >>> collector.activate(tag='batch')  # key prefix -> 'train/batch'
+            >>> collector.deactivate()           # key prefix -> 'train'
+            >>> collector.deactivate()           # the collector has been stopped
+            >>> collector.activate(tag='test')   # key prefix -> 'test'
+        """
+        with self._lock:
+            if self._metric_buffer is None or tag not in self._tags:
+                self._tags.add(tag)
+                self._metric_buffer = _MetricBuffer(tag, self, prev=self._metric_buffer)
+                self._last_timestamp = timer() - 2.0 * self.interval
+            else:
+                raise RuntimeError(f'Resource metric collector is already started with tag "{tag}"')
+
+        self._daemon_running.set()
+        try:
+            self._daemon.start()
+        except RuntimeError:
+            pass
+
+        return self
+
+    start = activate
+
+    def deactivate(self, tag: str | None = None) -> ResourceMetricCollector:
+        """Stop the current collection with the given tag and remove all sub-tags.
+
+        If the tag is not specified, deactivate the current active collection. For nested
+        collections, the sub-collections will be deactivated as well.
+
+        Args:
+            tag (Optional[str]):
+                The tag to deactivate. If :data:`None`, the current active collection will be used.
+        """
+        with self._lock:
+            if self._metric_buffer is None:
+                if tag is not None:
+                    raise RuntimeError('Resource metric collector has not been started yet.')
+                return self
+
+            if tag is None:
+                tag = self._metric_buffer.tag
+            elif tag not in self._tags:
+                raise RuntimeError(
+                    f'Resource metric collector has not been started with tag "{tag}".',
+                )
+
+            buffer = self._metric_buffer
+            while True:
+                self._tags.remove(buffer.tag)
+                if buffer.tag == tag:
+                    self._metric_buffer = buffer.prev
+                    break
+                buffer = buffer.prev  # type: ignore[assignment]
+
+            if self._metric_buffer is None:
+                self._daemon_running.clear()
+
+        return self
+
+    stop = deactivate
+
+    @contextlib.contextmanager
+    def context(self, tag: str) -> Generator[ResourceMetricCollector]:
+        """A context manager for starting and stopping resource metric collection.
+
+        Args:
+            tag (str):
+                The name of the new metric collection. The tag will be used to identify the metric
+                collection. It must be a unique string.
+
+        Examples:
+            >>> collector = ResourceMetricCollector()
+
+            >>> with collector.context(tag='train'):  # key prefix -> 'train'
+            ...     # Do something
+            ...     collector.collect()  # -> Dict[str, float]
+        """
+        try:
+            self.activate(tag=tag)
+            yield self
+        finally:
+            self.deactivate(tag=tag)
+
+    __call__ = context  # alias for `with collector(tag='<tag>')`
+
+    def clear(self, tag: str | None = None) -> None:
+        """Clear the metric collection with the given tag.
+
+        If the tag is not specified, clear the current active collection. For nested collections,
+        the sub-collections will be cleared as well.
+
+        Args:
+            tag (Optional[str]):
+                The tag to clear. If :data:`None`, the current active collection will be reset.
+
+        Examples:
+            >>> collector = ResourceMetricCollector()
+
+            >>> with collector(tag='train'):          # key prefix -> 'train'
+            ...     time.sleep(5.0)
+            ...     collector.collect()               # metrics within the 5.0s interval
+            ...
+            ...     time.sleep(5.0)
+            ...     collector.collect()               # metrics within the cumulative 10.0s interval
+            ...
+            ...     collector.clear()                 # clear the active collection
+            ...     time.sleep(5.0)
+            ...     collector.collect()               # metrics within the 5.0s interval
+            ...
+            ...     with collector(tag='batch'):      # key prefix -> 'train/batch'
+            ...         collector.clear(tag='train')  # clear both 'train' and 'train/batch'
+        """
+        with self._lock:
+            if self._metric_buffer is None:
+                if tag is not None:
+                    raise RuntimeError('Resource metric collector has not been started yet.')
+                return
+
+            if tag is None:
+                tag = self._metric_buffer.tag
+            elif tag not in self._tags:
+                raise RuntimeError(
+                    f'Resource metric collector has not been started with tag "{tag}".',
+                )
+
+            buffer = self._metric_buffer
+            while True:
+                buffer.clear()
+                if buffer.tag == tag:
+                    break
+                buffer = buffer.prev  # type: ignore[assignment]
+
+    reset = clear
+
+    def collect(self) -> dict[str, float]:
+        """Get the average resource consumption during collection."""
+        with self._lock:
+            if self._metric_buffer is None:
+                raise RuntimeError('Resource metric collector has not been started yet.')
+
+            if timer() - self._last_timestamp > self.interval / 2.0:
+                self.take_snapshots()
+            return self._metric_buffer.collect()
+
+    # pylint: disable-next=too-many-arguments
+    def daemonize(
+        self,
+        on_collect: Callable[[dict[str, float]], bool],
+        interval: float | None = None,
+        *,
+        on_start: Callable[[ResourceMetricCollector], None] | None = None,
+        on_stop: Callable[[ResourceMetricCollector], None] | None = None,
+        tag: str = 'metrics-daemon',
+        start: bool = True,
+    ) -> threading.Thread:
+        """Start a background daemon thread that collect and call the callback function periodically.
+
+        See also :func:`collect_in_background`.
+
+        Args:
+            on_collect (Callable[[Dict[str, float]], bool]):
+                A callback function that will be called periodically. It takes a dictionary containing
+                the resource metrics and returns a boolean indicating whether to continue monitoring.
+            interval (Optional[float]):
+                The collect interval. If not given, use ``collector.interval``.
+            on_start (Optional[Callable[[ResourceMetricCollector], None]]):
+                A function to initialize the daemon thread and collector.
+            on_stop (Optional[Callable[[ResourceMetricCollector], None]]):
+                A function that do some necessary cleanup after the daemon thread is stopped.
+            tag (str):
+                The tag prefix used for metrics results.
+            start (bool):
+                Whether to start the daemon thread on return.
+
+        Returns: threading.Thread
+            A daemon thread object.
+
+        Examples:
+            .. code-block:: python
+
+                logger = ...
+
+                def on_collect(metrics):  # will be called periodically
+                    if logger.is_closed():  # closed manually by user
+                        return False
+                    logger.log(metrics)
+                    return True
+
+                def on_stop(collector):  # will be called only once at stop
+                    if not logger.is_closed():
+                        logger.close()  # cleanup
+
+                # Record metrics to the logger in the background every 5 seconds.
+                # It will collect 5-second mean/min/max for each metric.
+                ResourceMetricCollector(Device.cuda.all()).daemonize(
+                    on_collect,
+                    ResourceMetricCollector(Device.cuda.all()),
+                    interval=5.0,
+                    on_stop=on_stop,
+                )
+        """
+        return collect_in_background(
+            on_collect,
+            collector=self,
+            interval=interval,
+            on_start=on_start,
+            on_stop=on_stop,
+            tag=tag,
+            start=start,
+        )
+
+    def __del__(self) -> None:
+        """Clean up the demon thread on destruction."""
+        self._daemon_running.clear()
+
+    # pylint: disable-next=too-many-branches,too-many-locals,too-many-statements
+    def take_snapshots(self) -> SnapshotResult:
+        """Take snapshots of the current resource metrics and update the metric buffer."""
+        if len(self.root_pids) > 0:
+            all_gpu_processes: list[GpuProcess] = []
+            for device in self.leaf_devices:
+                all_gpu_processes.extend(device.processes().values())
+
+            gpu_processes = []
+            for process in all_gpu_processes:
+                if process.host in self._negative_processes:
+                    continue
+
+                positive = True
+                if process.host not in self._positive_processes:
+                    positive = False
+                    p = process.host
+                    parents = []
+                    while p is not None:
+                        parents.append(p)
+                        if p in self._positive_processes:
+                            positive = True
+                            break
+                        try:
+                            p = p.parent()  # type: ignore[assignment]
+                        except host.PsutilError:
+                            break
+                    if positive:
+                        self._positive_processes.update(parents)
+                    else:
+                        self._negative_processes.update(parents)
+
+                if positive:
+                    gpu_processes.append(process)
+        else:
+            gpu_processes = []
+
+        timestamp = timer()
+        epoch_timestamp = time.time()
+        metrics = {}
+        device_snapshots = [device.as_snapshot() for device in self.all_devices]
+        gpu_process_snapshots = GpuProcess.take_snapshots(gpu_processes, failsafe=True)
+
+        metrics.update(
+            {
+                'host/cpu_percent (%)': host.cpu_percent(),
+                'host/memory_percent (%)': host.memory_percent(),
+                'host/swap_percent (%)': host.swap_percent(),
+                'host/memory_used (GiB)': host.virtual_memory().used / GiB,
+            },
+        )
+        load_average = host.load_average()
+        if load_average is not None:
+            metrics.update(
+                {
+                    'host/load_average (%) (1 min)': load_average[0],
+                    'host/load_average (%) (5 min)': load_average[1],
+                    'host/load_average (%) (15 min)': load_average[2],
+                },
+            )
+
+        device_identifiers = {}
+        for device_snapshot in device_snapshots:
+            identifier = f'gpu:{device_snapshot.index}'
+            if isinstance(device_snapshot.real, CudaDevice):
+                identifier = f'cuda:{device_snapshot.cuda_index} ({identifier})'
+            device_identifiers[device_snapshot.real] = identifier
+
+            for attr, name, unit in self.DEVICE_METRICS:
+                value = float(getattr(device_snapshot, attr)) / unit
+                metrics[f'{identifier}/{name}'] = value
+
+        for process_snapshot in gpu_process_snapshots:
+            device_identifier = device_identifiers[process_snapshot.device]
+            identifier = f'pid:{process_snapshot.pid}'
+
+            for attr, scope, name, unit in self.PROCESS_METRICS:
+                scope = scope or device_identifier
+                value = float(getattr(process_snapshot, attr)) / unit
+                metrics[f'{identifier}/{scope}/{name}'] = value
+
+        with self._lock:
+            if self._metric_buffer is not None:
+                self._metric_buffer.add(
+                    metrics,
+                    timestamp=timestamp,
+                    epoch_timestamp=epoch_timestamp,
+                )
+                self._last_timestamp = timestamp
+
+        return SnapshotResult(device_snapshots, gpu_process_snapshots)
+
+    def _target(self) -> None:
+        self._daemon_running.wait()
+        while self._daemon_running.is_set():
+            next_snapshot = timer() + self.interval
+            self.take_snapshots()
+            time.sleep(max(0.0, next_snapshot - timer()))
+            next_snapshot += self.interval
+
+
+class _MetricBuffer:  # pylint: disable=missing-class-docstring,missing-function-docstring,too-many-instance-attributes
+    def __init__(
+        self,
+        tag: str,
+        collector: ResourceMetricCollector,
+        *,
+        prev: _MetricBuffer | None = None,
+    ) -> None:
+        self.collector: ResourceMetricCollector = collector
+        self.prev: _MetricBuffer | None = prev
+
+        self.tag: str = tag
+        self.key_prefix: str
+        if self.prev is not None:
+            self.key_prefix = f'{self.prev.key_prefix}/{self.tag}'
+        else:
+            self.key_prefix = self.tag
+
+        self.last_timestamp = self.start_timestamp = timer()
+        self.last_epoch_timestamp = time.time()
+        self.buffer: defaultdict[str, _StatisticsMaintainer] = defaultdict(
+            lambda: _StatisticsMaintainer(self.last_timestamp),
+        )
+
+        self.len = 0
+
+    def add(
+        self,
+        metrics: dict[str, float],
+        timestamp: float | None = None,
+        epoch_timestamp: float | None = None,
+    ) -> None:
+        if timestamp is None:
+            timestamp = timer()
+        if epoch_timestamp is None:
+            epoch_timestamp = time.time()
+
+        for key in set(self.buffer).difference(metrics):
+            self.buffer[key].add(math.nan, timestamp=timestamp)
+        for key, value in metrics.items():
+            self.buffer[key].add(value, timestamp=timestamp)
+        self.len += 1
+        self.last_timestamp = timestamp
+        self.last_epoch_timestamp = epoch_timestamp
+
+        if self.prev is not None:
+            self.prev.add(metrics, timestamp=timestamp)
+
+    def clear(self) -> None:
+        self.last_timestamp = self.start_timestamp = timer()
+        self.last_epoch_timestamp = time.time()
+        self.buffer.clear()
+        self.len = 0
+
+    def collect(self) -> dict[str, float]:
+        metrics = {
+            f'{self.key_prefix}/{key}/{name}': value
+            for key, stats in self.buffer.items()
+            for name, value in stats.items()
+        }
+        for key in tuple(metrics.keys()):
+            if key.endswith('host/running_time (min)/max'):
+                metrics[key[:-4]] = metrics[key]
+                del metrics[key]
+            elif key.endswith(('host/running_time (min)/mean', 'host/running_time (min)/min')):
+                del metrics[key]
+        metrics[f'{self.key_prefix}/duration (s)'] = timer() - self.start_timestamp
+        metrics[f'{self.key_prefix}/timestamp'] = time.time()
+        metrics[f'{self.key_prefix}/last_timestamp'] = self.last_epoch_timestamp
+        return metrics
+
+    def __len__(self) -> int:
+        return self.len
+
+
+class _StatisticsMaintainer:  # pylint: disable=missing-class-docstring,missing-function-docstring
+    def __init__(self, timestamp: float) -> None:
+        self.start_timestamp: float = timestamp
+        self.last_timestamp: float = math.nan
+        self.integral: float | None = None
+        self.last_value: float | None = None
+        self.min_value: float | None = None
+        self.max_value: float | None = None
+        self.has_nan: bool = False
+
+    def add(self, value: float, timestamp: float | None = None) -> None:
+        if timestamp is None:
+            timestamp = timer()
+
+        if math.isnan(value):
+            self.has_nan = True
+            return
+
+        if self.last_value is None:
+            self.integral = value * (timestamp - self.start_timestamp)
+            self.last_value = self.min_value = self.max_value = value
+        else:
+            # pylint: disable-next=line-too-long
+            self.integral += (value + self.last_value) * (timestamp - self.last_timestamp) / 2.0  # type: ignore[operator]
+            self.last_value = value
+            self.min_value = min(self.min_value, value)  # type: ignore[type-var]
+            self.max_value = max(self.max_value, value)  # type: ignore[type-var]
+
+        self.last_timestamp = timestamp
+
+    def mean(self) -> float:
+        if self.integral is None:
+            return math.nan
+
+        if self.has_nan:
+            return self.integral / (self.last_timestamp - self.start_timestamp)
+
+        timestamp = timer()
+        integral = self.integral + self.last_value * (timestamp - self.last_timestamp)  # type: ignore[operator]
+        return integral / (timestamp - self.start_timestamp)
+
+    def min(self) -> float:
+        if self.min_value is None:
+            return math.nan
+        return self.min_value
+
+    def max(self) -> float:
+        if self.max_value is None:
+            return math.nan
+        return self.max_value
+
+    def last(self) -> float:
+        if self.last_value is None:
+            return math.nan
+        return self.last_value
+
+    def items(self) -> Iterable[tuple[str, float]]:
+        yield ('mean', self.mean())
+        yield ('min', self.min())
+        yield ('max', self.max())
+        yield ('last', self.last())

.venv/lib/python3.10/site-packages/nvitop/api/host.py

@@ -0,0 +1,149 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Shortcuts for package ``psutil``.
+
+``psutil`` is a cross-platform library for retrieving information on running processes and system
+utilization (CPU, memory, disks, network, sensors) in Python.
+"""
+
+from __future__ import annotations
+
+import os as _os
+
+import psutil as _psutil
+from psutil import *  # noqa: F403 # pylint: disable=wildcard-import,unused-wildcard-import,redefined-builtin
+from psutil import (  # noqa: F401
+    LINUX,
+    MACOS,
+    POSIX,
+    WINDOWS,
+    AccessDenied,
+    Error,
+    NoSuchProcess,
+    Process,
+    ZombieProcess,
+    boot_time,
+    cpu_percent,
+    pids,
+    swap_memory,
+    virtual_memory,
+)
+from psutil import Error as PsutilError  # pylint: disable=reimported
+
+
+__all__ = [
+    'WINDOWS_SUBSYSTEM_FOR_LINUX',
+    'WSL',
+    'PsutilError',
+    'getuser',
+    'hostname',
+    'load_average',
+    'memory_percent',
+    'ppid_map',
+    'reverse_ppid_map',
+    'swap_percent',
+    'uptime',
+]
+__all__ += [name for name in _psutil.__all__ if not name.startswith('_') and name != 'Error']
+
+
+del Error  # renamed to PsutilError
+
+
+def getuser() -> str:
+    """Get the current username from the environment or password database."""
+    import getpass  # pylint: disable=import-outside-toplevel
+
+    try:
+        return getpass.getuser()
+    except (ModuleNotFoundError, OSError):
+        return _os.getlogin()
+
+
+def hostname() -> str:
+    """Get the hostname of the machine."""
+    import platform  # pylint: disable=import-outside-toplevel
+
+    return platform.node()
+
+
+if hasattr(_psutil, 'getloadavg'):
+
+    def load_average() -> tuple[float, float, float]:
+        """Get the system load average."""
+        return _psutil.getloadavg()
+
+else:
+
+    def load_average() -> None:  # type: ignore[misc]
+        """Get the system load average."""
+        return
+
+
+def uptime() -> float:
+    """Get the system uptime."""
+    import time as _time  # pylint: disable=import-outside-toplevel
+
+    return _time.time() - boot_time()
+
+
+def memory_percent() -> float:
+    """The percentage usage of virtual memory, calculated as ``(total - available) / total * 100``."""
+    return virtual_memory().percent
+
+
+def swap_percent() -> float:
+    """The percentage usage of virtual memory, calculated as ``used / total * 100``."""
+    return swap_memory().percent
+
+
+def ppid_map() -> dict[int, int]:
+    """Obtain a ``{pid: ppid, ...}`` dict for all running processes in one shot."""
+    ret = {}
+    for pid in pids():
+        try:
+            ret[pid] = Process(pid).ppid()
+        except (NoSuchProcess, ZombieProcess):  # noqa: PERF203
+            pass
+    return ret
+
+
+try:
+    from psutil import _ppid_map as ppid_map  # type: ignore[no-redef] # noqa: F811,RUF100
+except ImportError:
+    pass
+
+
+def reverse_ppid_map() -> dict[int, list[int]]:
+    """Obtain a ``{ppid: [pid, ...], ...}`` dict for all running processes in one shot."""
+    from collections import defaultdict  # pylint: disable=import-outside-toplevel
+
+    ret = defaultdict(list)
+    for pid, ppid in ppid_map().items():
+        ret[ppid].append(pid)
+
+    return ret
+
+
+if LINUX:
+    WSL = _os.getenv('WSL_DISTRO_NAME', default=None)
+    if WSL is not None and WSL == '':
+        WSL = 'WSL'
+else:
+    WSL = None
+WINDOWS_SUBSYSTEM_FOR_LINUX = WSL
+"""The Linux distribution name of the Windows Subsystem for Linux."""

.venv/lib/python3.10/site-packages/nvitop/api/libcuda.py

@@ -0,0 +1,747 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python bindings for the `CUDA Driver APIs <https://docs.nvidia.com/cuda/cuda-driver-api>`_."""
+
+# pylint: disable=invalid-name
+
+from __future__ import annotations
+
+import ctypes as _ctypes
+import itertools as _itertools
+import platform as _platform
+import string as _string
+import sys as _sys
+import threading as _threading
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+from typing import Any as _Any
+from typing import ClassVar as _ClassVar
+
+
+if _TYPE_CHECKING:
+    from collections.abc import Callable as _Callable
+    from typing_extensions import Self as _Self  # Python 3.11+
+    from typing_extensions import TypeAlias as _TypeAlias  # Python 3.10+
+
+
+# pylint: disable-next=missing-class-docstring,too-few-public-methods
+class _struct_c_CUdevice_t(_ctypes.Structure):
+    pass  # opaque handle
+
+
+_c_CUdevice_t: _TypeAlias = _ctypes.POINTER(  # type: ignore[valid-type] # noqa: PYI042
+    _struct_c_CUdevice_t,
+)
+
+_CUresult_t: _TypeAlias = _ctypes.c_uint
+
+# Error codes #
+# pylint: disable=line-too-long
+CUDA_SUCCESS = 0
+"""The API call returned with no errors. In the case of query calls, this also means that the operation being queried is complete (see :func:`cuEventQuery` and :func:`cuStreamQuery`)."""
+CUDA_ERROR_INVALID_VALUE = 1
+"""This indicates that one or more of the parameters passed to the API call is not within an acceptable range of values."""
+CUDA_ERROR_OUT_OF_MEMORY = 2
+"""The API call failed because it was unable to allocate enough memory to perform the requested operation."""
+CUDA_ERROR_NOT_INITIALIZED = 3
+"""This indicates that the CUDA driver has not been initialized with :func:`cuInit` or that initialization has failed."""
+CUDA_ERROR_DEINITIALIZED = 4
+"""This indicates that the CUDA driver is in the process of shutting down."""
+CUDA_ERROR_PROFILER_DISABLED = 5
+"""This indicates profiler is not initialized for this run. This can happen when the application is running with external profiling tools like visual profiler."""
+CUDA_ERROR_STUB_LIBRARY = 34
+"""This indicates that the CUDA driver that the application has loaded is a stub library. Applications that run with the stub rather than a real driver loaded will result in CUDA API returning this error."""
+CUDA_ERROR_DEVICE_UNAVAILABLE = 46
+"""This indicates that requested CUDA device is unavailable at the current time. Devices are often unavailable due to use of :data:`CU_COMPUTEMODE_EXCLUSIVE_PROCESS` or :data:`CU_COMPUTEMODE_PROHIBITED`."""
+CUDA_ERROR_NO_DEVICE = 100
+"""This indicates that no CUDA - capable devices were detected by the installed CUDA driver."""
+CUDA_ERROR_INVALID_DEVICE = 101
+"""This indicates that the device ordinal supplied by the user does not correspond to a valid CUDA device or that the action requested is invalid for the specified device."""
+CUDA_ERROR_DEVICE_NOT_LICENSED = 102
+"""This error indicates that the Grid license is not applied."""
+CUDA_ERROR_INVALID_IMAGE = 200
+"""This indicates that the device kernel image is invalid. This can also indicate an invalid CUDA module."""
+CUDA_ERROR_INVALID_CONTEXT = 201
+"""This most frequently indicates that there is no context bound to the current thread. This can also be returned if the context passed to an API call is not a valid handle (such as a context that has had :func:`cuCtxDestroy` invoked on it). This can also be returned if a user mixes different API versions (i.e. 3010 context with 3020 API calls). See :func:`cuCtxGetApiVersion` for more details."""
+CUDA_ERROR_MAP_FAILED = 205
+"""This indicates that a map or register operation has failed."""
+CUDA_ERROR_UNMAP_FAILED = 206
+"""This indicates that an unmap or unregister operation has failed."""
+CUDA_ERROR_ARRAY_IS_MAPPED = 207
+"""This indicates that the specified array is currently mapped and thus cannot be destroyed."""
+CUDA_ERROR_ALREADY_MAPPED = 208
+"""This indicates that the resource is already mapped."""
+CUDA_ERROR_NO_BINARY_FOR_GPU = 209
+"""This indicates that there is no kernel image available that is suitable for the device. This can occur when a user specifies code generation options for a particular CUDA source file that do not include the corresponding device configuration."""
+CUDA_ERROR_ALREADY_ACQUIRED = 210
+"""This indicates that a resource has already been acquired."""
+CUDA_ERROR_NOT_MAPPED = 211
+"""This indicates that a resource is not mapped."""
+CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212
+"""This indicates that a mapped resource is not available for access as an array."""
+CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213
+"""This indicates that a mapped resource is not available for access as a pointer."""
+CUDA_ERROR_ECC_UNCORRECTABLE = 214
+"""This indicates that an uncorrectable ECC error was detected during execution."""
+CUDA_ERROR_UNSUPPORTED_LIMIT = 215
+"""This indicates that the :class:`CUlimit` passed to the API call is not supported by the active device."""
+CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216
+"""This indicates that the :class:`CUcontext` passed to the API call can only be bound to a single CPU thread at a time but is already bound to a CPU thread."""
+CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217
+"""This indicates that peer access is not supported across the given devices."""
+CUDA_ERROR_INVALID_PTX = 218
+"""This indicates that a PTX JIT compilation failed."""
+CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = 219
+"""This indicates an error with OpenGL or DirectX context."""
+CUDA_ERROR_NVLINK_UNCORRECTABLE = 220
+"""This indicates that an uncorrectable NVLink error was detected during the execution."""
+CUDA_ERROR_JIT_COMPILER_NOT_FOUND = 221
+"""This indicates that the PTX JIT compiler library was not found."""
+CUDA_ERROR_UNSUPPORTED_PTX_VERSION = 222
+"""This indicates that the provided PTX was compiled with an unsupported toolchain."""
+CUDA_ERROR_JIT_COMPILATION_DISABLED = 223
+"""This indicates that the PTX JIT compilation was disabled."""
+CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY = 224
+"""This indicates that the :class:`CUexecAffinityType` passed to the API call is not supported by the active device."""
+CUDA_ERROR_INVALID_SOURCE = 300
+"""This indicates that the device kernel source is invalid. This includes compilation / linker errors encountered in device code or user error."""
+CUDA_ERROR_FILE_NOT_FOUND = 301
+"""This indicates that the file specified was not found."""
+CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302
+"""This indicates that a link to a shared object failed to resolve."""
+CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303
+"""This indicates that initialization of a shared object failed."""
+CUDA_ERROR_OPERATING_SYSTEM = 304
+"""This indicates that an OS call failed."""
+CUDA_ERROR_INVALID_HANDLE = 400
+"""This indicates that a resource handle passed to the API call was not valid. Resource handles are opaque types like :class:`CUstream` and :class:`CUevent`."""
+CUDA_ERROR_ILLEGAL_STATE = 401
+"""This indicates that a resource required by the API call is not in a valid state to perform the requested operation."""
+CUDA_ERROR_NOT_FOUND = 500
+"""This indicates that a named symbol was not found. Examples of symbols are global / constant variable names, driver function names, texture names, and surface names."""
+CUDA_ERROR_NOT_READY = 600
+"""This indicates that asynchronous operations issued previously have not completed yet. This result is not actually an error, but must be indicated differently than :data:`CUDA_SUCCESS` (which indicates completion). Calls that may return this value include :func:`cuEventQuery` and :func:`cuStreamQuery`."""
+CUDA_ERROR_ILLEGAL_ADDRESS = 700
+"""While executing a kernel, the device encountered a load or store instruction on an invalid memory address. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701
+"""This indicates that a launch did not occur because it did not have appropriate resources. This error usually indicates that the user has attempted to pass too many arguments to the device kernel, or the kernel launch specifies too many threads for the kernel's register count. Passing arguments of the wrong size (i.e. a 64 - bit pointer when a 32 - bit int is expected) is equivalent to passing too many arguments and can also result in this error."""
+CUDA_ERROR_LAUNCH_TIMEOUT = 702
+"""This indicates that the device kernel took too long to execute. This can only occur if timeouts are enabled - see the device attribute :data:`CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT` for more information. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703
+"""This error indicates a kernel launch that uses an incompatible texturing mode."""
+CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704
+"""This error indicates that a call to :func:`cuCtxEnablePeerAccess` is trying to re - enable peer access to a context which has already had peer access to it enabled."""
+CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705
+"""This error indicates that :func:`cuCtxDisablePeerAccess` is trying to disable peer access which has not been enabled yet via :func:`cuCtxEnablePeerAccess`."""
+CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708
+"""This error indicates that the primary context for the specified device has already been initialized."""
+CUDA_ERROR_CONTEXT_IS_DESTROYED = 709
+"""This error indicates that the context current to the calling thread has been destroyed using :func:`cuCtxDestroy`, or is a primary context which has not yet been initialized."""
+CUDA_ERROR_ASSERT = 710
+"""A device - side assert triggered during kernel execution. The context cannot be used anymore, and must be destroyed. All existing device memory allocations from this context are invalid and must be reconstructed if the program is to continue using CUDA."""
+CUDA_ERROR_TOO_MANY_PEERS = 711
+"""This error indicates that the hardware resources required to enable peer access have been exhausted for one or more of the devices passed to :func:`cuCtxEnablePeerAccess`."""
+CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712
+"""This error indicates that the memory range passed to :func:`cuMemHostRegister` has already been registered."""
+CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713
+"""This error indicates that the pointer passed to :func:`cuMemHostUnregister` does not correspond to any currently registered memory region."""
+CUDA_ERROR_HARDWARE_STACK_ERROR = 714
+"""While executing a kernel, the device encountered a stack error. This can be due to stack corruption or exceeding the stack size limit. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_ILLEGAL_INSTRUCTION = 715
+"""While executing a kernel, the device encountered an illegal instruction. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_MISALIGNED_ADDRESS = 716
+"""While executing a kernel, the device encountered a load or store instruction on a memory address which is not aligned. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_INVALID_ADDRESS_SPACE = 717
+"""While executing a kernel, the device encountered an instruction which can only operate on memory locations in certain address spaces (global, shared, or local), but was supplied a memory address not belonging to an allowed address space. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_INVALID_PC = 718
+"""While executing a kernel, the device program counter wrapped its address space. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_LAUNCH_FAILED = 719
+"""An exception occurred on the device while executing a kernel. Common causes include dereferencing an invalid device pointer and accessing out of bounds shared memory. Less common cases can be system specific - more information about these cases can be found in the system specific user guide. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE = 720
+"""This error indicates that the number of blocks launched per grid for a kernel that was launched via either :func:`cuLaunchCooperativeKernel` or :func:`cuLaunchCooperativeKernelMultiDevice` exceeds the maximum number of blocks as allowed by :func:`cuOccupancyMaxActiveBlocksPerMultiprocessor` or :func:`cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags` times the number of multiprocessors as specified by the device attribute :data:`CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT`."""
+CUDA_ERROR_NOT_PERMITTED = 800
+"""This error indicates that the attempted operation is not permitted."""
+CUDA_ERROR_NOT_SUPPORTED = 801
+"""This error indicates that the attempted operation is not supported on the current system or device."""
+CUDA_ERROR_SYSTEM_NOT_READY = 802
+"""This error indicates that the system is not yet ready to start any CUDA work. To continue using CUDA, verify the system configuration is in a valid state and all required driver daemons are actively running. More information about this error can be found in the system specific user guide."""
+CUDA_ERROR_SYSTEM_DRIVER_MISMATCH = 803
+"""This error indicates that there is a mismatch between the versions of the display driver and the CUDA driver. Refer to the compatibility documentation for supported versions."""
+CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE = 804
+"""This error indicates that the system was upgraded to run with forward compatibility but the visible hardware detected by CUDA does not support this configuration. Refer to the compatibility documentation for the supported hardware matrix or ensure that only supported hardware is visible during initialization via the ``CUDA_VISIBLE_DEVICES`` environment variable."""
+CUDA_ERROR_MPS_CONNECTION_FAILED = 805
+"""This error indicates that the MPS client failed to connect to the MPS control daemon or the MPS server."""
+CUDA_ERROR_MPS_RPC_FAILURE = 806
+"""This error indicates that the remote procedural call between the MPS server and the MPS client failed."""
+CUDA_ERROR_MPS_SERVER_NOT_READY = 807
+"""This error indicates that the MPS server is not ready to accept new MPS client requests. This error can be returned when the MPS server is in the process of recovering from a fatal failure."""
+CUDA_ERROR_MPS_MAX_CLIENTS_REACHED = 808
+"""This error indicates that the hardware resources required to create MPS client have been exhausted."""
+CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED = 809
+"""This error indicates the the hardware resources required to support device connections have been exhausted."""
+CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED = 900
+"""This error indicates that the operation is not permitted when the stream is capturing."""
+CUDA_ERROR_STREAM_CAPTURE_INVALIDATED = 901
+"""This error indicates that the current capture sequence on the stream has been invalidated due to a previous error."""
+CUDA_ERROR_STREAM_CAPTURE_MERGE = 902
+"""This error indicates that the operation would have resulted in a merge of two independent capture sequences."""
+CUDA_ERROR_STREAM_CAPTURE_UNMATCHED = 903
+"""This error indicates that the capture was initiated not in this stream."""
+CUDA_ERROR_STREAM_CAPTURE_UNJOINED = 904
+"""This error indicates that the capture sequence contains a fork that was not joined to the primary stream."""
+CUDA_ERROR_STREAM_CAPTURE_ISOLATION = 905
+"""This error indicates that a dependency would have been created which crosses the capture sequence boundary. Only implicit in -stream ordering dependencies are allowed to cross the boundary."""
+CUDA_ERROR_STREAM_CAPTURE_IMPLICIT = 906
+"""This error indicates a disallowed implicit dependency on a current capture sequence from :func:`cudaStreamLegacy`."""
+CUDA_ERROR_CAPTURED_EVENT = 907
+"""This error indicates that the operation is not permitted on an event which was last recorded in a capturing stream."""
+CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD = 908
+"""A stream capture sequence not initiated with the :data:`CU_STREAM_CAPTURE_MODE_RELAXED` argument to :func:`cuStreamBeginCapture` was passed to :func:`cuStreamEndCapture` in a different thread."""
+CUDA_ERROR_TIMEOUT = 909
+"""This error indicates that the timeout specified for the wait operation has lapsed."""
+CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE = 910
+"""This error indicates that the graph update was not performed because it included changes which violated constraints specific to instantiated graph update."""
+CUDA_ERROR_EXTERNAL_DEVICE = 911
+"""This indicates that an async error has occurred in a device outside of CUDA. If CUDA was waiting for an external device's signal before consuming shared data, the external device signaled an error indicating that the data is not valid for consumption. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+CUDA_ERROR_UNKNOWN = 999
+"""This indicates that an unknown internal error has occurred."""
+# pylint: enable=line-too-long
+
+
+# Error Checking #
+class CUDAError(Exception):
+    """Base exception class for CUDA driver query errors."""
+
+    _value_class_mapping: _ClassVar[dict[int, type[CUDAError]]] = {}
+    _errcode_to_string: _ClassVar[dict[int, str]] = {  # List of currently known error codes
+        CUDA_ERROR_NOT_INITIALIZED:                'Initialization error.',
+        CUDA_ERROR_NOT_FOUND:                      'Named symbol not found.',
+        CUDA_ERROR_INVALID_VALUE:                  'Invalid argument.',
+        CUDA_ERROR_NO_DEVICE:                      'No CUDA-capable device is detected.',
+        CUDA_ERROR_INVALID_DEVICE:                 'Invalid device ordinal.',
+        CUDA_ERROR_SYSTEM_DRIVER_MISMATCH:         'System has unsupported display driver / CUDA driver combination.',
+        CUDA_ERROR_DEINITIALIZED:                  'Driver shutting down.',
+        CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE: 'Forward compatibility was attempted on non supported Hardware.',
+        CUDA_ERROR_INVALID_CONTEXT:                'Invalid device context.',
+    }  # fmt:skip
+    _errcode_to_name: _ClassVar[dict[int, str]] = {}
+    value: int
+
+    def __new__(cls, value: int) -> _Self:
+        """Map value to a proper subclass of :class:`CUDAError`."""
+        if cls is CUDAError:
+            # pylint: disable-next=self-cls-assignment
+            cls = CUDAError._value_class_mapping.get(value, cls)  # type: ignore[assignment]
+        obj = Exception.__new__(cls)
+        obj.value = value
+        return obj
+
+    def __repr__(self) -> str:
+        """Return a string representation of the error."""
+        # pylint: disable=no-member
+        try:
+            if self.value not in CUDAError._errcode_to_string:
+                CUDAError._errcode_to_string[self.value] = '{}.'.format(
+                    cuGetErrorString(self.value).rstrip('.').capitalize(),
+                )
+            if self.value not in CUDAError._errcode_to_name:
+                CUDAError._errcode_to_name[self.value] = cuGetErrorName(self.value)
+            return (
+                f'{CUDAError._errcode_to_string[self.value]} '
+                f'Code: {CUDAError._errcode_to_name[self.value]} ({self.value}).'
+            )
+        except CUDAError:
+            return f'CUDA Error with code {self.value}.'
+
+    def __eq__(self, other: object) -> bool:
+        """Test equality to other object."""
+        if not isinstance(other, CUDAError):
+            return NotImplemented
+        return self.value == other.value  # pylint: disable=no-member
+
+    def __reduce__(self) -> tuple[type[CUDAError], tuple[int]]:
+        """Return state information for pickling."""
+        return CUDAError, (self.value,)  # pylint: disable=no-member
+
+
+def cudaExceptionClass(cudaErrorCode: int, /) -> type[CUDAError]:
+    """Map value to a proper subclass of :class:`CUDAError`.
+
+    Raises:
+        ValueError: If the error code is not valid.
+    """
+    if cudaErrorCode not in CUDAError._value_class_mapping:  # pylint: disable=protected-access
+        raise ValueError(f'cudaErrorCode {cudaErrorCode} is not valid.')
+    return CUDAError._value_class_mapping[cudaErrorCode]  # pylint: disable=protected-access
+
+
+def _extract_cuda_errors_as_classes() -> None:
+    """Generate a hierarchy of classes on top of :class:`CUDAError` class.
+
+    Each CUDA Error gets a new :class:`CUDAError` subclass. This way try-except blocks can filter
+    appropriate exceptions more easily.
+
+    :class:`CUDAError` is a parent class. Each ``CUDA_ERROR_*`` gets it's own subclass.
+    e.g. :data:`CUDA_ERROR_INVALID_VALUE` will be turned into :class:`CUDAError_InvalidValue`.
+    """
+    this_module = _sys.modules[__name__]
+    cuda_error_names = [x for x in dir(this_module) if x.startswith('CUDA_ERROR_')]
+    for err_name in cuda_error_names:
+        # e.g. Turn CUDA_ERROR_INVALID_VALUE into CUDAError_InvalidValue
+        pascal_case = _string.capwords(err_name.replace('CUDA_ERROR_', ''), '_').replace('_', '')
+        class_name = f'CUDAError_{pascal_case}'
+        err_val = getattr(this_module, err_name)
+
+        def gen_new(value: int) -> _Callable[[type[CUDAError]], CUDAError]:
+            def new(cls: type[CUDAError]) -> CUDAError:
+                return CUDAError.__new__(cls, value)
+
+            return new
+
+        # pylint: disable=protected-access
+        new_error_class = type(class_name, (CUDAError,), {'__new__': gen_new(err_val)})
+        new_error_class.__module__ = __name__
+        if err_val in CUDAError._errcode_to_string:
+            new_error_class.__doc__ = (
+                f'CUDA Error: {CUDAError._errcode_to_string[err_val]} '
+                f'Code: :data:`{err_name}` ({err_val}).'
+            )
+        else:
+            new_error_class.__doc__ = f'CUDA Error with code :data:`{err_name}` ({err_val})'
+        setattr(this_module, class_name, new_error_class)
+        CUDAError._value_class_mapping[err_val] = new_error_class
+        CUDAError._errcode_to_name[err_val] = err_name
+
+
+# Add explicit references to appease linters
+class __CUDAError(CUDAError):
+    value: int
+
+    def __new__(cls) -> CUDAError:  # type: ignore[misc,empty-body]
+        ...
+
+
+CUDAError_NotInitialized: type[__CUDAError]
+CUDAError_NotFound: type[__CUDAError]
+CUDAError_InvalidValue: type[__CUDAError]
+CUDAError_NoDevice: type[__CUDAError]
+CUDAError_InvalidDevice: type[__CUDAError]
+CUDAError_SystemDriverMismatch: type[__CUDAError]
+CUDAError_Deinitialized: type[__CUDAError]
+CUDAError_CompatNotSupportedOnDevice: type[__CUDAError]
+CUDAError_InvalidContext: type[__CUDAError]
+
+_extract_cuda_errors_as_classes()
+del _extract_cuda_errors_as_classes
+
+
+def _cudaCheckReturn(ret: _Any, /) -> _Any:
+    if ret != CUDA_SUCCESS:
+        raise CUDAError(ret)
+    return ret
+
+
+# Function access #
+__cudaLib: _ctypes.CDLL | None = None
+__initialized: bool = False
+__libLoadLock: _threading.Lock = _threading.Lock()
+# Function pointers are cached to prevent unnecessary libLoadLock locking
+__cudaGetFunctionPointer_cache: dict[str, _ctypes._CFuncPtr] = {}  # type: ignore[name-defined]
+
+
+def __cudaGetFunctionPointer(name: str) -> _ctypes._CFuncPtr:  # type: ignore[name-defined]
+    """Get the function pointer from the CUDA driver library.
+
+    Raises:
+        CUDAError_NotInitialized:
+            If cannot found the CUDA driver library.
+        CUDAError_NotFound:
+            If cannot found the function pointer.
+    """
+    if name in __cudaGetFunctionPointer_cache:
+        return __cudaGetFunctionPointer_cache[name]
+
+    with __libLoadLock:
+        # Ensure library was loaded
+        if __cudaLib is None:
+            raise CUDAError(CUDA_ERROR_NOT_INITIALIZED)
+        try:
+            __cudaGetFunctionPointer_cache[name] = getattr(__cudaLib, name)
+            return __cudaGetFunctionPointer_cache[name]
+        except AttributeError as ex:
+            raise CUDAError(CUDA_ERROR_NOT_FOUND) from ex
+
+
+def __LoadCudaLibrary() -> None:
+    """Load the library if it isn't loaded already.
+
+    Raises:
+        CUDAError_NotInitialized:
+            If cannot found the CUDA driver library.
+    """
+    global __cudaLib  # pylint: disable=global-statement
+
+    if __cudaLib is None:
+        # Lock to ensure only one caller loads the library
+        with __libLoadLock:
+            # Ensure the library still isn't loaded
+            if __cudaLib is None:
+                # Platform specific libcuda location
+                system = _platform.system()
+                if system == 'Darwin':
+                    lib_filenames = [
+                        'libcuda.1.dylib',  # check library path first
+                        'libcuda.dylib',
+                        '/usr/local/cuda/lib/libcuda.1.dylib',
+                        '/usr/local/cuda/lib/libcuda.dylib',
+                    ]
+                elif system == 'Linux':
+                    lib_filenames = [
+                        'libcuda.so',  # check library path first
+                        '/usr/lib64/nvidia/libcuda.so',  # Redhat/CentOS/Fedora
+                        '/usr/lib/x86_64-linux-gnu/libcuda.so',  # Ubuntu
+                        '/usr/lib/wsl/lib/libcuda.so',  # WSL
+                    ]
+                    # Also add libraries with version suffix `.1`
+                    lib_filenames = list(
+                        _itertools.chain.from_iterable((f'{lib}.1', lib) for lib in lib_filenames),
+                    )
+                elif system == 'Windows':
+                    bits = 8 * _ctypes.sizeof(_ctypes.c_void_p)  # 64 or 32
+                    lib_filenames = [f'nvcuda{bits}.dll', 'nvcuda.dll']
+                # Open library
+                for lib_filename in lib_filenames:
+                    try:
+                        __cudaLib = _ctypes.CDLL(lib_filename)
+                        break
+                    except OSError:
+                        pass
+                if __cudaLib is None:
+                    _cudaCheckReturn(CUDA_ERROR_NOT_INITIALIZED)
+
+
+def cuInit(flags: int = 0) -> None:
+    """Initialize the CUDA driver API.
+
+    Initialize the driver API and must be called before any other function from the driver API.
+    Currently, the ``flags`` parameter must be :data:`0`. If :func:`cuInit` has not been called,
+    any function from the driver API will return :data:`CUDA_ERROR_NOT_INITIALIZED`.
+
+    Raises:
+        CUDAError_NoDevice:
+            If no CUDA-capable device is available.
+        CUDAError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device or
+            that the action requested is invalid for the specified device.
+        CUDAError_SystemDriverMismatch:
+            If there is a mismatch between the versions of the display driver and the CUDA driver.
+        CUDAError_CompatNotSupportedOnDevice:
+            If the system was upgraded to run with forward compatibility but the visible hardware
+            detected by CUDA does not support this configuration.
+        CUDAError_InvalidValue:
+            If passed with invalid flag value.
+        CUDAError_NotInitialized:
+            If cannot found the CUDA driver library.
+    """
+    global __initialized  # pylint: disable=global-statement
+
+    __LoadCudaLibrary()
+
+    if __initialized:
+        return
+
+    fn = __cudaGetFunctionPointer('cuInit')
+
+    ret = fn(_ctypes.c_uint(flags))
+    _cudaCheckReturn(ret)
+
+    with __libLoadLock:
+        __initialized = True
+
+
+def cuGetErrorName(error: int) -> str:
+    """Get the string representation of an error code enum name.
+
+    Raises:
+        CUDAError_InvalidValue:
+            If the error code is not recognized.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuGetErrorName')
+
+    p_name = _ctypes.POINTER(_ctypes.c_char_p)()
+    ret = fn(_CUresult_t(error), _ctypes.byref(p_name))
+    _cudaCheckReturn(ret)
+    name = _ctypes.string_at(p_name)
+    return name.decode('utf-8', errors='replace')
+
+
+def cuGetErrorString(error: int) -> str:
+    """Get the string description of an error code.
+
+    Raises:
+        CUDAError_InvalidValue:
+            If the error code is not recognized.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuGetErrorString')
+
+    p_name = _ctypes.POINTER(_ctypes.c_char_p)()
+    ret = fn(_CUresult_t(error), _ctypes.byref(p_name))
+    _cudaCheckReturn(ret)
+    name = _ctypes.string_at(p_name)
+    return name.decode('utf-8', errors='replace')
+
+
+def cuDriverGetVersion() -> str:
+    """Get the latest CUDA version supported by driver.
+
+    Returns:
+        A string of the form :data:`'<major>.<minor>'`.
+
+    Raises:
+        CUDAError_InvalidValue:
+            If the driver call fails.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuDriverGetVersion')
+
+    driver_version = _ctypes.c_int(0)
+    ret = fn(_ctypes.byref(driver_version))
+    _cudaCheckReturn(ret)
+    major = driver_version.value // 1000
+    minor = (driver_version.value % 1000) // 10
+    return f'{major}.{minor}'
+
+
+def cuDeviceGetCount() -> int:
+    """Get the number of compute-capable devices.
+
+    Returns: int
+        The number of devices with compute capability greater than or equal to 2.0 that are available
+        for execution. If there is no such device, :func:`cuDeviceGetCount` returns :data:`0`.
+
+    Raises:
+        CUDAError_InvalidContext:
+            If there is no context bound to the current thread.
+        CUDAError_InvalidValue:
+            If the driver call fails.
+        CUDAError_Deinitialized:
+            If the CUDA driver in the process is shutting down.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuDeviceGetCount')
+
+    count = _ctypes.c_int(0)
+    ret = fn(_ctypes.byref(count))
+    _cudaCheckReturn(ret)
+    return count.value
+
+
+def cuDeviceGet(ordinal: int) -> _c_CUdevice_t:
+    """Get a handle to a compute device.
+
+    Returns:
+        A device handle given an ordinal in the range :code:`[0, ..., cuDeviceGetCount() - 1]`.
+
+    Raises:
+        CUDAError_InvalidContext:
+            If there is no context bound to the current thread.
+        CUDAError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device or
+            that the action requested is invalid for the specified device.
+        CUDAError_InvalidValue:
+            If the driver call fails.
+        CUDAError_Deinitialized:
+            If the CUDA driver in the process is shutting down.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuDeviceGet')
+
+    device = _c_CUdevice_t()
+    ret = fn(_ctypes.byref(device), _ctypes.c_int(ordinal))
+    _cudaCheckReturn(ret)
+    return device
+
+
+def cuDeviceGetByPCIBusId(pciBusId: str) -> _c_CUdevice_t:
+    """Get a handle to a compute device.
+
+    Args:
+        pciBusId (str):
+            String in one of the following forms: ``[domain]:[bus]:[device].[function]``,
+            ``[domain]:[bus]:[device]``, ``[bus]:[device].[function]`` where ``domain``, ``bus``,
+            ``device``, and ``function`` are all hexadecimal values.
+
+    Returns: int
+        A device handle given a PCI bus ID string.
+
+    Raises:
+        CUDAError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device or
+            that the action requested is invalid for the specified device.
+        CUDAError_InvalidValue:
+            If the value of :data:`pciBusId` is not a valid PCI bus identifier.
+        CUDAError_Deinitialized:
+            If the CUDA driver in the process is shutting down.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuDeviceGetByPCIBusId')
+
+    device = _c_CUdevice_t()
+    ret = fn(_ctypes.byref(device), _ctypes.c_char_p(pciBusId.encode('utf-8')))
+    _cudaCheckReturn(ret)
+    return device
+
+
+def cuDeviceGetPCIBusId(device: _c_CUdevice_t) -> str:
+    """Get a PCI Bus Id string for the device.
+
+    Returns: str
+        An identifier string for the device in the following format ``[domain]:[bus]:[device].[function]``
+        where ``domain``, ``bus``, ``device``, and ``function`` are all hexadecimal values.
+
+    Raises:
+        CUDAError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device or
+            that the action requested is invalid for the specified device.
+        CUDAError_InvalidValue:
+            If the driver call fails.
+        CUDAError_Deinitialized:
+            If the CUDA driver in the process is shutting down.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuDeviceGetPCIBusId')
+
+    pciBusId = _ctypes.create_string_buffer(256)
+    ret = fn(pciBusId, _ctypes.c_int(256), device)
+    _cudaCheckReturn(ret)
+    return pciBusId.value.decode('utf-8', errors='replace')
+
+
+def cuDeviceGetName(device: _c_CUdevice_t) -> str:
+    """Get an identifier string for the device.
+
+    Returns: str
+        An ASCII string identifying the device.
+
+    Raises:
+        CUDAError_InvalidContext:
+            If there is no context bound to the current thread.
+        CUDAError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device or
+            that the action requested is invalid for the specified device.
+        CUDAError_InvalidValue:
+            If the driver call fails.
+        CUDAError_Deinitialized:
+            If the CUDA driver in the process is shutting down.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuDeviceGetName')
+
+    name = _ctypes.create_string_buffer(256)
+    ret = fn(name, _ctypes.c_int(256), device)
+    _cudaCheckReturn(ret)
+    return name.value.decode('utf-8', errors='replace')
+
+
+def cuDeviceGetUuid(device: _c_CUdevice_t) -> str:
+    """Get a UUID for the device.
+
+    Raises:
+        CUDAError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device or
+            that the action requested is invalid for the specified device.
+        CUDAError_InvalidValue:
+            If the driver call fails.
+        CUDAError_Deinitialized:
+            If the CUDA driver in the process is shutting down.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    try:
+        fn = __cudaGetFunctionPointer('cuDeviceGetUuid_v2')
+    except CUDAError_NotFound:  # noqa: F821 # pylint: disable=undefined-variable
+        fn = __cudaGetFunctionPointer('cuDeviceGetUuid')
+
+    uuid = (_ctypes.c_ubyte * 16)()
+    ret = fn(uuid, device)
+    _cudaCheckReturn(ret)
+    uuid = ''.join(map('{:02x}'.format, uuid))
+    return '-'.join((uuid[:8], uuid[8:12], uuid[12:16], uuid[16:20], uuid[20:32]))
+
+
+def cuDeviceGetUuid_v2(device: _c_CUdevice_t) -> str:
+    """Get a UUID for the device (CUDA 11.4+).
+
+    Raises:
+        CUDAError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device or
+            that the action requested is invalid for the specified device.
+        CUDAError_InvalidValue:
+            If the driver call fails.
+        CUDAError_Deinitialized:
+            If the CUDA driver in the process is shutting down.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuDeviceGetUuid_v2')
+
+    uuid = (_ctypes.c_ubyte * 16)()
+    ret = fn(uuid, device)
+    _cudaCheckReturn(ret)
+    uuid = ''.join(map('{:02x}'.format, uuid))
+    return '-'.join((uuid[:8], uuid[8:12], uuid[12:16], uuid[16:20], uuid[20:32]))
+
+
+def cuDeviceTotalMem(device: _c_CUdevice_t) -> int:
+    """Get the total amount of memory on the device (in bytes).
+
+    Raises:
+        CUDAError_InvalidContext:
+            If there is no context bound to the current thread.
+        CUDAError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device or
+            that the action requested is invalid for the specified device.
+        CUDAError_InvalidValue:
+            If the driver call fails.
+        CUDAError_Deinitialized:
+            If the CUDA driver in the process is shutting down.
+        CUDAError_NotInitialized:
+            If the CUDA driver API is not initialized.
+    """
+    fn = __cudaGetFunctionPointer('cuDeviceTotalMem')
+
+    bytes = _ctypes.c_size_t(0)  # pylint: disable=redefined-builtin
+    ret = fn(_ctypes.byref(bytes), device)
+    _cudaCheckReturn(ret)
+    return bytes.value
+
+
+def is_available() -> bool:
+    """Test whether there are any CUDA visible devices."""
+    try:
+        return cuDeviceGetCount() > 0
+    except CUDAError:
+        return False

.venv/lib/python3.10/site-packages/nvitop/api/libcudart.py

@@ -0,0 +1,735 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python bindings for the `CUDA Runtime APIs <https://docs.nvidia.com/cuda/cuda-runtime-api>`_."""
+
+# pylint: disable=invalid-name
+
+from __future__ import annotations
+
+import ctypes as _ctypes
+import glob as _glob
+import os as _os
+import platform as _platform
+import sys as _sys
+import threading as _threading
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+from typing import Any as _Any
+from typing import ClassVar as _ClassVar
+
+
+if _TYPE_CHECKING:
+    from collections.abc import Callable as _Callable
+    from typing_extensions import Self as _Self  # Python 3.11+
+
+
+_cudaError_t = _ctypes.c_int
+
+# Error codes #
+# pylint: disable=line-too-long
+cudaSuccess = 0
+"""The API call returned with no errors. In the case of query calls, this also means that the operation being queried is complete (see :func:`cudaEventQuery` and :func:`cudaStreamQuery`)."""
+cudaErrorInvalidValue = 1
+"""This indicates that one or more of the parameters passed to the API call is not within an acceptable range of values."""
+cudaErrorMemoryAllocation = 2
+"""The API call failed because it was unable to allocate enough memory to perform the requested operation."""
+cudaErrorInitializationError = 3
+"""The API call failed because the CUDA driver and runtime could not be initialized."""
+cudaErrorCudartUnloading = 4
+"""This indicates that a CUDA Runtime API call cannot be executed because it is being called during process shut down, at a point in time after CUDA driver has been unloaded."""
+cudaErrorProfilerDisabled = 5
+"""This indicates profiler is not initialized for this run. This can happen when the application is running with external profiling tools like visual profiler."""
+cudaErrorInvalidConfiguration = 9
+"""This indicates that a kernel launch is requesting resources that can never be satisfied by the current device. Requesting more shared memory per block than the device supports will trigger this error, as will requesting too many threads or blocks. See cudaDeviceProp for more device limitations."""
+cudaErrorInvalidPitchValue = 12
+"""This indicates that one or more of the pitch-related parameters passed to the API call is not within the acceptable range for pitch."""
+cudaErrorInvalidSymbol = 13
+"""This indicates that the symbol name / identifier passed to the API call is not a valid name or identifier."""
+cudaErrorInvalidTexture = 18
+"""This indicates that the texture passed to the API call is not a valid texture."""
+cudaErrorInvalidTextureBinding = 19
+"""This indicates that the texture binding is not valid. This occurs if you call :func:`cudaGetTextureAlignmentOffset` with an unbound texture."""
+cudaErrorInvalidChannelDescriptor = 20
+"""This indicates that the channel descriptor passed to the API call is not valid. This occurs if the format is not one of the formats specified by :data:`cudaChannelFormatKind`, or if one of the dimensions is invalid."""
+cudaErrorInvalidMemcpyDirection = 21
+"""This indicates that the direction of the :func:`memcpy` passed to the API call is not one of the types specified by :data:`cudaMemcpyKind`."""
+cudaErrorInvalidFilterSetting = 26
+"""This indicates that a non-float texture was being accessed with linear filtering. This is not supported by CUDA."""
+cudaErrorInvalidNormSetting = 27
+"""This indicates that an attempt was made to read a non-float texture as a normalized float. This is not supported by CUDA."""
+cudaErrorStubLibrary = 34
+"""This indicates that the CUDA driver that the application has loaded is a stub library. Applications that run with the stub rather than a real driver loaded will result in CUDA API returning this error."""
+cudaErrorInsufficientDriver = 35
+"""This indicates that the installed NVIDIA CUDA driver is older than the CUDA Runtime library. This is not a supported configuration. Users should install an updated NVIDIA display driver to allow the application to run."""
+cudaErrorCallRequiresNewerDriver = 36
+"""This indicates that the API call requires a newer CUDA driver than the one currently installed. Users should install an updated NVIDIA CUDA driver to allow the API call to succeed."""
+cudaErrorInvalidSurface = 37
+"""This indicates that the surface passed to the API call is not a valid surface."""
+cudaErrorDuplicateVariableName = 43
+"""This indicates that multiple global or constant variables (across separate CUDA source files in the application) share the same string name."""
+cudaErrorDuplicateTextureName = 44
+"""This indicates that multiple textures (across separate CUDA source files in the application) share the same string name."""
+cudaErrorDuplicateSurfaceName = 45
+"""This indicates that multiple surfaces (across separate CUDA source files in the application) share the same string name."""
+cudaErrorDevicesUnavailable = 46
+"""This indicates that all CUDA devices are busy or unavailable at the current time. Devices are often busy / unavailable due to use of :data:`cudaComputeModeProhibited`, :data:`cudaComputeModeExclusiveProcess`, or when long running CUDA kernels have filled up the GPU and are blocking new work from starting. They can also be unavailable due to memory constraints on a device that already has active CUDA work being performed."""
+cudaErrorIncompatibleDriverContext = 49
+"""This indicates that the current context is not compatible with this the CUDA Runtime. This can only occur if you are using CUDA Runtime / Driver interoperability and have created an existing Driver context using the driver API. The Driver context may be incompatible either because the Driver context was created using an older version of the API, because the Runtime API call expects a primary driver context and the Driver context is not primary, or because the Driver context has been destroyed."""
+cudaErrorMissingConfiguration = 52
+"""The device function being invoked (usually via :func:`cudaLaunchKernel`) was not previously configured via the :func:`cudaConfigureCall` function."""
+cudaErrorLaunchMaxDepthExceeded = 65
+"""This error indicates that a device runtime grid launch did not occur because the depth of the child grid would exceed the maximum supported number of nested grid launches."""
+cudaErrorLaunchFileScopedTex = 66
+"""This error indicates that a grid launch did not occur because the kernel uses file-scoped textures which are unsupported by the device runtime. Kernels launched via the device runtime only support textures created with the Texture Object API's."""
+cudaErrorLaunchFileScopedSurf = 67
+"""This error indicates that a grid launch did not occur because the kernel uses file-scoped surfaces which are unsupported by the device runtime. Kernels launched via the device runtime only support surfaces created with the Surface Object API's."""
+cudaErrorSyncDepthExceeded = 68
+"""This error indicates that a call to :func:`cudaDeviceSynchronize` made from the device runtime failed because the call was made at grid depth greater than than either the default (2 levels of grids) or user specified device limit :data:`cudaLimitDevRuntimeSyncDepth`. To be able to synchronize on launched grids at a greater depth successfully, the maximum nested depth at which :func:`cudaDeviceSynchronize` will be called must be specified with the :data:`cudaLimitDevRuntimeSyncDepth` limit to the :func:`cudaDeviceSetLimit` api before the host-side launch of a kernel using the device runtime. Keep in mind that additional levels of sync depth require the runtime to reserve large amounts of device memory that cannot be used for user allocations. Note that :func:`cudaDeviceSynchronize` made from device runtime is only supported on devices of compute capability < 9.0."""
+cudaErrorLaunchPendingCountExceeded = 69
+"""This error indicates that a device runtime grid launch failed because the launch would exceed the limit :data:`cudaLimitDevRuntimePendingLaunchCount`. For this launch to proceed successfully, :func:`cudaDeviceSetLimit` must be called to set the :data:`cudaLimitDevRuntimePendingLaunchCount` to be higher than the upper bound of outstanding launches that can be issued to the device runtime. Keep in mind that raising the limit of pending device runtime launches will require the runtime to reserve device memory that cannot be used for user allocations."""
+cudaErrorInvalidDeviceFunction = 98
+"""The requested device function does not exist or is not compiled for the proper device architecture."""
+cudaErrorNoDevice = 100
+"""This indicates that no CUDA-capable devices were detected by the installed CUDA driver."""
+cudaErrorInvalidDevice = 101
+"""This indicates that the device ordinal supplied by the user does not correspond to a valid CUDA device or that the action requested is invalid for the specified device."""
+cudaErrorDeviceNotLicensed = 102
+"""This indicates that the device doesn't have a valid Grid License."""
+cudaErrorSoftwareValidityNotEstablished = 103
+"""By default, the CUDA Runtime may perform a minimal set of self-tests, as well as CUDA driver tests, to establish the validity of both. Introduced in CUDA 11.2, this error return indicates that at least one of these tests has failed and the validity of either the runtime or the driver could not be established."""
+cudaErrorStartupFailure = 127
+"""This indicates an internal startup failure in the CUDA Runtime."""
+cudaErrorInvalidKernelImage = 200
+"""This indicates that the device kernel image is invalid."""
+cudaErrorDeviceUninitialized = 201
+"""This most frequently indicates that there is no context bound to the current thread. This can also be returned if the context passed to an API call is not a valid handle (such as a context that has had :func`cuCtxDestroy` invoked on it). This can also be returned if a user mixes different API versions (i.e. 3010 context with 3020 API calls)."""
+cudaErrorMapBufferObjectFailed = 205
+"""This indicates that the buffer object could not be mapped."""
+cudaErrorUnmapBufferObjectFailed = 206
+"""This indicates that the buffer object could not be unmapped."""
+cudaErrorArrayIsMapped = 207
+"""This indicates that the specified array is currently mapped and thus cannot be destroyed."""
+cudaErrorAlreadyMapped = 208
+"""This indicates that the resource is already mapped."""
+cudaErrorNoKernelImageForDevice = 209
+"""This indicates that there is no kernel image available that is suitable for the device. This can occur when a user specifies code generation options for a particular CUDA source file that do not include the corresponding device configuration."""
+cudaErrorAlreadyAcquired = 210
+"""This indicates that a resource has already been acquired."""
+cudaErrorNotMapped = 211
+"""This indicates that a resource is not mapped."""
+cudaErrorNotMappedAsArray = 212
+"""This indicates that a mapped resource is not available for access as an array."""
+cudaErrorNotMappedAsPointer = 213
+"""This indicates that a mapped resource is not available for access as a pointer."""
+cudaErrorECCUncorrectable = 214
+"""This indicates that an uncorrectable ECC error was detected during execution."""
+cudaErrorUnsupportedLimit = 215
+"""This indicates that the :class:`cudaLimit` passed to the API call is not supported by the active device."""
+cudaErrorDeviceAlreadyInUse = 216
+"""This indicates that a call tried to access an exclusive-thread device that is already in use by a different thread."""
+cudaErrorPeerAccessUnsupported = 217
+"""This error indicates that P2P access is not supported across the given devices."""
+cudaErrorInvalidPtx = 218
+"""A PTX compilation failed. The runtime may fall back to compiling PTX if an application does not contain a suitable binary for the current device."""
+cudaErrorInvalidGraphicsContext = 219
+"""This indicates an error with the OpenGL or DirectX context."""
+cudaErrorNvlinkUncorrectable = 220
+"""This indicates that an uncorrectable NVLink error was detected during the execution."""
+cudaErrorJitCompilerNotFound = 221
+"""This indicates that the PTX JIT compiler library was not found. The JIT Compiler library is used for PTX compilation. The runtime may fall back to compiling PTX if an application does not contain a suitable binary for the current device."""
+cudaErrorUnsupportedPtxVersion = 222
+"""This indicates that the provided PTX was compiled with an unsupported toolchain. The most common reason for this, is the PTX was generated by a compiler newer than what is supported by the CUDA driver and PTX JIT compiler."""
+cudaErrorJitCompilationDisabled = 223
+"""This indicates that the JIT compilation was disabled. The JIT compilation compiles PTX. The runtime may fall back to compiling PTX if an application does not contain a suitable binary for the current device."""
+cudaErrorUnsupportedExecAffinity = 224
+"""This indicates that the provided execution affinity is not supported by the device."""
+cudaErrorInvalidSource = 300
+"""This indicates that the device kernel source is invalid."""
+cudaErrorFileNotFound = 301
+"""This indicates that the file specified was not found."""
+cudaErrorSharedObjectSymbolNotFound = 302
+"""This indicates that a link to a shared object failed to resolve."""
+cudaErrorSharedObjectInitFailed = 303
+"""This indicates that initialization of a shared object failed."""
+cudaErrorOperatingSystem = 304
+"""This error indicates that an OS call failed."""
+cudaErrorInvalidResourceHandle = 400
+"""This indicates that a resource handle passed to the API call was not valid. Resource handles are opaque types like :data:`cudaStream_t` and :data:`cudaEvent_t`."""
+cudaErrorIllegalState = 401
+"""This indicates that a resource required by the API call is not in a valid state to perform the requested operation."""
+cudaErrorSymbolNotFound = 500
+"""This indicates that a named symbol was not found. Examples of symbols are global / constant variable names, driver function names, texture names, and surface names."""
+cudaErrorNotReady = 600
+"""This indicates that asynchronous operations issued previously have not completed yet. This result is not actually an error, but must be indicated differently than :data:`cudaSuccess` (which indicates completion). Calls that may return this value include :func:`cudaEventQuery` and :func:`cudaStreamQuery`."""
+cudaErrorIllegalAddress = 700
+"""The device encountered a load or store instruction on an invalid memory address. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorLaunchOutOfResources = 701
+"""This indicates that a launch did not occur because it did not have appropriate resources. Although this error is similar to :data:`cudaErrorInvalidConfiguration`, this error usually indicates that the user has attempted to pass too many arguments to the device kernel, or the kernel launch specifies too many threads for the kernel's register count."""
+cudaErrorLaunchTimeout = 702
+"""This indicates that the device kernel took too long to execute. This can only occur if timeouts are enabled - see the device property kernelExecTimeoutEnabled for more information. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorLaunchIncompatibleTexturing = 703
+"""This error indicates a kernel launch that uses an incompatible texturing mode."""
+cudaErrorPeerAccessAlreadyEnabled = 704
+"""This error indicates that a call to :func:`cudaDeviceEnablePeerAccess` is trying to re-enable peer addressing on from a context which has already had peer addressing enabled."""
+cudaErrorPeerAccessNotEnabled = 705
+"""This error indicates that :func:`cudaDeviceDisablePeerAccess` is trying to disable peer addressing which has not been enabled yet via :func:`cudaDeviceEnablePeerAccess`."""
+cudaErrorSetOnActiveProcess = 708
+"""This indicates that the user has called :func:`cudaSetValidDevices`, :func:`cudaSetDeviceFlags`, :func:`cudaD3D9SetDirect3DDevice`, :func:`cudaD3D10SetDirect3DDevice`, :func:`cudaD3D11SetDirect3DDevice`, or :func:`cudaVDPAUSetVDPAUDevice` after initializing the CUDA Runtime by calling non-device management operations (allocating memory and launching kernels are examples of non-device management operations). This error can also be returned if using runtime / driver interoperability and there is an existing :class:`CUcontext` active on the host thread."""
+cudaErrorContextIsDestroyed = 709
+"""This error indicates that the context current to the calling thread has been destroyed using cuCtxDestroy, or is a primary context which has not yet been initialized."""
+cudaErrorAssert = 710
+"""An assert triggered in device code during kernel execution. The device cannot be used again. All existing allocations are invalid. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorTooManyPeers = 711
+"""This error indicates that the hardware resources required to enable peer access have been exhausted for one or more of the devices passed to :func:`cudaEnablePeerAccess`."""
+cudaErrorHostMemoryAlreadyRegistered = 712
+"""This error indicates that the memory range passed to :func:`cudaHostRegister` has already been registered."""
+cudaErrorHostMemoryNotRegistered = 713
+"""This error indicates that the pointer passed to :func:`cudaHostUnregister` does not correspond to any currently registered memory region."""
+cudaErrorHardwareStackError = 714
+"""Device encountered an error in the call stack during kernel execution, possibly due to stack corruption or exceeding the stack size limit. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorIllegalInstruction = 715
+"""The device encountered an illegal instruction during kernel execution This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorMisalignedAddress = 716
+"""The device encountered a load or store instruction on a memory address which is not aligned. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorInvalidAddressSpace = 717
+"""While executing a kernel, the device encountered an instruction which can only operate on memory locations in certain address spaces (global, shared, or local), but was supplied a memory address not belonging to an allowed address space. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorInvalidPc = 718
+"""The device encountered an invalid program counter. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorLaunchFailure = 719
+"""An exception occurred on the device while executing a kernel. Common causes include dereferencing an invalid device pointer and accessing out of bounds shared memory. Less common cases can be system specific - more information about these cases can be found in the system specific user guide. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorCooperativeLaunchTooLarge = 720
+"""This error indicates that the number of blocks launched per grid for a kernel that was launched via either :func:`cudaLaunchCooperativeKernel` or :func:`cudaLaunchCooperativeKernelMultiDevice` exceeds the maximum number of blocks as allowed by :func:`cudaOccupancyMaxActiveBlocksPerMultiprocessor` or :func:`cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags` times the number of multiprocessors as specified by the device attribute :func:`cudaDevAttrMultiProcessorCount`."""
+cudaErrorNotPermitted = 800
+"""This error indicates the attempted operation is not permitted."""
+cudaErrorNotSupported = 801
+"""This error indicates the attempted operation is not supported on the current system or device."""
+cudaErrorSystemNotReady = 802
+"""This error indicates that the system is not yet ready to start any CUDA work. To continue using CUDA, verify the system configuration is in a valid state and all required driver daemons are actively running. More information about this error can be found in the system specific user guide."""
+cudaErrorSystemDriverMismatch = 803
+"""This error indicates that there is a mismatch between the versions of the display driver and the CUDA driver. Refer to the compatibility documentation for supported versions."""
+cudaErrorCompatNotSupportedOnDevice = 804
+"""This error indicates that the system was upgraded to run with forward compatibility but the visible hardware detected by CUDA does not support this configuration. Refer to the compatibility documentation for the supported hardware matrix or ensure that only supported hardware is visible during initialization via the ``CUDA_VISIBLE_DEVICES`` environment variable."""
+cudaErrorMpsConnectionFailed = 805
+"""This error indicates that the MPS client failed to connect to the MPS control daemon or the MPS server."""
+cudaErrorMpsRpcFailure = 806
+"""This error indicates that the remote procedural call between the MPS server and the MPS client failed."""
+cudaErrorMpsServerNotReady = 807
+"""This error indicates that the MPS server is not ready to accept new MPS client requests. This error can be returned when the MPS server is in the process of recovering from a fatal failure."""
+cudaErrorMpsMaxClientsReached = 808
+"""This error indicates that the hardware resources required to create MPS client have been exhausted."""
+cudaErrorMpsMaxConnectionsReached = 809
+"""This error indicates the the hardware resources required to device connections have been exhausted."""
+cudaErrorMpsClientTerminated = 810
+"""This error indicates that the MPS client has been terminated by the server. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorCdpNotSupported = 811
+"""This error indicates, that the program is using CUDA Dynamic Parallelism, but the current configuration, like MPS, does not support it."""
+cudaErrorCdpVersionMismatch = 812
+"""This error indicates, that the program contains an unsupported interaction between different versions of CUDA Dynamic Parallelism."""
+cudaErrorStreamCaptureUnsupported = 900
+"""The operation is not permitted when the stream is capturing."""
+cudaErrorStreamCaptureInvalidated = 901
+"""The current capture sequence on the stream has been invalidated due to a previous error."""
+cudaErrorStreamCaptureMerge = 902
+"""The operation would have resulted in a merge of two independent capture sequences."""
+cudaErrorStreamCaptureUnmatched = 903
+"""The capture was not initiated in this stream."""
+cudaErrorStreamCaptureUnjoined = 904
+"""The capture sequence contains a fork that was not joined to the primary stream."""
+cudaErrorStreamCaptureIsolation = 905
+"""A dependency would have been created which crosses the capture sequence boundary. Only implicit in-stream ordering dependencies are allowed to cross the boundary."""
+cudaErrorStreamCaptureImplicit = 906
+"""The operation would have resulted in a disallowed implicit dependency on a current capture sequence from :data:`cudaStreamLegacy`."""
+cudaErrorCapturedEvent = 907
+"""The operation is not permitted on an event which was last recorded in a capturing stream."""
+cudaErrorStreamCaptureWrongThread = 908
+"""A stream capture sequence not initiated with the :data:`cudaStreamCaptureModeRelaxed` argument to :func:`cudaStreamBeginCapture` was passed to :func:`cudaStreamEndCapture` in a different thread."""
+cudaErrorTimeout = 909
+"""This indicates that the wait operation has timed out."""
+cudaErrorGraphExecUpdateFailure = 910
+"""This error indicates that the graph update was not performed because it included changes which violated constraints specific to instantiated graph update."""
+cudaErrorExternalDevice = 911
+"""This indicates that an async error has occurred in a device outside of CUDA. If CUDA was waiting for an external device's signal before consuming shared data, the external device signaled an error indicating that the data is not valid for consumption. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched."""
+cudaErrorInvalidClusterSize = 912
+"""This indicates that a kernel launch error has occurred due to cluster misconfiguration."""
+cudaErrorUnknown = 999
+"""This indicates that an unknown internal error has occurred."""
+# pylint: enable=line-too-long
+
+
+# Error Checking #
+class cudaError(Exception):
+    """Base exception class for CUDA driver query errors."""
+
+    _value_class_mapping: _ClassVar[dict[int, type[cudaError]]] = {}
+    _errcode_to_string: _ClassVar[dict[int, str]] = {  # List of currently known error codes
+        cudaErrorInitializationError:        'Initialization error.',
+        cudaErrorSymbolNotFound:             'Named symbol not found.',
+        cudaErrorInvalidValue:               'Invalid argument.',
+        cudaErrorNoDevice:                   'No CUDA-capable device is detected.',
+        cudaErrorInvalidDevice:              'Invalid device ordinal.',
+        cudaErrorSystemDriverMismatch:       'System has unsupported display driver / CUDA driver combination.',
+        cudaErrorCudartUnloading:            'Driver shutting down.',
+        cudaErrorCompatNotSupportedOnDevice: 'Forward compatibility was attempted on non supported Hardware.',
+        cudaErrorDeviceUninitialized:        'Invalid device context.',
+    }  # fmt:skip
+    _errcode_to_name: _ClassVar[dict[int, str]] = {}
+    value: int
+
+    def __new__(cls, value: int) -> _Self:
+        """Map value to a proper subclass of :class:`cudaError`."""
+        if cls is cudaError:
+            # pylint: disable-next=self-cls-assignment
+            cls = cudaError._value_class_mapping.get(value, cls)  # type: ignore[assignment]
+        obj = Exception.__new__(cls)
+        obj.value = value
+        return obj
+
+    def __repr__(self) -> str:
+        """Return a string representation of the error."""
+        # pylint: disable=no-member
+        try:
+            if self.value not in cudaError._errcode_to_string:
+                cudaError._errcode_to_string[self.value] = '{}.'.format(
+                    cuGetErrorString(self.value).rstrip('.').capitalize(),
+                )
+            if self.value not in cudaError._errcode_to_name:
+                cudaError._errcode_to_name[self.value] = cudaGetErrorName(self.value)
+            return (
+                f'{cudaError._errcode_to_string[self.value]} '
+                f'Code: {cudaError._errcode_to_name[self.value]} ({self.value}).'
+            )
+        except cudaError:
+            return f'CUDA Error with code {self.value}.'
+
+    def __eq__(self, other: object) -> bool:
+        """Test equality to other object."""
+        if not isinstance(other, cudaError):
+            return NotImplemented
+        return self.value == other.value  # pylint: disable=no-member
+
+    def __reduce__(self) -> tuple[type[cudaError], tuple[int]]:
+        """Return state information for pickling."""
+        return cudaError, (self.value,)  # pylint: disable=no-member
+
+
+def cudaExceptionClass(cudaErrorCode: int, /) -> type[cudaError]:
+    """Map value to a proper subclass of :class:`cudaError`.
+
+    Raises:
+        ValueError: If the error code is not valid.
+    """
+    if cudaErrorCode not in cudaError._value_class_mapping:  # pylint: disable=protected-access
+        raise ValueError(f'cudaErrorCode {cudaErrorCode} is not valid.')
+    return cudaError._value_class_mapping[cudaErrorCode]  # pylint: disable=protected-access
+
+
+def _extract_cuda_errors_as_classes() -> None:
+    """Generate a hierarchy of classes on top of :class:`cudaError` class.
+
+    Each CUDA Error gets a new :class:`cudaError` subclass. This way try-except blocks can filter
+    appropriate exceptions more easily.
+
+    :class:`cudaError` is a parent class. Each ``cudaError*`` gets it's own subclass.
+    e.g. :data:`cudaErrorInvalidValue` will be turned into :class:`cudaError_InvalidValue`.
+    """
+    this_module = _sys.modules[__name__]
+    cuda_error_names = [
+        x
+        for x in dir(this_module)
+        if x.startswith('cudaError') and not x.startswith('cudaError_') and x != 'cudaError'
+    ]
+    for err_name in cuda_error_names:
+        # e.g. Turn cudaErrorInvalidValue into cudaError_InvalidValue
+        class_name = err_name.replace('cudaError', 'cudaError_')
+        err_val = getattr(this_module, err_name)
+
+        def gen_new(value: int) -> _Callable[[type[cudaError]], cudaError]:
+            def new(cls: type[cudaError]) -> cudaError:
+                return cudaError.__new__(cls, value)
+
+            return new
+
+        # pylint: disable=protected-access
+        new_error_class = type(class_name, (cudaError,), {'__new__': gen_new(err_val)})
+        new_error_class.__module__ = __name__
+        if err_val in cudaError._errcode_to_string:
+            new_error_class.__doc__ = (
+                f'cudaError: {cudaError._errcode_to_string[err_val]} '
+                f'Code: :data:`{err_name}` ({err_val}).'
+            )
+        else:
+            new_error_class.__doc__ = f'CUDA Error with code :data:`{err_name}` ({err_val})'
+        setattr(this_module, class_name, new_error_class)
+        cudaError._value_class_mapping[err_val] = new_error_class
+        cudaError._errcode_to_name[err_val] = err_name
+
+
+# Add explicit references to appease linters
+class __cudaError(cudaError):
+    value: int
+
+    def __new__(cls) -> cudaError:  # type: ignore[misc,empty-body]
+        ...
+
+
+cudaError_InitializationError: type[__cudaError]
+cudaError_SymbolNotFound: type[__cudaError]
+cudaError_InvalidValue: type[__cudaError]
+cudaError_NoDevice: type[__cudaError]
+cudaError_InvalidDevice: type[__cudaError]
+cudaError_SystemDriverMismatch: type[__cudaError]
+cudaError_CudartUnloading: type[__cudaError]
+cudaError_CompatNotSupportedOnDevice: type[__cudaError]
+cudaError_DeviceUninitialized: type[__cudaError]
+
+_extract_cuda_errors_as_classes()
+del _extract_cuda_errors_as_classes
+
+
+def _cudaCheckReturn(ret: _Any, /) -> _Any:
+    if ret != cudaSuccess:
+        raise cudaError(ret)
+    return ret
+
+
+# Function access #
+__cudaLib: _ctypes.CDLL | None = None
+__libLoadLock: _threading.Lock = _threading.Lock()
+# Function pointers are cached to prevent unnecessary libLoadLock locking
+__cudaGetFunctionPointer_cache: dict[str, _ctypes._CFuncPtr] = {}  # type: ignore[name-defined]
+
+
+def __cudaGetFunctionPointer(name: str, /) -> _ctypes._CFuncPtr:  # type: ignore[name-defined]
+    """Get the function pointer from the CUDA Runtime library.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+        cudaError_SymbolNotFound:
+            If cannot found the function pointer.
+    """
+    if name in __cudaGetFunctionPointer_cache:
+        return __cudaGetFunctionPointer_cache[name]
+
+    if __cudaLib is None:
+        __LoadCudaLibrary()
+
+    with __libLoadLock:
+        try:
+            __cudaGetFunctionPointer_cache[name] = getattr(__cudaLib, name)
+            return __cudaGetFunctionPointer_cache[name]
+        except AttributeError as ex:
+            raise cudaError(cudaErrorSymbolNotFound) from ex
+
+
+def __LoadCudaLibrary() -> None:  # pylint: disable=too-many-branches
+    """Load the library if it isn't loaded already.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+    """
+    global __cudaLib  # pylint: disable=global-statement
+
+    if __cudaLib is None:
+        # Lock to ensure only one caller loads the library
+        with __libLoadLock:
+            # Ensure the library still isn't loaded
+            if __cudaLib is None:  # pylint: disable=too-many-nested-blocks
+                # Platform specific libcudart location
+                system = _platform.system()
+                bits = 8 * _ctypes.sizeof(_ctypes.c_void_p)  # 64 or 32
+                if system == 'Darwin':
+                    lib_filenames = ['libcudart.dylib']
+                elif system == 'Linux':
+                    lib_filenames = ['libcudart.so']
+                elif system == 'Windows':
+                    lib_filenames = [f'cudart{bits}.dll', 'cudart.dll']
+                else:
+                    lib_filenames = []
+
+                # Open library
+                for lib_filename in lib_filenames:
+                    try:
+                        __cudaLib = _ctypes.CDLL(lib_filename)
+                        break
+                    except OSError:
+                        pass
+
+                # Try to load the library from the CUDA_PATH environment variable
+                if __cudaLib is None:
+                    cuda_paths = [
+                        _os.getenv(env_name, '')
+                        for env_name in ('CUDA_PATH', 'CUDA_HOME', 'CUDA_ROOT')
+                    ]
+                    if system != 'Windows':
+                        cuda_paths.append('/usr/local/cuda')
+                        candidate_paths = []
+                        for cuda_path in cuda_paths:
+                            if _os.path.isdir(cuda_path):
+                                for lib_filename in lib_filenames:
+                                    candidate_paths.extend(
+                                        [
+                                            _os.path.join(cuda_path, f'lib{bits}', lib_filename),
+                                            _os.path.join(cuda_path, 'lib', lib_filename),
+                                        ],
+                                    )
+                    else:
+                        candidate_dirs = _os.getenv('PATH', '').split(_os.path.pathsep)
+                        candidate_paths = []
+                        for cuda_path in cuda_paths:
+                            if _os.path.isdir(cuda_path):
+                                candidate_dirs.extend(
+                                    [
+                                        _os.path.join(cuda_path, 'bin'),
+                                        _os.path.join(cuda_path, f'lib{bits}'),
+                                        _os.path.join(cuda_path, 'lib'),
+                                    ],
+                                )
+                        for candidate_dir in candidate_dirs:
+                            candidate_paths.extend(
+                                _glob.iglob(_os.path.join(candidate_dir, f'cudart{bits}*.dll')),
+                            )
+
+                    # Normalize paths and remove duplicates
+                    candidate_paths = list(
+                        dict.fromkeys(
+                            _os.path.normpath(_os.path.normcase(p)) for p in candidate_paths
+                        ),
+                    )
+                    for lib_filename in candidate_paths:
+                        try:
+                            __cudaLib = _ctypes.CDLL(lib_filename)
+                            break
+                        except OSError:
+                            pass
+
+                if __cudaLib is None:
+                    _cudaCheckReturn(cudaErrorInitializationError)
+
+
+def cudaGetErrorName(error: int) -> str:
+    """Get the string representation of an error code enum name.
+
+    Returns: str
+        A string containing the name of an error code in the enum. If the error code is not
+        recognized, "unrecognized error code" is returned.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+    """
+    fn = __cudaGetFunctionPointer('cudaGetErrorName')
+
+    fn.restype = _ctypes.c_char_p  # otherwise return is an int
+    p_name = fn(_cudaError_t(error))
+    name = _ctypes.string_at(p_name)
+    return name.decode('utf-8', errors='replace')
+
+
+def cuGetErrorString(error: int) -> str:
+    """Get the description string for an error code.
+
+    Returns: str
+        The description string for an error code. If the error code is not recognized, "unrecognized
+        error code" is returned.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+    """
+    fn = __cudaGetFunctionPointer('cudaGetErrorString')
+
+    fn.restype = _ctypes.c_char_p  # otherwise return is an int
+    p_name = fn(_cudaError_t(error))
+    name = _ctypes.string_at(p_name)
+    return name.decode('utf-8', errors='replace')
+
+
+def cudaGetLastError() -> int:
+    """Get the last error from a runtime call.
+
+    Returns: int
+        The last error that has been produced by any of the runtime calls in the same instance of
+        the CUDA Runtime library in the host thread and resets it to :data:`cudaSuccess`.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+        cudaError_InsufficientDriver:
+            If the installed NVIDIA CUDA driver is older than the CUDA Runtime library.
+        cudaError_NoDevice:
+            If no CUDA-capable devices were detected by the installed CUDA driver.
+    """
+    fn = __cudaGetFunctionPointer('cudaGetLastError')
+    return fn()
+
+
+def cudaPeekAtLastError() -> int:
+    """Get the last error from a runtime call.
+
+    Returns: int
+        The last error that has been produced by any of the runtime calls in the same instance of
+        the CUDA Runtime library in the host thread. This call does not reset the error to
+        :data:`cudaSuccess` like :func:`cudaGetLastError`.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+        cudaError_InsufficientDriver:
+            If the installed NVIDIA CUDA driver is older than the CUDA Runtime library.
+        cudaError_NoDevice:
+            If no CUDA-capable devices were detected by the installed CUDA driver.
+    """
+    fn = __cudaGetFunctionPointer('cudaPeekAtLastError')
+    return fn()
+
+
+def cudaDriverGetVersion() -> str:
+    """Get the latest CUDA version supported by driver.
+
+    Returns: str
+        The latest version of CUDA supported by the driver of the form :data:`'<major>.<minor>'`.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+        cudaError_InsufficientDriver:
+            If the installed NVIDIA CUDA driver is older than the CUDA Runtime library.
+        cudaError_NoDevice:
+            If no CUDA-capable devices were detected by the installed CUDA driver.
+    """
+    fn = __cudaGetFunctionPointer('cudaDriverGetVersion')
+
+    driver_version = _ctypes.c_int(0)
+    ret = fn(_ctypes.byref(driver_version))
+    _cudaCheckReturn(ret)
+    major = driver_version.value // 1000
+    minor = (driver_version.value % 1000) // 10
+    return f'{major}.{minor}'
+
+
+def cudaRuntimeGetVersion() -> str:
+    """Get the CUDA Runtime version.
+
+    Returns: str
+        The version number of the current CUDA Runtime instance of the form :data:`'<major>.<minor>'`.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+        cudaError_InsufficientDriver:
+            If the installed NVIDIA CUDA driver is older than the CUDA Runtime library.
+        cudaError_NoDevice:
+            If no CUDA-capable devices were detected by the installed CUDA driver.
+    """
+    fn = __cudaGetFunctionPointer('cudaRuntimeGetVersion')
+
+    runtime_version = _ctypes.c_int(0)
+    ret = fn(_ctypes.byref(runtime_version))
+    _cudaCheckReturn(ret)
+    major = runtime_version.value // 1000
+    minor = (runtime_version.value % 1000) // 10
+    return f'{major}.{minor}'
+
+
+def cudaGetDeviceCount() -> int:
+    """Get the number of compute-capable devices.
+
+    Returns: int
+        The number of devices with compute capability greater or equal to 2.0 that are available for
+        execution.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+        cudaError_InsufficientDriver:
+            If the installed NVIDIA CUDA driver is older than the CUDA Runtime library.
+        cudaError_NoDevice:
+            If no CUDA-capable devices were detected by the installed CUDA driver.
+    """
+    fn = __cudaGetFunctionPointer('cudaGetDeviceCount')
+
+    count = _ctypes.c_int(0)
+    ret = fn(_ctypes.byref(count))
+    _cudaCheckReturn(ret)
+    return count.value
+
+
+def cudaDeviceGetByPCIBusId(pciBusId: str) -> int:
+    """Get a handle to a compute device.
+
+    Args:
+        pciBusId (str):
+            String in one of the following forms: ``[domain]:[bus]:[device].[function]``,
+            ``[domain]:[bus]:[device]``, ``[bus]:[device].[function]`` where ``domain``, ``bus``,
+            ``device``, and ``function`` are all hexadecimal values.
+
+    Returns: int
+        A device ordinal given a PCI bus ID string.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+        cudaError_InsufficientDriver:
+            If the installed NVIDIA CUDA driver is older than the CUDA Runtime library.
+        cudaError_NoDevice:
+            If no CUDA-capable devices were detected by the installed CUDA driver.
+        cudaError_InvalidValue:
+            If the value of :data:`pciBusId` is not a valid PCI bus identifier.
+        cudaError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device.
+    """
+    fn = __cudaGetFunctionPointer('cudaDeviceGetByPCIBusId')
+
+    device = _ctypes.c_int(0)
+    ret = fn(_ctypes.byref(device), _ctypes.c_char_p(pciBusId.encode('utf-8')))
+    _cudaCheckReturn(ret)
+    return device.value
+
+
+def cudaDeviceGetPCIBusId(device: int) -> str:
+    """Get a PCI Bus Id string for the device.
+
+    Returns: str
+        An ASCII string identifying the device.
+
+    Raises:
+        cudaError_InitializationError:
+            If cannot found the CUDA Runtime library.
+        cudaError_InsufficientDriver:
+            If the installed NVIDIA CUDA driver is older than the CUDA Runtime library.
+        cudaError_NoDevice:
+            If no CUDA-capable devices were detected by the installed CUDA driver.
+        cudaError_InvalidValue:
+            If the value of :data:`device` is not a valid device ordinal.
+        cudaError_InvalidDevice:
+            If the device ordinal supplied by the user does not correspond to a valid CUDA device.
+    """
+    fn = __cudaGetFunctionPointer('cudaDeviceGetPCIBusId')
+
+    pciBusId = _ctypes.create_string_buffer(256)
+    ret = fn(pciBusId, _ctypes.c_int(256), _ctypes.c_int(device))
+    _cudaCheckReturn(ret)
+    return pciBusId.value.decode('utf-8', errors='replace')
+
+
+def is_available() -> bool:
+    """Test whether there are any CUDA visible devices."""
+    try:
+        return cudaGetDeviceCount() > 0
+    except cudaError:
+        return False

.venv/lib/python3.10/site-packages/nvitop/api/libnvml.py

@@ -0,0 +1,1020 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities for the NVML Python bindings (`nvidia-ml-py <https://pypi.org/project/nvidia-ml-py>`_)."""
+
+# pylint: disable=too-many-lines,invalid-name
+
+from __future__ import annotations
+
+import atexit as _atexit
+import ctypes as _ctypes
+import inspect as _inspect
+import logging as _logging
+import os as _os
+import re as _re
+import sys as _sys
+import threading as _threading
+import time as _time
+from types import FunctionType as _FunctionType
+from types import ModuleType as _ModuleType
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+from typing import Any as _Any
+from typing import ClassVar as _ClassVar
+
+# Python Bindings for the NVIDIA Management Library (NVML)
+# https://pypi.org/project/nvidia-ml-py
+import pynvml as _pynvml
+from pynvml import *  # noqa: F403 # pylint: disable=wildcard-import,unused-wildcard-import
+from pynvml import nvmlDeviceGetPciInfo  # appease mypy # noqa: F401 # pylint: disable=unused-import
+
+from nvitop.api.utils import NA, UINT_MAX, ULONGLONG_MAX, NaType
+from nvitop.api.utils import colored as __colored
+
+
+if _TYPE_CHECKING:
+    from collections.abc import Callable as _Callable
+    from typing_extensions import Self as _Self  # Python 3.11+
+    from typing_extensions import TypeAlias as _TypeAlias  # Python 3.10+
+
+
+__all__ = [  # will be updated in below
+    'NA',
+    'UINT_MAX',
+    'ULONGLONG_MAX',
+    'NVMLError',
+    'nvmlCheckReturn',
+    'nvmlInit',
+    'nvmlInitWithFlags',
+    'nvmlQuery',
+    'nvmlQueryFieldValues',
+    'nvmlShutdown',
+]
+
+
+if not callable(getattr(_pynvml, 'nvmlInitWithFlags', None)):
+    raise ImportError(  # noqa: TRY004
+        'Your installed package `nvidia-ml-py` is corrupted. Please reinstall package '
+        '`nvidia-ml-py` via `pip3 install --force-reinstall nvidia-ml-py nvitop`.',
+    )
+
+
+# Members from `pynvml` ############################################################################
+
+NVMLError: type[_pynvml.NVMLError] = _pynvml.NVMLError
+NVMLError.__doc__ = """Base exception class for NVML query errors."""
+NVMLError.__new__.__doc__ = """Map value to a proper subclass of :class:`NVMLError`."""
+nvmlExceptionClass: _Callable[[int], type[_pynvml.NVMLError]] = _pynvml.nvmlExceptionClass
+nvmlExceptionClass.__doc__ = """Map value to a proper subclass of :class:`NVMLError`."""
+
+# Load members from module `pynvml` and register them in `__all__` and globals.
+_vars_pynvml = vars(_pynvml)
+_name = _attr = None
+_errcode_to_name = {}
+_const_names = []
+_errcode_to_string = NVMLError._errcode_to_string  # pylint: disable=protected-access
+
+# 1. Put error classes in `__all__` first
+for _name, _attr in _vars_pynvml.items():
+    if _name in {'nvmlInit', 'nvmlInitWithFlags', 'nvmlShutdown'}:
+        continue
+    if _name.startswith(('NVML_ERROR_', 'NVMLError_')):
+        __all__.append(_name)  # noqa: PYI056
+        if _name.startswith('NVML_ERROR_'):
+            _errcode_to_name[_attr] = _name
+            _const_names.append(_name)
+
+# 2. Then the remaining members
+for _name, _attr in _vars_pynvml.items():
+    if _name in {'nvmlInit', 'nvmlInitWithFlags', 'nvmlShutdown'}:
+        continue
+    if (_name.startswith('NVML_') and not _name.startswith('NVML_ERROR_')) or (
+        _name.startswith('nvml') and isinstance(_attr, _FunctionType)
+    ):
+        __all__.append(_name)  # noqa: PYI056
+        if _name.startswith('NVML_'):
+            _const_names.append(_name)
+
+# 3. Add docstring to exception classes
+_errcode = _reason = _subclass = None
+for _errcode, _reason in _errcode_to_string.items():
+    _subclass = nvmlExceptionClass(_errcode)
+    _subclass.__doc__ = '{}. Code: :data:`{}` ({})'.format(
+        _reason.rstrip('.'),
+        _errcode_to_name[_errcode],
+        _errcode,
+    )
+
+# 4. Add undocumented constants into module docstring
+_data_docs = []
+_sphinx_doc = None
+for _name in _const_names:
+    _attr = _vars_pynvml[_name]
+    _sphinx_doc = f"""
+.. data:: {_name}
+    :type: {_attr.__class__.__name__}
+    :value: {_attr!r}
+"""
+    if _name.startswith('NVML_ERROR_') and _attr in _errcode_to_string:
+        _reason = _errcode_to_string[_attr]
+        _sphinx_doc += """
+    {}. See also class :class:`NVMLError` and :class:`{}`.
+""".format(_reason.rstrip('.'), nvmlExceptionClass(_attr).__name__)  # fmt: skip
+    _data_docs.append(_sphinx_doc.strip())
+__doc__ += """
+
+---------
+
+Constants
+^^^^^^^^^
+
+{}
+
+---------
+
+Functions and Exceptions
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. function:: __enter__() -> libnvml
+
+    Entry of the context manager for ``with`` statement.
+
+.. function:: __exit__(*args, **kwargs) -> None
+
+    Shutdown the NVML context in the context manager for ``with`` statement.
+
+""".format('\n\n'.join(_data_docs))  # fmt: skip
+
+del (
+    _name,
+    _attr,
+    _vars_pynvml,
+    _errcode,
+    _reason,
+    _subclass,
+    _errcode_to_name,
+    _errcode_to_string,
+    _const_names,
+    _data_docs,
+    _sphinx_doc,
+)
+
+# 5. Add explicit references to appease linters
+# pylint: disable=no-member
+if _TYPE_CHECKING:
+    # pylint: disable-next=missing-class-docstring,too-few-public-methods,function-redefined
+    class c_nvmlDevice_t(_ctypes.c_void_p):
+        pass
+
+else:
+    c_nvmlDevice_t: _TypeAlias = _pynvml.c_nvmlDevice_t  # type: ignore[no-redef] # noqa: PYI042
+
+c_nvmlFieldValue_t: _TypeAlias = _pynvml.c_nvmlFieldValue_t  # noqa: PYI042
+NVML_SUCCESS: int = _pynvml.NVML_SUCCESS
+NVML_ERROR_INSUFFICIENT_SIZE: int = _pynvml.NVML_ERROR_INSUFFICIENT_SIZE
+NVMLError_FunctionNotFound: _TypeAlias = _pynvml.NVMLError_FunctionNotFound
+NVMLError_GpuIsLost: _TypeAlias = _pynvml.NVMLError_GpuIsLost
+NVMLError_InvalidArgument: _TypeAlias = _pynvml.NVMLError_InvalidArgument
+NVMLError_LibraryNotFound: _TypeAlias = _pynvml.NVMLError_LibraryNotFound
+NVMLError_NoPermission: _TypeAlias = _pynvml.NVMLError_NoPermission
+NVMLError_NotFound: _TypeAlias = _pynvml.NVMLError_NotFound
+NVMLError_NotSupported: _TypeAlias = _pynvml.NVMLError_NotSupported
+NVMLError_Unknown: _TypeAlias = _pynvml.NVMLError_Unknown
+NVML_CLOCK_GRAPHICS: int = _pynvml.NVML_CLOCK_GRAPHICS
+NVML_CLOCK_SM: int = _pynvml.NVML_CLOCK_SM
+NVML_CLOCK_MEM: int = _pynvml.NVML_CLOCK_MEM
+NVML_CLOCK_VIDEO: int = _pynvml.NVML_CLOCK_VIDEO
+NVML_TEMPERATURE_GPU: int = _pynvml.NVML_TEMPERATURE_GPU
+NVML_DRIVER_WDDM: int = _pynvml.NVML_DRIVER_WDDM
+NVML_DRIVER_WDM: int = _pynvml.NVML_DRIVER_WDM
+NVML_MEMORY_ERROR_TYPE_UNCORRECTED: int = _pynvml.NVML_MEMORY_ERROR_TYPE_UNCORRECTED
+NVML_VOLATILE_ECC: int = _pynvml.NVML_VOLATILE_ECC
+NVML_COMPUTEMODE_DEFAULT: int = _pynvml.NVML_COMPUTEMODE_DEFAULT
+NVML_COMPUTEMODE_EXCLUSIVE_THREAD: int = _pynvml.NVML_COMPUTEMODE_EXCLUSIVE_THREAD
+NVML_COMPUTEMODE_PROHIBITED: int = _pynvml.NVML_COMPUTEMODE_PROHIBITED
+NVML_COMPUTEMODE_EXCLUSIVE_PROCESS: int = _pynvml.NVML_COMPUTEMODE_EXCLUSIVE_PROCESS
+NVML_PCIE_UTIL_TX_BYTES: int = _pynvml.NVML_PCIE_UTIL_TX_BYTES
+NVML_PCIE_UTIL_RX_BYTES: int = _pynvml.NVML_PCIE_UTIL_RX_BYTES
+NVML_NVLINK_MAX_LINKS: int = _pynvml.NVML_NVLINK_MAX_LINKS
+NVML_FI_DEV_NVLINK_LINK_COUNT: int = _pynvml.NVML_FI_DEV_NVLINK_LINK_COUNT
+NVML_FI_DEV_NVLINK_THROUGHPUT_DATA_TX: int = _pynvml.NVML_FI_DEV_NVLINK_THROUGHPUT_DATA_TX
+NVML_FI_DEV_NVLINK_THROUGHPUT_DATA_RX: int = _pynvml.NVML_FI_DEV_NVLINK_THROUGHPUT_DATA_RX
+NVML_FI_DEV_NVLINK_THROUGHPUT_RAW_TX: int = _pynvml.NVML_FI_DEV_NVLINK_THROUGHPUT_RAW_TX
+NVML_FI_DEV_NVLINK_THROUGHPUT_RAW_RX: int = _pynvml.NVML_FI_DEV_NVLINK_THROUGHPUT_RAW_RX
+NVML_VALUE_TYPE_DOUBLE: int = getattr(_pynvml, 'NVML_VALUE_TYPE_DOUBLE', 0)
+NVML_VALUE_TYPE_UNSIGNED_INT: int = getattr(_pynvml, 'NVML_VALUE_TYPE_UNSIGNED_INT', 1)
+NVML_VALUE_TYPE_UNSIGNED_LONG: int = getattr(_pynvml, 'NVML_VALUE_TYPE_UNSIGNED_LONG', 2)
+NVML_VALUE_TYPE_UNSIGNED_LONG_LONG: int = getattr(_pynvml, 'NVML_VALUE_TYPE_UNSIGNED_LONG_LONG', 3)
+NVML_VALUE_TYPE_SIGNED_LONG_LONG: int = getattr(_pynvml, 'NVML_VALUE_TYPE_SIGNED_LONG_LONG', 4)
+NVML_VALUE_TYPE_SIGNED_INT: int = getattr(_pynvml, 'NVML_VALUE_TYPE_SIGNED_INT', 5)
+# pylint: enable=no-member
+
+# New members in `libnvml` #########################################################################
+
+__flags: list[int] = []
+__initialized: bool = False
+__lock: _threading.Lock = _threading.Lock()
+
+LOGGER: _logging.Logger = _logging.getLogger(__name__)
+try:
+    LOGGER.setLevel(_os.getenv('LOGLEVEL', default='WARNING').upper())
+except (ValueError, TypeError):
+    pass
+if not LOGGER.hasHandlers() and LOGGER.isEnabledFor(_logging.DEBUG):
+    _formatter = _logging.Formatter(
+        '[%(levelname)s] %(asctime)s %(name)s::%(funcName)s: %(message)s',
+    )
+    _stream_handler = _logging.StreamHandler()
+    _stream_handler.setFormatter(_formatter)
+    _file_handler = _logging.FileHandler('nvitop.log')
+    _file_handler.setFormatter(_formatter)
+    LOGGER.addHandler(_stream_handler)
+    LOGGER.addHandler(_file_handler)
+    del _formatter, _stream_handler, _file_handler
+
+UNKNOWN_FUNCTIONS: dict[str, tuple[_Callable | str, NVMLError_FunctionNotFound]] = {}
+UNKNOWN_FUNCTIONS_CACHE_SIZE: int = 1024
+VERSIONED_PATTERN: _re.Pattern = _re.compile(r'^(?P<name>\w+)(?P<suffix>_v(\d)+)$')
+
+
+def _lazy_init() -> None:
+    """Lazily initialize the NVML context.
+
+    Raises:
+        NVMLError_LibraryNotFound:
+            If cannot find the NVML library, usually the NVIDIA driver is not installed.
+        NVMLError_DriverNotLoaded:
+            If NVIDIA driver is not loaded.
+        NVMLError_LibRmVersionMismatch:
+            If RM detects a driver/library version mismatch, usually after an upgrade for NVIDIA
+            driver without reloading the kernel module.
+        AttributeError:
+            If cannot find function :func:`pynvml.nvmlInitWithFlags`, usually the :mod:`pynvml` module
+            is overridden by other modules. Need to reinstall package ``nvidia-ml-py``.
+    """
+    if __initialized:
+        return
+
+    with __lock:
+        if __initialized:
+            return  # type: ignore[unreachable]
+
+    nvmlInit()
+    _atexit.register(nvmlShutdown)
+
+
+def nvmlInit() -> None:  # pylint: disable=function-redefined
+    """Initialize the NVML context with default flag (0).
+
+    Raises:
+        NVMLError_LibraryNotFound:
+            If cannot find the NVML library, usually the NVIDIA driver is not installed.
+        NVMLError_DriverNotLoaded:
+            If NVIDIA driver is not loaded.
+        NVMLError_LibRmVersionMismatch:
+            If RM detects a driver/library version mismatch, usually after an upgrade for NVIDIA
+            driver without reloading the kernel module.
+        AttributeError:
+            If cannot find function :func:`pynvml.nvmlInitWithFlags`, usually the :mod:`pynvml` module
+            is overridden by other modules. Need to reinstall package ``nvidia-ml-py``.
+    """
+    nvmlInitWithFlags(0)
+
+
+def nvmlInitWithFlags(flags: int) -> None:  # pylint: disable=function-redefined
+    """Initialize the NVML context with the given flags.
+
+    Raises:
+        NVMLError_LibraryNotFound:
+            If cannot find the NVML library, usually the NVIDIA driver is not installed.
+        NVMLError_DriverNotLoaded:
+            If NVIDIA driver is not loaded.
+        NVMLError_LibRmVersionMismatch:
+            If RM detects a driver/library version mismatch, usually after an upgrade for NVIDIA
+            driver without reloading the kernel module.
+        AttributeError:
+            If cannot find function :func:`pynvml.nvmlInitWithFlags`, usually the :mod:`pynvml` module
+            is overridden by other modules. Need to reinstall package ``nvidia-ml-py``.
+    """
+    global __flags, __initialized  # pylint: disable=global-statement,global-variable-not-assigned
+
+    with __lock:
+        if len(__flags) > 0 and flags == __flags[-1]:
+            __initialized = True
+            return
+
+    try:
+        _pynvml.nvmlInitWithFlags(flags)
+    except NVMLError_LibraryNotFound:
+        message = (
+            'FATAL ERROR: NVIDIA Management Library (NVML) not found.\n'
+            'HINT: The NVIDIA Management Library ships with the NVIDIA display driver (available at\n'
+            '      https://www.nvidia.com/Download/index.aspx), or can be downloaded as part of the\n'
+            '      NVIDIA CUDA Toolkit (available at https://developer.nvidia.com/cuda-downloads).\n'
+            '      The lists of OS platforms and NVIDIA-GPUs supported by the NVML library can be\n'
+            '      found in the NVML API Reference at https://docs.nvidia.com/deploy/nvml-api.'
+        )
+        for text, color, attrs in (
+            ('FATAL ERROR:', 'red', ('bold',)),
+            ('HINT:', 'yellow', ('bold',)),
+            ('https://www.nvidia.com/Download/index.aspx', None, ('underline',)),
+            ('https://developer.nvidia.com/cuda-downloads', None, ('underline',)),
+            ('https://docs.nvidia.com/deploy/nvml-api', None, ('underline',)),
+        ):
+            message = message.replace(text, __colored(text, color=color, attrs=attrs))  # type: ignore[arg-type]
+
+        LOGGER.critical(message)
+        raise
+    except AttributeError:
+        message = (
+            'FATAL ERROR: The dependency package `nvidia-ml-py` is corrupted. You may have installed\n'
+            '             other packages overriding the module `pynvml`.\n'
+            'Please reinstall `nvitop` with command:\n'
+            '    python3 -m pip install --force-reinstall nvitop'
+        )
+        for text, color, attrs in (
+            ('FATAL ERROR:', 'red', ('bold',)),
+            ('nvidia-ml-py', None, ('bold',)),
+            ('pynvml', None, ('bold',)),
+            ('nvitop', None, ('bold',)),
+        ):
+            message = message.replace(text, __colored(text, color=color, attrs=attrs), 1)  # type: ignore[arg-type]
+
+        LOGGER.critical(message)
+        raise
+
+    with __lock:
+        __flags.append(flags)
+        __initialized = True
+
+
+def nvmlShutdown() -> None:  # pylint: disable=function-redefined
+    """Shutdown the NVML context.
+
+    Raises:
+        NVMLError_LibraryNotFound:
+            If cannot find the NVML library, usually the NVIDIA driver is not installed.
+        NVMLError_DriverNotLoaded:
+            If NVIDIA driver is not loaded.
+        NVMLError_LibRmVersionMismatch:
+            If RM detects a driver/library version mismatch, usually after an upgrade for NVIDIA
+            driver without reloading the kernel module.
+        NVMLError_Uninitialized:
+            If NVML was not first initialized with :func:`nvmlInit`.
+    """
+    global __flags, __initialized  # pylint: disable=global-statement,global-variable-not-assigned
+
+    _pynvml.nvmlShutdown()
+    with __lock:
+        try:
+            __flags.pop()
+        except IndexError:
+            pass
+        __initialized = len(__flags) > 0
+
+
+def nvmlQuery(
+    func: _Callable[..., _Any] | str,
+    /,
+    *args: _Any,
+    default: _Any = NA,
+    ignore_errors: bool = True,
+    ignore_function_not_found: bool = False,
+    **kwargs: _Any,
+) -> _Any:
+    """Call a function with the given arguments from NVML.
+
+    The NVML context will be automatically initialized.
+
+    Args:
+        func (Union[Callable[..., Any], str]):
+            The function to call. If it is given by string, lookup for the function first from
+            module :mod:`pynvml`.
+        default (Any):
+            The default value if the query fails.
+        ignore_errors (bool):
+            Whether to ignore errors and return the default value.
+        ignore_function_not_found (bool):
+            Whether to ignore function not found errors and return the default value. If set to
+            :data:`False`, an error message will be logged to the logger.
+        *args:
+            Positional arguments to pass to the query function.
+        **kwargs:
+            Keyword arguments to pass to the query function.
+
+    Raises:
+        NVMLError_LibraryNotFound:
+            If cannot find the NVML library, usually the NVIDIA driver is not installed.
+        NVMLError_DriverNotLoaded:
+            If NVIDIA driver is not loaded.
+        NVMLError_LibRmVersionMismatch:
+            If RM detects a driver/library version mismatch, usually after an upgrade for NVIDIA
+            driver without reloading the kernel module.
+        NVMLError_FunctionNotFound:
+            If the function is not found, usually the installed ``nvidia-ml-py`` is not compatible
+            with the installed NVIDIA driver.
+        NVMLError_NotSupported:
+            If the function is not supported by the driver or the device.
+        NVMLError_InvalidArgument:
+            If passed with an invalid argument.
+    """
+    global UNKNOWN_FUNCTIONS  # pylint: disable=global-statement,global-variable-not-assigned
+
+    _lazy_init()
+
+    try:
+        if isinstance(func, str):
+            try:
+                func = getattr(__modself, func)
+            except AttributeError as e1:
+                raise NVMLError_FunctionNotFound from e1
+
+        try:
+            retval = func(*args, **kwargs)  # type: ignore[operator]
+        except UnicodeDecodeError as e2:
+            raise NVMLError_Unknown from e2
+    except NVMLError_FunctionNotFound as e3:
+        if not ignore_function_not_found:
+            identifier = (
+                func
+                if isinstance(func, str)
+                else (_inspect.getsource(func) if func.__name__ == '<lambda>' else repr(func))
+            )
+            with __lock:
+                if (
+                    identifier not in UNKNOWN_FUNCTIONS
+                    and len(UNKNOWN_FUNCTIONS) < UNKNOWN_FUNCTIONS_CACHE_SIZE
+                ):
+                    UNKNOWN_FUNCTIONS[identifier] = (func, e3)
+                    LOGGER.exception(
+                        (
+                            'ERROR: A FunctionNotFound error occurred while calling %s.\n'
+                            'Please verify whether the `nvidia-ml-py` package is '
+                            'compatible with your NVIDIA driver version.'
+                        ),
+                        f'nvmlQuery({func!r}, *args, **kwargs)',
+                    )
+        if ignore_errors or ignore_function_not_found:
+            return default
+        raise
+    except NVMLError:
+        if ignore_errors:
+            return default
+        raise
+
+    if isinstance(retval, bytes):
+        retval = retval.decode('utf-8', errors='replace')
+    return retval
+
+
+def nvmlQueryFieldValues(
+    handle: c_nvmlDevice_t,
+    field_ids: list[int | tuple[int, int]],
+) -> list[tuple[float | int | NaType, int]]:
+    """Query multiple field values from NVML.
+
+    Request values for a list of fields for a device. This API allows multiple fields to be queried
+    at once. If any of the underlying fieldIds are populated by the same driver call, the results
+    for those field IDs will be populated from a single call rather than making a driver call for
+    each fieldId.
+
+    Raises:
+        NVMLError_InvalidArgument:
+            If device or field_ids is invalid.
+    """
+    field_values = nvmlQuery('nvmlDeviceGetFieldValues', handle, field_ids)
+
+    if not nvmlCheckReturn(field_values):
+        timestamp = _time.time_ns() // 1000
+        return [(NA, timestamp) for _ in range(len(field_ids))]
+
+    values_with_timestamps: list[tuple[float | int | NaType, int]] = []
+    for field_value in field_values:
+        timestamp = field_value.timestamp
+        if field_value.nvmlReturn != NVML_SUCCESS:
+            value = NA
+            timestamp = _time.time_ns() // 1000
+        elif field_value.valueType == NVML_VALUE_TYPE_DOUBLE:
+            value = field_value.value.dVal
+        elif field_value.valueType == NVML_VALUE_TYPE_UNSIGNED_INT:
+            value = field_value.value.uiVal
+        elif field_value.valueType == NVML_VALUE_TYPE_UNSIGNED_LONG:
+            value = field_value.value.ulVal
+        elif field_value.valueType == NVML_VALUE_TYPE_UNSIGNED_LONG_LONG:
+            value = field_value.value.ullVal
+        elif field_value.valueType == NVML_VALUE_TYPE_SIGNED_LONG_LONG:
+            value = field_value.value.llVal
+        elif field_value.valueType == NVML_VALUE_TYPE_SIGNED_INT:
+            value = field_value.value.iVal
+        else:
+            value = NA
+        values_with_timestamps.append((value, timestamp))
+    return values_with_timestamps
+
+
+def nvmlCheckReturn(retval: _Any, types: type | tuple[type, ...] | None = None, /) -> bool:
+    """Check whether the return value is not :const:`nvitop.NA` and is one of the given types."""
+    if types is None:
+        return retval != NA
+    return retval != NA and isinstance(retval, types)
+
+
+# Patch layers for backward compatibility ##########################################################
+_pynvml_installation_corrupted: bool = not callable(
+    getattr(_pynvml, '_nvmlGetFunctionPointer', None),
+) and isinstance(getattr(_pynvml, '_PrintableStructure', None), type)
+
+# Patch function `nvmlDeviceGet{Compute,Graphics,MPSCompute}RunningProcesses`
+if not _pynvml_installation_corrupted:
+    # pylint: disable-next=ungrouped-imports
+    from pynvml import _nvmlGetFunctionPointer, _PrintableStructure, nvmlStructToFriendlyObject
+
+    def _nvmlLookupFunctionPointer(symbol: str) -> _Any | None:
+        try:
+            ptr = _nvmlGetFunctionPointer(symbol)
+        except NVMLError_FunctionNotFound:
+            LOGGER.debug('Failed to found symbol `%s`.', symbol)
+            return None
+        LOGGER.debug('Found symbol `%s`.', symbol)
+        return ptr
+
+    # pylint: disable-next=missing-class-docstring,too-few-public-methods,function-redefined
+    class c_nvmlProcessInfo_v1_t(_PrintableStructure):
+        _fields_: _ClassVar[list[tuple[str, type]]] = [
+            # Process ID
+            ('pid', _ctypes.c_uint),
+            # Amount of used GPU memory in bytes.
+            # Under WDDM, NVML_VALUE_NOT_AVAILABLE is always reported because Windows KMD manages
+            # all the memory and not the NVIDIA driver.
+            ('usedGpuMemory', _ctypes.c_ulonglong),
+        ]
+        _fmt_: _ClassVar[dict[str, str]] = {
+            'usedGpuMemory': '%d B',
+        }
+
+    # pylint: disable-next=missing-class-docstring,too-few-public-methods,function-redefined
+    class c_nvmlProcessInfo_v2_t(_PrintableStructure):
+        _fields_: _ClassVar[list[tuple[str, type]]] = [
+            # Process ID
+            ('pid', _ctypes.c_uint),
+            # Amount of used GPU memory in bytes.
+            # Under WDDM, NVML_VALUE_NOT_AVAILABLE is always reported because Windows KMD manages
+            # all the memory and not the NVIDIA driver.
+            ('usedGpuMemory', _ctypes.c_ulonglong),
+            # If MIG is enabled, stores a valid GPU instance ID. gpuInstanceId is set to 0xFFFFFFFF
+            # otherwise.
+            ('gpuInstanceId', _ctypes.c_uint),
+            # If MIG is enabled, stores a valid compute instance ID. computeInstanceId is set to
+            # 0xFFFFFFFF otherwise.
+            ('computeInstanceId', _ctypes.c_uint),
+        ]
+        _fmt_: _ClassVar[dict[str, str]] = {
+            'usedGpuMemory': '%d B',
+        }
+
+    # pylint: disable-next=missing-class-docstring,too-few-public-methods,function-redefined
+    class c_nvmlProcessInfo_v3_t(_PrintableStructure):
+        _fields_: _ClassVar[list[tuple[str, type]]] = [
+            # Process ID
+            ('pid', _ctypes.c_uint),
+            # Amount of used GPU memory in bytes.
+            # Under WDDM, NVML_VALUE_NOT_AVAILABLE is always reported because Windows KMD manages
+            # all the memory and not the NVIDIA driver.
+            ('usedGpuMemory', _ctypes.c_ulonglong),
+            # If MIG is enabled, stores a valid GPU instance ID. gpuInstanceId is set to 0xFFFFFFFF
+            # otherwise.
+            ('gpuInstanceId', _ctypes.c_uint),
+            # If MIG is enabled, stores a valid compute instance ID. computeInstanceId is set to
+            # 0xFFFFFFFF otherwise.
+            ('computeInstanceId', _ctypes.c_uint),
+            # Amount of used GPU conf compute protected memory in bytes.
+            ('usedGpuCcProtectedMemory', _ctypes.c_ulonglong),
+        ]
+        _fmt_: _ClassVar[dict[str, str]] = {
+            'usedGpuMemory': '%d B',
+            'usedGpuCcProtectedMemory': '%d B',
+        }
+
+    __get_running_processes_version_suffix: str | None = None
+    c_nvmlProcessInfo_t = c_nvmlProcessInfo_v3_t
+
+    def __determine_get_running_processes_version_suffix() -> str:
+        global __get_running_processes_version_suffix, c_nvmlProcessInfo_t  # pylint: disable=global-statement
+
+        if __get_running_processes_version_suffix is None:
+            __get_running_processes_version_suffix = '_v3'
+            if _nvmlLookupFunctionPointer('nvmlDeviceGetComputeRunningProcesses_v3') is not None:
+                if (
+                    _nvmlLookupFunctionPointer('nvmlDeviceGetConfComputeMemSizeInfo') is not None
+                    and _nvmlLookupFunctionPointer('nvmlDeviceGetRunningProcessDetailList') is None
+                ):
+                    LOGGER.debug(
+                        'NVML get running process version 3 API with v3 type struct is available.',
+                    )
+                else:
+                    c_nvmlProcessInfo_t = c_nvmlProcessInfo_v2_t
+                    LOGGER.debug(
+                        'NVML get running process version 3 API with v3 type struct is not '
+                        'available due to incompatible NVIDIA driver. Fallback to use get running '
+                        'process version 3 API with v2 type struct.',
+                    )
+            else:
+                c_nvmlProcessInfo_t = c_nvmlProcessInfo_v2_t
+                __get_running_processes_version_suffix = '_v2'
+                LOGGER.debug(
+                    'NVML get running process version 3 API with v3 type struct is not available '
+                    'due to incompatible NVIDIA driver. Fallback to use get running process '
+                    'version 2 API with v2 type struct.',
+                )
+                if (
+                    _nvmlLookupFunctionPointer('nvmlDeviceGetComputeRunningProcesses_v2')
+                    is not None
+                ):
+                    LOGGER.debug(
+                        'NVML get running process version 2 API with v2 type struct is available.',
+                    )
+                else:
+                    c_nvmlProcessInfo_t = c_nvmlProcessInfo_v1_t
+                    __get_running_processes_version_suffix = ''
+                    LOGGER.debug(
+                        'NVML get running process version 2 API with v2 type struct is not '
+                        'available due to incompatible NVIDIA driver. Fallback to use get '
+                        'running process version 1 API with v1 type struct.',
+                    )
+
+        return __get_running_processes_version_suffix
+
+    def __nvml_device_get_running_processes(
+        func: str,
+        /,
+        handle: c_nvmlDevice_t,
+    ) -> list[c_nvmlProcessInfo_t]:
+        """Helper function for :func:`nvmlDeviceGet{Compute,Graphics,MPSCompute}RunningProcesses`.
+
+        Modified from function :func:`pynvml.nvmlDeviceGetComputeRunningProcesses` in package
+        `nvidia-ml-py <https://pypi.org/project/nvidia-ml-py>`_.
+        """
+        version_suffix = __determine_get_running_processes_version_suffix()
+
+        # First call to get the size
+        c_count = _ctypes.c_uint(0)
+        fn = _nvmlGetFunctionPointer(f'{func}{version_suffix}')
+        ret = fn(handle, _ctypes.byref(c_count), None)
+
+        if ret == NVML_SUCCESS:
+            # Special case, no running processes
+            return []
+        if ret == NVML_ERROR_INSUFFICIENT_SIZE:
+            # Typical case
+            # Oversize the array in case more processes are created
+            c_count.value = c_count.value * 2 + 5
+            process_array = c_nvmlProcessInfo_t * c_count.value  # type: ignore[operator]
+            c_processes = process_array()  # type: ignore[operator]
+
+            # Make the call again
+            ret = fn(handle, _ctypes.byref(c_count), c_processes)
+            if ret != NVML_SUCCESS:
+                raise NVMLError(ret)
+
+            processes = []
+            for i in range(c_count.value):
+                # Use an alternative struct for this object
+                obj = nvmlStructToFriendlyObject(c_processes[i])
+                if obj.usedGpuMemory == ULONGLONG_MAX:
+                    # Special case for WDDM on Windows, see comment above
+                    obj.usedGpuMemory = None
+                processes.append(obj)
+
+            return processes
+
+        # Error case
+        raise NVMLError(ret)
+
+    def nvmlDeviceGetComputeRunningProcesses(  # pylint: disable=function-redefined
+        handle: c_nvmlDevice_t,
+    ) -> list[c_nvmlProcessInfo_t]:
+        """Get information about processes with a compute context on a device.
+
+        Note:
+            - In MIG mode, if device handle is provided, the API returns aggregate information, only
+              if the caller has appropriate privileges. Per-instance information can be queried by
+              using specific MIG device handles.
+
+        Raises:
+            NVMLError_Uninitialized:
+                If NVML was not first initialized with :func:`nvmlInit`.
+            NVMLError_NoPermission:
+                If the user doesn't have permission to perform this operation.
+            NVMLError_InvalidArgument:
+                If device is invalid.
+            NVMLError_GpuIsLost:
+                If the target GPU has fallen off the bus or is otherwise inaccessible.
+            NVMLError_Unknown:
+                On any unexpected error.
+        """
+        return __nvml_device_get_running_processes('nvmlDeviceGetComputeRunningProcesses', handle)
+
+    def nvmlDeviceGetGraphicsRunningProcesses(  # pylint: disable=function-redefined
+        handle: c_nvmlDevice_t,
+    ) -> list[c_nvmlProcessInfo_t]:
+        """Get information about processes with a graphics context on a device.
+
+        Note:
+            - In MIG mode, if device handle is provided, the API returns aggregate information, only
+              if the caller has appropriate privileges. Per-instance information can be queried by
+              using specific MIG device handles.
+
+        Raises:
+            NVMLError_Uninitialized:
+                If NVML was not first initialized with :func:`nvmlInit`.
+            NVMLError_NoPermission:
+                If the user doesn't have permission to perform this operation.
+            NVMLError_InvalidArgument:
+                If device is invalid.
+            NVMLError_GpuIsLost:
+                If the target GPU has fallen off the bus or is otherwise inaccessible.
+            NVMLError_Unknown:
+                On any unexpected error.
+        """
+        return __nvml_device_get_running_processes('nvmlDeviceGetGraphicsRunningProcesses', handle)
+
+    def nvmlDeviceGetMPSComputeRunningProcesses(  # pylint: disable=function-redefined
+        handle: c_nvmlDevice_t,
+    ) -> list[c_nvmlProcessInfo_t]:
+        """Get information about processes with a MPS compute context on a device.
+
+        Note:
+            - In MIG mode, if device handle is provided, the API returns aggregate information, only
+              if the caller has appropriate privileges. Per-instance information can be queried by
+              using specific MIG device handles.
+
+        Raises:
+            NVMLError_Uninitialized:
+                If NVML was not first initialized with :func:`nvmlInit`.
+            NVMLError_NoPermission:
+                If the user doesn't have permission to perform this operation.
+            NVMLError_InvalidArgument:
+                If device is invalid.
+            NVMLError_GpuIsLost:
+                If the target GPU has fallen off the bus or is otherwise inaccessible.
+            NVMLError_Unknown:
+                On any unexpected error.
+        """
+        return __nvml_device_get_running_processes(
+            'nvmlDeviceGetMPSComputeRunningProcesses',
+            handle,
+        )
+
+else:
+    LOGGER.warning(
+        'Your installed package `nvidia-ml-py` is corrupted. '
+        'Skip patch functions `nvmlDeviceGet{Compute,Graphics,MPSCompute}RunningProcesses`. '
+        'You may get incorrect or incomplete results. Please consider reinstall package '
+        '`nvidia-ml-py` via `pip3 install --force-reinstall nvidia-ml-py nvitop`.',
+    )
+
+# Patch function `nvmlDeviceGetMemoryInfo`
+if not _pynvml_installation_corrupted:
+    # pylint: disable-next=missing-class-docstring,too-few-public-methods,function-redefined
+    class c_nvmlMemory_v1_t(_PrintableStructure):
+        _fields_: _ClassVar[list[tuple[str, type]]] = [
+            # Total physical device memory (in bytes).
+            ('total', _ctypes.c_ulonglong),
+            # Unallocated device memory (in bytes).
+            ('free', _ctypes.c_ulonglong),
+            # Allocated device memory (in bytes).
+            # Note that the driver/GPU always sets aside a small amount of memory for bookkeeping.
+            ('used', _ctypes.c_ulonglong),
+        ]
+        _fmt_: _ClassVar[dict[str, str]] = {'<default>': '%d B'}
+
+    # pylint: disable-next=missing-class-docstring,too-few-public-methods,function-redefined
+    class c_nvmlMemory_v2_t(_PrintableStructure):
+        _fields_: _ClassVar[list[tuple[str, type]]] = [
+            # Structure format version (must be 2).
+            ('version', _ctypes.c_uint),
+            # Total physical device memory (in bytes).
+            ('total', _ctypes.c_ulonglong),
+            # Device memory (in bytes) reserved for system use (driver or firmware).
+            ('reserved', _ctypes.c_ulonglong),
+            # Unallocated device memory (in bytes).
+            ('free', _ctypes.c_ulonglong),
+            # Allocated device memory (in bytes).
+            # Note that the driver/GPU always sets aside a small amount of memory for bookkeeping.
+            ('used', _ctypes.c_ulonglong),
+        ]
+        _fmt_: _ClassVar[dict[str, str]] = {'<default>': '%d B'}
+
+    nvmlMemory_v2 = getattr(_pynvml, 'nvmlMemory_v2', _ctypes.sizeof(c_nvmlMemory_v2_t) | (2 << 24))
+    __get_memory_info_version_suffix: str | None = None
+    c_nvmlMemory_t = c_nvmlMemory_v2_t
+
+    def __determine_get_memory_info_version_suffix() -> str:
+        global __get_memory_info_version_suffix, c_nvmlMemory_t  # pylint: disable=global-statement
+
+        if __get_memory_info_version_suffix is None:
+            __get_memory_info_version_suffix = '_v2'
+            if _nvmlLookupFunctionPointer('nvmlDeviceGetMemoryInfo_v2') is not None:
+                LOGGER.debug('NVML get memory info version 2 is available.')
+            else:
+                c_nvmlMemory_t = c_nvmlMemory_v1_t
+                __get_memory_info_version_suffix = ''
+                LOGGER.debug(
+                    'NVML get memory info version 2 API is not available due to incompatible '
+                    'NVIDIA driver. Fallback to use NVML get memory info version 1 API.',
+                )
+
+        return __get_memory_info_version_suffix
+
+    def nvmlDeviceGetMemoryInfo(  # pylint: disable=function-redefined
+        handle: c_nvmlDevice_t,
+    ) -> c_nvmlMemory_t:
+        """Retrieve the amount of used, free, reserved and total memory available on the device, in bytes.
+
+        Note:
+            - The version 2 API adds additional memory information. The reserved amount is supported
+              on version 2 only.
+            - In MIG mode, if device handle is provided, the API returns aggregate information, only
+              if the caller has appropriate privileges. Per-instance information can be queried by
+              using specific MIG device handles.
+
+        Raises:
+            NVMLError_Uninitialized:
+                If NVML was not first initialized with :func:`nvmlInit`.
+            NVMLError_NoPermission:
+                If the user doesn't have permission to perform this operation.
+            NVMLError_InvalidArgument:
+                If device is invalid.
+            NVMLError_GpuIsLost:
+                If the target GPU has fallen off the bus or is otherwise inaccessible.
+            NVMLError_Unknown:
+                On any unexpected error.
+        """
+        version_suffix = __determine_get_memory_info_version_suffix()
+        if version_suffix == '_v2':
+            c_memory = c_nvmlMemory_v2_t()
+            c_memory.version = nvmlMemory_v2  # pylint: disable=attribute-defined-outside-init
+        elif version_suffix in {'_v1', ''}:
+            c_memory = c_nvmlMemory_v1_t()
+            version_suffix = ''
+        else:
+            raise ValueError(
+                f'Unknown version suffix {version_suffix!r} for '
+                'function `nvmlDeviceGetMemoryInfo`.',
+            )
+
+        fn = _nvmlGetFunctionPointer(f'nvmlDeviceGetMemoryInfo{version_suffix}')
+        ret = fn(handle, _ctypes.byref(c_memory))
+        if ret != NVML_SUCCESS:
+            raise NVMLError(ret)
+        return c_memory
+
+else:
+    LOGGER.warning(
+        'Your installed package `nvidia-ml-py` is corrupted. '
+        'Skip patch functions `nvmlDeviceGetMemoryInfo`. '
+        'You may get incorrect or incomplete results. Please consider reinstall package '
+        '`nvidia-ml-py` via `pip3 install --force-reinstall nvidia-ml-py nvitop`.',
+    )
+
+# Patch function `nvmlDeviceGetTemperature`
+if not _pynvml_installation_corrupted:
+    # pylint: disable-next=missing-class-docstring,too-few-public-methods,function-redefined
+    class c_nvmlTemperature_v1_t(_PrintableStructure):
+        _fields_: _ClassVar[list[tuple[str, type]]] = [
+            # Structure format version (must be 1).
+            ('version', _ctypes.c_uint),
+            # Sensor type.
+            ('sensorType', _ctypes.c_uint),
+            # Temperature in degrees Celsius.
+            ('temperature', _ctypes.c_int),
+        ]
+
+    nvmlTemperature_v1: int = getattr(
+        _pynvml,
+        'nvmlTemperature_v1',
+        _ctypes.sizeof(c_nvmlTemperature_v1_t) | (1 << 24),
+    )
+    __get_temperature_version_suffix: str | None = None
+
+    def __determine_get_temperature_version_suffix() -> str:
+        """Determine the version suffix for the NVML temperature functions."""
+        global __get_temperature_version_suffix  # pylint: disable=global-statement
+
+        if __get_temperature_version_suffix is None:
+            __get_temperature_version_suffix = 'V'
+            if _nvmlLookupFunctionPointer('nvmlDeviceGetTemperatureV') is not None:
+                LOGGER.debug('NVML get temperature version 1 API is available.')
+            else:
+                __get_temperature_version_suffix = ''
+                LOGGER.debug(
+                    'NVML get temperature version 1 API is not available due to incompatible '
+                    'NVIDIA driver. Fallback to use NVML get temperature API without version.',
+                )
+
+        return __get_temperature_version_suffix
+
+    def nvmlDeviceGetTemperature(  # pylint: disable=function-redefined
+        handle: c_nvmlDevice_t,
+        sensor: int,
+    ) -> int:
+        """Retrieve the current temperature readings (in degrees C) for the given device.
+
+        Raises:
+            NVMLError_Uninitialized:
+                If NVML was not first initialized with :func:`nvmlInit`.
+            NVMLError_InvalidArgument:
+                If device is invalid, sensorType is invalid or temp is NULL.
+            NVMLError_NotSupported:
+                If the device does not have the specified sensor.
+            NVMLError_GpuIsLost:
+                If the target GPU has fallen off the bus or is otherwise inaccessible.
+            NVMLError_Unknown:
+                On any unexpected error.
+        """
+        version_suffix = __determine_get_temperature_version_suffix()
+        if version_suffix == 'V':
+            c_temp_v1 = c_nvmlTemperature_v1_t()
+            # pylint: disable-next=attribute-defined-outside-init
+            c_temp_v1.version = nvmlTemperature_v1
+            # pylint: disable-next=attribute-defined-outside-init
+            c_temp_v1.sensorType = _ctypes.c_uint(sensor)
+            fn = _nvmlGetFunctionPointer('nvmlDeviceGetTemperatureV')
+            ret = fn(handle, _ctypes.byref(c_temp_v1))
+            if ret != NVML_SUCCESS:
+                raise NVMLError(ret)
+            return int(c_temp_v1.temperature)
+
+        if version_suffix == '':
+            c_temp = _ctypes.c_uint(0)
+            fn = _nvmlGetFunctionPointer('nvmlDeviceGetTemperature')
+            ret = fn(handle, _ctypes.c_uint(sensor), _ctypes.byref(c_temp))
+            if ret != NVML_SUCCESS:
+                raise NVMLError(ret)
+            return c_temp.value
+
+        raise ValueError(
+            f'Unknown version suffix {version_suffix!r} for function `nvmlDeviceGetTemperature`.',
+        )
+
+else:
+    LOGGER.warning(
+        'Your installed package `nvidia-ml-py` is corrupted. '
+        'Skip patch functions `nvmlDeviceGetTemperature`. '
+        'You may get incorrect or incomplete results. Please consider reinstall package '
+        '`nvidia-ml-py` via `pip3 install --force-reinstall nvidia-ml-py nvitop`.',
+    )
+
+
+# Add support for lookup fallback and context manager ##############################################
+class _CustomModule(_ModuleType):
+    """Modified module type to support lookup fallback and context manager.
+
+    Automatic lookup fallback:
+
+        >>> libnvml.c_nvmlGpuInstance_t  # fallback to pynvml.c_nvmlGpuInstance_t
+        <class 'pynvml.LP_struct_c_nvmlGpuInstance_t'>
+
+    Context manager:
+
+        >>> with libnvml:
+        ...     handle = libnvml.nvmlDeviceGetHandleByIndex(0)
+        ... # The NVML context has been shutdown
+    """
+
+    def __getattribute__(self, name: str) -> _Any | _Callable[..., _Any]:
+        """Get a member from the current module. Fallback to the original package if missing."""
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            return getattr(_pynvml, name)
+
+    def __enter__(self) -> _Self:
+        """Entry of the context manager for ``with`` statement."""
+        _lazy_init()
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        """Shutdown the NVML context in the context manager for ``with`` statement."""
+        try:
+            nvmlShutdown()
+        except NVMLError:
+            pass
+
+
+# Replace entry in sys.modules for this module with an instance of _CustomModule
+__modself = _sys.modules[__name__]
+__modself.__class__ = _CustomModule

.venv/lib/python3.10/site-packages/nvitop/api/process.py

@@ -0,0 +1,1056 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""The live classes for process running on the host and the GPU devices."""
+
+# pylint: disable=too-many-lines
+
+from __future__ import annotations
+
+import contextlib
+import datetime
+import functools
+import os
+import threading
+from abc import ABC
+from types import FunctionType
+from typing import TYPE_CHECKING, Any
+from weakref import WeakValueDictionary
+
+from nvitop.api import host, libnvml
+from nvitop.api.utils import (
+    NA,
+    UINT_MAX,
+    NaType,
+    Snapshot,
+    bytes2human,
+    memoize_when_activated,
+    timedelta2human,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Iterable
+    from typing_extensions import Self  # Python 3.11+
+
+    from nvitop.api.device import Device
+
+
+__all__ = ['GpuProcess', 'HostProcess', 'command_join']
+
+
+if host.POSIX:
+
+    def add_quotes(s: str) -> str:
+        """Return a shell-escaped version of the string."""
+        if s == '':
+            return '""'
+        if '$' not in s and '\\' not in s and '\n' not in s:
+            if ' ' not in s:
+                return s
+            if '"' not in s:
+                return f'"{s}"'
+        if "'" not in s and '\n' not in s:
+            return f"'{s}'"
+        return '"{}"'.format(
+            s.replace('\\', r'\\').replace('"', r'\"').replace('$', r'\$').replace('\n', r'\n'),
+        )
+
+elif host.WINDOWS:
+
+    def add_quotes(s: str) -> str:
+        """Return a shell-escaped version of the string."""
+        if s == '':
+            return '""'
+        if '%' not in s and '^' not in s and '\n' not in s:
+            if ' ' not in s:
+                return s
+            if '"' not in s:
+                return f'"{s}"'
+        return '"{}"'.format(
+            s.replace('^', '^^').replace('"', '^"').replace('%', '^%').replace('\n', r'\n'),
+        )
+
+else:
+
+    def add_quotes(s: str) -> str:
+        """Return a shell-escaped version of the string."""
+        return '"{}"'.format(s.replace('\n', r'\n'))
+
+
+def command_join(cmdline: list[str]) -> str:
+    """Return a shell-escaped string from command line arguments."""
+    if len(cmdline) == 1 and not (
+        # May be modified by `setproctitle`
+        os.path.isfile(cmdline[0]) and os.path.isabs(cmdline[0])
+    ):
+        return cmdline[0]
+    return ' '.join(map(add_quotes, cmdline))
+
+
+_RAISE = object()
+_USE_FALLBACK_WHEN_RAISE = threading.local()  # see also `GpuProcess.failsafe`
+
+
+def auto_garbage_clean(
+    fallback: Any = _RAISE,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Remove the object references in the instance cache if the method call fails (the process is gone).
+
+    The fallback value will be used with `:meth:`GpuProcess.failsafe`` context manager, otherwise
+    raises an exception when falls.
+    """
+
+    def wrapper(func: Callable[..., Any], /) -> Callable[..., Any]:
+        @functools.wraps(func)
+        def wrapped(self: GpuProcess, /, *args: Any, **kwargs: Any) -> Any:
+            try:
+                return func(self, *args, **kwargs)
+            except host.PsutilError as ex:
+                try:
+                    with GpuProcess.INSTANCE_LOCK:
+                        del GpuProcess.INSTANCES[self.pid, self.device]
+                except (KeyError, AttributeError):
+                    pass
+                try:
+                    with HostProcess.INSTANCE_LOCK:
+                        del HostProcess.INSTANCES[self.pid]
+                except KeyError:
+                    pass
+                # See also `GpuProcess.failsafe`
+                if fallback is _RAISE or not getattr(_USE_FALLBACK_WHEN_RAISE, 'value', False):
+                    raise
+                if isinstance(fallback, tuple):
+                    if isinstance(ex, host.AccessDenied) and fallback == ('No Such Process',):
+                        return ['No Permissions']
+                    return list(fallback)
+                return fallback
+
+        return wrapped
+
+    return wrapper
+
+
+class HostProcess(host.Process, ABC):
+    """Represent an OS process with the given PID.
+
+    If PID is omitted current process PID (:func:`os.getpid`) is used. The instance will be cache
+    during the lifetime of the process.
+
+    Examples:
+        >>> HostProcess()  # the current process
+        HostProcess(pid=12345, name='python3', status='running', started='00:55:43')
+
+        >>> p1 = HostProcess(12345)
+        >>> p2 = HostProcess(12345)
+        >>> p1 is p2                 # the same instance
+        True
+
+        >>> import copy
+        >>> copy.deepcopy(p1) is p1  # the same instance
+        True
+
+        >>> p = HostProcess(pid=12345)
+        >>> p.cmdline()
+        ['python3', '-c', 'import IPython; IPython.terminal.ipapp.launch_new_instance()']
+        >>> p.command()  # the result is in shell-escaped format
+        'python3 -c "import IPython; IPython.terminal.ipapp.launch_new_instance()"'
+
+        >>> p.as_snapshot()
+        HostProcessSnapshot(
+            real=HostProcess(pid=12345, name='python3', status='running', started='00:55:43'),
+            cmdline=['python3', '-c', 'import IPython; IPython.terminal.ipapp.launch_new_instance()'],
+            command='python3 -c "import IPython; IPython.terminal.ipapp.launch_new_instance()"',
+            connections=[],
+            cpu_percent=0.3,
+            cpu_times=pcputimes(user=2.180019456, system=0.18424464, children_user=0.0, children_system=0.0),
+            create_time=1656608143.31,
+            cwd='/home/panxuehai',
+            environ={...},
+            ...
+        )
+    """
+
+    INSTANCE_LOCK: threading.RLock = threading.RLock()
+    INSTANCES: WeakValueDictionary[int, HostProcess] = WeakValueDictionary()
+
+    _pid: int
+    _super_gone: bool
+    _username: str | None
+    _ident: tuple
+    _lock: threading.RLock
+
+    def __new__(cls, pid: int | None = None) -> Self:
+        """Return the cached instance of :class:`HostProcess`."""
+        if pid is None:
+            pid = os.getpid()
+
+        with cls.INSTANCE_LOCK:
+            try:
+                instance = cls.INSTANCES[pid]
+                if instance.is_running():
+                    return instance
+            except KeyError:
+                pass
+
+            instance = super().__new__(cls)
+
+            instance._super_gone = False
+            instance._username = None
+            host.Process._init(instance, pid, True)
+            try:
+                host.Process.cpu_percent(instance)
+            except host.PsutilError:
+                pass
+
+            cls.INSTANCES[pid] = instance
+
+            return instance
+
+    # pylint: disable-next=unused-argument,super-init-not-called
+    def __init__(self, pid: int | None = None) -> None:
+        """Initialize the instance."""
+
+    @property
+    def _gone(self) -> bool:
+        return self._super_gone
+
+    @_gone.setter
+    def _gone(self, value: bool) -> None:
+        if value:
+            with self.INSTANCE_LOCK:
+                self.INSTANCES.pop(self.pid, None)
+        self._super_gone = value
+
+    def __repr__(self) -> str:
+        """Return a string representation of the process."""
+        return super().__repr__().replace(f'{self.__class__.__module__}.', '', 1)
+
+    def __reduce__(self) -> tuple[type[HostProcess], tuple[int]]:
+        """Return state information for pickling."""
+        return self.__class__, (self.pid,)
+
+    if host.WINDOWS:
+
+        def username(self) -> str:
+            """The name of the user that owns the process.
+
+            On Windows, the domain name will be removed if it is present.
+
+            Raises:
+                host.NoSuchProcess:
+                    If the process is gone.
+                host.AccessDenied:
+                    If the user do not have read privilege to the process' status file.
+            """
+            if self._username is None:  # pylint: disable=access-member-before-definition
+                self._username = (  # pylint: disable=attribute-defined-outside-init
+                    super().username().split('\\')[-1]
+                )
+            return self._username
+
+    else:
+
+        def username(self) -> str:
+            """The name of the user that owns the process.
+
+            On UNIX this is calculated by using *real* process uid.
+
+            Raises:
+                host.NoSuchProcess:
+                    If the process is gone.
+                host.AccessDenied:
+                    If the user do not have read privilege to the process' status file.
+            """
+            if self._username is None:  # pylint: disable=access-member-before-definition
+                self._username = (  # pylint: disable=attribute-defined-outside-init
+                    super().username()
+                )
+            return self._username
+
+    @memoize_when_activated
+    def cmdline(self) -> list[str]:
+        """The command line this process has been called with.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        cmdline = super().cmdline()
+        if len(cmdline) > 1:
+            cmdline = '\0'.join(cmdline).rstrip('\0').split('\0')
+        return cmdline
+
+    def command(self) -> str:
+        """Return a shell-escaped string from command line arguments.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        return command_join(self.cmdline())
+
+    @memoize_when_activated
+    def running_time(self) -> datetime.timedelta:
+        """The elapsed time this process has been running in :class:`datetime.timedelta`.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        return datetime.datetime.now() - datetime.datetime.fromtimestamp(self.create_time())
+
+    def running_time_human(self) -> str:
+        """The elapsed time this process has been running in human readable format.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        return timedelta2human(self.running_time())
+
+    def running_time_in_seconds(self) -> float:  # in seconds
+        """The elapsed time this process has been running in seconds.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        return self.running_time().total_seconds()
+
+    elapsed_time = running_time
+    elapsed_time_human = running_time_human
+    elapsed_time_in_seconds = running_time_in_seconds
+
+    def rss_memory(self) -> int:  # in bytes
+        """The used resident set size (RSS) memory of the process in bytes.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        return self.memory_info().rss
+
+    def parent(self) -> HostProcess | None:
+        """Return the parent process as a :class:`HostProcess` instance or :data:`None` if there is no parent.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        parent = super().parent()
+        if parent is not None:
+            return HostProcess(parent.pid)
+        return None
+
+    def children(self, recursive: bool = False) -> list[HostProcess]:
+        """Return the children of this process as a list of :class:`HostProcess` instances.
+
+        If *recursive* is :data:`True` return all the descendants.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        return [HostProcess(child.pid) for child in super().children(recursive)]
+
+    @contextlib.contextmanager
+    def oneshot(self) -> Generator[None]:
+        """A utility context manager which considerably speeds up the retrieval of multiple process information at the same time.
+
+        Internally different process info (e.g. name, ppid, uids, gids, ...) may be fetched by using
+        the same routine, but only one information is returned and the others are discarded. When
+        using this context manager the internal routine is executed once (in the example below on
+        ``name()``) and the other info are cached.
+
+        The cache is cleared when exiting the context manager block. The advice is to use this every
+        time you retrieve more than one information about the process.
+
+        Examples:
+            >>> from nvitop import HostProcess
+            >>> p = HostProcess()
+            >>> with p.oneshot():
+            ...     p.name()         # collect multiple info
+            ...     p.cpu_times()    # return cached value
+            ...     p.cpu_percent()  # return cached value
+            ...     p.create_time()  # return cached value
+        """  # pylint: disable=line-too-long
+        with self._lock:
+            if hasattr(self, '_cache'):
+                yield
+            else:
+                with super().oneshot():
+                    # pylint: disable=no-member
+                    try:
+                        self.cmdline.cache_activate(self)  # type: ignore[attr-defined]
+                        self.running_time.cache_activate(self)  # type: ignore[attr-defined]
+                        yield
+                    finally:
+                        self.cmdline.cache_deactivate(self)  # type: ignore[attr-defined]
+                        self.running_time.cache_deactivate(self)  # type: ignore[attr-defined]
+
+    def as_snapshot(
+        self,
+        attrs: Iterable[str] | None = None,
+        ad_value: Any | None = None,
+    ) -> Snapshot:
+        """Return a onetime snapshot of the process."""
+        with self.oneshot():
+            attributes = self.as_dict(attrs=attrs, ad_value=ad_value)
+
+            if attrs is None:
+                for attr in ('command', 'running_time', 'running_time_human'):
+                    try:
+                        attributes[attr] = getattr(self, attr)()
+                    except (host.AccessDenied, host.ZombieProcess):  # noqa: PERF203
+                        attributes[attr] = ad_value
+
+        return Snapshot(real=self, **attributes)
+
+
+@HostProcess.register
+class GpuProcess:  # pylint: disable=too-many-instance-attributes,too-many-public-methods
+    """Represent a process with the given PID running on the given GPU device.
+
+    The instance will be cache during the lifetime of the process.
+
+    The same host process can use multiple GPU devices. The :class:`GpuProcess` instances
+    representing the same PID on the host but different GPU devices are different.
+    """
+
+    INSTANCE_LOCK: threading.RLock = threading.RLock()
+    INSTANCES: WeakValueDictionary[tuple[int, Device], GpuProcess] = WeakValueDictionary()
+
+    _pid: int
+    _host: HostProcess
+    _device: Device
+    _username: str | None
+    _ident: tuple
+    _hash: int | None
+
+    # pylint: disable-next=too-many-arguments,unused-argument
+    def __new__(
+        cls,
+        pid: int | None,
+        device: Device,
+        *,
+        gpu_memory: int | NaType | None = None,
+        gpu_instance_id: int | NaType | None = None,
+        compute_instance_id: int | NaType | None = None,
+        type: str | NaType | None = None,  # pylint: disable=redefined-builtin
+    ) -> Self:
+        """Return the cached instance of :class:`GpuProcess`."""
+        if pid is None:
+            pid = os.getpid()
+
+        with cls.INSTANCE_LOCK:
+            try:
+                instance = cls.INSTANCES[pid, device]
+                if instance.is_running():
+                    return instance  # type: ignore[return-value]
+            except KeyError:
+                pass
+
+            instance = super().__new__(cls)
+
+            instance._pid = pid
+            instance._host = HostProcess(pid)
+            instance._ident = (*instance._host._ident, device.index)
+            instance._device = device
+
+            instance._hash = None
+            instance._username = None
+
+            cls.INSTANCES[pid, device] = instance
+
+            return instance
+
+    # pylint: disable-next=too-many-arguments
+    def __init__(
+        self,
+        pid: int | None,  # pylint: disable=unused-argument
+        device: Device,
+        *,
+        gpu_memory: int | NaType | None = None,
+        gpu_instance_id: int | NaType | None = None,
+        compute_instance_id: int | NaType | None = None,
+        type: str | NaType | None = None,  # pylint: disable=redefined-builtin
+    ) -> None:
+        """Initialize the instance returned by :meth:`__new__()`."""
+        if gpu_memory is None and not hasattr(self, '_gpu_memory'):
+            gpu_memory = NA
+        if gpu_memory is not None:
+            self.set_gpu_memory(gpu_memory)
+
+        if type is None and not hasattr(self, '_type'):
+            type = NA
+        if type is not None:
+            self.type = type
+
+        if gpu_instance_id is not None and compute_instance_id is not None:
+            self._gpu_instance_id = gpu_instance_id if gpu_instance_id != UINT_MAX else NA
+            self._compute_instance_id = (
+                compute_instance_id if compute_instance_id != UINT_MAX else NA
+            )
+        elif device.is_mig_device():
+            self._gpu_instance_id = device.gpu_instance_id()
+            self._compute_instance_id = device.compute_instance_id()
+        else:
+            self._gpu_instance_id = self._compute_instance_id = NA
+
+        for util in ('sm', 'memory', 'encoder', 'decoder'):
+            if not hasattr(self, f'_gpu_{util}_utilization'):
+                setattr(self, f'_gpu_{util}_utilization', NA)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the GPU process."""
+        return '{}(pid={}, gpu_memory={}, type={}, device={}, host={})'.format(  # noqa: UP032
+            self.__class__.__name__,
+            self.pid,
+            self.gpu_memory_human(),
+            self.type,
+            self.device,
+            self.host,
+        )
+
+    def __eq__(self, other: object) -> bool:
+        """Test equality to other object."""
+        if not isinstance(other, (GpuProcess, host.Process)):
+            return NotImplemented
+        return self._ident == other._ident
+
+    def __hash__(self) -> int:
+        """Return a hash value of the GPU process."""
+        if self._hash is None:  # pylint: disable=access-member-before-definition
+            self._hash = hash(self._ident)  # pylint: disable=attribute-defined-outside-init
+        return self._hash
+
+    def __getattr__(self, name: str) -> Any | Callable[..., Any]:
+        """Get a member from the instance or fallback to the host process instance if missing.
+
+        Raises:
+            AttributeError:
+                If the attribute is not defined in either :class:`GpuProcess` nor :class:`HostProcess`.
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+        """
+        try:
+            return super().__getattr__(name)  # type: ignore[misc]
+        except AttributeError:
+            if name == '_cache':
+                raise
+            attribute = getattr(self.host, name)
+            if isinstance(attribute, FunctionType):
+                attribute = auto_garbage_clean(fallback=_RAISE)(attribute)
+
+            setattr(self, name, attribute)
+            return attribute
+
+    @property
+    def pid(self) -> int:
+        """The process PID."""
+        return self._pid
+
+    @property
+    def host(self) -> HostProcess:
+        """The process instance running on the host."""
+        return self._host
+
+    @property
+    def device(self) -> Device:
+        """The GPU device the process running on.
+
+        The same host process can use multiple GPU devices. The :class:`GpuProcess` instances
+        representing the same PID on the host but different GPU devices are different.
+        """
+        return self._device
+
+    def gpu_instance_id(self) -> int | NaType:
+        """The GPU instance ID of the MIG device, or :const:`nvitop.NA` if not applicable."""
+        return self._gpu_instance_id
+
+    def compute_instance_id(self) -> int | NaType:
+        """The compute instance ID of the MIG device, or :const:`nvitop.NA` if not applicable."""
+        return self._compute_instance_id
+
+    def gpu_memory(self) -> int | NaType:  # in bytes
+        """The used GPU memory in bytes, or :const:`nvitop.NA` if not applicable."""
+        return self._gpu_memory
+
+    def gpu_memory_human(self) -> str | NaType:  # in human readable
+        """The used GPU memory in human readable format, or :const:`nvitop.NA` if not applicable."""
+        return self._gpu_memory_human
+
+    def gpu_memory_percent(self) -> float | NaType:  # in percentage
+        """The percentage of used GPU memory by the process, or :const:`nvitop.NA` if not applicable."""
+        return self._gpu_memory_percent
+
+    def gpu_sm_utilization(self) -> int | NaType:  # in percentage
+        """The utilization rate of SM (Streaming Multiprocessor), or :const:`nvitop.NA` if not applicable."""
+        return self._gpu_sm_utilization
+
+    def gpu_memory_utilization(self) -> int | NaType:  # in percentage
+        """The utilization rate of GPU memory bandwidth, or :const:`nvitop.NA` if not applicable."""
+        return self._gpu_memory_utilization
+
+    def gpu_encoder_utilization(self) -> int | NaType:  # in percentage
+        """The utilization rate of the encoder, or :const:`nvitop.NA` if not applicable."""
+        return self._gpu_encoder_utilization
+
+    def gpu_decoder_utilization(self) -> int | NaType:  # in percentage
+        """The utilization rate of the decoder, or :const:`nvitop.NA` if not applicable."""
+        return self._gpu_decoder_utilization
+
+    def set_gpu_memory(self, value: int | NaType) -> None:
+        """Set the used GPU memory in bytes."""
+        # pylint: disable=attribute-defined-outside-init
+        self._gpu_memory = memory_used = value
+        self._gpu_memory_human = bytes2human(self.gpu_memory())
+        memory_total = self.device.memory_total()
+        gpu_memory_percent = NA
+        if libnvml.nvmlCheckReturn(memory_used, int) and libnvml.nvmlCheckReturn(memory_total, int):
+            gpu_memory_percent = round(100.0 * memory_used / memory_total, 1)  # type: ignore[assignment]
+        self._gpu_memory_percent = gpu_memory_percent
+
+    def set_gpu_utilization(
+        self,
+        gpu_sm_utilization: int | NaType | None = None,
+        gpu_memory_utilization: int | NaType | None = None,
+        gpu_encoder_utilization: int | NaType | None = None,
+        gpu_decoder_utilization: int | NaType | None = None,
+    ) -> None:
+        """Set the GPU utilization rates."""
+        # pylint: disable=attribute-defined-outside-init
+        if gpu_sm_utilization is not None:
+            self._gpu_sm_utilization = gpu_sm_utilization
+        if gpu_memory_utilization is not None:
+            self._gpu_memory_utilization = gpu_memory_utilization
+        if gpu_encoder_utilization is not None:
+            self._gpu_encoder_utilization = gpu_encoder_utilization
+        if gpu_decoder_utilization is not None:
+            self._gpu_decoder_utilization = gpu_decoder_utilization
+
+    def update_gpu_status(self) -> int | NaType:
+        """Update the GPU consumption status from a new NVML query."""
+        self.set_gpu_memory(NA)
+        self.set_gpu_utilization(NA, NA, NA, NA)
+        processes = self.device.processes()
+        process = processes.get(self.pid, self)
+        if process is not self:
+            # The current process is gone and the instance has been removed from the cache.
+            # Update GPU status from the new instance.
+            self.set_gpu_memory(process.gpu_memory())
+            self.set_gpu_utilization(
+                process.gpu_sm_utilization(),
+                process.gpu_memory_utilization(),
+                process.gpu_encoder_utilization(),
+                process.gpu_decoder_utilization(),
+            )
+        return self.gpu_memory()
+
+    @property
+    def type(self) -> str | NaType:
+        """The type of the GPU context.
+
+        The type is one of the following:
+            - :data:`'C'`: compute context
+            - :data:`'G'`: graphics context
+            - :data:`'C+G'`: both compute context and graphics context
+            - :data:`'N/A'`: not applicable
+        """
+        return self._type
+
+    @type.setter
+    def type(self, value: str | NaType) -> None:
+        if 'C' in value and 'G' in value:
+            self._type = 'C+G'
+        elif 'C' in value:
+            self._type = 'C'
+        elif 'G' in value:
+            self._type = 'G'
+        else:
+            self._type = NA
+
+    @auto_garbage_clean(fallback=False)
+    def is_running(self) -> bool:
+        """Return whether this process is running."""
+        return self.host.is_running()
+
+    @auto_garbage_clean(fallback='terminated')
+    def status(self) -> str:
+        """The process current status.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return self.host.status()
+
+    @auto_garbage_clean(fallback=NA)
+    def create_time(self) -> float | NaType:
+        """The process creation time as a floating point number expressed in seconds since the epoch.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return self.host.create_time()
+
+    @auto_garbage_clean(fallback=NA)
+    def running_time(self) -> datetime.timedelta | NaType:
+        """The elapsed time this process has been running in :class:`datetime.timedelta`.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return self.host.running_time()
+
+    def running_time_human(self) -> str | NaType:
+        """The elapsed time this process has been running in human readable format.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return timedelta2human(self.running_time())
+
+    def running_time_in_seconds(self) -> float | NaType:
+        """The elapsed time this process has been running in seconds.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        running_time = self.running_time()
+        if running_time is NA:
+            return NA
+        return running_time.total_seconds()
+
+    elapsed_time = running_time
+    elapsed_time_human = running_time_human
+    elapsed_time_in_seconds = running_time_in_seconds
+
+    @auto_garbage_clean(fallback=NA)
+    def username(self) -> str | NaType:
+        """The name of the user that owns the process.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        if self._username is None:  # pylint: disable=access-member-before-definition
+            self._username = self.host.username()  # pylint: disable=attribute-defined-outside-init
+        return self._username
+
+    @auto_garbage_clean(fallback=NA)
+    def name(self) -> str | NaType:
+        """The process name.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return self.host.name()
+
+    @auto_garbage_clean(fallback=NA)
+    def cpu_percent(self) -> float | NaType:  # in percentage
+        """Return a float representing the current process CPU utilization as a percentage.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return self.host.cpu_percent()
+
+    @auto_garbage_clean(fallback=NA)
+    def memory_percent(self) -> float | NaType:  # in percentage
+        """Compare process RSS memory to total physical system memory and calculate process memory utilization as a percentage.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """  # pylint: disable=line-too-long
+        return self.host.memory_percent()
+
+    host_memory_percent = memory_percent  # in percentage
+
+    @auto_garbage_clean(fallback=NA)
+    def host_memory(self) -> int | NaType:  # in bytes
+        """The used resident set size (RSS) memory of the process in bytes.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return self.host.rss_memory()
+
+    def host_memory_human(self) -> str | NaType:
+        """The used resident set size (RSS) memory of the process in human readable format.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return bytes2human(self.host_memory())
+
+    rss_memory = host_memory  # in bytes
+
+    # For `AccessDenied` error the fallback value is `['No Permissions']`
+    @auto_garbage_clean(fallback=('No Such Process',))
+    def cmdline(self) -> list[str]:
+        """The command line this process has been called with.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        cmdline = self.host.cmdline()
+        if len(cmdline) == 0 and not self._gone:
+            cmdline = ['Zombie Process']
+        return cmdline
+
+    def command(self) -> str:
+        """Return a shell-escaped string from command line arguments.
+
+        Raises:
+            host.NoSuchProcess:
+                If the process is gone.
+            host.AccessDenied:
+                If the user do not have read privilege to the process' status file.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        return command_join(self.cmdline())
+
+    @auto_garbage_clean(fallback=_RAISE)
+    def host_snapshot(self) -> Snapshot:
+        """Return a onetime snapshot of the host process."""
+        with self.host.oneshot():
+            return Snapshot(
+                real=self.host,
+                is_running=self.is_running(),
+                status=self.status(),
+                username=self.username(),
+                name=self.name(),
+                cmdline=self.cmdline(),
+                command=self.command(),
+                cpu_percent=self.cpu_percent(),
+                memory_percent=self.memory_percent(),
+                host_memory=self.host_memory(),
+                host_memory_human=self.host_memory_human(),
+                running_time=self.running_time(),
+                running_time_human=self.running_time_human(),
+                running_time_in_seconds=self.running_time_in_seconds(),
+            )
+
+    @auto_garbage_clean(fallback=_RAISE)
+    def as_snapshot(
+        self,
+        *,
+        host_process_snapshot_cache: dict[int, Snapshot] | None = None,
+    ) -> Snapshot:
+        """Return a onetime snapshot of the process on the GPU device.
+
+        Note:
+            To return the fallback value rather than raise an exception, please use the context
+            manager :meth:`GpuProcess.failsafe`. Also, consider using the batched version to take
+            snapshots with :meth:`GpuProcess.take_snapshots`, which caches the results and reduces
+            redundant queries. See also :meth:`take_snapshots` and :meth:`failsafe`.
+        """
+        if host_process_snapshot_cache is None:
+            host_process_snapshot_cache = {}
+        try:
+            host_snapshot = host_process_snapshot_cache[self.pid]
+        except KeyError:
+            host_snapshot = host_process_snapshot_cache[self.pid] = self.host_snapshot()
+
+        return Snapshot(
+            real=self,
+            pid=self.pid,
+            # host
+            host=host_snapshot,
+            is_running=host_snapshot.is_running,
+            status=host_snapshot.status,
+            username=host_snapshot.username,
+            name=host_snapshot.name,
+            cmdline=host_snapshot.cmdline,
+            command=host_snapshot.command,
+            cpu_percent=host_snapshot.cpu_percent,
+            memory_percent=host_snapshot.memory_percent,
+            host_memory=host_snapshot.host_memory,
+            host_memory_human=host_snapshot.host_memory_human,
+            running_time=host_snapshot.running_time,
+            running_time_human=host_snapshot.running_time_human,
+            running_time_in_seconds=host_snapshot.running_time_in_seconds,
+            # device
+            device=self.device,
+            type=self.type,
+            gpu_instance_id=self.gpu_instance_id(),
+            compute_instance_id=self.compute_instance_id(),
+            gpu_memory=self.gpu_memory(),
+            gpu_memory_human=self.gpu_memory_human(),
+            gpu_memory_percent=self.gpu_memory_percent(),
+            gpu_sm_utilization=self.gpu_sm_utilization(),
+            gpu_memory_utilization=self.gpu_memory_utilization(),
+            gpu_encoder_utilization=self.gpu_encoder_utilization(),
+            gpu_decoder_utilization=self.gpu_decoder_utilization(),
+        )
+
+    @classmethod
+    def take_snapshots(  # batched version of `as_snapshot`
+        cls,
+        gpu_processes: Iterable[GpuProcess],
+        *,
+        failsafe: bool = False,
+    ) -> list[Snapshot]:
+        """Take snapshots for a list of :class:`GpuProcess` instances.
+
+        If *failsafe* is :data:`True`, then if any method fails, the fallback value in
+        :func:`auto_garbage_clean` will be used.
+        """
+        cache: dict[int, Snapshot] = {}
+        context: Callable[[], contextlib.AbstractContextManager[None]] = (
+            cls.failsafe if failsafe else contextlib.nullcontext
+        )
+        with context():
+            return [
+                process.as_snapshot(host_process_snapshot_cache=cache) for process in gpu_processes
+            ]
+
+    @classmethod
+    @contextlib.contextmanager
+    def failsafe(cls) -> Generator[None]:
+        """A context manager that enables fallback values for methods that fail.
+
+        Examples:
+            >>> p = GpuProcess(pid=10000, device=Device(0))  # process does not exist
+            >>> p
+            GpuProcess(pid=10000, gpu_memory=N/A, type=N/A, device=PhysicalDevice(index=0, name="NVIDIA GeForce RTX 3070", total_memory=8192MiB), host=HostProcess(pid=10000, status='terminated'))
+            >>> p.cpu_percent()
+            Traceback (most recent call last):
+                ...
+            NoSuchProcess: process no longer exists (pid=10000)
+
+            >>> # Failsafe to the fallback value instead of raising exceptions
+            ... with GpuProcess.failsafe():
+            ...     print('fallback:              {!r}'.format(p.cpu_percent()))
+            ...     print('fallback (float cast): {!r}'.format(float(p.cpu_percent())))  # `nvitop.NA` can be cast to float or int
+            ...     print('fallback (int cast):   {!r}'.format(int(p.cpu_percent())))    # `nvitop.NA` can be cast to float or int
+            fallback:              'N/A'
+            fallback (float cast): nan
+            fallback (int cast):   0
+        """  # pylint: disable=line-too-long
+        global _USE_FALLBACK_WHEN_RAISE  # pylint: disable=global-statement,global-variable-not-assigned
+
+        prev_value = getattr(_USE_FALLBACK_WHEN_RAISE, 'value', False)
+        try:
+            _USE_FALLBACK_WHEN_RAISE.value = True
+            yield
+        finally:
+            _USE_FALLBACK_WHEN_RAISE.value = prev_value

.venv/lib/python3.10/site-packages/nvitop/api/termcolor.py

@@ -0,0 +1,284 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+# pylint: disable=wrong-spelling-in-comment
+# Vendored from the `termcolor` package: https://github.com/termcolor/termcolor
+# ==============================================================================
+# Copyright (c) 2008-2011 Volvox Development Team
+#
+# 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.
+#
+# Author: Konstantin Lepa <[email protected]>
+# ==============================================================================
+"""ANSI color formatting for output in terminal."""
+
+from __future__ import annotations
+
+import io
+import os
+import sys
+from typing import TYPE_CHECKING, Any, Literal
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    Attribute = Literal[
+        'bold',
+        'dark',
+        'underline',
+        'blink',
+        'reverse',
+        'concealed',
+        'strike',
+    ]
+    Highlight = Literal[
+        'on_black',
+        'on_grey',
+        'on_red',
+        'on_green',
+        'on_yellow',
+        'on_blue',
+        'on_magenta',
+        'on_cyan',
+        'on_light_grey',
+        'on_dark_grey',
+        'on_light_red',
+        'on_light_green',
+        'on_light_yellow',
+        'on_light_blue',
+        'on_light_magenta',
+        'on_light_cyan',
+        'on_white',
+    ]
+    Color = Literal[
+        'black',
+        'grey',
+        'red',
+        'green',
+        'yellow',
+        'blue',
+        'magenta',
+        'cyan',
+        'light_grey',
+        'dark_grey',
+        'light_red',
+        'light_green',
+        'light_yellow',
+        'light_blue',
+        'light_magenta',
+        'light_cyan',
+        'white',
+    ]
+
+
+__all__ = ['colored', 'cprint']
+
+
+if os.name == 'nt':  # Windows
+    try:
+        from colorama import init
+    except ImportError:
+        pass
+    else:
+        init()
+
+
+ATTRIBUTES: dict[Attribute, int] = {
+    'bold': 1,
+    'dark': 2,
+    'underline': 4,
+    'blink': 5,
+    'reverse': 7,
+    'concealed': 8,
+    'strike': 9,
+}
+
+HIGHLIGHTS: dict[Highlight, int] = {
+    'on_black': 40,
+    'on_grey': 40,  # Actually black but kept for backwards compatibility
+    'on_red': 41,
+    'on_green': 42,
+    'on_yellow': 43,
+    'on_blue': 44,
+    'on_magenta': 45,
+    'on_cyan': 46,
+    'on_light_grey': 47,
+    'on_dark_grey': 100,
+    'on_light_red': 101,
+    'on_light_green': 102,
+    'on_light_yellow': 103,
+    'on_light_blue': 104,
+    'on_light_magenta': 105,
+    'on_light_cyan': 106,
+    'on_white': 107,
+}
+
+COLORS: dict[Color, int] = {
+    'black': 30,
+    'grey': 30,  # Actually black but kept for backwards compatibility
+    'red': 31,
+    'green': 32,
+    'yellow': 33,
+    'blue': 34,
+    'magenta': 35,
+    'cyan': 36,
+    'light_grey': 37,
+    'dark_grey': 90,
+    'light_red': 91,
+    'light_green': 92,
+    'light_yellow': 93,
+    'light_blue': 94,
+    'light_magenta': 95,
+    'light_cyan': 96,
+    'white': 97,
+}
+
+
+RESET = '\033[0m'
+
+
+# pylint: disable-next=too-many-return-statements
+def _can_do_color(
+    *,
+    no_color: bool | None = None,
+    force_color: bool | None = None,
+) -> bool:
+    """Check env vars and for tty/dumb terminal."""
+    # First check overrides:
+    # "User-level configuration files and per-instance command-line arguments should
+    # override $NO_COLOR. A user should be able to export $NO_COLOR in their shell
+    # configuration file as a default, but configure a specific program in its
+    # configuration file to specifically enable color."
+    # https://no-color.org
+    if no_color is not None and no_color:
+        return False
+    if force_color is not None and force_color:
+        return True
+
+    # Then check env vars:
+    if 'ANSI_COLORS_DISABLED' in os.environ:
+        return False
+    if 'NO_COLOR' in os.environ:
+        return False
+    if 'FORCE_COLOR' in os.environ:
+        return True
+
+    # Then check system:
+    if os.environ.get('TERM') == 'dumb':
+        return False
+    if not hasattr(sys.stdout, 'fileno'):
+        return False
+
+    try:
+        return os.isatty(sys.stdout.fileno())
+    except io.UnsupportedOperation:
+        return sys.stdout.isatty()
+
+
+# pylint: disable-next=too-many-arguments
+def colored(
+    text: Any,
+    /,
+    color: Color | None = None,
+    on_color: Highlight | None = None,
+    attrs: Iterable[Attribute] | None = None,
+    *,
+    no_color: bool | None = None,
+    force_color: bool | None = None,
+) -> str:
+    """Colorize text.
+
+    Available text colors:
+        black, red, green, yellow, blue, magenta, cyan, white,
+        light_grey, dark_grey, light_red, light_green, light_yellow, light_blue,
+        light_magenta, light_cyan.
+
+    Available text highlights:
+        on_black, on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white,
+        on_light_grey, on_dark_grey, on_light_red, on_light_green, on_light_yellow,
+        on_light_blue, on_light_magenta, on_light_cyan.
+
+    Available attributes:
+        bold, dark, underline, blink, reverse, concealed.
+
+    Example:
+        colored('Hello, World!', 'red', 'on_black', ['bold', 'blink'])
+        colored('Hello, World!', 'green')
+    """
+    result = str(text)
+    if not _can_do_color(no_color=no_color, force_color=force_color):
+        return result
+
+    fmt_str = '\033[%dm%s'
+    if color is not None:
+        result = fmt_str % (COLORS[color], result)
+
+    if on_color is not None:
+        result = fmt_str % (HIGHLIGHTS[on_color], result)
+
+    if attrs is not None:
+        for attr in attrs:
+            result = fmt_str % (ATTRIBUTES[attr], result)
+
+    result += RESET
+
+    return result
+
+
+# pylint: disable-next=too-many-arguments
+def cprint(
+    text: object,
+    /,
+    color: Color | None = None,
+    on_color: Highlight | None = None,
+    attrs: Iterable[Attribute] | None = None,
+    *,
+    no_color: bool | None = None,
+    force_color: bool | None = None,
+    **kwargs: Any,
+) -> None:
+    """Print colorized text.
+
+    It accepts arguments of print function.
+    """
+    print(
+        colored(
+            text,
+            color,
+            on_color,
+            attrs,
+            no_color=no_color,
+            force_color=force_color,
+        ),
+        **kwargs,
+    )

.venv/lib/python3.10/site-packages/nvitop/api/utils.py

@@ -0,0 +1,799 @@
+# This file is part of nvitop, the interactive NVIDIA-GPU process viewer.
+#
+# Copyright 2021-2025 Xuehai Pan. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities of nvitop APIs."""
+
+# pylint: disable=invalid-name
+
+from __future__ import annotations
+
+import ctypes
+import datetime
+import functools
+import math
+import os
+import re
+import sys
+import time
+from collections.abc import KeysView
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, TypeVar, final
+
+from nvitop.api import termcolor
+
+
+if TYPE_CHECKING:
+    from collections.abc import Generator, Iterable, Iterator
+
+
+__all__ = [  # noqa: RUF022
+    'NA',
+    'NaType',
+    'NotApplicable',
+    'NotApplicableType',
+    'UINT_MAX',
+    'ULONGLONG_MAX',
+    'KiB',
+    'MiB',
+    'GiB',
+    'TiB',
+    'PiB',
+    'SIZE_UNITS',
+    'bytes2human',
+    'human2bytes',
+    'timedelta2human',
+    'utilization2string',
+    'colored',
+    'set_color',
+    'boolify',
+    'Snapshot',
+]
+
+
+COLOR: bool = sys.stdout.isatty()
+
+
+def set_color(value: bool) -> None:
+    """Force enable text coloring."""
+    global COLOR  # pylint: disable=global-statement
+    COLOR = bool(value)
+    if COLOR:
+        os.environ['FORCE_COLOR'] = '1'
+        os.environ.pop('NO_COLOR', None)
+    else:
+        os.environ.pop('FORCE_COLOR', None)
+        os.environ['NO_COLOR'] = '1'
+
+
+def colored(
+    text: Any,
+    /,
+    color: termcolor.Color | None = None,
+    on_color: termcolor.Highlight | None = None,
+    attrs: Iterable[termcolor.Attribute] | None = None,
+) -> str:
+    """Colorize text with ANSI color escape codes.
+
+    Available text colors:
+        red, green, yellow, blue, magenta, cyan, white.
+
+    Available text highlights:
+        on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white.
+
+    Available attributes:
+        bold, dark, underline, blink, reverse, concealed.
+
+    Examples:
+        >>> colored('Hello, World!', 'red', 'on_grey', ['bold', 'blink'])  # doctest: +ELLIPSIS
+        '...Hello, World!...'
+        >>> colored('Hello, World!', 'green')  # doctest: +ELLIPSIS
+        '...Hello, World!...'
+    """
+    if COLOR:
+        return termcolor.colored(text, color=color, on_color=on_color, attrs=attrs)
+    return str(text)
+
+
+@final
+class NaType(str):
+    """A singleton (:const:`str: 'N/A'`) class represents a not applicable value.
+
+    The :const:`NA` instance behaves like a :class:`str` instance (:const:`'N/A'`) when doing string
+    manipulation (e.g. concatenation). For arithmetic operations, for example ``NA / 1024 / 1024``,
+    it acts like the :data:`math.nan`.
+
+    Examples:
+        >>> NA
+        'N/A'
+
+        >>> 'memory usage: {}'.format(NA)  # NA is an instance of `str`
+        'memory usage: N/A'
+        >>> NA.lower()                     # NA is an instance of `str`
+        'n/a'
+        >>> NA.ljust(5)                    # NA is an instance of `str`
+        'N/A  '
+        >>> NA + ' str'                    # string contamination if the operand is a string
+        'N/A str'
+
+        >>> float(NA)                      # explicit conversion to float (`math.nan`)
+        nan
+        >>> NA + 1                         # auto-casting to float if the operand is a number
+        nan
+        >>> NA * 1024                      # auto-casting to float if the operand is a number
+        nan
+        >>> NA / (1024 * 1024)             # auto-casting to float if the operand is a number
+        nan
+    """
+
+    __slots__: ClassVar[tuple[()]] = ()
+
+    def __new__(cls) -> NaType:
+        """Get the singleton instance (:const:`nvitop.NA`)."""
+        instance = getattr(cls, '_instance', None)
+        if instance is None:
+            cls._instance = instance = super().__new__(cls, 'N/A')
+        return instance
+
+    def __bool__(self) -> bool:
+        """Convert :const:`NA` to :class:`bool` and return :data:`False`.
+
+        >>> bool(NA)
+        False
+        """
+        return False
+
+    def __int__(self) -> int:
+        """Convert :const:`NA` to :class:`int` and return :const:`0`.
+
+        >>> int(NA)
+        0
+        """
+        return 0
+
+    def __float__(self) -> float:
+        """Convert :const:`NA` to :class:`float` and return :data:`math.nan`.
+
+        >>> float(NA)
+        nan
+        >>> float(NA) is math.nan
+        True
+        """
+        return math.nan
+
+    def __add__(self, other: object) -> str | float:  # type: ignore[override]
+        """Return :data:`math.nan` if the operand is a number or uses string concatenation if the operand is a string (``NA + other``).
+
+        A special case is when the operand is :const:`nvitop.NA` itself, the result is
+        :data:`math.nan` instead of :const:`'N/AN/A'`.
+
+        >>> NA + ' str'
+        'N/A str'
+        >>> NA + NA
+        nan
+        >>> NA + 1
+        nan
+        >>> NA + 1.0
+        nan
+        """  # pylint: disable=line-too-long
+        if isinstance(other, (int, float)):
+            return float(self) + other
+        if other is NA:
+            return float(self)
+        return super().__add__(other)  # type: ignore[operator]
+
+    def __radd__(self, other: object) -> str | float:
+        """Return :data:`math.nan` if the operand is a number or uses string concatenation if the operand is a string (``other + NA``).
+
+        >>> 'str' + NA
+        'strN/A'
+        >>> 1 + NA
+        nan
+        >>> 1.0 + NA
+        nan
+        """  # pylint: disable=line-too-long
+        if isinstance(other, (int, float)):
+            return other + float(self)
+        return NotImplemented
+
+    def __sub__(self, other: object) -> float:
+        """Return :data:`math.nan` if the operand is a number (``NA - other``).
+
+        >>> NA - 'str'
+        Traceback (most recent call last):
+            ...
+        TypeError: unsupported operand type(s) for -: 'NaType' and 'str'
+        >>> NA - NA
+        nan
+        >>> NA + 1
+        nan
+        >>> NA + 1.0
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return float(self) - other
+        if other is NA:
+            return float(self)
+        return NotImplemented
+
+    def __rsub__(self, other: object) -> float:
+        """Return :data:`math.nan` if the operand is a number (``other - NA``).
+
+        >>> 'str' - NA
+        Traceback (most recent call last):
+            ...
+        TypeError: unsupported operand type(s) for -: 'str' and 'NaType'
+        >>> 1 - NA
+        nan
+        >>> 1.0 - NA
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return other - float(self)
+        return NotImplemented
+
+    def __mul__(self, other: object) -> float:  # type: ignore[override]
+        """Return :data:`math.nan` if the operand is a number (``NA * other``).
+
+        A special case is when the operand is :const:`nvitop.NA` itself, the result is also :data:`math.nan`.
+
+        >>> NA * 1024
+        nan
+        >>> NA * 1024.0
+        nan
+        >>> NA * NA
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return float(self) * other
+        if other is NA:
+            return float(self)
+        return NotImplemented
+
+    def __rmul__(self, other: object) -> float:  # type: ignore[override]
+        """Return :data:`math.nan` if the operand is a number (``other * NA``).
+
+        >>> 1024 * NA
+        nan
+        >>> 1024.0 * NA
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return other * float(self)
+        return NotImplemented
+
+    def __truediv__(self, other: object) -> float:
+        """Return :data:`math.nan` if the operand is a number (``NA / other``).
+
+        >>> NA / 1024
+        nan
+        >>> NA / 1024.0
+        nan
+        >>> NA / 0
+        Traceback (most recent call last):
+            ...
+        ZeroDivisionError: ...
+        >>> NA / 0.0
+        Traceback (most recent call last):
+            ...
+        ZeroDivisionError: ...
+        >>> NA / NA
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return float(self) / other
+        if other is NA:
+            return float(self)
+        return NotImplemented
+
+    def __rtruediv__(self, other: object) -> float:
+        """Return :data:`math.nan` if the operand is a number (``other / NA``).
+
+        >>> 1024 / NA
+        nan
+        >>> 1024.0 / NA
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return other / float(self)
+        return NotImplemented
+
+    def __floordiv__(self, other: object) -> float:
+        """Return :data:`math.nan` if the operand is a number (``NA // other``).
+
+        >>> NA // 1024
+        nan
+        >>> NA // 1024.0
+        nan
+        >>> NA / 0
+        Traceback (most recent call last):
+            ...
+        ZeroDivisionError: ...
+        >>> NA / 0.0
+        Traceback (most recent call last):
+            ...
+        ZeroDivisionError: ...
+        >>> NA // NA
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return float(self) // other
+        if other is NA:
+            return float(self)
+        return NotImplemented
+
+    def __rfloordiv__(self, other: object) -> float:
+        """Return :data:`math.nan` if the operand is a number (``other // NA``).
+
+        >>> 1024 // NA
+        nan
+        >>> 1024.0 // NA
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return other // float(self)
+        return NotImplemented
+
+    def __mod__(self, other: object) -> float:  # type: ignore[override]
+        """Return :data:`math.nan` if the operand is a number (``NA % other``).
+
+        >>> NA % 1024
+        nan
+        >>> NA % 1024.0
+        nan
+        >>> NA % 0
+        Traceback (most recent call last):
+            ...
+        ZeroDivisionError: ...
+        >>> NA % 0.0
+        Traceback (most recent call last):
+            ...
+        ZeroDivisionError: ...
+        """
+        if isinstance(other, (int, float)):
+            return float(self) % other
+        if other is NA:
+            return float(self)
+        return NotImplemented
+
+    def __rmod__(self, other: object) -> float:
+        """Return :data:`math.nan` if the operand is a number (``other % NA``).
+
+        >>> 1024 % NA
+        nan
+        >>> 1024.0 % NA
+        nan
+        """
+        if isinstance(other, (int, float)):
+            return other % float(self)
+        return NotImplemented
+
+    def __divmod__(self, other: object) -> tuple[float, float]:
+        """The pair ``(NA // other, NA % other)`` (``divmod(NA, other)``).
+
+        >>> divmod(NA, 1024)
+        (nan, nan)
+        >>> divmod(NA, 1024.0)
+        (nan, nan)
+        >>> divmod(NA, 0)
+        Traceback (most recent call last):
+            ...
+        ZeroDivisionError: ...
+        >>> divmod(NA, 0.0)
+        Traceback (most recent call last):
+            ...
+        ZeroDivisionError: ...
+        """
+        return (self // other, self % other)
+
+    def __rdivmod__(self, other: object) -> tuple[float, float]:
+        """The pair ``(other // NA, other % NA)`` (``divmod(other, NA)``).
+
+        >>> divmod(1024, NA)
+        (nan, nan)
+        >>> divmod(1024.0, NA)
+        (nan, nan)
+        """
+        return (other // self, other % self)
+
+    def __pos__(self) -> float:
+        """Return :data:`math.nan` (``+NA``).
+
+        >>> +NA
+        nan
+        """
+        return +float(self)
+
+    def __neg__(self) -> float:
+        """Return :data:`math.nan` (``-NA``).
+
+        >>> -NA
+        nan
+        """
+        return -float(self)
+
+    def __abs__(self) -> float:
+        """Return :data:`math.nan` (``abs(NA)``).
+
+        >>> abs(NA)
+        nan
+        """
+        return abs(float(self))
+
+    def __round__(self, ndigits: int | None = None) -> int | float:
+        """Round :const:`nvitop.NA` to ``ndigits`` decimal places, defaulting to :data:`None`.
+
+        If ``ndigits`` is omitted or :data:`None`, returns :const:`0`, otherwise returns :data:`math.nan`.
+
+        >>> round(NA)
+        0
+        >>> round(NA, 0)
+        nan
+        >>> round(NA, 1)
+        nan
+        """
+        if ndigits is None:
+            return int(self)
+        return round(float(self), ndigits)
+
+    def __lt__(self, x: object) -> bool:
+        """The :const:`nvitop.NA` is always greater than any number, or uses the dictionary order for string."""
+        if isinstance(x, (int, float)):
+            return False
+        return super().__lt__(x)  # type: ignore[operator]
+
+    def __le__(self, x: object) -> bool:
+        """The :const:`nvitop.NA` is always greater than any number, or uses the dictionary order for string."""
+        if isinstance(x, (int, float)):
+            return False
+        return super().__le__(x)  # type: ignore[operator]
+
+    def __gt__(self, x: object) -> bool:
+        """The :const:`nvitop.NA` is always greater than any number, or uses the dictionary order for string."""
+        if isinstance(x, (int, float)):
+            return True
+        return super().__gt__(x)  # type: ignore[operator]
+
+    def __ge__(self, x: object) -> bool:
+        """The :const:`nvitop.NA` is always greater than any number, or uses the dictionary order for string."""
+        if isinstance(x, (int, float)):
+            return True
+        return super().__ge__(x)  # type: ignore[operator]
+
+    def __format__(self, format_spec: str) -> str:
+        """Format :const:`nvitop.NA` according to ``format_spec``."""
+        try:
+            return super().__format__(format_spec)
+        except ValueError:
+            return format(math.nan, format_spec)
+
+
+NotApplicableType = NaType
+
+# isinstance(NA, str) -> True
+# NA == 'N/A'         -> True
+# NA is NaType()      -> True (`NaType` is a singleton class)
+NA = NaType()
+"""The singleton instance of :class:`NaType`. The actual value is :const:`str: 'N/A'`."""
+
+NotApplicable = NA
+"""The singleton instance of :class:`NaType`. The actual value is :const:`str: 'N/A'`."""
+
+UINT_MAX: int = ctypes.c_uint(-1).value  # 0xFFFFFFFF
+"""The maximum value of :class:`ctypes.c_uint`."""
+ULONGLONG_MAX: int = ctypes.c_ulonglong(-1).value  # 0XFFFFFFFFFFFFFFFF
+"""The maximum value of :class:`ctypes.c_ulonglong`."""
+
+KiB: int = 1 << 10
+"""Kibibyte (1024)"""
+
+MiB: int = 1 << 20
+"""Mebibyte (1024 * 1024)"""
+
+GiB: int = 1 << 30
+"""Gibibyte (1024 * 1024 * 1024)"""
+
+TiB: int = 1 << 40
+"""Tebibyte (1024 * 1024 * 1024 * 1024)"""
+
+PiB: int = 1 << 50
+"""Pebibyte (1024 * 1024 * 1024 * 1024 * 1024)"""
+
+SIZE_UNITS: dict[str | None, int] = {
+    None: 1,
+    '': 1,
+    'B': 1,
+    'KiB': KiB,
+    'MiB': MiB,
+    'GiB': GiB,
+    'TiB': TiB,
+    'PiB': PiB,
+    'KB': 1000,
+    'MB': 1000**2,
+    'GB': 1000**3,
+    'TB': 1000**4,
+    'PB': 1000**5,
+}
+"""Units of storage and memory measurements."""
+SIZE_PATTERN: re.Pattern = re.compile(
+    r'^\s*\+?\s*(?P<size>\d+(?:\.\d+)?)\s*(?P<unit>([KMGTP]i?)?)B?\s*$',
+    flags=re.IGNORECASE,
+)
+"""The regex pattern for human readable size."""
+
+
+# pylint: disable-next=too-many-return-statements,too-many-branches
+def bytes2human(
+    b: int | float | NaType,  # noqa: PYI041
+    /,
+    *,
+    min_unit: int = 1,
+) -> str:
+    """Convert bytes to a human readable string."""
+    if b == NA:
+        return NA
+
+    if not isinstance(b, int):
+        try:
+            b = round(float(b))
+        except ValueError:
+            return NA
+
+    if b < KiB and min_unit < KiB:
+        return f'{b}B'
+    if b < MiB and min_unit <= KiB:
+        return f'{round(b / KiB)}KiB'
+    if b < 100 * MiB and min_unit <= MiB:
+        return f'{round(b / MiB, 2):.2f}MiB'
+    if b < 1000 * MiB and min_unit <= MiB:
+        return f'{round(b / MiB, 1):.1f}MiB'
+    if b < 20 * GiB and min_unit <= MiB:
+        return f'{round(b / MiB)}MiB'
+    if b < 100 * GiB and min_unit <= GiB:
+        return f'{round(b / GiB, 2):.2f}GiB'
+    if b < 1000 * GiB and min_unit <= GiB:
+        return f'{round(b / GiB, 1):.1f}GiB'
+    if b < 100 * TiB and min_unit <= TiB:
+        return f'{round(b / TiB, 2):.2f}TiB'
+    if b < 1000 * TiB and min_unit <= TiB:
+        return f'{round(b / TiB, 1):.1f}TiB'
+    if b < 100 * PiB:
+        return f'{round(b / PiB, 2):.2f}PiB'
+    return f'{round(b / PiB, 1):.1f}PiB'
+
+
+def human2bytes(s: int | str, /) -> int:
+    """Convert a human readable size string (*case insensitive*) to bytes.
+
+    Raises:
+        ValueError:
+            If cannot convert the given size string.
+
+    Examples:
+        >>> human2bytes('200')
+        200
+        >>> human2bytes('500B')
+        500
+        >>> human2bytes('10k')
+        10000
+        >>> human2bytes('10ki')
+        10240
+        >>> human2bytes('1M')
+        1000000
+        >>> human2bytes('1MiB')
+        1048576
+        >>> human2bytes('1.5GiB')
+        1610612736
+    """
+    if isinstance(s, int):
+        if s >= 0:
+            return s
+        raise ValueError(f'Cannot convert {s!r} to bytes.')
+
+    match = SIZE_PATTERN.fullmatch(s)
+    if match is None:
+        raise ValueError(f'Cannot convert {s!r} to bytes.')
+    size, unit = match.group('size', 'unit')
+    unit = unit.upper().replace('I', 'i')
+    return int(float(size) * SIZE_UNITS[f'{unit}B'])
+
+
+def timedelta2human(
+    dt: int | float | datetime.timedelta | NaType,  # noqa: PYI041
+    /,
+    *,
+    round: bool = False,  # pylint: disable=redefined-builtin
+) -> str:
+    """Convert a number in seconds or a :class:`datetime.timedelta` instance to a human readable string."""
+    if isinstance(dt, (int, float)):
+        dt = datetime.timedelta(seconds=dt)
+
+    if not isinstance(dt, datetime.timedelta):
+        return NA
+
+    if dt.days >= 4 or (round and dt.days >= 1):
+        return f'{dt.days + dt.seconds / 86400:.1f} days'
+
+    hours, seconds = divmod(86400 * dt.days + dt.seconds, 3600)
+    if hours > 0:
+        return '{:d}:{:02d}:{:02d}'.format(hours, *divmod(seconds, 60))
+    return '{:d}:{:02d}'.format(*divmod(seconds, 60))
+
+
+def utilization2string(utilization: int | float | NaType, /) -> str:  # noqa: PYI041
+    """Convert a utilization rate to string."""
+    if utilization != NA:
+        if isinstance(utilization, int):
+            return f'{utilization}%'
+        if isinstance(utilization, float):
+            return f'{utilization:.1f}%'
+    return NA
+
+
+def boolify(string: str, /, default: Any = None) -> bool:
+    """Convert the given value, usually a string, to boolean."""
+    if string.lower() in {'true', 'yes', 'on', 'enabled', '1'}:
+        return True
+    if string.lower() in {'false', 'no', 'off', 'disabled', '0'}:
+        return False
+    if default is not None:
+        return bool(default)
+    return bool(string)
+
+
+class Snapshot:
+    """A dict-like object holds the snapshot values.
+
+    The value can be accessed by ``snapshot.name`` or ``snapshot['name']`` syntax.
+    The Snapshot can also be converted to a dictionary by ``dict(snapshot)`` or ``{**snapshot}``.
+
+    Missing attributes will be automatically fetched from the original object.
+    """
+
+    def __init__(self, real: Any, **items: Any) -> None:
+        """Initialize a new :class:`Snapshot` object with the given attributes."""
+        object.__setattr__(self, 'real', real)
+        object.__setattr__(self, 'timestamp', time.time())
+        for key, value in items.items():
+            setattr(self, key, value)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the snapshot."""
+        keys = set(self.__dict__.keys()).difference({'real', 'timestamp'})
+        keys = ['real', *sorted(keys)]
+        keyvals = []
+        for key in keys:
+            value = getattr(self, key)
+            keyval = f'{key}={value!r}'
+            if isinstance(value, Snapshot):
+                keyval = keyval.replace('\n', '\n    ')  # extra indentation for nested snapshots
+            keyvals.append(keyval)
+        return '{}{}(\n    {},\n)'.format(
+            self.real.__class__.__name__,
+            self.__class__.__name__,
+            ',\n    '.join(keyvals),
+        )
+
+    def __hash__(self) -> int:
+        """Return a hash value of the snapshot."""
+        return hash((self.real, self.timestamp))
+
+    def __getattr__(self, name: str) -> Any:
+        """Get a member from the instance.
+
+        If the attribute is not defined, fetches from the original object and makes a function call.
+        """
+        try:
+            return super().__getattr__(name)  # type: ignore[misc]
+        except AttributeError:
+            attribute = getattr(self.real, name)
+            if callable(attribute):
+                attribute = attribute()
+
+            setattr(self, name, attribute)
+            return attribute
+
+    def __getitem__(self, name: str) -> Any:
+        """Support ``snapshot['name']`` syntax."""
+        try:
+            return getattr(self, name)
+        except AttributeError as ex:
+            raise KeyError(name) from ex
+
+    def __setitem__(self, name: str, value: Any) -> None:
+        """Support ``snapshot['name'] = value`` syntax."""
+        setattr(self, name, value)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Set or update a member of the instance.
+
+        If the attribute is not defined, set it to the snapshot object.
+        """
+        if name in ('real', 'timestamp'):
+            raise AttributeError(f'Cannot set attribute {name!r} of {self.__class__.__name__!r}')
+        super().__setattr__(name, value)
+
+    def __iter__(self) -> Iterator[str]:
+        """Support ``for name in snapshot`` syntax and ``*`` tuple unpack ``[*snapshot]`` syntax."""
+
+        def gen() -> Generator[str]:
+            yield from (name for name in self.__dict__ if name not in {'real', 'timestamp'})
+
+        return gen()
+
+    def keys(self) -> Iterable[str]:
+        # pylint: disable-next=line-too-long
+        """Support ``**`` dictionary unpack ``{**snapshot}`` / ``dict(**snapshot)`` syntax and ``dict(snapshot)`` dictionary conversion."""
+        return KeysView(self)  # type: ignore[arg-type]
+
+
+Method = TypeVar('Method', bound=Callable[..., Any])
+
+
+# Modified from psutil (https://github.com/giampaolo/psutil)
+def memoize_when_activated(method: Method, /) -> Method:
+    """A memoize decorator which is disabled by default.
+
+    It can be activated and deactivated on request. For efficiency reasons it can be used only
+    against class methods accepting no arguments.
+    """
+
+    @functools.wraps(method)
+    def wrapped(self: object, /, *args: Any, **kwargs: Any) -> Any:
+        try:
+            # case 1: we previously entered oneshot() ctx
+            # pylint: disable-next=protected-access
+            ret = self._cache[method]  # type: ignore[attr-defined]
+        except AttributeError:
+            # case 2: we never entered oneshot() ctx
+            return method(self, *args, **kwargs)
+        except KeyError:
+            # case 3: we entered oneshot() ctx but there's no cache
+            # for this entry yet
+            ret = method(self, *args, **kwargs)
+            try:
+                # pylint: disable-next=protected-access
+                self._cache[method] = ret  # type: ignore[attr-defined]
+            except AttributeError:
+                # multi-threading race condition, see:
+                # https://github.com/giampaolo/psutil/issues/1948
+                pass
+        return ret
+
+    def cache_activate(self: object) -> None:
+        """Activate cache.
+
+        Expects an instance. Cache will be stored as a "_cache" instance attribute.
+        """
+        if not hasattr(self, '_cache'):
+            # pylint: disable-next=protected-access
+            self._cache = {}  # type: ignore[attr-defined]
+
+    def cache_deactivate(self: object) -> None:
+        """Deactivate and clear cache."""
+        try:
+            # pylint: disable-next=protected-access
+            del self._cache  # type: ignore[attr-defined]
+        except AttributeError:
+            pass
+
+    wrapped.cache_activate = cache_activate  # type: ignore[attr-defined]
+    wrapped.cache_deactivate = cache_deactivate  # type: ignore[attr-defined]
+    return wrapped  # type: ignore[return-value]
+
+
+if __name__ == '__main__':
+    import doctest
+
+    doctest.testmod()