tiptop is a command-line system monitoring tool in the spirit of top.

Overview

tiptop

Command-line system monitoring.

PyPi Version PyPI pyversions GitHub stars Downloads

Discord Donate Sponsor Coffee

gh-actions codecov LGTM Code style: black

tiptop is a command-line system monitoring tool in the spirit of top. It displays various interesting system stats, graphs it, and works on all operating systems.

Install and run with

pip install tiptop
tiptop

screenshot

tiptop uses Textual for layouting and psutil for fetching system data.

Other top alternatives in alphabetical order:

See here for a comparison by GitHub stars.

Comments
  • Test the aplication and I've got Errors

    Test the aplication and I've got Errors

    My machine:

    OS: Fedora release 35 (Thirty Five) Host: MS-7D54 1.0 Kernel: 5.16.12-200.fc35.x86_64 Shell: zsh 5.8.1 DE: GNOME 41.4 WM: Mutter Terminal: tilix CPU: AMD Ryzen 9 5900X (24) @ 3.700GHz GPU: NVIDIA GeForce GT 730 Memory: 32078MiB 2 SSD 1.- nvme and 2.- normal SSD card 1 SATA 4TB Memory: 32078MiB

    Regards.,

    This is what I've Got:

    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/tiptop/_disk.py:49 in         │
    │ on_mount                                                                     │
    │                                                                              │
    │    46 │   │   │   for item in psutil.disk_partitions()                       │
    │    47 │   │   │   if not item.device.startswith("/dev/loop")                 │
    │    48 │   │   ]                                                              │
    │ ❱  49 │   │   self.total = [                                                 │
    │    50 │   │   │   sizeof_fmt(psutil.disk_usage(mp).total, fmt=".1f")         │
    │    51 │   │   │   for mp in self.mountpoints                                 │
    │    52 │   │   ]                                                              │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    │ /home/hhlp/.local/lib/python3.10/site-packages/tiptop/_disk.py:50 in         │
    │ <listcomp>                                                                   │
    │                                                                              │
    │    47 │   │   │   if not item.device.startswith("/dev/loop")                 │
    │    48 │   │   ]                                                              │
    │    49 │   │   self.total = [                                                 │
    │ ❱  50 │   │   │   sizeof_fmt(psutil.disk_usage(mp).total, fmt=".1f")         │
    │    51 │   │   │   for mp in self.mountpoints                                 │
    │    52 │   │   ]                                                              │
    │    53                                                                        │
    │                                                                              │
    │ ╭─────────────────── locals ────────────────────╮                            │
    │ │ .0 = <list_iterator object at 0x7f7cc094e5f0> │                            │
    │ │ mp = '/var/lib/docker/btrfs'                  │                            │
    │ ╰───────────────────────────────────────────────╯                            │
    │                                                                              │
    │ /usr/lib64/python3.10/site-packages/psutil/__init__.py:1995 in disk_usage    │
    │                                                                              │
    │   1992 │   namedtuple including total, used and free space expressed in byte │
    │   1993 │   plus the percentage usage.                                        │
    │   1994 │   """                                                               │
    │ ❱ 1995 │   return _psplatform.disk_usage(path)                               │
    │   1996                                                                       │
    │   1997                                                                       │
    │   1998 def disk_partitions(all=False):                                       │
    │                                                                              │
    │ ╭──────────── locals ────────────╮                                           │
    │ │ path = '/var/lib/docker/btrfs' │                                           │
    │ ╰────────────────────────────────╯                                           │
    │                                                                              │
    │ /usr/lib64/python3.10/site-packages/psutil/_psposix.py:169 in disk_usage     │
    │                                                                              │
    │   166 │   the "free" and "used percent" user disk space.                     │
    │   167 │   """                                                                │
    │   168 │   if PY3:                                                            │
    │ ❱ 169 │   │   st = os.statvfs(path)                                          │
    │   170 │   else:  # pragma: no cover                                          │
    │   171 │   │   # os.statvfs() does not support unicode on Python 2:           │
    │   172 │   │   # - https://github.com/giampaolo/psutil/issues/416             │
    │                                                                              │
    │ ╭──────────── locals ────────────╮                                           │
    │ │ path = '/var/lib/docker/btrfs' │                                           │
    │ ╰────────────────────────────────╯                                           │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    PermissionError: [Errno 13] Permission denied: '/var/lib/docker/btrfs'
    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:202 in      │
    │ _get_lines                                                                   │
    │                                                                              │
    │   199 │   def _get_lines(self) -> Lines:                                     │
    │   200 │   │   """Get segment lines to render the widget."""                  │
    │   201 │   │   if self.render_cache is None:                                  │
    │ ❱ 202 │   │   │   self.render_lines()                                        │
    │   203 │   │   assert self.render_cache is not None                           │
    │   204 │   │   lines = self.render_cache.lines                                │
    │   205 │   │   return lines                                                   │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:188 in      │
    │ render_lines                                                                 │
    │                                                                              │
    │   185 │                                                                      │
    │   186 │   def render_lines(self) -> None:                                    │
    │   187 │   │   width, height = self.size                                      │
    │ ❱ 188 │   │   renderable = self.render_styled()                              │
    │   189 │   │   options = self.console.options.update_dimensions(width, height │
    │   190 │   │   lines = self.console.render_lines(renderable, options)         │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)              │
    │                                                                              │
    │ ╭─────────── locals ───────────╮                                             │
    │ │ height = 8                   │                                             │
    │ │   self = Disk(name='Disk#1') │                                             │
    │ │  width = 31                  │                                             │
    │ ╰──────────────────────────────╯                                             │
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:128 in      │
    │ render_styled                                                                │
    │                                                                              │
    │   125 │   │   Returns:                                                       │
    │   126 │   │   │   RenderableType: A new renderable.                          │
    │   127 │   │   """                                                            │
    │ ❱ 128 │   │   renderable = self.render()                                     │
    │   129 │   │   if self.padding is not None:                                   │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)             │
    │   131 │   │   if self.border in self.BOX_MAP:                                │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/tiptop/_disk.py:159 in render │
    │                                                                              │
    │   156 │   │   self.refresh()                                                 │
    │   157 │                                                                      │
    │   158 │   def render(self):                                                  │
    │ ❱ 159 │   │   return self.panel                                              │
    │   160 │                                                                      │
    │   161 │   async def on_resize(self, event):                                  │
    │   162 │   │   self.read_stream.reset_width(event.width - 25)                 │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    AttributeError: 'Disk' object has no attribute 'panel'
    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:202 in      │
    │ _get_lines                                                                   │
    │                                                                              │
    │   199 │   def _get_lines(self) -> Lines:                                     │
    │   200 │   │   """Get segment lines to render the widget."""                  │
    │   201 │   │   if self.render_cache is None:                                  │
    │ ❱ 202 │   │   │   self.render_lines()                                        │
    │   203 │   │   assert self.render_cache is not None                           │
    │   204 │   │   lines = self.render_cache.lines                                │
    │   205 │   │   return lines                                                   │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:188 in      │
    │ render_lines                                                                 │
    │                                                                              │
    │   185 │                                                                      │
    │   186 │   def render_lines(self) -> None:                                    │
    │   187 │   │   width, height = self.size                                      │
    │ ❱ 188 │   │   renderable = self.render_styled()                              │
    │   189 │   │   options = self.console.options.update_dimensions(width, height │
    │   190 │   │   lines = self.console.render_lines(renderable, options)         │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)              │
    │                                                                              │
    │ ╭─────────── locals ───────────╮                                             │
    │ │ height = 8                   │                                             │
    │ │   self = Disk(name='Disk#1') │                                             │
    │ │  width = 31                  │                                             │
    │ ╰──────────────────────────────╯                                             │
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:128 in      │
    │ render_styled                                                                │
    │                                                                              │
    │   125 │   │   Returns:                                                       │
    │   126 │   │   │   RenderableType: A new renderable.                          │
    │   127 │   │   """                                                            │
    │ ❱ 128 │   │   renderable = self.render()                                     │
    │   129 │   │   if self.padding is not None:                                   │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)             │
    │   131 │   │   if self.border in self.BOX_MAP:                                │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/tiptop/_disk.py:159 in render │
    │                                                                              │
    │   156 │   │   self.refresh()                                                 │
    │   157 │                                                                      │
    │   158 │   def render(self):                                                  │
    │ ❱ 159 │   │   return self.panel                                              │
    │   160 │                                                                      │
    │   161 │   async def on_resize(self, event):                                  │
    │   162 │   │   self.read_stream.reset_width(event.width - 25)                 │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    AttributeError: 'Disk' object has no attribute 'panel'
    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:202 in      │
    │ _get_lines                                                                   │
    │                                                                              │
    │   199 │   def _get_lines(self) -> Lines:                                     │
    │   200 │   │   """Get segment lines to render the widget."""                  │
    │   201 │   │   if self.render_cache is None:                                  │
    │ ❱ 202 │   │   │   self.render_lines()                                        │
    │   203 │   │   assert self.render_cache is not None                           │
    │   204 │   │   lines = self.render_cache.lines                                │
    │   205 │   │   return lines                                                   │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:188 in      │
    │ render_lines                                                                 │
    │                                                                              │
    │   185 │                                                                      │
    │   186 │   def render_lines(self) -> None:                                    │
    │   187 │   │   width, height = self.size                                      │
    │ ❱ 188 │   │   renderable = self.render_styled()                              │
    │   189 │   │   options = self.console.options.update_dimensions(width, height │
    │   190 │   │   lines = self.console.render_lines(renderable, options)         │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)              │
    │                                                                              │
    │ ╭─────────── locals ───────────╮                                             │
    │ │ height = 8                   │                                             │
    │ │   self = Disk(name='Disk#1') │                                             │
    │ │  width = 31                  │                                             │
    │ ╰──────────────────────────────╯                                             │
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/textual/widget.py:128 in      │
    │ render_styled                                                                │
    │                                                                              │
    │   125 │   │   Returns:                                                       │
    │   126 │   │   │   RenderableType: A new renderable.                          │
    │   127 │   │   """                                                            │
    │ ❱ 128 │   │   renderable = self.render()                                     │
    │   129 │   │   if self.padding is not None:                                   │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)             │
    │   131 │   │   if self.border in self.BOX_MAP:                                │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    │                                                                              │
    │ /home/hhlp/.local/lib/python3.10/site-packages/tiptop/_disk.py:159 in render │
    │                                                                              │
    │   156 │   │   self.refresh()                                                 │
    │   157 │                                                                      │
    │   158 │   def render(self):                                                  │
    │ ❱ 159 │   │   return self.panel                                              │
    │   160 │                                                                      │
    │   161 │   async def on_resize(self, event):                                  │
    │   162 │   │   self.read_stream.reset_width(event.width - 25)                 │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ self = Disk(name='Disk#1') │                                               │
    │ ╰────────────────────────────╯                                               │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    AttributeError: 'Disk' object has no attribute 'panel'
    
    opened by hhlp 11
  • Feature: Flag for those who use white background terminal

    Feature: Flag for those who use white background terminal

    I use a white background terminal (it is easier on my eyes as visually impaired). Could there be a flag/config option so it inverts the colours used? At least on my Mac a lot of the stuff is not displayed with a white background.

    This is what I see:

    f

    opened by DarrenPIngram 11
  • fixes to make tiptop work on macOS

    fixes to make tiptop work on macOS

    These are just some basic fixes and a WIP, not ready for merging yet.

    Turns out some neat features have to be solved differently for macOS specifically, or are specifically Linux-only, which will make them either go missing or have weird values on non-Linux OSes.

    Fixes #6.

    opened by jkbecker 9
  • No module named 'termios'

    No module named 'termios'

    Hi, I really wanted to try this monitoring system but when I pip install it throw ModuleNotFoundError: No module named 'termios'.

    I Installed it on virtualenv, with Windows OS, python 3.7.8.

    opened by ghazalli 6
  • AttributeError: 'CPU' object has no attribute 'box_title'

    AttributeError: 'CPU' object has no attribute 'box_title'

    Doesn't run on my server:

    Python Version: 3.9.2.final.0 (64 bit)
    Cpuinfo Version: 8.0.0
    Vendor ID Raw: GenuineIntel
    Hardware Raw: 
    Brand Raw: Intel(R) Xeon(R) CPU E7-4830 v3 @ 2.10GHz
    Hz Advertised Friendly: 2.1000 GHz
    Hz Actual Friendly: 1.2000 GHz
    Hz Advertised: (2100000000, 0)
    Hz Actual: (1200000000, 0)
    Arch: X86_64
    Bits: 64
    Count: 96
    Arch String Raw: x86_64
    L1 Data Cache Size: 1,5 MiB
    L1 Instruction Cache Size: 1,5 MiB
    L2 Cache Size: 12 MiB
    L2 Cache Line Size: 256
    L2 Cache Associativity: 6
    L3 Cache Size: 31457280
    Stepping: 4
    Model: 63
    Family: 6
    Processor Type: 
    Flags: abm, acpi, aes, aperfmperf, apic, arat, arch_perfmon, avx, avx2, bmi1, bmi2, bts, clflush, cmov, constant_tsc, cpuid, cpuid_fault, cqm, cqm_llc, cqm_occup_llc, cx16, cx8, dca, de, ds_cpl, dtes64, dtherm, dts, epb, ept, ept_ad, erms, est, f16c, flexpriority, flush_l1d, fma, fpu, fsgsbase, fxsr, hle, ht, ibpb, ibrs, ida, intel_ppin, invpcid, invpcid_single, lahf_lm, lm, mca, mce, md_clear, mmx, monitor, movbe, msr, mtrr, nonstop_tsc, nopl, nx, osxsave, pae, pat, pbe, pcid, pclmulqdq, pdcm, pdpe1gb, pebs, pge, pln, pni, popcnt, pqm, pse, pse36, pti, pts, rdrand, rdrnd, rdtscp, rep_good, rtm, sdbg, sep, smep, smx, ss, ssbd, sse, sse2, sse4_1, sse4_2, ssse3, stibp, syscall, tm, tm2, tpr_shadow, tsc, tsc_adjust, tsc_deadline_timer, tscdeadline, vme, vmx, vnmi, vpid, x2apic, xsave, xsaveopt, xtopology, xtpr
    
    

    error.log

    opened by leshaker 3
  • [BUG] On app start: `AttributeError: module 'psutil' has no attribute 'sensors_temperatures'`

    [BUG] On app start: `AttributeError: module 'psutil' has no attribute 'sensors_temperatures'`

    Issue description

    I get an AttributeError upon starting the application. See traceback below for details.

    Traceback
    ➜ tiptop
    ╭───────────────────────── Traceback (most recent call last) ─────────────────────────╮
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:202 in _get_lines                                                                 │
    │                                                                                     │
    │   199 │   def _get_lines(self) -> Lines:                                            │
    │   200 │   │   """Get segment lines to render the widget."""                         │
    │   201 │   │   if self.render_cache is None:                                         │
    │ ❱ 202 │   │   │   self.render_lines()                                               │
    │   203 │   │   assert self.render_cache is not None                                  │
    │   204 │   │   lines = self.render_cache.lines                                       │
    │   205 │   │   return lines                                                          │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:188 in render_lines                                                               │
    │                                                                                     │
    │   185 │                                                                             │
    │   186 │   def render_lines(self) -> None:                                           │
    │   187 │   │   width, height = self.size                                             │
    │ ❱ 188 │   │   renderable = self.render_styled()                                     │
    │   189 │   │   options = self.console.options.update_dimensions(width, height)       │
    │   190 │   │   lines = self.console.render_lines(renderable, options)                │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)                     │
    │                                                                                     │
    │ ╭────────── locals ──────────╮                                                      │
    │ │ height = 13                │                                                      │
    │ │   self = CPU(name='CPU#1') │                                                      │
    │ │  width = 87                │                                                      │
    │ ╰────────────────────────────╯                                                      │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:128 in render_styled                                                              │
    │                                                                                     │
    │   125 │   │   Returns:                                                              │
    │   126 │   │   │   RenderableType: A new renderable.                                 │
    │   127 │   │   """                                                                   │
    │ ❱ 128 │   │   renderable = self.render()                                            │
    │   129 │   │   if self.padding is not None:                                          │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)                    │
    │   131 │   │   if self.border in self.BOX_MAP:                                       │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/tiptop/_cpu.py:2 │
    │ 20 in render                                                                        │
    │                                                                                     │
    │   217 │                                                                             │
    │   218 │   def render(self):                                                         │
    │   219 │   │   if self.is_first_render:                                              │
    │ ❱ 220 │   │   │   self.collect_data()                                               │
    │   221 │   │   │   self.is_first_render = False                                      │
    │   222 │   │   return self.panel                                                     │
    │   223                                                                               │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/tiptop/_cpu.py:1 │
    │ 19 in collect_data                                                                  │
    │                                                                                     │
    │   116 │   │   │   stream.add_value(load)                                            │
    │   117 │   │                                                                         │
    │   118 │   │   # CPU temperatures                                                    │
    │ ❱ 119 │   │   temps = psutil.sensors_temperatures()                                 │
    │   120 │   │   if self.has_cpu_temp:                                                 │
    │   121 │   │   │   assert self.tempkey is not None                                   │
    │   122 │   │   │   self.temp_total_stream.add_value(temps[self.tempkey][0].current)  │
    │                                                                                     │
    │ ╭──────────────────────────────────── locals ─────────────────────────────────────╮ │
    │ │            load = 0.0                                                           │ │
    │ │ load_per_thread = [                                                             │ │
    │ │                   │   25.2,                                                     │ │
    │ │                   │   0.0,                                                      │ │
    │ │                   │   24.2,                                                     │ │
    │ │                   │   0.0,                                                      │ │
    │ │                   │   22.1,                                                     │ │
    │ │                   │   0.0,                                                      │ │
    │ │                   │   14.4,                                                     │ │
    │ │                   │   0.0,                                                      │ │
    │ │                   │   5.3,                                                      │ │
    │ │                   │   0.0,                                                      │ │
    │ │                   │   ... +2                                                    │ │
    │ │                   ]                                                             │ │
    │ │            self = CPU(name='CPU#1')                                             │ │
    │ │          stream = <tiptop.braille_stream.BrailleStream object at 0x10d7e6580>   │ │
    │ ╰─────────────────────────────────────────────────────────────────────────────────╯ │
    ╰─────────────────────────────────────────────────────────────────────────────────────╯
    AttributeError: module 'psutil' has no attribute 'sensors_temperatures'
    ╭───────────────────────── Traceback (most recent call last) ─────────────────────────╮
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:202 in _get_lines                                                                 │
    │                                                                                     │
    │   199 │   def _get_lines(self) -> Lines:                                            │
    │   200 │   │   """Get segment lines to render the widget."""                         │
    │   201 │   │   if self.render_cache is None:                                         │
    │ ❱ 202 │   │   │   self.render_lines()                                               │
    │   203 │   │   assert self.render_cache is not None                                  │
    │   204 │   │   lines = self.render_cache.lines                                       │
    │   205 │   │   return lines                                                          │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:188 in render_lines                                                               │
    │                                                                                     │
    │   185 │                                                                             │
    │   186 │   def render_lines(self) -> None:                                           │
    │   187 │   │   width, height = self.size                                             │
    │ ❱ 188 │   │   renderable = self.render_styled()                                     │
    │   189 │   │   options = self.console.options.update_dimensions(width, height)       │
    │   190 │   │   lines = self.console.render_lines(renderable, options)                │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)                     │
    │                                                                                     │
    │ ╭────────── locals ──────────╮                                                      │
    │ │ height = 13                │                                                      │
    │ │   self = CPU(name='CPU#1') │                                                      │
    │ │  width = 87                │                                                      │
    │ ╰────────────────────────────╯                                                      │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:128 in render_styled                                                              │
    │                                                                                     │
    │   125 │   │   Returns:                                                              │
    │   126 │   │   │   RenderableType: A new renderable.                                 │
    │   127 │   │   """                                                                   │
    │ ❱ 128 │   │   renderable = self.render()                                            │
    │   129 │   │   if self.padding is not None:                                          │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)                    │
    │   131 │   │   if self.border in self.BOX_MAP:                                       │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/tiptop/_cpu.py:2 │
    │ 20 in render                                                                        │
    │                                                                                     │
    │   217 │                                                                             │
    │   218 │   def render(self):                                                         │
    │   219 │   │   if self.is_first_render:                                              │
    │ ❱ 220 │   │   │   self.collect_data()                                               │
    │   221 │   │   │   self.is_first_render = False                                      │
    │   222 │   │   return self.panel                                                     │
    │   223                                                                               │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/tiptop/_cpu.py:1 │
    │ 19 in collect_data                                                                  │
    │                                                                                     │
    │   116 │   │   │   stream.add_value(load)                                            │
    │   117 │   │                                                                         │
    │   118 │   │   # CPU temperatures                                                    │
    │ ❱ 119 │   │   temps = psutil.sensors_temperatures()                                 │
    │   120 │   │   if self.has_cpu_temp:                                                 │
    │   121 │   │   │   assert self.tempkey is not None                                   │
    │   122 │   │   │   self.temp_total_stream.add_value(temps[self.tempkey][0].current)  │
    │                                                                                     │
    │ ╭─────────────────────────────────── locals ────────────────────────────────────╮   │
    │ │            load = 0.0                                                         │   │
    │ │ load_per_thread = [0.0, 0.0, 0.0, 0.0, 50.0, 0.0, 0.0, 0.0, 0.0, 0.0, ... +2] │   │
    │ │            self = CPU(name='CPU#1')                                           │   │
    │ │          stream = <tiptop.braille_stream.BrailleStream object at 0x10d7e6580> │   │
    │ ╰───────────────────────────────────────────────────────────────────────────────╯   │
    ╰─────────────────────────────────────────────────────────────────────────────────────╯
    AttributeError: module 'psutil' has no attribute 'sensors_temperatures'
    ╭───────────────────────── Traceback (most recent call last) ─────────────────────────╮
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:202 in _get_lines                                                                 │
    │                                                                                     │
    │   199 │   def _get_lines(self) -> Lines:                                            │
    │   200 │   │   """Get segment lines to render the widget."""                         │
    │   201 │   │   if self.render_cache is None:                                         │
    │ ❱ 202 │   │   │   self.render_lines()                                               │
    │   203 │   │   assert self.render_cache is not None                                  │
    │   204 │   │   lines = self.render_cache.lines                                       │
    │   205 │   │   return lines                                                          │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:188 in render_lines                                                               │
    │                                                                                     │
    │   185 │                                                                             │
    │   186 │   def render_lines(self) -> None:                                           │
    │   187 │   │   width, height = self.size                                             │
    │ ❱ 188 │   │   renderable = self.render_styled()                                     │
    │   189 │   │   options = self.console.options.update_dimensions(width, height)       │
    │   190 │   │   lines = self.console.render_lines(renderable, options)                │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)                     │
    │                                                                                     │
    │ ╭────────── locals ──────────╮                                                      │
    │ │ height = 13                │                                                      │
    │ │   self = CPU(name='CPU#1') │                                                      │
    │ │  width = 87                │                                                      │
    │ ╰────────────────────────────╯                                                      │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/textual/widget.p │
    │ y:128 in render_styled                                                              │
    │                                                                                     │
    │   125 │   │   Returns:                                                              │
    │   126 │   │   │   RenderableType: A new renderable.                                 │
    │   127 │   │   """                                                                   │
    │ ❱ 128 │   │   renderable = self.render()                                            │
    │   129 │   │   if self.padding is not None:                                          │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)                    │
    │   131 │   │   if self.border in self.BOX_MAP:                                       │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/tiptop/_cpu.py:2 │
    │ 20 in render                                                                        │
    │                                                                                     │
    │   217 │                                                                             │
    │   218 │   def render(self):                                                         │
    │   219 │   │   if self.is_first_render:                                              │
    │ ❱ 220 │   │   │   self.collect_data()                                               │
    │   221 │   │   │   self.is_first_render = False                                      │
    │   222 │   │   return self.panel                                                     │
    │   223                                                                               │
    │                                                                                     │
    │ ╭───────── locals ─────────╮                                                        │
    │ │ self = CPU(name='CPU#1') │                                                        │
    │ ╰──────────────────────────╯                                                        │
    │                                                                                     │
    │ /Users/leroyv/.local/pipx/venvs/tiptop/lib/python3.9/site-packages/tiptop/_cpu.py:1 │
    │ 19 in collect_data                                                                  │
    │                                                                                     │
    │   116 │   │   │   stream.add_value(load)                                            │
    │   117 │   │                                                                         │
    │   118 │   │   # CPU temperatures                                                    │
    │ ❱ 119 │   │   temps = psutil.sensors_temperatures()                                 │
    │   120 │   │   if self.has_cpu_temp:                                                 │
    │   121 │   │   │   assert self.tempkey is not None                                   │
    │   122 │   │   │   self.temp_total_stream.add_value(temps[self.tempkey][0].current)  │
    │                                                                                     │
    │ ╭──────────────────────────────────── locals ─────────────────────────────────────╮ │
    │ │            load = 0.0                                                           │ │
    │ │ load_per_thread = [25.0, 0.0, 50.0, 0.0, 25.0, 0.0, 0.0, 0.0, 0.0, 0.0, ... +2] │ │
    │ │            self = CPU(name='CPU#1')                                             │ │
    │ │          stream = <tiptop.braille_stream.BrailleStream object at 0x10d7e6580>   │ │
    │ ╰─────────────────────────────────────────────────────────────────────────────────╯ │
    ╰─────────────────────────────────────────────────────────────────────────────────────╯
    AttributeError: module 'psutil' has no attribute 'sensors_temperatures'
    

    Configuration

    • Machine: Mac mini (2018)
    • OS: macOS Monterey 12.0.1 (21A559)
    • Python 3.9 (Homebrew, running the app installed with pipx)
    opened by leroyvn 3
  • ModuleNotFoundError: No module named 'termios'

    ModuleNotFoundError: No module named 'termios'

    $ tiptop Traceback (most recent call last): File "C:\Users\Conrad\AppData\Local\Programs\Python\Python38-32\lib\runpy.py", line 194, in _run_module_as_main return run_code(code, main_globals, None, File "C:\Users\Conrad\AppData\Local\Programs\Python\Python38-32\lib\runpy.py", line 87, in run_code exec(code, run_globals) File "C:\Users\Conrad\AppData\Local\Programs\Python\Python38-32\Scripts\tiptop.exe_main.py", line 4, in
    File "C:\Users\Conrad\AppData\Local\Programs\Python\Python38-32\lib\site-packages\tiptop_init
    .py", line 1, in from ._app import run File "C:\Users\Conrad\AppData\Local\Programs\Python\Python38-32\lib\site-packages\tiptop_app.py", line 1, in
    from textual.app import App File "C:\Users\Conrad\AppData\Local\Programs\Python\Python38-32\lib\site-packages\textual\app.py", line 27, in
    from ._linux_driver import LinuxDriver File "C:\Users\Conrad\AppData\Local\Programs\Python\Python38-32\lib\site-packages\textual_linux_driver.py", line 9, in import termios ModuleNotFoundError: No module named 'termios'

    opened by conradstorz 3
  • AttributeError: 'ProcsList' object has no attribute 'panel'

    AttributeError: 'ProcsList' object has no attribute 'panel'

    Hello. I am trying to install tiptop, but I get this error:

    pip install tiptop
    
    │ /Users/erik/env/swida/lib/python3.9/site-packages/tiptop/_procs_list.py:112 in render                                                                                    │
    │                                                                                                                                                                          │
    │   109 │   │   self.refresh()                                                                  ╭─────────────── locals ───────────────╮                                   │
    │   110 │                                                                                       │ self = ProcsList(name='ProcsList#1') │                                   │
    │   111 │   def render(self) -> Panel:                                                          ╰──────────────────────────────────────╯                                   │
    │ ❱ 112 │   │   return self.panel                                                                                                                                          │
    │   113 │                                                                                                                                                                  │
    │   114 │   async def on_resize(self, event):                                                                                                                              │
    │   115 │   │   self.max_num_procs = event.height - 3                                                                                                                      │
    ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
    AttributeError: 'ProcsList' object has no attribute 'panel'
    

    Using:

    Python 3.9.7 pip 21.3.1 tiptop 0.0.10 macOS Big Sur Apple Silicon M1

    opened by eriktelepovsky 3
  • ModuleNotFoundError: No module named 'tiptop.__about__'

    ModuleNotFoundError: No module named 'tiptop.__about__'

    System : Ubuntu 18.04.6 LTS Python version : Python 3.6.9

    Steps taken :

    pip3 install tiptop 
    tiptop
    

    Error :

    Traceback (most recent call last):
      File "/home/robi/.local/bin/tiptop", line 7, in <module>
        from tiptop.cli import main
      File "/home/robi/.local/lib/python3.6/site-packages/tiptop/__init__.py", line 1, in <module>
        from .cli import show
      File "/home/robi/.local/lib/python3.6/site-packages/tiptop/cli.py", line 3, in <module>
        from .__about__ import __version__
    ModuleNotFoundError: No module named 'tiptop.__about__'
    
    opened by RobiMez 3
  • Black screen after start

    Black screen after start

    Hi, Windows 10 (19042.1466) in an Enterprise setup, using Mambaforge with a Python 3.9 virtual environment. Starting tiptop clears the console and shows a blinking half-caret cursor in the lower right corner. Nothing else happens.

    Is there a way to debug this situation? I would like to help.

    opened by ArneBachmannDLR 2
  • select incorrect network interface on ubuntu 20.04.3

    select incorrect network interface on ubuntu 20.04.3

    I have a lot of interfaces (mostly virtual) on my machine. I expect eno1 to be selected (that is the physical interface), however toptop selects a virtual interface (vethacf3bfc in this case).

    I would really like to define an environment variable (tiptop_net) or command-line flag (--net) to force election of an interface.

    $ cat /proc/net/dev
    
    Inter-|   Receive                                                |  Transmit
     face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
    vethacf3bfc: 316700731   24655    0    0    0     0          0         0 2113849936  343113    0    0    0     0       0          0
    br-d266d89317cd:       0       0    0    0    0     0          0         0        0       0    0    0    0     0       0          0
    veth55c75e0: 661706604  113223    0    0    0     0          0         0 117348026  587397    0    0    0     0       0          0
      eno1: 3797543484664 4400450459    0 1088    0     0          0  10788249 3567014262499 4196462622    0    0    0     0       0          0
    br-7360eb7107c1:       0       0    0    0    0     0          0         0        0       0    0    0    0     0       0          0
    br-d97c504c507d: 660121482  113223    0    0    0     0          0         0 117348026  587397    0    0    0     0       0          0
        lo: 7349578962 29952387    0    0    0     0          0         0 7349578962 29952387    0    0    0     0       0          0
    docker0: 316666568   26044    0    0    0     0          0         0 2114125269  344828    0    0    0     0       0          0
    veth49c7311: 952073846  304906    0    0    0     0          0         0 152216565  851237    0    0    0     0       0          0
    br-867b3a9015a7: 947805162  304906    0    0    0     0          0         0 152216565  851237    0    0    0     0       0          0
    br-6b911ca9bb3d:       0       0    0    0    0     0          0         0        0       0    0    0    0     0       0          0
    br-31b870ab3794:       0       0    0    0    0     0          0         0        0       0    0    0    0     0       0          0
    
    opened by jakane 2
  • AttributeError: 'CPU' object has no attribute 'panel'

    AttributeError: 'CPU' object has no attribute 'panel'

    Installed with pip and received this error on ArchLinux kernel 5.19, CPU Intel i7-12700K

    [[email protected] ~]# tiptop
    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │ /usr/lib/python3.10/site-packages/tiptop/_cpu.py:129 in on_mount             │
    │                                                                              │
    │   126 │   │   num_threads = psutil.cpu_count(logical=True)                   │
    │   127 │   │                                                                  │
    │   128 │   │   # 8 threads, 4 cores -> [[0, 4], [1, 5], [2, 6], [3, 7]]       │
    │ ❱ 129 │   │   assert num_threads % self.num_cores == 0                       │
    │   130 │   │   self.core_threads = transpose(list(chunks(range(num_threads),  │
    │   131 │   │                                                                  │
    │   132 │   │   self.cpu_total_stream = BrailleStream(50, 7, 0.0, 100.0)       │
    │                                                                              │
    │ ╭──────────── locals ─────────────╮                                          │
    │ │ num_threads = 20                │                                          │
    │ │        self = CPU(name='CPU#1') │                                          │
    │ ╰─────────────────────────────────╯                                          │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    AssertionError
    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │ /usr/lib/python3.10/site-packages/textual/widget.py:202 in _get_lines        │
    │                                                                              │
    │   199 │   def _get_lines(self) -> Lines:                                     │
    │   200 │   │   """Get segment lines to render the widget."""                  │
    │   201 │   │   if self.render_cache is None:                                  │
    │ ❱ 202 │   │   │   self.render_lines()                                        │
    │   203 │   │   assert self.render_cache is not None                           │
    │   204 │   │   lines = self.render_cache.lines                                │
    │   205 │   │   return lines                                                   │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/textual/widget.py:188 in render_lines      │
    │                                                                              │
    │   185 │                                                                      │
    │   186 │   def render_lines(self) -> None:                                    │
    │   187 │   │   width, height = self.size                                      │
    │ ❱ 188 │   │   renderable = self.render_styled()                              │
    │   189 │   │   options = self.console.options.update_dimensions(width, height │
    │   190 │   │   lines = self.console.render_lines(renderable, options)         │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)              │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ height = 8                 │                                               │
    │ │   self = CPU(name='CPU#1') │                                               │
    │ │  width = 49                │                                               │
    │ ╰────────────────────────────╯                                               │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/textual/widget.py:128 in render_styled     │
    │                                                                              │
    │   125 │   │   Returns:                                                       │
    │   126 │   │   │   RenderableType: A new renderable.                          │
    │   127 │   │   """                                                            │
    │ ❱ 128 │   │   renderable = self.render()                                     │
    │   129 │   │   if self.padding is not None:                                   │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)             │
    │   131 │   │   if self.border in self.BOX_MAP:                                │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/tiptop/_cpu.py:312 in render               │
    │                                                                              │
    │   309 │   │   self.info_box_width = 4 + len(Text.from_markup(lines[0]))      │
    │   310 │                                                                      │
    │   311 │   def render(self):                                                  │
    │ ❱ 312 │   │   return self.panel                                              │
    │   313 │                                                                      │
    │   314 │   async def on_resize(self, event):                                  │
    │   315 │   │   self.width = event.width                                       │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    AttributeError: 'CPU' object has no attribute 'panel'
    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │ /usr/lib/python3.10/site-packages/textual/widget.py:202 in _get_lines        │
    │                                                                              │
    │   199 │   def _get_lines(self) -> Lines:                                     │
    │   200 │   │   """Get segment lines to render the widget."""                  │
    │   201 │   │   if self.render_cache is None:                                  │
    │ ❱ 202 │   │   │   self.render_lines()                                        │
    │   203 │   │   assert self.render_cache is not None                           │
    │   204 │   │   lines = self.render_cache.lines                                │
    │   205 │   │   return lines                                                   │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/textual/widget.py:188 in render_lines      │
    │                                                                              │
    │   185 │                                                                      │
    │   186 │   def render_lines(self) -> None:                                    │
    │   187 │   │   width, height = self.size                                      │
    │ ❱ 188 │   │   renderable = self.render_styled()                              │
    │   189 │   │   options = self.console.options.update_dimensions(width, height │
    │   190 │   │   lines = self.console.render_lines(renderable, options)         │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)              │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ height = 8                 │                                               │
    │ │   self = CPU(name='CPU#1') │                                               │
    │ │  width = 49                │                                               │
    │ ╰────────────────────────────╯                                               │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/textual/widget.py:128 in render_styled     │
    │                                                                              │
    │   125 │   │   Returns:                                                       │
    │   126 │   │   │   RenderableType: A new renderable.                          │
    │   127 │   │   """                                                            │
    │ ❱ 128 │   │   renderable = self.render()                                     │
    │   129 │   │   if self.padding is not None:                                   │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)             │
    │   131 │   │   if self.border in self.BOX_MAP:                                │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/tiptop/_cpu.py:312 in render               │
    │                                                                              │
    │   309 │   │   self.info_box_width = 4 + len(Text.from_markup(lines[0]))      │
    │   310 │                                                                      │
    │   311 │   def render(self):                                                  │
    │ ❱ 312 │   │   return self.panel                                              │
    │   313 │                                                                      │
    │   314 │   async def on_resize(self, event):                                  │
    │   315 │   │   self.width = event.width                                       │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    AttributeError: 'CPU' object has no attribute 'panel'
    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │ /usr/lib/python3.10/site-packages/textual/widget.py:202 in _get_lines        │
    │                                                                              │
    │   199 │   def _get_lines(self) -> Lines:                                     │
    │   200 │   │   """Get segment lines to render the widget."""                  │
    │   201 │   │   if self.render_cache is None:                                  │
    │ ❱ 202 │   │   │   self.render_lines()                                        │
    │   203 │   │   assert self.render_cache is not None                           │
    │   204 │   │   lines = self.render_cache.lines                                │
    │   205 │   │   return lines                                                   │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/textual/widget.py:188 in render_lines      │
    │                                                                              │
    │   185 │                                                                      │
    │   186 │   def render_lines(self) -> None:                                    │
    │   187 │   │   width, height = self.size                                      │
    │ ❱ 188 │   │   renderable = self.render_styled()                              │
    │   189 │   │   options = self.console.options.update_dimensions(width, height │
    │   190 │   │   lines = self.console.render_lines(renderable, options)         │
    │   191 │   │   self.render_cache = RenderCache(self.size, lines)              │
    │                                                                              │
    │ ╭────────── locals ──────────╮                                               │
    │ │ height = 8                 │                                               │
    │ │   self = CPU(name='CPU#1') │                                               │
    │ │  width = 49                │                                               │
    │ ╰────────────────────────────╯                                               │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/textual/widget.py:128 in render_styled     │
    │                                                                              │
    │   125 │   │   Returns:                                                       │
    │   126 │   │   │   RenderableType: A new renderable.                          │
    │   127 │   │   """                                                            │
    │ ❱ 128 │   │   renderable = self.render()                                     │
    │   129 │   │   if self.padding is not None:                                   │
    │   130 │   │   │   renderable = Padding(renderable, self.padding)             │
    │   131 │   │   if self.border in self.BOX_MAP:                                │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    │                                                                              │
    │ /usr/lib/python3.10/site-packages/tiptop/_cpu.py:312 in render               │
    │                                                                              │
    │   309 │   │   self.info_box_width = 4 + len(Text.from_markup(lines[0]))      │
    │   310 │                                                                      │
    │   311 │   def render(self):                                                  │
    │ ❱ 312 │   │   return self.panel                                              │
    │   313 │                                                                      │
    │   314 │   async def on_resize(self, event):                                  │
    │   315 │   │   self.width = event.width                                       │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    
    
    opened by petersulyok 4
  • Dependency Dashboard

    Dependency Dashboard

    This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

    This repository currently has no open or pending branches.

    Detected dependencies

    github-actions
    .github/workflows/ci.yml
    • actions/checkout v3
    • pre-commit/action v3.0.0
    • actions/setup-python v4
    • actions/checkout v3
    • codecov/codecov-action v3

    • [ ] Check this box to trigger a request for Renovate to run again on this repository
    opened by renovate[bot] 0
  • [Feature Request] Two improvements to procs section (filter by user like `top -u username` and wrap args column)

    [Feature Request] Two improvements to procs section (filter by user like `top -u username` and wrap args column)

    Amazing project! It's so much more useful than the typical top command I'm used to using.

    I have two feature requests if possible:

    1. Being able to supply a username filter (like tiptop -u username) that can be used to filter the proc list like top does (top -u username)
    2. Having the procs' args column optionally wrap would really help differentiate processes. For the majority of my processes the best identifying column (args) cuts off most commands when the processes originate from within virtual environments (ex: /www/projectname/venv/bin/celery --app="app.tasks.celery" worker ...). One extensive command looks like this:
      /www/projectname/venv/bin/celery
          --app="app.tasks.celery"
          worker
          --queues="maintenance"
          --hostname="maintenance@%%h"
          --concurrency="1"
          --statedb="/www/projectname/syslogs/celery-maintenance-worker-state.sqlite"
          --loglevel="info"
      

      I get that such a large command might cause issues when attempting to wrap, so I guess that's what leads me to suggestion 2.1

    2.1) Ability to limit the number of processes shown in the procs list.

    opened by caffeinatedMike 0
  • CallbackError

    CallbackError

    After installing by using the command "pip install tiptop", I ran the command "tiptop" and got the desired result. However, the result is just kept 1s, then I got the following errors:

    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │                                                                              │
    │ /home/roger/miniconda3/lib/python3.8/site-packages/tiptop/_cpu.py:210 in     │
    │ collect_data                                                                 │
    │                                                                              │
    │   207 │                                                                      │
    │   208 │   def collect_data(self):                                            │
    │   209 │   │   # CPU loads                                                    │
    │ ❱ 210 │   │   self.cpu_total_stream.add_value(psutil.cpu_percent())          │
    │   211 │   │   #                                                              │
    │   212 │   │   load_per_thread = psutil.cpu_percent(percpu=True)              │
    │   213 │   │   assert isinstance(load_per_thread, list)                       │
    │                                                                              │
    │ ╭───────── locals ─────────╮                                                 │
    │ │ self = CPU(name='CPU#1') │                                                 │
    │ ╰──────────────────────────╯                                                 │
    │ /home/roger/miniconda3/lib/python3.8/site-packages/tiptop/braille_stream.py: │
    │ 87 in add_value                                                              │
    │                                                                              │
    │    84 │   │                                                                  │
    │    85 │   │   # update stream                                                │
    │    86 │   │   for k, char in enumerate(chars):                               │
    │ ❱  87 │   │   │   g[k] = g[k][1:] + char                                     │
    │    88 │   │                                                                  │
    │    89 │   │   self.values = self.values[1:] + [value]                        │
    │    90 │   │   self._last_blocks = blocks                                     │
    │                                                                              │
    │ ╭──────────────────────────────── locals ─────────────────────────────────╮  │
    │ │ blocks = [1, 0, 0, 0]                                                   │  │
    │ │   char = ' '                                                            │  │
    │ │  chars = [' ', ' ', ' ', '⣀']                                           │  │
    │ │      g = []                                                             │  │
    │ │      k = 0                                                              │  │
    │ │   self = <tiptop.braille_stream.BrailleStream object at 0x7f9d3a4a1ca0> │  │
    │ │  value = 3.3                                                            │  │
    │ ╰─────────────────────────────────────────────────────────────────────────╯  │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    IndexError: list index out of range
    
    During handling of the above exception, another exception occurred:
    
    ╭───────────────────── Traceback (most recent call last) ──────────────────────╮
    │                                                                              │
    │ /home/roger/miniconda3/lib/python3.8/site-packages/textual/message_pump.py:3 │
    │ 27 in on_timer                                                               │
    │                                                                              │
    │   324 │   │   │   try:                                                       │
    │   325 │   │   │   │   await invoke(event.callback)                           │
    │   326 │   │   │   except Exception as error:                                 │
    │ ❱ 327 │   │   │   │   raise CallbackError(                                   │
    │   328 │   │   │   │   │   f"unable to run callback {event.callback!r}; {erro │
    │   329 │   │   │   │   )                                                      │
    │   330                                                                        │
    │                                                                              │
    │ ╭───────────── locals ──────────────╮                                        │
    │ │ event = Timer('Timer#1', count=0) │                                        │
    │ │  self = CPU(name='CPU#1')         │                                        │
    │ ╰───────────────────────────────────╯                                        │
    ╰──────────────────────────────────────────────────────────────────────────────╯
    CallbackError: unable to run callback <bound method CPU.collect_data of 
    CPU(name='CPU#1')>; list index out of range
    
    opened by JintaoLee-Roger 4
  • View more of process list

    View more of process list

    Currently it only displays part of the processes - would be really nice if I could see the rest.

    Some ways to achieve this that I can imagine:

    • allow scrolling
    • allow filtering
    • allow different sorting criteria.

    What do you think?

    opened by dwt 3
Releases(v0.2.8)
Owner
Nico Schlömer
Mathematics, numerical analysis, scientific computing, Python. Always interested in new problems.
Nico Schlömer
Open a file in your locally running Visual Studio Code instance from arbitrary terminal connections.

code-connect Open a file in your locally running Visual Studio Code instance from arbitrary terminal connections. Motivation VS Code supports opening

Christian Volkmann 56 Nov 19, 2022
A simple CLI application helps you to find giant files that are eating up your system storage

Large file finder Sometimes it's very hard to find if some giant files are eating up your system storage. We might need to hunt those down. This simpl

Rahul Baruri 5 Nov 18, 2022
gcp-doctor - Diagnostics for Google Cloud Platform

gcp-doctor is a command-line diagnostics tool for GCP customers. It finds and helps to fix common issues in Google Cloud Platform projects. It is used to test projects against a wide range of best-pr

Google Cloud Platform 185 Dec 20, 2022
Ipylivebash - Run shell script in Jupyter with live output

ipylivebash ipylivebash is a library to run shell script in Jupyter with live ou

Ben Lau 6 Aug 27, 2022
WazirX Portfolio Tracker on your Terminal!

If you have been investing in crypto in India, there is a very good chance that you are using WazirX. If you are using WazirX, then you definitely know that there is no P&L report, no green arrows no

Raunit 15 Jan 10, 2022
Tiny command-line utility for mapping broken keys to other positions.

brokenkey Tiny command-line utility for mapping broken keys to other positions. Installation Clone this repository using git: git clone https://github

0 Oct 04, 2021
This a simple tool to query the awesome ippsec.rocks website from your terminal

ippsec-cli This a simple tool to query the awesome ippsec.rocks website from your terminal Installation and usage cd /opt git clone https://github.com

stark0de 5 Nov 26, 2022
py-image-dedup is a tool to sort out or remove duplicates within a photo library

py-image-dedup is a tool to sort out or remove duplicates within a photo library. Unlike most other solutions, py-image-dedup intentionally uses an approximate image comparison to also detect duplica

Markus Ressel 96 Jan 02, 2023
nbcommands bring the goodness of Unix commands to Jupyter notebooks.

nbcommands nbcommands bring the goodness of Unix commands to Jupyter notebooks. Installation You can simply use pip to install nbcommands: $ pip insta

Vinayak Mehta 181 Dec 23, 2022
Urial (URI Addition tooL) intelligently updates URIs stored in Finder comments of macOS files

Urial Urial (URI addition tool) is a simple but intelligent command-line tool to add or replace URIs found inside macOS Finder comments. Table of cont

Mike Hucka 3 Sep 14, 2022
Ntfy - 🖥️📱🔔 A utility for sending notifications, on demand and when commands finish.

About ntfy ntfy brings notification to your shell. It can automatically provide desktop notifications when long running commands finish or it can send

Daniel Schep 4.5k Jan 01, 2023
googler is a power tool to Google (web, news, videos and site search) from the command-line.

googler is a power tool to Google (web, news, videos and site search) from the command-line.

Terminator X 5.9k Jan 04, 2023
Albert launcher extension for converting units of length, mass, speed, temperature, time, current, luminosity, printing measurements, molecular substance, and more

unit-converter-albert-ext Extension for converting units of length, mass, speed, temperature, time, current, luminosity, printing measurements, molecu

Jonah Lawrence 2 Jan 13, 2022
🐾 Get the nftables counters easier to read

nft-stats Get the nftables counters easier to read It kind of hard to read the output of nft list ruleset so there is a small program parcising the ou

7 Oct 08, 2022
Cli tool to browse and play anime

browse and watch anime (scrape from gogoanime) (wip) basically ani-cli but in python cuz python good demo dependencies mpv installation from pypi pip

sheep padowo 2 Apr 20, 2022
dsub is a command-line tool that makes it easy to submit and run batch scripts in the cloud.

Open-source command-line tool to run batch computing tasks and workflows on backend services such as Google Cloud.

Data Biosphere 233 Jan 01, 2023
Tmux Based Dropdown Dashboard For Python

sextans It's a private configuration and an ongoing experiment while I use Archlinux. A simple drop down dashboard based on tmux. It includes followin

秋葉 4 Dec 22, 2021
Simple tool, to update linux kernel on ubuntu

Kerbswap Simple tool, to update linux kernel on ubuntu Information At the moment, this tool only supports "Ubuntu" distributions, but will be expanded

dword 1 Oct 31, 2021
An awesome Python wrapper for an awesome Docker CLI!

An awesome Python wrapper for an awesome Docker CLI!

Gabriel de Marmiesse 303 Jan 03, 2023
Kubernetes shell: An integrated shell for working with the Kubernetes

kube-shell Kube-shell: An integrated shell for working with the Kubernetes CLI Under the hood kube-shell still calls kubectl. Kube-shell aims to provi

CloudNative Labs 2.2k Jan 08, 2023