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
Interactive Redis: A Terminal Client for Redis with AutoCompletion and Syntax Highlighting.

Interactive Redis: A Cli for Redis with AutoCompletion and Syntax Highlighting. IRedis is a terminal client for redis with auto-completion and syntax

2.2k Dec 29, 2022
Command Line Based Todo Script

Todo-CLI Features Full-Fledged Command Line Based Todo List with the following features planned: Interactive Interface OS Notifications Save and Remov

DSC IIEST 5 Nov 17, 2021
A Terminal UI for Discord

ToastCord ToastCord is a Discord Terminal UI. At the moment you can only look at Direct messages. TODO: - Add support for guilds - Message sending sup

toast 82 Dec 18, 2022
A Python package for a basic CLI and GUI user interface

Organizer CLI Organizer CLI is a python command line tool that goes through a given directory and organizes all un-folder bound files into folders by

Caltech Library 12 Mar 25, 2022
Command Line (CLI) Application to automate creation of tasks in Redmine, issues on Github and the sync process of them.

Task Manager Automation Tool (TMAT) CLI Command Line (CLI) Application to automate creation of tasks in Redmine, issues on Github and the sync process

Tiamat 5 Apr 12, 2022
Fylm is a wonderful automated command line app for organizing your film media.

Overview Fylm is a wonderful automated command line app for organizing your film media. You can pronounce it Film or File 'em, whichever you like! It

Brandon Shelley 30 Dec 05, 2022
📦 A command line utility to put text in a box.

boxie A command line utility to put text in a box. Installation pip install boxie If you are on Linux you may need to use sudo to access this globally

Eliaz Bobadilla 10 Jun 30, 2022
Yet another bash/zsh prompt script

Here we have yet another script for Git-aware customization of the command prompt in Bash and zsh. Unlike all the other scripts, I wrote this one, so

John T. Wodder II 5 Oct 13, 2021
Magnificent app which corrects your previous console command.

The Fuck The Fuck is a magnificent app, inspired by a @liamosaur tweet, that corrects errors in previous console commands. Is The Fuck too slow? Try t

Vladimir Iakovlev 75k Jan 02, 2023
A startpage configured aesthetically with terminal-esque link formatting

Terminal-y Startpage Setup Clone the repository, then make an unformatted.txt file following the specifications in example.txt. Run format.py Open ind

belkarx 13 May 01, 2022
This is a CLI program which can help you generate your own QR Code.

Python-QR-code-generator This is a CLI program which can help you generate your own QR Code. Single.py This will allow you only to input a single mess

1 Dec 24, 2021
f90nml - A Fortran namelist parser, generator, and editor

f90nml - A Fortran namelist parser, generator, and editor A Python module and command line tool for parsing Fortran namelist files Documentation The c

Marshall Ward 110 Dec 14, 2022
Magma is a NeoVim plugin for running code interactively with Jupyter.

Magma Magma is a NeoVim plugin for running code interactively with Jupyter. Requirements NeoVim 0.5+ Python 3.8+ Required Python packages: pynvim (for

Daniel Csillag 372 Dec 26, 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
Get Air Quality Index for your city/country 😷

Air Quality Index CLI Get Air Quality index for your City. Installation $ pip install air-quality-cli Contents Air Quality Index CLI Installation Cont

Yankee 40 Oct 21, 2022
Bear-Shell is a shell based in the terminal or command prompt.

Bear-Shell is a shell based in the terminal or command prompt. You can navigate files, run python files, create files via the BearUtils text editor, and a lot more coming up!

MichaelBear 6 Dec 25, 2021
RSS reader client for CLI (Command Line Interface),

rReader is RSS reader client for CLI(Command Line Interface)

Lee JunHaeng 10 Dec 24, 2022
Kattis shell for getting examples, testing and submitting.

Kattis shell for getting examples, testing and submitting.

Simon Green Kristensen 15 Sep 30, 2022
Rover is a command line interface application that allows through browse through mission data, images, metadata from the NASA Official Website

🤖 rover Rover is a command line interface application that allows through browse through mission data, images, metadata from the NASA Official Websit

Saketha Ramanjam 4 Jan 19, 2022
CLI para o projeto Compilado (Newsletter e Podcast do Código Fonte TV)

Compilado CLI Automatização de tarefas através de linha de comando para a geração de assets para episódios do Compilado, a newsletter e podcast do can

Gabriel Froes 18 Nov 21, 2022