Rich: A Python library for rich text and formatting in the terminal | Hacker News Reader

Rich: A Python library for rich text and formatting in the terminal

github.com

389 pointswillm82 comments

An extremely useful hidden gem in Rich is its `inspect` function [1].

When called on an object, it pretty prints a list of its public attributes (though you can also request private and dunder attributes) [2]. It can also be called on a class or function; it'll then pretty print the docstrings, parameters with types, methods, etc. It's great for debugging and for starting to code with libraries you're not familiar with, don't have comprehensive documentation, or have some dynamic aspect.

In a similar vein, `objexplore` [3] is another library that lets you dive into an object's nested attributes to understand how it's laid out.

In interactive debugging sessions I often find these to be more useful than the IDE's features which provide similar functionality.

[1] https://rich.readthedocs.io/en/stable/reference/init.html#ri...

[2] https://i2.paste.pics/798cff2903f6b3351289a24c839d4f44.png

[3] https://github.com/kylepollina/objexplore

The ipython ? Syntax also does this: “some_object?”

IPythons ? and tab-autocomplete feel like superpowers when exploring a new module you're unfamiliar with.

See also Textual by the same developer. Really impressive work.

https://github.com/Textualize/textual

oh man

    python -m textual.app

is so satisfying. You get web like layout dynamicism without the whole browser stack.

Widget layouts systems are older than the web. I would say "much older", but after thirty years the much is not very large in comparison any longer.

the only one I remember is Borland's Turbo Vision. I'm not sure it had layouts or only overlapping windows.

A good video walkthrough of Textual from September, 2021 with Paul Everitt interviewing the author, Will McGugan: A Look At – and Inside – Textual (https://www.youtube.com/watch?v=1kTWxamIJ_k).

Woah. That calculator and file tree _look_ like native widgets. Impressive indeed.

I am not sure if it's only me, but as time passes I find myself using more and more simple Terminal stuff. No fancy air/earth lines, no fancy formatting, no fancy ligatures or typefaces.

Oddly, I'm the opposite. Working in devops and vscode, I find the visual aspect of color and logical formatting improves my work dramatically. Small tools like "bat" vs. "cat" on the terminal are great at quick data parsing for things like yaml, json, and the like. Staying old school for the sake of old school is a bit of a fallacy IMHO.

I understand you but bat, exa, etc.. have a huge downside. I have to change many platforms and systems at work and I can't be bothered to install all those new utilities in every new system.

cat, ls, etc.. just work, bat has to be installed, and I have a pretty high threshold for a utility to be so vital for me that I absolutely have to install it in every Unix box I work.

I started to keep an Ansible playbook to setup everything for me. Basically, it replaces most of the core utils with modern alternatives like like cat -> bat, grep -> ripgrep, top -> htop, and so on.

That way, I don't have manually install everything for new systems or when I'm doing a clean install on one of my existing systems.

You might enjoy looking into nix and nixos. It’s designed to make that workflow as bulletproof as possible. One of my coworkers maintains a github repo that describes his exact system, and can create a sandbox that behaves the exact same as the one he’s used to with one command (on any machine that has nix installed).

The problem isn't getting these tools on our own systems. The problem is getting these tools onto every box that might have to SSH into sometime.

Github link?

I haven't thought about making it public because it's just a matter of using the get_url command to download the binaries into /usr/bin and then outputting a .bashrc and /etc/bash.bashrc that contains aliases for every command like "alias cat=bat".

bat especially was a revelation. I don't think I'll ever use cat again if I can help it. I recently found exa[1] which was a bit too colorful for my taste but very nice too

[1] https://github.com/ogham/exa

> I don't think I'll ever use cat again if I can help it.

I just tested simple concatenation and bat is over 10x slower:

  $ time cat 1GiB 1GiB 1GiB 1GiB >/dev/null
  real 0m0.414s
  user 0m0.014s
  sys 0m0.400s
  $ time bat 1GiB 1GiB 1GiB 1GiB >/dev/null
  real 0m4.257s
  user 0m1.659s
  sys 0m2.594s

Seems like a lot of these "modern" replacements lose what the original simpler utils do well.

I don't use bat as a replacement for cat, but as a replacement for less. Sure, bat can concatenate a file, but I'd say that's not the main use. The syntax coloring of file contents is my favorite use case. Line numbers and some of the other options are useful at times too. Also, I don't think I've ever needed to concatenate multiple gigabyte sized files (yes, I am sure it exists for a lot of people, but would say it's not as common as looking at a file).

> I just tested simple concatenation and bat is over 10x slower

Seems like a recurring thing[0] with the modern alternatives.

0: https://news.ycombinator.com/item?id=29616727

Have you tried LSDeluxe?

https://github.com/Peltoche/lsd

LSD has always been a favorite for those who like to watch the pretty colours go by.

I'm the same way. Why waste time reading when syntax highlighting draws your eyes to important info? Also, iTerm2 with triggers or whatever they are called? Magnifique.

I have limited focus as is, if I can make mental search easier, it takes a noticeable cognitive load off.

We have 5k monitors, Gpus with 12GB of RAM, fast networks, etc. color in consoles, underline, bold and italics seem overdue.

What rubs me wrong is the collective halfassedness of it all. When less craps out ANSI codes, when the terminal tears and your cursor is offset because it got confused about control characters, dozens of different color configs rather than a system theme.

There was this time in the Linux dark ages, red hat Linux 2 era. The enlightenment window manager was considered part of protocol GNOME, there were a lot of really exotic or organic themes, skinning was the hotness. Windows couldn’t do it. Ux be damned, if you wanted your desktop to look like some sort of demonic rune set, you could do it. Rationality, ux, consistency, etc took over. Cli skinning never seems to grow that way. I keep hoping some hacker that doesn’t know better will write a new terminal emulator, replaces ANSI codes with some minimal html and invents console css and the community embraces it.

It is crazy, I agree. But you have to keep in mind how old this protocol is. Layers and layers of cruft which you can trace back to before the computing era. Here is Rich running on a Teletype Model 33, circa 1963. And it works (kinda).

https://twitter.com/willmcgugan/status/1476940291819069441

> Layers and layers of cruft which you can trace back to before the computing era.

Even those layers and layers don't _have to_ slow things down. Check the refterm "debacle" ([2] for the context, [0, 1] as Muratori's answer to it). It's just the way things are usually programmed doesn't care about performance and how fast things really can be. I sometimes wonder in we're not due for a massive round of optimization on a couple of the layers that we're used to using/depend on.

[0] https://www.youtube.com/watch?v=hxM8QmyZXtg

[1] https://www.youtube.com/watch?v=99dKzubvpKE

[2] https://github.com/microsoft/terminal/issues/10362

No question, it cuts deep and we would/should look at it end to end. A big part of it is all the tty/pty black magic that we’ve just built on top of.

It’s a gigantic task, but when I see new folks reimplementing “ls” as a “modern replacement” and I do find value with many of these tools (I love ripgrep and bat, among others) I hope/wish someone felt the itch to tackle this.

https://hyper.is/

Someone has tried on macOS. It hasn't really seen mass uptake though.

Take a look at TermKit - https://github.com/unconed/TermKit

Long abandoned but I’d love something like this. Someone I know tried to revive it but Node has changed so much that they gave up.

I would donate to an effort to revive it.

Mozilla included such a terminal in the early seamonkey days. I can’t recall the name. You could “cat foo.jpg” and it would render inline. It was a neat novelty. I think graphics is where it goes too far.

Mainframes and minis modeled many apps as “screens.” Some blend of the streaming style text we have now, with screens, with a new and understood set of protocols that are similar to what we use everywhere else. I think some sort of table in console html would be about my limit, various “modern shells” already support tabular data with, like, their three magic built ins.

Kitty has extensions (kittens) for displaying graphics: https://sw.kovidgoyal.net/kitty/graphics-protocol/

Not something I use, I tend to just `xdg-open .` to view them in Nautilus/EOG.

I just started with kitty, and I think it's a very important development specifically because I don't have to use xdg-open. To clarify, the problem is that I typically use remote resources to run analysis - typically on via ssh/tmux. So to view the output png in the terminal and not break from that environment is very useful.

I was thinking the other day that we need an object based terminal, like the Lisp listener in Genera. Each item printed would have context, be clickable (or otherwise inspectable), and be able to output more than just text: images, diagrams, graphs, etc.

I have been learning Powershell and given its object based nature, a PowerTerm that extended PowerShell in this way seems like an obvious extension.

Of course, my next thought is, why do you not build it yourself? LOL

> We have 5k monitors, Gpus with 12GB of RAM, [...stalled progress...] What rubs me wrong is the collective halfassedness of it all.

Shallow 3D UIs might be an opportunity for spring cleaning? Playing with them years ago, my stack was full-screen browser glued to kernel evdev - the rest of the usual stack (wm, libinput, much of X, browser input events) was easier to replace than adapt.

I would add: make the line protocol coming in transmit key-up and key-down events -- not only full keypress events. Thus let modifiers be handled on the receiving end.

Or at least as one perhaps-modal option.

xterm-compatible terminals have been able to report modifier state for about 15 years.

i remember this era, i remember going to the oreilly oss conference in monterey and all the public terminals were running enlightenment with alpha blended terminals and all the crazy chrome of the time.

personally i hated it, it was laggy, slow and unstable... made a fast linux machine feel like a slow windows thing. i think i ran windowmaker at the time with a color scheme that reminded me of an old indy i used to have. it looked good and stayed out of my way...

I tend to agree with this. I'm not anti-formatting, but it seems that in the majority of cases, the "formatting" isn't done artfully, and actively makes it harder to read command output, etc.

Yeah, it's the lack of taste that gets to me.

Many 'modern' CLI prompts look like an emoji trashheap affixed with a lot of status information that eats up space and isn't directly actionable.

Personally, I find colors distracting, so I do the opposite: I use text attributes more and more, like bold, faint, underline, italics (...) even in my bash prompt

Example: https://raw.githubusercontent.com/csdvrx/bash-timestamping-s...

Absolutely. I still have a Terminal window open all the time to do various tasks. The ability to say 'find me x or y or z' and not having the overhead of looking through other visual clutter. Plus a few well chosen directory jump shortcuts make things easier.

What’s an air/earth line?

Fancy shell prompts, often requiring patched fonts. Something like powerlevel10k[0] or starship[1]

[0]: https://github.com/romkatv/powerlevel10k

[1]: https://starship.rs/

Nope, not just you. Been coding since the 80's, and command-line tooling has become more noisy and less parser/redirect-friendly over the past decade (but option parsers have def. gotten better). To be fair, once terminals started supporting escape color codes, things started to fall apart (circa late 90's). IMHO.

EDIT: Just noticed a peer comment below captures the issues with ANSI way better than I did.

Perhaps because you're gradually learning to distinguish what's style and what's substance?

Exact same thing happened to me. At one point I tried out not even including $(pwd) in the prompt, and … turns out it actually works fine.

same, it's too much to keep up with. would rather miss out at this point.

Same. I don’t even use syntax highlighting anymore. It changes how you focus.

Not sure how people put up with all that powerline stuff either, or multi-line PS1s that have shit on either side. Reminds me of geocities.

Past discussion:

Show HN: Python lib for rich text, markdown, tables, etc. in the terminal (https://news.ycombinator.com/item?id=23070821 2020, 47 comments)

Related discussion:

Textual: a Python text user interface with Rich as the renderer (https://news.ycombinator.com/item?id=27526031 7 months ago, 21 comments)

I feel this library gets posted here every month. But maybe it is just my personal impression between HN and GitHub trending.

The way structlog and rich work together makes for a really great and simple development experience;

Stack traces are presented in a gorgeous fashion, log.debug lines have lots of great meta data with them. I almost always start new projects with those as my first imports.

does it just work out of the box?

I've been following Will McGugan (the author) on twitter for a while. I learnt PyGame from his book. He more or less documented his thought processes on twitter and it's been very nice to see it develop over time.

It got me thinking that, atleast for technology developers, this is the ideal use of twitter. An uncensored "thoughtstream". Some tools to mine that and extract lessons might be an interesting project.

Very nice. Two other great python libraries for cli display are:

1 tabulate: helps render ASCII tables in various formats (https://github.com/astanin/python-tabulate)

2. typer: write cli commands by decorating python functions. It uses type annotations to automatically parse input (https://typer.tiangolo.com/)

We're using both of those in our Kubernetes troubleshooting tool (https://robusta.dev). Going to look at adding Rich too

I've found https://github.com/salt-die/nurses_2 recently , if you're looking for more graphics in the console.

Thanks, looks cool and I wasnt familiar with it.

We're actually sending data to both terminal and non terminal destinations like Slack/MsTeams. We render to html or markdown when we can, but sometimes we have to fall back to ASCII.

If you're curious, you can see the way we're using tabulate here:

https://docs.robusta.dev/master/developer-guide/actions/find...

Is there a companion project for the input side of these apps, like a modernized readline type thing yet?

This would be so helpful. About a year ago I got the combination of FZF and bat working for my command line history. It’s wild how much better and easier that makes it to find complex commands from the past.

What purpose does bat serve in showing command-line history?

I'm guessing it's for showing a syntax highlighted preview of multi line commands. That's what I use it for.

The UI would be similar to this: https://user-images.githubusercontent.com/700826/113683873-a...

Isocline, a readline alternative by Daan Leijen (an absolute legend) is about the closest I've found to this: https://github.com/daanx/isocline

That said it doesn't push "input controls" quite to the extreme Rich/Textual do for UI controls, but it might be a starting point to look into.

Take a look at prompt_toolkit which is a Python library used by IPython among others: https://github.com/prompt-toolkit/python-prompt-toolkit

The library looks brilliant! The author's clearly put a lot of thought and effort into it. Looking forward to using it.

Great library and an amazing README. I kind of wish this functionality was built into the language tooling and other languages.

I especially like pretty print in rich. Makes it so much fun to introspect on deeply nested objects and JSON.

This looks interesting. Can anyone explain to me why cli rich text editors seemingly died after DOS?

I think the quick answer is that they most certainly didn't. Vim or Emacs are popular and fill most use cases while obviously working in dozens of other languages. For actual text rendering use cases their are plenty of popular libraries such as curses

Emacs kinda allows for that and org mode is sort of a rich text editing, but I'm actually talking about cli word like things. There was a very popular German one whichs name I forgot also, that people were using long into Windows 95/98.

Some Jerk called Tim Berners-Lee invented the “web”

Anyone know what font he's using for the screenshots?

It looks like Fira Code.

It's Atreides and Hawat not Atriedies and Haway

Having logging integrated would be awesome.

It has it, and I use this feature extensively. It’s fantastic.

Use the integrated logging handler. That's all you need.

Have a look at Loguru:

https://github.com/Delgan/loguru

It seems Rich is not compatible with communism.

I hate CLI utilities that think they are so cool for turning my terminal into a disco.

Colour hating curmudgeons can set NO_COLOR env var, which Rich will respect.

Not what you replied to in the first place, but for some people it's not about hate, it's about color blindness or bad vision. I'm glad Rich has an option for that.

So don't use them or configure your terminal for monochrome? I for one welcome the disco.

Well, you can tell from the way I use nGrok, I'm a jq man, no time for awk

Reply on news.ycombinator.com