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
Simple Tool To Grab Like-Card Coupon

Simple Tool To Grab Like-Card Coupon

Soud 10 Jan 30, 2022
liquidctl – liquid cooler control Cross-platform tool and drivers for liquid coolers and other devices

Cross-platform CLI and Python drivers for AIO liquid coolers and other devices

1.7k Jan 08, 2023
Container images for portable development environments

Docker Dev Spin up a container to develop from anywhere! To run, just: docker run -ti aghost7/nodejs-dev:boron tmux new Alternatively, if on Linux: p

Jonathan Boudreau 163 Dec 22, 2022
Bringing emacs' greatest feature to neovim - Tetris!

nvim-tetris Bringing emacs' greatest feature to neovim - Tetris! This plugin is written in Fennel using Olical's project Aniseed for creating the proj

129 Dec 26, 2022
command line tool for frequent nmigen tasks (generate sources, show design)

nmigen-tool command line tool for frequent nmigen tasks (generate sources, show design) Usage: generate verilog: nmigen generate verilog nmigen_librar

Hans Baier 8 Nov 27, 2022
Python script to tabulate data formats like json, csv, html, etc

pyT PyT is a a command line tool and as well a library for visualising various data formats like: JSON HTML Table CSV XML, etc. Features Print table o

Mobolaji Abdulsalam 1 Dec 30, 2021
Termtyper is a TUI typing application that provides you a great feel with typing with a lot of options to tweak

Termtyper Termtyper is a TUI (Text User Interface) typing application that provides you a great feel with typing with a lot of options to tweak! It is

Noob Coder 834 Dec 27, 2022
Python implementation of SSH file transfer across servers.

SSH Transfer Python implementation of SSH file transfer across servers. Requirements paramiko=2.7.2 Usage Config Preparation Configure some informatio

Zhe Kong 1 Nov 23, 2021
A Terminal Client for MySQL with AutoCompletion and Syntax Highlighting.

mycli A command line client for MySQL that can do auto-completion and syntax highlighting. HomePage: http://mycli.net Documentation: http://mycli.net/

dbcli 10.7k Jan 07, 2023
🦎 A NeoVim plugin for highlighting visual selections like in a normal document editor!

🦎 HighStr.nvim A NeoVim plugin for highlighting visual selections like in a normal document editor! Demo TL;DR HighStr.nvim is a NeoVim plugin writte

Pocco81 222 Jan 03, 2023
A simple CLI to convert snapshots into EAVT log, and EAVT log into SCD.

EAVT helper CLI Simple CLI to convert snapshots into eavt log, and eavt log into slowly changing dimensions Usage Installation Snapshot to EAVT log EA

2 Apr 07, 2022
Management commands to help backup and restore your project database and media files

Django Database Backup This Django application provides management commands to help backup and restore your project database and media files with vari

687 Jan 04, 2023
Euporie is a text-based user interface for running and editing Jupyter notebooks

Euporie is a text-based user interface for running and editing Jupyter notebooks

781 Jan 01, 2023
Simple subcommand CLIs with argparse

multicommand Simple subcommand CLIs with argparse. multicommand uses only the standard library and is ~150 lines of code (modulo comments and whitespa

Andrew Ross 10 Aug 01, 2022
Shellcode runner to execute malicious payload and bypass AV

buffshark-shellcode-runner Python Shellcode Runner to execute malicious payload and bypass AV This script utilizes mmap(for linux) and win api wrapper

Momo Lenard 9 Dec 29, 2022
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 fantasy life simulator and role-playing game hybrid distributed as CLI, written in Python 3.

Life is Fantasy Epic (LIFE) A fantasy life simulator and role-playing game hybrid distributed as CLI, written in Python 3. This repository will be pro

Pawitchaya Chaloeijanya 2 Oct 24, 2021
Create animated ASCII-art for the command line almost instantly!

clippy Create and play colored 🟥 🟩 🟦 or colorless ⬛️ ⬜️ animated, or static, ASCII-art in the command line! clippy can help if you are wanting to;

Connor 10 Jun 26, 2022
jrnl is a simple journal application for the command line.

jrnl To get help, submit an issue on Github. jrnl is a simple journal application for the command line. You can use it to easily create, search, and v

jrnl 5.7k Dec 31, 2022
A CLI tool to disable and enable security standards controls in AWS Security Hub

Security Hub Controls CLI A CLI tool to disable and enable security standards controls in AWS Security Hub. It is designed to work together with AWS S

AWS Samples 4 Nov 14, 2022