DEV Community: rsteube

Puking Rainbows

rsteube — Sat, 14 Oct 2023 02:02:41 +0000

Shells support colored output. Some do so also during tab completion.

It can provide extra context like whether an issue is open (green) or closed (red).
Or reflect the color of labels:

Here is how this works and how it is done in carapace...

ANSI escape sequences

Text style is set in the shell using an escape sequence like \e[31;42m.
This instructs the terminal that the text following it is red (31) with a green background (41).

It consists of

\e escape.
[ an opening square bracket.
31;42 a semicolon-separated list of escape codes.
m the letter m.

A common approach is to restore the default style using \e[0m afterwards.

echo "\e[1;2;4;35mdim bold underlined magenta\e[0m" # you might need `echo -e` for this

There are basic foreground colors (30-37), background colors (40-47),
modes (1-9) and reset (0) to restore the default. 256-colors
and RGB are also possible.

You can find a full list at ANSI Escape Sequences.

Elvish

This one is easy.

Styled

Elvish provides an abstraction for escape sequences using a list of human-readable keywords.

echo (styled "dim bold underlined magenta" dim bold underlined magenta)

You can read more about this at styled.

Complex candidate

Adding colors to tab completion is thus pretty easy with edit:complex-candidate.

set edit:completion:arg-completer[example] = {|@args|
  edit:complex-candidate true &display=(styled true green)' (true in green)'
  edit:complex-candidate false &display=(styled false red)' (false in red)'
}

Powershell

This one is a bit tricky.

Backtick

First of all, the escape character is different in Powershell.
It uses backtick instead of backslash.

echo "`e[1;2;4;35mdim bold underlined magenta`e[0m"

Completion result

CompletionResult allows escape sequences in the ListItemText to add color.

Function _example_completer {
    [CompletionResult]::new("false", "`e[31mfalse`e[0m", [CompletionResultType]::ParameterValue, "false in red")
    [CompletionResult]::new("true", "`e[32mtrue`e[0m", [CompletionResultType]::ParameterValue, "true in green")
}
Register-ArgumentCompleter -Native -CommandName 'example' -ScriptBlock (Get-Item "Function:_example_completer").ScriptBlock

By default, it uses tooltips to show the descriptions.
But the value by itself often gives no sign of what it represents.

ListItemText

Luckily, we can add the description to the ListItemText ourselves.

Function _example_completer {
    [CompletionResult]::new("false", "`e[31mfalse`e[0m (false in red)", [CompletionResultType]::ParameterValue, " ")
    [CompletionResult]::new("true", "`e[32mtrue`e[0m (true in green)", [CompletionResultType]::ParameterValue, " ")
}
Register-ArgumentCompleter -Native -CommandName 'example' -ScriptBlock (Get-Item "Function:_example_completer").ScriptBlock

Tooltip must not be empty though, so we need to set it to a single space.

Selection

Fix the highlighting by setting Selection to inverse.

Set-PSReadLineOption -Colors @{ "Selection" = "`e[7m" }

Description

And add some finishing touches to the description.

Function _example_completer {
    [CompletionResult]::new("false", "`e[21;22;23;24;25;29m`e[31mfalse`e[21;22;23;24;25;29;39;49m`e[2m `e[2m(false in red)`e[21;22;23;24;25;29;39;49m`e[0m", [CompletionResultType]::ParameterValue, " ")
    [CompletionResult]::new("true", "`e[21;22;23;24;25;29m`e[32mtrue`e[21;22;23;24;25;29;39;49m`e[2m `e[2m(true in green)`e[21;22;23;24;25;29;39;49m`e[0m", [CompletionResultType]::ParameterValue, " ")
}
Register-ArgumentCompleter -Native -CommandName 'example' -ScriptBlock (Get-Item "Function:_example_completer").ScriptBlock

Zsh

This one is hard.

Arrangement

First, let's have a look at how Zsh arranges values for tab completion.

Values without a description are arranged side-by-side.
Values with a description have it appended in the format -- description It is also aligned with other entries.
Values with the same description are also arranged side-by-side in front of the description.

Zstyle

Colors are set using the zstyle list-colors.

With ${curcontext} we can configure it for the current context during tab completion.

zstyle ":completion:${curcontext}:*" list-colors "{...}"

List Colors

It contains a colon-separated list of patterns and formats.
Formats are the semicolon-separated escape codes from ANSI escape sequences.

There is a simple and a complex way to specify the patterns.

=pattern=format to apply one format.
=(#b)(pattern1)(pattern2)=format0=format1=format2 to apply many formats.

See here for a good explanation.

Pattern

Given the value "true", three patterns are relevant.

=(#b)(true)=0=32 Set "true" to green (32).
=(#b)(true)([ ]## -- *)=0=32=2 Set "true" to green (32) and the description to dim (2).
=(#b)(-- *)=0=2 Set the description to dim for everything else.

Take this with a grain of salt, but there was an edge case in regards to the arrangement.
So it's best to set both the pattern for with and without a description for each value.

Compdef

Putting it all together.

#compdef example
function _example_completion {
  zstyle ":completion:${curcontext}:*" list-colors "=(#b)(false)([ ]## -- *)=0=31=2:=(#b)(false)=0=31:=(#b)(true)([ ]## -- *)=0=32=2:=(#b)(true)=0=32:=(#b)(-- *)=0=2"

  vals=('true:true in green' 'false:false in red')
  _describe 'values' vals
}
compquote '' 2>/dev/null && _example_completion
compdef _example_completion example

Carapace

Now to how carapace simplifies the above.

Style

Styles are adopted from Elvish.
There are colors like style.Red, modes like style.Dim and style.Of to combine them.

Action

They can be set directly with ActionStyledValues and ActionStyledValuesDescribed.

carapace.ActionStyledValues(
    "true", style.Green,
    "false", style.Red,
)

carapace.ActionStyledValuesDescribed(
    "true", "true in green", style.Green,
    "false", "false in red", style.Red,
)

Modifier

Or with the modifiers Style, StyleR and StyleF.

carapace.ActionValues(
    "1",
    "true",
).Style(style.Green)

carapace.ActionValues(
    "0",
    "false",
).StyleR(&style.Carapace.KeywordNegative)

carapace.ActionValues(
    "true",
    "false",
    "unknown",
).StyleF(func(s string, sc style.Context) string {
    switch s {
    case "true":
        return style.Green
    case "false":
        return style.Red
    default:
        return style.Default
    }
})

Style functions

The following functions can be passed to StyleF for common highlighting tasks:

ForPath highlights paths using the LS_COLORS environment variable.

ForPathExt does the same, but by extension only.

ForLogLevel highlights log levels.

ForKeyword highlights common keywords like true and false.

That's all

Enjoy the rainbow!

Go is bigger than crab!

rsteube — Sun, 08 Oct 2023 11:08:47 +0000

Ever wanted your custom Gopher but didn't have the drawing skills?

Well seems now you can generate them.
Type the title into your favorite AI prompt to get this:

Well no. But it's close enough so let's dive in...

What you need

Easy Diffusion

Which is a 1-click install of Stable Diffusion with an alternative web interface.
You can choose a different approach but this one is pretty simple and I am new to this stuff.

Make sure you meet the hardware requirements (GPU) and have enough disk space (this is a whopping 20+GB install).

golang gopher

This one does all the magic to ensure the generated image resembles a gopher.

Place it into EasyDiffusion/models/lora/.

Anything V5/Ink

By pure chance, I used this model instead of the default one and it gave amazing results.
If you are looking for the classic gopher style use the default (sd-v1-5), but this one is more fun.

Place it into EasyDiffusion/models/stable-diffusion/.

It tends to give the gophers a bit of a teddy bear look though so experiment with the settings (e.g. increase the strength of the golang LoRa to 0.8). And regenerate until you get something that pleases you.

Studio Ghibli Style LoRA

This one is optional but also has some nice effects when adding it into the mix.

Place it into EasyDiffusion/models/lora/.

See What are LoRA models and how to use them in AUTOMATIC1111 for the difference between LoRa and base models.

Example

sd (top-left)
sd+gopher (top-right)
anything+gopher (bottom-left)
anything+gopher+ghibli (bottom-right)

Settings

Start Easy Diffusion and it should open http://localhost:9000/ in your browser.

Network access

Under Settings you can configure it to allow remote access.

It is NOT SECURED so best to only do this in a safe local environment.

Image

Seed: Random for new creations.
Number of Images: 4 to have some options to choose from.
Model: AnythingV5Ink_ink or keep the standard model.
Image Size: 512x512 is fine for the usual gopher image as we can upscale it later but you can choose a different format.
LoRa: gophers_v1 [0.5] and optionally ghibli_style_offset [0.5] as well.
Output Format: png

Images are NOT STORED by default and closing the browser tab causes loss of data.
So remember to save the generated image and json.
You can do this by highlighting it and clicking the corresponding button.
Or download the full set with Download images at the top.

The Prompt

In the Prompt, you can add a comma-separated list of keywords of what you want in the image.
You can also emphasize specific keywords with brackets (e.g. (coffee) or (holding a mug)).

Be sure to add one of golangGopher (recommended), gopherArt, gopherCircle or gopher3d for the gopher model.

Have a look at the Prompt Guide for advanced techniques.

There is also the Negative Prompt where you can define what you don't want in the image.
You may add rust, ferris here, but best to leave this for later when you want to get rid of something specific.

The first attempt

Fill the prompt with golanggopher, <keywords...> and hit Make.

Here's what I got for golanggopher, podcast:

If there is nothing of interest try again.
But if one has a nice theme or composition don't start from zero.
Highlight the image and click Make Similar Images to use it as input.

In my case, the upper left already looks pretty nice, but there are some issues...

Fixing the teeth

See how there are no teeth? This happens pretty often when they are missing or not right.
Highlight the image and click Use as Input.

If you've done something else in the meantime you should select Use these settings on the top right first.

Klick Inpaint.

Mask the part to regenerate.

Save it, hit Make and if you're lucky that fixes it.

If it didn't work you can try to add teeth to the prompt.
Otherwise set the seed to random and try again.

Fixing the logo

The logo looks okay, but it isn't an O.
It's pretty close though, so mask the part that doesn't fit.

This one worked on the first try.

Upscale

Finally, highlight the image and click Upscale for a higher resolution.
Then highlight it again to save it with Download Image.

So what about the big one above

That is a composition of two generated images.

The big one (golanggopher, studio ghibli, totoro):

The small one (golanggopher, crab):

By removing the background.
Placing it over the other image.
Overpainting parts of the old gopher.
Importing it in Easy Diffusion as Input.
Masking the outline for inpainting.
And letting it regenerate various parts a couple of iterations.
It ended up as above.

Examples

You can find some examples at https://github.com/rsteube/gopher.

Have fun!

Oh, and give Easy Diffusion a tip if you like it.

A pragmatic approach to shell completion

rsteube — Thu, 13 Jan 2022 14:53:05 +0000