# Python API documentation

This documentation describes the Glances Python API.

Note: This API is only available in Glances 4.4.0 or higher.

## TL;DR

You can access the Glances API by importing the glances.api module and creating an instance of the GlancesAPI class. This instance provides access to all Glances plugins and their fields. For example, to access the CPU plugin and its total field, you can use the following code:

    >>> from glances import api
    >>> gl = api.GlancesAPI()
    >>> gl.cpu
    {'cpucore': 16,
     'ctx_switches': 43534099,
     'guest': 0.0,
     'idle': 57.9,
     'interrupts': 23606364,
     'iowait': 35.5,
     'irq': 0.0,
     'nice': 0.0,
     'soft_interrupts': 11191044,
     'steal': 0.0,
     'syscalls': 0,
     'system': 4.6,
     'total': 7.2,
     'user': 1.9}
    >>> gl.cpu.get("total")
    7.2
    >>> gl.mem.get("used")
    10322544704
    >>> gl.auto_unit(gl.mem.get("used"))
    9.61G

If the stats return a list of items (like network interfaces or processes), you can access them by their name:

    >>> gl.network.keys()
    ['wlp0s20f3']
    >>> gl.network["wlp0s20f3"]
    {'alias': None,
     'bytes_all': 192,
     'bytes_all_gauge': 1466811879,
     'bytes_all_rate_per_sec': 948.0,
     'bytes_recv': 86,
     'bytes_recv_gauge': 1366452723,
     'bytes_recv_rate_per_sec': 424.0,
     'bytes_sent': 106,
     'bytes_sent_gauge': 100359156,
     'bytes_sent_rate_per_sec': 523.0,
     'interface_name': 'wlp0s20f3',
     'key': 'interface_name',
     'speed': 0,
     'time_since_update': 0.2023918628692627}

## Init Glances Python API

Init the Glances API:

    >>> from glances import api
    >>> gl = api.GlancesAPI()

## Get Glances plugins list

Get the plugins list:

    >>> gl.plugins()
    ['alert', 'ports', 'diskio', 'containers', 'processcount', 'programlist', 'gpu', 'percpu', 'system', 'network', 'cpu', 'amps', 'processlist', 'load', 'sensors', 'uptime', 'now', 'fs', 'wifi', 'ip', 'help', 'version', 'psutilversion', 'core', 'mem', 'folders', 'quicklook', 'memswap']

## Glances alert

Alert stats:

    >>> type(gl.alert)
    <class 'glances.plugins.alert.AlertPlugin'>
    >>> gl.alert
    []

Alert fields description:

- begin: Begin timestamp of the event

- end: End timestamp of the event (or -1 if ongoing)

- state: State of the event (WARNING|CRITICAL)

- type: Type of the event (CPU|LOAD|MEM)

- max: Maximum value during the event period

- avg: Average value during the event period

- min: Minimum value during the event period

- sum: Sum of the values during the event period

- count: Number of values during the event period

- top: Top 3 processes name during the event period

- desc: Description of the event

- sort: Sort key of the top processes

- global_msg: Global alert message

Alert limits:

    >>> gl.alert.limits
    {'alert_disable': ['False'], 'history_size': 1200.0}

## Glances ports

Ports stats:

    >>> type(gl.ports)
    <class 'glances.plugins.ports.PortsPlugin'>
    >>> gl.ports
    [{'description': 'DefaultGateway',
      'host': '192.168.1.1',
      'indice': 'port_0',
      'port': 0,
      'refresh': 30,
      'rtt_warning': None,
      'status': 0.005254,
      'timeout': 3}]

Ports fields description:

- host: Measurement is be done on this host (or IP address)

- port: Measurement is be done on this port (0 for ICMP)

- description: Human readable description for the host/port

- refresh: Refresh time (in seconds) for this host/port

- timeout: Timeout (in seconds) for the measurement

- status: Measurement result (in seconds)

- rtt_warning: Warning threshold (in seconds) for the measurement

- indice: Unique indice for the host/port

Ports limits:

    >>> gl.ports.limits
    {'history_size': 1200.0,
     'ports_disable': ['False'],
     'ports_port_default_gateway': ['True'],
     'ports_refresh': 30.0,
     'ports_timeout': 3.0}

## Glances diskio

Diskio stats:

    >>> type(gl.diskio)
    <class 'glances.plugins.diskio.DiskioPlugin'>
    >>> gl.diskio
    Return a dict of dict with key=<disk_name>
    >>> gl.diskio.keys()
    ['nvme0n1', 'nvme0n1p1', 'nvme0n1p2', 'nvme0n1p3', 'dm-0', 'dm-1']
    >>> gl.diskio.get("nvme0n1")
    {'disk_name': 'nvme0n1',
     'key': 'disk_name',
     'read_bytes': 9630865920,
     'read_count': 550371,
     'read_latency': 0,
     'read_time': 62457,
     'write_bytes': 12931978240,
     'write_count': 739071,
     'write_latency': 0,
     'write_time': 605074}

Diskio fields description:

- disk_name: Disk name.

- read_count: Number of reads.

- write_count: Number of writes.

- read_bytes: Number of bytes read.

- write_bytes: Number of bytes written.

- read_time: Time spent reading.

- write_time: Time spent writing.

- read_latency: Mean time spent reading per operation.

- write_latency: Mean time spent writing per operation.

Diskio limits:

    >>> gl.diskio.limits
    {'diskio_disable': ['False'],
     'diskio_hide': ['loop.*', '/dev/loop.*'],
     'diskio_hide_zero': ['False'],
     'diskio_rx_latency_careful': 10.0,
     'diskio_rx_latency_critical': 50.0,
     'diskio_rx_latency_warning': 20.0,
     'diskio_tx_latency_careful': 10.0,
     'diskio_tx_latency_critical': 50.0,
     'diskio_tx_latency_warning': 20.0,
     'history_size': 1200.0}

## Glances containers

Containers stats:

    >>> type(gl.containers)
    <class 'glances.plugins.containers.ContainersPlugin'>
    >>> gl.containers
    []

Containers fields description:

- name: Container name

- id: Container ID

- image: Container image

- status: Container status

- created: Container creation date

- command: Container command

- cpu_percent: Container CPU consumption

- cpu_limit: Container CPU limit

- memory_inactive_file: Container memory inactive file

- memory_limit: Container memory limit

- memory_usage: Container memory usage

- io_rx: Container IO bytes read rate

- io_wx: Container IO bytes write rate

- network_rx: Container network RX bitrate

- network_tx: Container network TX bitrate

- ports: Container ports

- uptime: Container uptime

- engine: Container engine (Docker, Podman, and LXD are currently supported)

- pod_name: Pod name (only with Podman)

- pod_id: Pod ID (only with Podman)

Containers limits:

    >>> gl.containers.limits
    {'containers_all': ['False'],
     'containers_disable': ['False'],
     'containers_disable_stats': ['command'],
     'containers_max_name_size': 20.0,
     'history_size': 1200.0}

## Glances processcount

Processcount stats:

    >>> type(gl.processcount)
    <class 'glances.plugins.processcount.ProcesscountPlugin'>
    >>> gl.processcount
    {'pid_max': 0, 'running': 1, 'sleeping': 421, 'thread': 2139, 'total': 565}
    >>> gl.processcount.keys()
    ['total', 'running', 'sleeping', 'thread', 'pid_max']
    >>> gl.processcount.get("total")
    565

Processcount fields description:

- total: Total number of processes

- running: Total number of running processes

- sleeping: Total number of sleeping processes

- thread: Total number of threads

- pid_max: Maximum number of processes

Processcount limits:

    >>> gl.processcount.limits
    {'history_size': 1200.0, 'processcount_disable': ['False']}

## Glances gpu

Gpu stats:

    >>> type(gl.gpu)
    <class 'glances.plugins.gpu.GpuPlugin'>
    >>> gl.gpu
    Return a dict of dict with key=<gpu_id>
    >>> gl.gpu.keys()
    ['intel0', 'intel1']
    >>> gl.gpu.get("intel0")
    {'fan_speed': None,
     'gpu_id': 'intel0',
     'key': 'gpu_id',
     'mem': None,
     'name': 'UHD Graphics',
     'proc': 0,
     'temperature': None}

Gpu fields description:

- gpu_id: GPU identification

- name: GPU name

- mem: Memory consumption

- proc: GPU processor consumption

- temperature: GPU temperature

- fan_speed: GPU fan speed

Gpu limits:

    >>> gl.gpu.limits
    {'gpu_disable': ['False'],
     'gpu_mem_careful': 50.0,
     'gpu_mem_critical': 90.0,
     'gpu_mem_warning': 70.0,
     'gpu_proc_careful': 50.0,
     'gpu_proc_critical': 90.0,
     'gpu_proc_warning': 70.0,
     'gpu_temperature_careful': 60.0,
     'gpu_temperature_critical': 80.0,
     'gpu_temperature_warning': 70.0,
     'history_size': 1200.0}

## Glances percpu

Percpu stats:

    >>> type(gl.percpu)
    <class 'glances.plugins.percpu.PercpuPlugin'>
    >>> gl.percpu
    Return a dict of dict with key=<cpu_number>
    >>> gl.percpu.keys()
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
    >>> gl.percpu.get("0")
    {'cpu_number': 0,
     'dpc': None,
     'guest': 0.0,
     'guest_nice': 0.0,
     'idle': 23.0,
     'interrupt': None,
     'iowait': 0.0,
     'irq': 0.0,
     'key': 'cpu_number',
     'nice': 0.0,
     'softirq': 0.0,
     'steal': 0.0,
     'system': 8.0,
     'total': 77.0,
     'user': 0.0}

Percpu fields description:

- cpu_number: CPU number

- total: Sum of CPU percentages (except idle) for current CPU number.

- system: Percent time spent in kernel space. System CPU time is the time spent running code in the Operating System kernel.

- user: CPU percent time spent in user space. User CPU time is the time spent on the processor running your program’s code (or code in libraries).

- iowait: (Linux): percent time spent by the CPU waiting for I/O operations to complete.

- idle: percent of CPU used by any program. Every program or task that runs on a computer system occupies a certain amount of processing time on the CPU. If the CPU has completed all tasks it is idle.

- irq: (Linux and BSD): percent time spent servicing/handling hardware/software interrupts. Time servicing interrupts (hardware + software).

- nice: (Unix): percent time occupied by user level processes with a positive nice value. The time the CPU has spent running users’ processes that have been niced.

- steal: (Linux): percentage of time a virtual CPU waits for a real CPU while the hypervisor is servicing another virtual processor.

- guest: (Linux): percent of time spent running a virtual CPU for guest operating systems under the control of the Linux kernel.

- guest_nice: (Linux): percent of time spent running a niced guest (virtual CPU).

- softirq: (Linux): percent of time spent handling software interrupts.

- dpc: (Windows): percent of time spent handling deferred procedure calls.

- interrupt: (Windows): percent of time spent handling software interrupts.

Percpu limits:

    >>> gl.percpu.limits
    {'history_size': 1200.0,
     'percpu_disable': ['False'],
     'percpu_iowait_careful': 50.0,
     'percpu_iowait_critical': 90.0,
     'percpu_iowait_warning': 70.0,
     'percpu_max_cpu_display': 4.0,
     'percpu_system_careful': 50.0,
     'percpu_system_critical': 90.0,
     'percpu_system_warning': 70.0,
     'percpu_user_careful': 50.0,
     'percpu_user_critical': 90.0,
     'percpu_user_warning': 70.0}

## Glances system

System stats:

    >>> type(gl.system)
    <class 'glances.plugins.system.SystemPlugin'>
    >>> gl.system
    {'hostname': 'nicolargo-xps15',
     'hr_name': 'Ubuntu 24.04 64bit / Linux 7.0.0-28-generic',
     'linux_distro': 'Ubuntu 24.04',
     'os_name': 'Linux',
     'os_version': '7.0.0-28-generic',
     'platform': '64bit'}
    >>> gl.system.keys()
    ['os_name', 'hostname', 'platform', 'os_version', 'linux_distro', 'hr_name']
    >>> gl.system.get("os_name")
    'Linux'

System fields description:

- os_name: Operating system name

- hostname: Hostname

- platform: Platform (32 or 64 bits)

- linux_distro: Linux distribution

- os_version: Operating system version

- hr_name: Human readable operating system name

System limits:

    >>> gl.system.limits
    {'history_size': 1200.0, 'system_disable': ['False'], 'system_refresh': 60}

## Glances network

Network stats:

    >>> type(gl.network)
    <class 'glances.plugins.network.NetworkPlugin'>
    >>> gl.network
    Return a dict of dict with key=<interface_name>
    >>> gl.network.keys()
    ['wlp0s20f3']
    >>> gl.network.get("wlp0s20f3")
    {'alias': None,
     'bytes_all': 0,
     'bytes_all_gauge': 1466811879,
     'bytes_all_rate_per_sec': 0.0,
     'bytes_recv': 0,
     'bytes_recv_gauge': 1366452723,
     'bytes_recv_rate_per_sec': 0.0,
     'bytes_sent': 0,
     'bytes_sent_gauge': 100359156,
     'bytes_sent_rate_per_sec': 0.0,
     'interface_name': 'wlp0s20f3',
     'key': 'interface_name',
     'speed': 0,
     'time_since_update': 0.004337787628173828}

Network fields description:

- interface_name: Interface name.

- alias: Interface alias name (optional).

- bytes_recv: Number of bytes received.

- bytes_sent: Number of bytes sent.

- bytes_all: Number of bytes received and sent.

- speed: Maximum interface speed (in bit per second). Can return 0 on some operating-system.

- is_up: Is the interface up ?

Network limits:

    >>> gl.network.limits
    {'history_size': 1200.0,
     'network_disable': ['False'],
     'network_hide': ['docker.*', 'lo'],
     'network_hide_no_ip': ['True'],
     'network_hide_no_up': ['True'],
     'network_hide_zero': ['False'],
     'network_rx_careful': 70.0,
     'network_rx_critical': 90.0,
     'network_rx_warning': 80.0,
     'network_tx_careful': 70.0,
     'network_tx_critical': 90.0,
     'network_tx_warning': 80.0}

## Glances cpu

Cpu stats:

    >>> type(gl.cpu)
    <class 'glances.plugins.cpu.CpuPlugin'>
    >>> gl.cpu
    {'cpucore': 16,
     'ctx_switches': 43534099,
     'guest': 0.0,
     'idle': 57.9,
     'interrupts': 23606364,
     'iowait': 35.5,
     'irq': 0.0,
     'nice': 0.0,
     'soft_interrupts': 11191044,
     'steal': 0.0,
     'syscalls': 0,
     'system': 4.6,
     'total': 7.2,
     'user': 1.9}
    >>> gl.cpu.keys()
    ['total', 'user', 'nice', 'system', 'idle', 'iowait', 'irq', 'steal', 'guest', 'ctx_switches', 'interrupts', 'soft_interrupts', 'syscalls', 'cpucore']
    >>> gl.cpu.get("total")
    7.2

Cpu fields description:

- total: Sum of all CPU percentages (except idle).

- system: Percent time spent in kernel space. System CPU time is the time spent running code in the Operating System kernel.

- user: CPU percent time spent in user space. User CPU time is the time spent on the processor running your program’s code (or code in libraries).

- iowait: (Linux): percent time spent by the CPU waiting for I/O operations to complete.

- dpc: (Windows): time spent servicing deferred procedure calls (DPCs)

- idle: percent of CPU used by any program. Every program or task that runs on a computer system occupies a certain amount of processing time on the CPU. If the CPU has completed all tasks it is idle.

- irq: (Linux and BSD): percent time spent servicing/handling hardware/software interrupts. Time servicing interrupts (hardware + software).

- nice: (Unix): percent time occupied by user level processes with a positive nice value. The time the CPU has spent running users’ processes that have been niced.

- steal: (Linux): percentage of time a virtual CPU waits for a real CPU while the hypervisor is servicing another virtual processor.

- guest: (Linux): time spent running a virtual CPU for guest operating systems under the control of the Linux kernel.

- ctx_switches: number of context switches (voluntary + involuntary) per second. A context switch is a procedure that a computer’s CPU (central processing unit) follows to change from one task (or process) to another while ensuring that the tasks do not conflict.

- interrupts: number of interrupts per second.

- soft_interrupts: number of software interrupts per second. Always set to 0 on Windows and SunOS.

- syscalls: number of system calls per second. Always 0 on Linux OS.

- cpucore: Total number of CPU core.

- time_since_update: Number of seconds since last update.

- total_min: Minimum total observed since Glances startup.

- total_max: Maximum total observed since Glances startup.

- total_mean: Mean (average) total computed from the history.

Cpu limits:

    >>> gl.cpu.limits
    {'cpu_ctx_switches_careful': 640000.0,
     'cpu_ctx_switches_critical': 800000.0,
     'cpu_ctx_switches_warning': 720000.0,
     'cpu_disable': ['False'],
     'cpu_iowait_careful': 50.0,
     'cpu_iowait_critical': 90.0,
     'cpu_iowait_warning': 70.0,
     'cpu_steal_careful': 50.0,
     'cpu_steal_critical': 90.0,
     'cpu_steal_warning': 70.0,
     'cpu_system_careful': 50.0,
     'cpu_system_critical': 90.0,
     'cpu_system_log': ['False'],
     'cpu_system_warning': 70.0,
     'cpu_total_careful': 65.0,
     'cpu_total_critical': 85.0,
     'cpu_total_log': ['True'],
     'cpu_total_warning': 75.0,
     'cpu_user_careful': 50.0,
     'cpu_user_critical': 90.0,
     'cpu_user_log': ['False'],
     'cpu_user_warning': 70.0,
     'history_size': 1200.0}

## Glances amps

Amps stats:

    >>> type(gl.amps)
    <class 'glances.plugins.amps.AmpsPlugin'>
    >>> gl.amps
    Return a dict of dict with key=<name>
    >>> gl.amps.keys()
    ['Dropbox', 'Python', 'Conntrack', 'Nginx', 'Systemd', 'SystemV']
    >>> gl.amps.get("Dropbox")
    {'count': 0,
     'countmax': None,
     'countmin': 1.0,
     'key': 'name',
     'name': 'Dropbox',
     'refresh': 3.0,
     'regex': True,
     'result': None,
     'timer': 0.230393648147583}

Amps fields description:

- name: AMP name.

- result: AMP result (a string).

- refresh: AMP refresh interval.

- timer: Time until next refresh.

- count: Number of matching processes.

- countmin: Minimum number of matching processes.

- countmax: Maximum number of matching processes.

Amps limits:

    >>> gl.amps.limits
    {'amps_disable': ['False'], 'history_size': 1200.0}

## Glances processlist

Processlist stats:

    >>> type(gl.processlist)
    <class 'glances.plugins.processlist.ProcesslistPlugin'>
    >>> gl.processlist
    Return a dict of dict with key=<pid>
    >>> gl.processlist.keys()
    [82816, 129, 5879, 16620, 31537, 31526, 15, 29879, 24387, 20546, 31625, 42194, 32412, 63717, 20793, 21145, 20787, 20801, 58867, 6275, 20736, 4137, 31368, 81577, 12546, 31595, 31388, 32323, 31596, 29696, 61495, 6274, 31709, 61496, 32003, 31426, 20745, 32072, 31480, 32464, 79279, 31398, 77923, 81688, 6120, 6008, 55282, 6304, 31371, 6852, 3018, 31370, 20718, 3418, 21634, 6557, 82813, 6562, 6237, 20715, 6380, 61524, 32286, 61544, 6193, 6021, 9716, 6609, 6644, 8644, 3411, 5572, 31420, 6000, 6044, 6054, 43812, 32284, 6999, 765, 3113, 4136, 6092, 6028, 6032, 3032, 32288, 5813, 1, 3001, 5570, 5565, 5688, 3451, 3033, 3034, 6543, 6245, 5549, 2837, 6023, 6070, 4143, 6228, 3388, 3218, 6030, 6056, 3007, 5518, 5575, 3115, 4093, 4144, 3374, 8219, 6521, 6266, 6087, 4215, 9798, 3029, 4094, 9780, 6131, 806, 6031, 3021, 6346, 3235, 3004, 5800, 6072, 2838, 3030, 2997, 5861, 6426, 6273, 6335, 32766, 5625, 2836, 5810, 5981, 6192, 6202, 6321, 6057, 6025, 3026, 5587, 6358, 2996, 5776, 56214, 54561, 5629, 5670, 6064, 6009, 3128, 3012, 28204, 3048, 9820, 5779, 6930, 5566, 5877, 2995, 31960, 32212, 2835, 31385, 5553, 3000, 4317, 2847, 3023, 9825, 82809, 4148, 20619, 4164, 4172, 4156, 5636, 52832, 4162, 3612, 82812, 32763, 54559, 56203, 3400, 3401, 2845, 3098, 4274, 3613, 2, 3, 4, 5, 6, 7, 8, 10, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 29, 30, 31, 33, 34, 35, 36, 37, 39, 40, 41, 42, 43, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 57, 58, 59, 60, 61, 63, 64, 65, 66, 67, 69, 70, 71, 72, 73, 75, 76, 77, 78, 79, 81, 82, 83, 84, 85, 87, 88, 89, 90, 91, 93, 94, 95, 96, 97, 99, 100, 101, 102, 103, 105, 106, 107, 108, 109, 111, 112, 113, 114, 115, 116, 117, 118, 120, 121, 122, 123, 124, 125, 126, 127, 128, 133, 135, 136, 137, 138, 139, 140, 141, 143, 144, 145, 146, 147, 148, 149, 152, 153, 154, 155, 156, 175, 340, 342, 344, 345, 346, 347, 362, 463, 486, 487, 488, 649, 650, 651, 652, 661, 687, 689, 691, 693, 696, 699, 700, 789, 798, 800, 804, 829, 835, 843, 862, 867, 898, 901, 908, 995, 1004, 1005, 1182, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1239, 1240, 1243, 1244, 1298, 1319, 1320, 1323, 1326, 1333, 1587, 1591, 1661, 2107, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2173, 2175, 2176, 2177, 2178, 2179, 2180, 2182, 2216, 2217, 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, 2280, 2281, 2282, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, 2305, 2308, 2309, 3389, 3390, 3391, 3393, 4186, 4259, 4260, 4261, 4262, 4264, 4265, 4266, 4267, 4413, 4480, 5484, 9794, 12757, 13926, 15919, 18041, 28453, 28454, 29401, 29878, 35787, 36010, 36012, 36460, 39855, 42155, 44272, 50548, 51622, 52410, 54481, 54870, 54971, 55748, 59774, 59776, 60497, 60645, 62601, 62719, 69447, 70172, 71963, 73822, 74039, 74051, 74217, 74230, 74323, 74538, 74684, 75257, 75591, 75765, 77392, 77640, 78215, 78265, 79359, 82518, 82519]
    >>> gl.processlist.get("82816")
    {'cmdline': ['/home/nicolargo/dev/glances/.venv/bin/python3',
                 '-m',
                 'glances',
                 '-C',
                 'conf/glances.conf',
                 '--api-doc'],
     'cpu_percent': 75.7,
     'cpu_times': {'children_system': 0.01,
                   'children_user': 0.0,
                   'iowait': 0.0,
                   'system': 0.41,
                   'user': 0.4},
     'gids': {'effective': 1000, 'real': 1000, 'saved': 1000},
     'io_counters': [1650688, 200704, 1036288, 200704, 1, 0, 32768, 0, 32768, 1],
     'key': 'pid',
     'memory_info': {'data': 140513280,
                     'dirty': 0,
                     'lib': 0,
                     'rss': 98471936,
                     'shared': 27254784,
                     'text': 31211520,
                     'vms': 696369152},
     'memory_percent': 0.5997856928122267,
     'name': 'python3',
     'nice': 0,
     'num_threads': 4,
     'pid': 82816,
     'status': 'R',
     'time_since_update': 0.5077733993530273,
     'username': 'nicolargo'}

Processlist fields description:

- pid: Process identifier (ID)

- name: Process name

- cmdline: Command line with arguments

- username: Process owner

- num_threads: Number of threads

- cpu_percent: Process CPU consumption (returned value can be > 100.0 in case of a process running multiple threads on different CPU cores)

- memory_percent: Process memory consumption

- memory_info: Process memory information (dict with rss, vms, shared, text, lib, data, dirty keys)

- status: Process status

- nice: Process nice value

- cpu_times: Process CPU times (dict with user, system, iowait keys)

- gids: Process group IDs (dict with real, effective, saved keys)

- io_counters: Process IO counters (list with read_count, write_count, read_bytes, write_bytes, io_tag keys)

- cpu_num: CPU core number where the process is currently executing (0-based indexing)

Processlist limits:

    >>> gl.processlist.limits
    {'history_size': 1200.0,
     'processlist_cpu_careful': 50.0,
     'processlist_cpu_critical': 90.0,
     'processlist_cpu_warning': 70.0,
     'processlist_disable': ['False'],
     'processlist_disable_stats': ['cpu_num'],
     'processlist_mem_careful': 50.0,
     'processlist_mem_critical': 90.0,
     'processlist_mem_warning': 70.0,
     'processlist_nice_warning': ['-20',
                                  '-19',
                                  '-18',
                                  '-17',
                                  '-16',
                                  '-15',
                                  '-14',
                                  '-13',
                                  '-12',
                                  '-11',
                                  '-10',
                                  '-9',
                                  '-8',
                                  '-7',
                                  '-6',
                                  '-5',
                                  '-4',
                                  '-3',
                                  '-2',
                                  '-1',
                                  '1',
                                  '2',
                                  '3',
                                  '4',
                                  '5',
                                  '6',
                                  '7',
                                  '8',
                                  '9',
                                  '10',
                                  '11',
                                  '12',
                                  '13',
                                  '14',
                                  '15',
                                  '16',
                                  '17',
                                  '18',
                                  '19'],
     'processlist_status_critical': ['Z', 'D'],
     'processlist_status_ok': ['R', 'W', 'P', 'I']}

## Glances load

Load stats:

    >>> type(gl.load)
    <class 'glances.plugins.load.LoadPlugin'>
    >>> gl.load
    {'cpucore': 16,
     'min1': 0.96240234375,
     'min15': 1.009765625,
     'min5': 0.9287109375}
    >>> gl.load.keys()
    ['min1', 'min5', 'min15', 'cpucore']
    >>> gl.load.get("min1")
    0.96240234375

Load fields description:

- min1: Average sum of the number of processes waiting in the run-queue plus the number currently executing over 1 minute.

- min5: Average sum of the number of processes waiting in the run-queue plus the number currently executing over 5 minutes.

- min15: Average sum of the number of processes waiting in the run-queue plus the number currently executing over 15 minutes.

- cpucore: Total number of CPU core.

- min1_min: Minimum min1 observed since Glances startup.

- min1_max: Maximum min1 observed since Glances startup.

- min1_mean: Mean (average) min1 computed from the history.

Load limits:

    >>> gl.load.limits
    {'history_size': 1200.0,
     'load_careful': 0.7,
     'load_critical': 5.0,
     'load_disable': ['False'],
     'load_warning': 1.0}

## Glances sensors

Sensors stats:

    >>> type(gl.sensors)
    <class 'glances.plugins.sensors.SensorsPlugin'>
    >>> gl.sensors
    Return a dict of dict with key=<label>
    >>> gl.sensors.keys()
    ['Ambient', 'Ambient 3', 'Ambient 5', 'Ambient 6', 'CPU', 'Composite', 'Core 0', 'Core 4', 'Core 8', 'Core 12', 'Core 16', 'Core 20', 'Core 28', 'Core 29', 'Core 30', 'Core 31', 'HDD', 'Package id 0', 'SODIMM', 'Sensor 1', 'Sensor 2', 'dell_smm 0', 'dell_smm 1', 'dell_smm 2', 'dell_smm 3', 'dell_smm 4', 'dell_smm 5', 'dell_smm 6', 'dell_smm 7', 'dell_smm 8', 'dell_smm 9', 'i915 0', 'iwlwifi_1 0', 'temp', 'CPU Fan', 'Video Fan', 'BAT BAT0']
    >>> gl.sensors.get("Ambient")
    {'critical': None,
     'key': 'label',
     'label': 'Ambient',
     'type': 'temperature_core',
     'unit': 'C',
     'value': 43,
     'warning': 0}

Sensors fields description:

- label: Sensor label

- unit: Sensor unit

- value: Sensor value

- warning: System warning threshold (regardless of the user configuration in the glances.conf file)

- critical: System critical threshold (regardless of the user configuration in the glances.conf file)

- type: Sensor type (one of battery, temperature_core, fan_speed)

Sensors limits:

    >>> gl.sensors.limits
    {'history_size': 1200.0,
     'sensors_battery_careful': 70.0,
     'sensors_battery_critical': 90.0,
     'sensors_battery_warning': 80.0,
     'sensors_disable': ['False'],
     'sensors_hide': ['unknown.*'],
     'sensors_refresh': 10.0,
     'sensors_temperature_core_careful': 45.0,
     'sensors_temperature_core_critical': 80.0,
     'sensors_temperature_core_warning': 65.0,
     'sensors_temperature_hdd_careful': 45.0,
     'sensors_temperature_hdd_critical': 60.0,
     'sensors_temperature_hdd_warning': 52.0}

## Glances uptime

Uptime stats:

    >>> type(gl.uptime)
    <class 'glances.plugins.uptime.UptimePlugin'>
    >>> gl.uptime
    '1:26:57'

Uptime limits:

    >>> gl.uptime.limits
    {'history_size': 1200.0}

## Glances now

Now stats:

    >>> type(gl.now)
    <class 'glances.plugins.now.NowPlugin'>
    >>> gl.now
    {'custom': '2026-08-01 10:56:03 CEST', 'iso': '2026-08-01T10:56:03+02:00'}
    >>> gl.now.keys()
    ['iso', 'custom']
    >>> gl.now.get("iso")
    '2026-08-01T10:56:03+02:00'

Now fields description:

- custom: Current date in custom format.

- iso: Current date in ISO 8601 format.

Now limits:

    >>> gl.now.limits
    {'history_size': 1200.0}

## Glances fs

Fs stats:

    >>> type(gl.fs)
    <class 'glances.plugins.fs.FsPlugin'>
    >>> gl.fs
    Return a dict of dict with key=<mnt_point>
    >>> gl.fs.keys()
    ['/', '/zsfpool']
    >>> gl.fs.get("/")
    {'device_name': '/dev/mapper/ubuntu--vg-ubuntu--lv',
     'free': 488287727616,
     'fs_type': 'ext4',
     'key': 'mnt_point',
     'mnt_point': '/',
     'options': 'rw,relatime',
     'percent': 48.7,
     'size': 1003736440832,
     'used': 464386207744}

Fs fields description:

- device_name: Device name.

- fs_type: File system type.

- mnt_point: Mount point.

- options: Mount options.

- size: Total size.

- used: Used size.

- free: Free size.

- percent: File system usage in percent.

Fs limits:

    >>> gl.fs.limits
    {'fs_careful': 50.0,
     'fs_critical': 90.0,
     'fs_disable': ['False'],
     'fs_hide': ['/boot.*', '.*/snap.*'],
     'fs_refresh': 60.0,
     'fs_warning': 70.0,
     'history_size': 1200.0}

## Glances wifi

Wifi stats:

    >>> type(gl.wifi)
    <class 'glances.plugins.wifi.WifiPlugin'>
    >>> gl.wifi
    Return a dict of dict with key=<ssid>
    >>> gl.wifi.keys()
    ['wlp0s20f3']
    >>> gl.wifi.get("wlp0s20f3")
    {'key': 'ssid',
     'quality_level': -58.0,
     'quality_link': 52.0,
     'ssid': 'wlp0s20f3'}

Wifi limits:

    >>> gl.wifi.limits
    {'history_size': 1200.0,
     'wifi_careful': -65.0,
     'wifi_critical': -85.0,
     'wifi_disable': ['False'],
     'wifi_warning': -75.0}

## Glances ip

Ip stats:

    >>> type(gl.ip)
    <class 'glances.plugins.ip.IpPlugin'>
    >>> gl.ip
    {'address': '192.168.1.26', 'mask': '255.255.255.0', 'mask_cidr': 24}
    >>> gl.ip.keys()
    ['address', 'mask', 'mask_cidr']
    >>> gl.ip.get("address")
    '192.168.1.26'

Ip fields description:

- address: Private IP address

- mask: Private IP mask

- mask_cidr: Private IP mask in CIDR format

- gateway: Private IP gateway

- public_address: Public IP address

- public_info_human: Public IP information

Ip limits:

    >>> gl.ip.limits
    {'history_size': 1200.0,
     'ip_disable': ['False'],
     'ip_public_api': ['https://ipv4.ipleak.net/json/'],
     'ip_public_disabled': ['True'],
     'ip_public_field': ['ip'],
     'ip_public_refresh_interval': 300.0,
     'ip_public_template': ['{continent_name}/{country_name}/{city_name}'],
     'ip_refresh': 60.0}

## Glances version

Version stats:

    >>> type(gl.version)
    <class 'glances.plugins.version.VersionPlugin'>
    >>> gl.version
    '4.5.6'

Version limits:

    >>> gl.version.limits
    {'history_size': 1200.0}

## Glances psutilversion

Psutilversion stats:

    >>> type(gl.psutilversion)
    <class 'glances.plugins.psutilversion.PsutilversionPlugin'>
    >>> gl.psutilversion
    '7.2.2'

Psutilversion limits:

    >>> gl.psutilversion.limits
    {'history_size': 1200.0}

## Glances core

Core stats:

    >>> type(gl.core)
    <class 'glances.plugins.core.CorePlugin'>
    >>> gl.core
    {'log': 16, 'phys': 10}
    >>> gl.core.keys()
    ['phys', 'log']
    >>> gl.core.get("phys")
    10

Core fields description:

- phys: Number of physical cores (hyper thread CPUs are excluded).

- log: Number of logical CPU cores. A logical CPU is the number of physical cores multiplied by the number of threads that can run on each core.

Core limits:

    >>> gl.core.limits
    {'history_size': 1200.0}

## Glances mem

Mem stats:

    >>> type(gl.mem)
    <class 'glances.plugins.mem.MemPlugin'>
    >>> gl.mem
    {'active': 5314899968,
     'available': 6095308736,
     'buffers': 205410304,
     'cached': 6905879616,
     'free': 245760000,
     'inactive': 8576086016,
     'percent': 62.9,
     'percent_max': 62.9,
     'percent_mean': 62.9,
     'percent_min': 62.9,
     'shared': 1939501056,
     'total': 16417853440,
     'used': 10322544704}
    >>> gl.mem.keys()
    ['total', 'available', 'percent', 'used', 'free', 'active', 'inactive', 'buffers', 'cached', 'shared', 'percent_min', 'percent_max', 'percent_mean']
    >>> gl.mem.get("total")
    16417853440

Mem fields description:

- total: Total physical memory available.

- available: The actual amount of available memory that can be given instantly to processes that request more memory in bytes; this is calculated by summing different memory values depending on the platform (e.g. free + buffers + cached on Linux) and it is supposed to be used to monitor actual memory usage in a cross platform fashion.

- percent: The percentage usage calculated as (total - available) / total * 100.

- used: Memory used, calculated differently depending on the platform and designed for informational purposes only.

- free: Memory not being used at all (zeroed) that is readily available; note that this doesn’t reflect the actual memory available (use ‘available’ instead).

- active: (UNIX): memory currently in use or very recently used, and so it is in RAM.

- inactive: (UNIX): memory that is marked as not used.

- buffers: (Linux, BSD): cache for things like file system metadata.

- cached: (Linux, BSD): cache for various things (including ZFS cache).

- wired: (BSD, macOS): memory that is marked to always stay in RAM. It is never moved to disk.

- shared: (BSD): memory that may be simultaneously accessed by multiple processes.

- percent_min: Minimum percent observed since Glances startup.

- percent_max: Maximum percent observed since Glances startup.

- percent_mean: Mean (average) percent computed from the history.

Mem limits:

    >>> gl.mem.limits
    {'history_size': 1200.0,
     'mem_careful': 50.0,
     'mem_critical': 90.0,
     'mem_disable': ['False'],
     'mem_warning': 70.0}

## Glances folders

Folders stats:

    >>> type(gl.folders)
    <class 'glances.plugins.folders.FoldersPlugin'>
    >>> gl.folders
    []

Folders fields description:

- path: Absolute path.

- size: Folder size in bytes.

- refresh: Refresh interval in seconds.

- errno: Return code when retrieving folder size (0 is no error).

- careful: Careful threshold in MB.

- warning: Warning threshold in MB.

- critical: Critical threshold in MB.

Folders limits:

    >>> gl.folders.limits
    {'folders_disable': ['False'], 'folders_refresh': 60.0, 'history_size': 1200.0}

## Glances quicklook

Quicklook stats:

    >>> type(gl.quicklook)
    <class 'glances.plugins.quicklook.QuicklookPlugin'>
    >>> gl.quicklook
    {'cpu': 7.2,
     'cpu_hz': 4475000000.0,
     'cpu_hz_current': 996174812.5000001,
     'cpu_log_core': 16,
     'cpu_name': '13th Gen Intel(R) Core(TM) i7-13620H',
     'cpu_phys_core': 10,
     'gpu_mem': 0,
     'gpu_proc': 0,
     'load': 6.3,
     'mem': 62.9,
     'percpu': [{'cpu_number': 0,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 23.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 8.0,
                 'total': 77.0,
                 'user': 0.0},
                {'cpu_number': 1,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 34.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 0.0,
                 'total': 66.0,
                 'user': 0.0},
                {'cpu_number': 2,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 32.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 1.0,
                 'total': 68.0,
                 'user': 0.0},
                {'cpu_number': 3,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 33.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 0.0,
                 'total': 67.0,
                 'user': 0.0},
                {'cpu_number': 4,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 17.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 12.0,
                 'total': 83.0,
                 'user': 5.0},
                {'cpu_number': 5,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 32.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 1.0,
                 'total': 68.0,
                 'user': 0.0},
                {'cpu_number': 6,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 0.0,
                 'interrupt': None,
                 'iowait': 30.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 1.0,
                 'total': 100.0,
                 'user': 3.0},
                {'cpu_number': 7,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 34.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 0.0,
                 'total': 66.0,
                 'user': 0.0},
                {'cpu_number': 8,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 28.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 1.0,
                 'total': 72.0,
                 'user': 4.0},
                {'cpu_number': 9,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 0.0,
                 'interrupt': None,
                 'iowait': 33.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 1.0,
                 'total': 100.0,
                 'user': 0.0},
                {'cpu_number': 10,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 0.0,
                 'interrupt': None,
                 'iowait': 33.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 0.0,
                 'total': 100.0,
                 'user': 0.0},
                {'cpu_number': 11,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 34.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 0.0,
                 'total': 66.0,
                 'user': 0.0},
                {'cpu_number': 12,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 33.0,
                 'interrupt': None,
                 'iowait': 0.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 0.0,
                 'total': 67.0,
                 'user': 1.0},
                {'cpu_number': 13,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 0.0,
                 'interrupt': None,
                 'iowait': 33.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 0.0,
                 'total': 100.0,
                 'user': 1.0},
                {'cpu_number': 14,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 0.0,
                 'interrupt': None,
                 'iowait': 32.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 1.0,
                 'total': 100.0,
                 'user': 1.0},
                {'cpu_number': 15,
                 'dpc': None,
                 'guest': 0.0,
                 'guest_nice': 0.0,
                 'idle': 0.0,
                 'interrupt': None,
                 'iowait': 33.0,
                 'irq': 0.0,
                 'key': 'cpu_number',
                 'nice': 0.0,
                 'softirq': 0.0,
                 'steal': 0.0,
                 'system': 0.0,
                 'total': 100.0,
                 'user': 1.0}],
     'swap': 23.4}
    >>> gl.quicklook.keys()
    ['cpu_name', 'cpu_hz_current', 'cpu_hz', 'cpu', 'percpu', 'mem', 'swap', 'cpu_log_core', 'cpu_phys_core', 'load', 'gpu_mem', 'gpu_proc']
    >>> gl.quicklook.get("cpu_name")
    '13th Gen Intel(R) Core(TM) i7-13620H'

Quicklook fields description:

- cpu: CPU percent usage

- mem: MEM percent usage

- swap: SWAP percent usage

- load: LOAD percent usage

- cpu_log_core: Number of logical CPU core

- cpu_phys_core: Number of physical CPU core

- cpu_name: CPU name

- cpu_hz_current: CPU current frequency

- cpu_hz: CPU max frequency

- gpu_mem: Average GPU Memory consumption

- gpu_proc: Average GPU Processor consumption

Quicklook limits:

    >>> gl.quicklook.limits
    {'history_size': 1200.0,
     'quicklook_bar_char': ['▪'],
     'quicklook_cpu_careful': 50.0,
     'quicklook_cpu_critical': 90.0,
     'quicklook_cpu_warning': 70.0,
     'quicklook_disable': ['False'],
     'quicklook_gpu_mem_careful': 50.0,
     'quicklook_gpu_mem_critical': 90.0,
     'quicklook_gpu_mem_warning': 70.0,
     'quicklook_gpu_proc_careful': 50.0,
     'quicklook_gpu_proc_critical': 90.0,
     'quicklook_gpu_proc_warning': 70.0,
     'quicklook_list': ['cpu', 'mem', 'load'],
     'quicklook_load_careful': 70.0,
     'quicklook_load_critical': 500.0,
     'quicklook_load_warning': 100.0,
     'quicklook_mem_careful': 50.0,
     'quicklook_mem_critical': 90.0,
     'quicklook_mem_warning': 70.0,
     'quicklook_swap_careful': 50.0,
     'quicklook_swap_critical': 90.0,
     'quicklook_swap_warning': 70.0}

## Glances memswap

Memswap stats:

    >>> type(gl.memswap)
    <class 'glances.plugins.memswap.MemswapPlugin'>
    >>> gl.memswap
    {'free': 3288137728,
     'percent': 23.4,
     'sin': 209350656,
     'sout': 1026351104,
     'time_since_update': 0.45430874824523926,
     'total': 4294963200,
     'used': 1006825472}
    >>> gl.memswap.keys()
    ['total', 'used', 'free', 'percent', 'sin', 'sout', 'time_since_update']
    >>> gl.memswap.get("total")
    4294963200

Memswap fields description:

- total: Total swap memory.

- used: Used swap memory.

- free: Free swap memory.

- percent: Used swap memory in percentage.

- sin: The number of bytes the system has swapped in from disk (cumulative).

- sout: The number of bytes the system has swapped out from disk (cumulative).

- time_since_update: Number of seconds since last update.

Memswap limits:

    >>> gl.memswap.limits
    {'history_size': 1200.0,
     'memswap_careful': 50.0,
     'memswap_critical': 90.0,
     'memswap_disable': ['False'],
     'memswap_warning': 70.0}

## Use auto_unit to display a human-readable string with the unit

Use auto_unit() function to generate a human-readable string with the unit:

    >>> gl.mem.get("used")
    10322544704

    >>> gl.auto_unit(gl.mem.get("used"))
    9.61G

Args:

> number (float or int): The numeric value to be converted.

> low_precision (bool, optional): If True, use lower precision for the output. Defaults to False.

> min_symbol (str, optional): The minimum unit symbol to use (e.g., ‘K’ for kilo). Defaults to ‘K’.

> none_symbol (str, optional): The symbol to display if the number is None. Defaults to ‘-‘.

Returns:

> str: A human-readable string representation of the number with units.

## Use to display stat as a bar

Use bar() function to generate a bar:

    >>> gl.bar(gl.mem["percent"])
    ■■■■■■■■■■■□□□□□□□

Args:

> value (float): The percentage value to represent in the bar (typically between 0 and 100).

> size (int, optional): The total length of the bar in characters. Defaults to 18.

> bar_char (str, optional): The character used to represent the filled portion of the bar. Defaults to ‘■’.

> empty_char (str, optional): The character used to represent the empty portion of the bar. Defaults to ‘□’.

> pre_char (str, optional): A string to prepend to the bar. Defaults to ‘’.

> post_char (str, optional): A string to append to the bar. Defaults to ‘’.

Returns:

> str: A string representing the progress bar.

## Use to display top process list

Use top_process() function to generate a list of top processes sorted by CPU or MEM usage:

    >>> gl.top_process()
    [{'cpu_percent': 6.1, 'nice': 0, 'num_threads': 39, 'memory_info': {'rss': 546607104, 'vms': 6096752640, 'shared': 248934400, 'text': 8192, 'lib': 0, 'data': 551526400, 'dirty': 0}, 'gids': {'real': 1000, 'effective': 1000, 'saved': 1000}, 'name': 'gnome-shell', 'io_counters': [335985664, 153677824, 335985664, 153677824, 1], 'pid': 5879, 'cpu_times': {'user': 241.58, 'system': 131.4, 'children_user': 19.01, 'children_system': 5.72, 'iowait': 0.0}, 'memory_percent': 3.3293457393660346, 'status': 'S', 'key': 'pid', 'time_since_update': 0.5077733993530273, 'cmdline': ['/usr/bin/gnome-shell'], 'username': 'nicolargo'}, {'cpu_percent': 4.1, 'nice': 0, 'num_threads': 27, 'memory_info': {'rss': 245682176, 'vms': 3255783424, 'shared': 113020928, 'text': 11780096, 'lib': 0, 'data': 501460992, 'dirty': 0}, 'gids': {'real': 1000, 'effective': 1000, 'saved': 1000}, 'name': 'ghostty', 'io_counters': [91455488, 188416, 91455488, 188416, 1], 'pid': 16620, 'cpu_times': {'user': 92.08, 'system': 26.62, 'children_user': 3.61, 'children_system': 2.82, 'iowait': 0.0}, 'memory_percent': 1.496432995323413, 'status': 'S', 'key': 'pid', 'time_since_update': 0.5077733993530273, 'cmdline': ['/snap/ghostty/820/bin/ghostty', '--gtk-single-instance=true'], 'username': 'nicolargo'}, {'cpu_percent': 2.0, 'nice': 0, 'num_threads': 26, 'memory_info': {'rss': 429604864, 'vms': 1561270198272, 'shared': 154923008, 'text': 162107392, 'lib': 0, 'data': 1412997120, 'dirty': 0}, 'gids': {'real': 1000, 'effective': 1000, 'saved': 1000}, 'name': 'code', 'io_counters': [39523328, 114688, 39523328, 114688, 1, 1267712, 0, 1267712, 0, 1, 294426624, 2113536, 294426624, 2113536, 1, 184255488, 1961984, 184255488, 1961984, 1, 81283072, 26791936, 81283072, 26791936, 1, 37664768, 59506688, 37664768, 59506688, 1, 24516608, 4096, 24516608, 4096, 1, 15375360, 0, 15375360, 0, 1, 472064, 0, 472064, 0, 1, 6592512, 45056, 6592512, 45056, 1, 368640, 0, 368640, 0, 1, 5734400, 0, 5734400, 0, 1, 1000448, 0, 1000448, 0, 1, 4985856, 1748992, 4985856, 1748992, 1, 3514368, 0, 3514368, 0, 1, 521216, 0, 521216, 0, 1, 644096, 0, 644096, 0, 1], 'pid': 31537, 'cpu_times': {'user': 121.09, 'system': 11.82, 'children_user': 0.0, 'children_system': 0.0, 'iowait': 0.0}, 'memory_percent': 2.616693257556574, 'status': 'S', 'key': 'pid', 'time_since_update': 0.5077733993530273, 'cmdline': ['/snap/code/252/usr/share/code/code', '--type=renderer', '--crashpad-handler-pid=31385', '--enable-crash-reporter=864d4bb7-dd20-4851-830f-29e81dd93517,no_channel', '--user-data-dir=/home/nicolargo/.config/Code', '--standard-schemes=vscode-webview,vscode-file', '--secure-schemes=vscode-webview,vscode-file,vscode-remote-resource,vscode-managed-remote-resource', '--cors-schemes=vscode-webview,vscode-file,vscode-remote-resource,vscode-managed-remote-resource', '--fetch-schemes=vscode-webview,vscode-file,vscode-remote-resource,vscode-managed-remote-resource', '--service-worker-schemes=vscode-webview', '--code-cache-schemes=vscode-webview,vscode-file', '--app-path=/snap/code/252/usr/share/code/resources/app', '--enable-sandbox', '--enable-blink-features=HighlightAPI', '--no-sandbox', '--max-active-webgl-contexts=32', '--ozone-platform=x11', '--disable-gpu-compositing', '--disable-blink-features=FontMatchingCTMigration,StandardizedBrowserZoom,', '--lang=en-US', '--num-raster-threads=4', '--enable-main-frame-before-activation', '--renderer-client-id=5', '--time-ticks-at-unix-epoch=-1785569346785715', '--launch-time-ticks=2499111991', '--shared-files=v8_context_snapshot_data:100', '--field-trial-handle=3,i,15701004025785094717,18098535858584220795,262144', '--enable-features=DocumentPolicyIncludeJSCallStacksInCrashReports,EarlyEstablishGpuChannel,EstablishGpuChannelAsync,GlobalShortcutsPortal,PdfUseShowSaveFilePicker', '--disable-features=CalculateNativeWinOcclusion,DropInputEventsWhilePaintHolding,LocalNetworkAccessChecks,ScreenAIOCREnabled,SpareRendererForSitePerProcess,TraceSiteInstanceGetProcessCreation', '--variations-seed-version', '--pseudonymization-salt-handle=7,i,5062963083377378361,851606893431495686,4', '--trace-process-track-uuid=3190708990997080739', '--vscode-window-config=vscode:060c7c2a-ca77-4dda-9bbf-430901d662ae'], 'username': 'nicolargo'}]

Args:

> limit (int, optional): The maximum number of top processes to return. Defaults to 3.

> sorted_by (str, optional): The primary key to sort processes by (e.g., ‘cpu_percent’).

>   Defaults to ‘cpu_percent’.

> sorted_by_secondary (str, optional): The secondary key to sort processes by if primary keys are equal

>   (e.g., ‘memory_percent’). Defaults to ‘memory_percent’.

Returns:

> list: A list of dictionaries representing the top processes, excluding those with ‘glances’ in their

>   command line.

Note:

> The ‘glances’ process is excluded from the returned list to avoid self-generated CPU load affecting the results.