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
A webmining CLI tool & library for python.

minet is a webmining command line tool & library for python (= 3.6) that can be used to collect and extract data from a large variety of web sources

médialab Sciences Po 165 Dec 17, 2022
Python and data science snippets on the command line

Python Snippet Tool A tool to get Python and data science snippets at Data Science Simplified on the command line. You can read my article to learn ho

Khuyen Tran 19 Dec 21, 2022
Apple Silicon 'top' CLI

asitop pip install asitop What A nvtop/htop style/inspired command line tool for Apple Silicon (aka M1) Macs. Note that it requires sudo to run due to

Timothy Liu 1.2k Dec 31, 2022
Command line parser for common log format (Nginx default).

Command line parser for common log format (Nginx default).

Lucian Marin 138 Dec 19, 2022
As easy as /aitch-tee-tee-pie/ 🥧 Modern, user-friendly command-line HTTP client for the API era. JSON support, colors, sessions, downloads, plugins & more. https://twitter.com/httpie

HTTPie: human-friendly CLI HTTP client for the API era HTTPie (pronounced aitch-tee-tee-pie) is a command-line HTTP client. Its goal is to make CLI in

HTTPie 25.4k Dec 30, 2022
Unofficial Open Corporates CLI: OpenCorporates is a website that shares data on corporations under the copyleft Open Database License. This is an unofficial open corporates python command line tool.

Unofficial Open Corporates CLI OpenCorporates is a website that shares data on corporations under the copyleft Open Database License. This is an unoff

Richard Mwewa 30 Sep 08, 2022
Microsoft Azure CLI - Azure Command-Line Interface

A great cloud needs great tools; we're excited to introduce Azure CLI, our next generation multi-platform command line experience for Azure.

Microsoft Azure 3.4k Dec 30, 2022
A command-line tool to flash python code to Codey Rocky without having to use the online mblock5 IDE.

What? A command-line tool to flash python code to Codey Rocky without having to use the online mblock5 IDE. Description This is a very low-effort proj

1 Dec 29, 2021
Palm CLI - the tool-belt for data teams

Palm CLI: The extensible CLI at your fingertips Palm is a universal CLI developed to improve the life and work of data professionals. Palm CLI documen

Palmetto 41 Dec 12, 2022
Generate an ASCII Art from keyword put in the cli

ascii-art-generator-cli Generate an ASCII Art from keyword put in the cli Install git clone https://github.com/Nathanlauga/ascii-art-generator-cli cd

Nathan Lauga 1 Nov 14, 2021
ServX | Bash Command as a Service

ServX | Bash Command as a Service Screenshots Instructions for running Run python3 servx.py. COMPATIBILITY TESTED ON ARCHLINUX(x64) & DEBIAN(x64) ONLY

ARPSyndicate 2 Mar 11, 2022
A CLI messenger for the Signum community.

A CLI messenger for the Signum community. Built for people who like using terminal for their work and want to communicate with other users in the Signum community.

Jush 5 Mar 18, 2022
This CLI give the possibility to do a queries in Star Wars API and returns a JSON in a terminal.

Star Wars CLI (swcli) This CLI give the possibility to do a queries in Star Wars API and returns a JSON in a terminal. Install $ pip install swcli Qu

Pery Lemke 5 Nov 05, 2021
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
Execute shell command lines in parallel on Slurm, S(on) of Grid Engine (SGE), PBS/Torque clusters

qbatch Execute shell command lines in parallel on Slurm, S(on) of Grid Engine (SGE), PBS/Torque clusters qbatch is a tool for executing commands in pa

Jon Pipitone 26 Dec 12, 2022
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
You'll never want to use cd again.

Jmp Description Have you ever used the cd command? You'll never touch that outdated thing again when you try jmp. Navigate your filesystem with unprec

Grant Holmes 21 Nov 03, 2022
CLI/GUI Math commands based on python 3

PyMath Commands Syntax Installation Commands: pymath add: usage: pymath add 12.5 12.5 sub: usage: pymath sub 25 12.5 div: usage: pymath div 144 12 mul

eggsnham07 0 Nov 22, 2021
A Telegram Bot Written In Python To Upload Medias To telegra.ph

Telegraph-Uploader A Telegram Bot Written In Python To Upload Medias To telegra.ph DEPLOY YOU CAN SIMPLY DEPLOY ON HEROKU BY CLICKING THE BUTTON BELOW

Rithunand 31 Dec 03, 2022
Python Processing Tool for Vasp Ipnut/Output

PivotPy A Python Processing Tool for Vasp Input/Output. A CLI is available in Powershell, see Vasp2Visual. stylea{text-decoration: none !important;c

Abdul Saboor 5 Aug 16, 2022