sglavoie.com – Tag: Bash

Managing multiple tmux sessions at once

Sébastien Lavoie — Sun, 19 Sep 2021 18:13:00 -0500

Introduction

Released back in 2007, tmux keeps being amazing! Because I have never bothered automating anything to make its use simpler, it took some time for it to become a working environment I enjoy for everyday use. This is a thing of the past: thanks to Oleksandr Kocherhin from Monsterlessons Academy, who shared his tmux workflow in his YouTube video titled Best Terminal Application for Web Development, I saw a few automation opportunities I thought were worth tackling.

In this post, I’m sharing a little tip about managing tmux sessions that was inspired from the mentioned video. I am using i3wm on Linux, but you can adapt this with any desktop environment as long as you can trigger the execution of programs with a keyboard shortcut in one way or another. I will be using Rofi and the find command, which you can find on Unix systems. If you would rather use dmenu instead of Rofi with this script, this article can serve as a reference. Enough said, let’s get to it.

What is this all about?

The idea is simple: have a few keyboard shortcuts to manage tmux sessions. That means being able to open new sessions and being able to kill them too. I kept this setup very simple on purpose but of course some improvements could be made. For instance, it could be nice to know which projects have already been opened so that the script doesn’t prompt you with a list of projects that include projects that you have already launched, but I haven’t found the need so far to deal with this potential issue as I tend to only work on a couple of projects during the course of a given day.

In summary, here is what we want to achieve in this post:

Configure projects so that when we want to open them, they will be set up in the right directory with servers running, etc.;
Open a tmux session with a keyboard shortcut, listing all projects that were configured in the previous step;
Kill any opened tmux session with another keyboard shortcut.

That’s it!

1. Configuring projects to launch tmux sessions

Firstly, we need to create new files to open our projects in the way we want. Basically, we need to create a file, let’s call it .tmux, and put it at the root of the project we’re interested in working with tmux. Then, we need to put some instructions that will be run with the shell (e.g. Bash or Zsh) so that tmux commands will be run automatically for us and let us “attach” to the session once all the necessary actions are performed. That means we need to make that file executable. In the terminal, this would be done as follows, assuming the project’s folder is the current working directory:

bash

chmod +x .tmux

At last, we want to give some orders to tmux so that when we execute that file, it will open our project in a pre-configured state so we’re ready to go. This will need to be customized depending on your needs, but here is a simple example to illustrate what could happen. So, we could put the following inside the .tmux file:

 bash
 
 
 
#!/bin/sh

set -e

if tmux has-session -t=my-project 2> /dev/null; then
 tmux attach -t my-project
 exit
fi

tmux new-session -d -s my-project -n nvim -x $(tput cols) -y $(tput lines)

# Neovim
tmux send-keys -t my-project:nvim "n" Enter

# Servers
tmux new-window -t my-project -n servers
tmux send-keys -t my-project:servers "cd frontend && yarn start" Enter

tmux split-window -t 2 -v -p 50 # split it into two halves
tmux send-keys -t my-project:servers "cd backend && ap && uvicorn main:app --reload" Enter

tmux attach -t my-project:nvim

Here is what is happening:

If our project, named my-project, has a tmux session already running, then we “attach” to it and nothing more is done.
Otherwise, the session is created in “detached” mode so we can run a few commands smoothly and later attach to the created session.
With the -n flag, we name the window to be created (here, the first window is nvim).
Then, we “send” keys to the session, to that newly created nvim window. In this case, we send a single keystroke n, which is just an alias for executing Neovim.
In a new window named servers, we send keys to execute the frontend server.
Then, we split the second window we just created vertically and we run the commands needed to launch the backend server, again making use of Bash aliases for convenience.
Finally, we attach to the session and we open the first window nvim, ready to work.

And just like this, what takes quite a few steps to do manually can be automated in one go when setting up the environment at the beginning of a working bout. Now, it could be convenient to create a generic template for the above script to use when creating new projects, especially if those tend to be short-lived and share some properties (e.g. maybe they all need to launch some kind of server in the background).

2. Script to open projects

Firstly, we need a way to list and open all “known” projects. This is achieved in this example very simply with the find command as well as with the help of rofi. The script in question is as follows:

 bash
 
 
 
#!/bin/bash

# Get the path to the `.tmux` file to execute using `find` and `rofi`
PROJECT=`find $HOME/dev -type d \( -name node_modules -o -name .venv \
 -o -path name \) -prune -false -o -name '.tmux' \
 | rofi -i -dmenu -theme purple -font 'JetBrainsMono 14' \
 -width 90 -show window`

# Get the full directory path to the `.tmux` file, excluding the filename
PROJECT_DIR=`echo $PROJECT | xargs -I {} dirname "{}"`

# If $PROJECT is empty (e.g. pressing Esc at the prompt), don't do anything
if [ ! -z "$PROJECT" ]; then
 kitty --directory "$PROJECT_DIR" -e "$PROJECT"
fi

So, what this does is this:

It finds all the directories where a .tmux file exists, excluding non-useful folders like node_modules. The -prune flag is passed to avoid recursion further inside a directory once a .tmux file is found. The results of find are “piped” into rofi, which displays the results. User selection is then stored in the PROJECT variable.
Once a file is selected, the full path without the filename is extracted and stored in the PROJECT_DIR variable.
Finally, all that is left to do is check if the user selected a project and if so, run it with the desired terminal from the correct directory. This will be different for most terminal emulators: here, an example is shown with the kitty terminal.

3. Script to close projects

Here, we are concerned with the sessions that are now opened and that we might want to close. In a similar fashion as what we did to open projects, we want to kill them with a script that will run Rofi and do the job silently in the background. One such script that will get us there is shown below:

 bash
 
 
 
#!/bin/bash

# Get the name of all running sessions
TMUX_SESSIONS=`tmux ls | cut -f1 -d ":"`

# No listed session, then notify about it
if [ -z "$TMUX_SESSIONS" ]; then
 notify-send "No active tmux session found"
 exit 0
fi

# Show all running sessions with Rofi and store the selection in a variable
SESSION=`echo $TMUX_SESSIONS | rofi -sep ' ' -i -dmenu -theme purple -font 'JetBrainsMono 14' \
 -width 90 -show window`

# Kill the selected session
tmux kill-session -t $SESSION

In this case, the usage is quite straightforward: only running sessions are shown, so it’s just a matter of choosing the one we want to kill or pressing the Escape key to abort the Rofi pop-up.

Example workflow

It’s a matter of setting up keyboard shortcuts to run the scripts to open and kill projects. For instance, one such configuration for the i3 window manager would be as follows:

 bash
 
bindsym $mod+Mod1+p $exec ~/path/to/projects-start.sh
bindsym $mod+Mod1+k $exec ~/path/to/projects-kill.sh

A simple shortcut lets us choose sessions to open.
Next, if we decide to kill a session at some point, we have another shortcut to do that.

Conclusion

Far from being a perfect solution (although it already feels comfortable as a main driver), this workflow initiates what I think can lead to substantial optimizations when it comes to using tmux. There’s room for improvement when a user selects an already opened session: ideally, we would just switch to that session automatically. These details need to be implemented based on the window manager that’s being used, but suffice to say, it can be done! In any case, I hope this may give you a semblance of inspiration to take this idea to the next level. There are tools to help with session persistence, such as tmux-resurrect, but that’s a topic for another time.

More resources and references

Best Terminal Application for Web Development, original inspiration for this workflow. — Monsterlessons Academy, YouTube.
The tmux wiki, GitHub.
tmux-resurrect, GitHub.

Using dmenu to Optimize Common Tasks

Sébastien Lavoie — Sun, 10 Nov 2019 09:02:00 -0600

Introduction

dmenu is one of those tools that look a little unimpressive at first but can accomplish so much! It’s a program that you can use to receive any output redirected from other programs (through pipes in the terminal, the symbol |) and treat that output so that it can pop up within a simple menu to make it available for execution. If you want to know more about other fantastic tools from suckless.org, I went over some of them before, such as the st terminal and slock, a dead simple screen locker.

Any Simple Example?

You bet! Before diving in with how to install it and some more concrete examples, you could give dmenu a go with a simple command such as the following (assuming the program is installed on your machine).

bash

ls | dmenu

This will effectively “pipe” the output of ls into dmenu and a menu like the following would appear (by default, it shows as a thin stripe at the top covering the width of the screen):

If you start typing, the displayed list will be filtered down like so:

You can also switch to the next item to be highlighted by typing Ctrl + n, to the previous item by typing Ctrl + p and exit by reaching for the Escape key. For now, if you type Enter once your desired selection is highlighted, the selection will be outputted to the terminal and that will be the end of it. Let’s convert this into a practical thing, then.

Keeping the same output as before which only contained directories, we could open a file manager (here, I’m going with pcmanfm) and do something like this (bear with me, the explanation follows!):

 bash
 
ls | dmenu -l 5 | xargs -I {} pcmanfm "{}"

This is now a fully functional example, albeit its practicality is debatable. What will happen, exactly?

First, ls will output a list of directories in the current working directory. That is, the following would be printed in the terminal without any piping:

Desktop Downloads Learning Pictures Public Templates virtualbox_vms
Documents Dropbox Music Programming SortOut Videos

When we pipe this into dmenu, we will get a menu with all that output nicely formatted vertically, which is what the -l 5 options does (here, we want only 5 lines to show). We will see a maximum of 5 items as this is the value we passed to the -l option:

We can still start typing a word that doesn’t show up in this list like Mu and we will see that this list is filtered to only include the matching directory Music even though we couldn’t see it before since we limited our results to 5 items. We could also use the same technique with Ctrl + n and Ctrl + p to cycle between the elements.

Up to this point, we are getting our selection outputted to the terminal. Next, we pipe it into xargs, which will allow us to specify a command to which we will pass our result (what is printed to the terminal) as an argument (we could make use of more arguments depending on the output we get, but let’s start simple). The -I {} option will make it possible to “quote” our result so it is read as a single argument and properly escaped. This means that without this option, if we have spaces or other special characters in the argument (such as a folder called My Music), it would try to pass each word as a new argument to pcmanfm, trying to open both My and Music directories at once.

We are representing our output as {} and when we quote it with pcmanfm "{}", spaces are interpreted without any trouble. If we wanted to use various arguments instead, we could try something like this:

 bash
 
echo "file1.txt file2.txt\nfile3.txt file4.txt" | dmenu -l 2 | xargs cat

The part before the first pipe character will print to the terminal those two lines:

file1.txt file2.txt
file3.txt file4.txt

When we pipe this into dmenu -l 2, we will get this menu:

Typing Enter on one of the highlighted items would then trigger xargs to pass the content literally to cat as arguments, which would then print to the terminal the content of both file1.txt and file2.txt (the first line containing two arguments for cat) or the content of both file3.txt and file4.txt (the second line also containing two arguments for cat) in succession.

Now that we got our feet wet with what dmenu does (displays a menu), we might want to install it.

How do You Install It?

In Manjaro Linux, it comes with i3 if you use that flavor of the distribution and can be opened by pressing the modifier key (either Super/Windows key or Alt key) along with the letter d, as in the shortcut mod + d, or by typing dmenu_run in a terminal, which will present a list of installed applications to launch. Otherwise:

Debian-based (such as Ubuntu)

bash

sudo apt install dmenu

Arch-based (such as Manjaro)

bash

pacman -Syu dmenu

You can also install it from your distribution’s package manager if available or from source.

Useful Real-World Examples

Here are a couple of ways I like to use dmenu to open a menu with a list of:

cheat sheets;
filesystem paths;
most used documents;
documents & books I read at the university;
custom scripts I want to run in the background.

Here are a few screenshots of how it currently looks like in my daily usage so you get a better idea.

Cheat sheets

University shortcuts

File manager shortcuts

So, how does that all work? As a starting point, all of those menus are launched through a specific keyboard shortcut that uses a mnemonic for each one (mod being the “modifier” key on i3, which is set to Super/Windows):

mod + Alt + c: cheat sheets;
mod + Alt + d: documents;
mod + Alt + f: file manager;
mod + Alt + s: scripts;
mod + Alt + u: university.

Let’s take the cheat sheets example, which is a bit more interesting since it launches different applications.

Setting Up a Custom Command

Configuration for i3 (bind a keyboard shortcut)

Here, I’m using i3 to set a keyboard shortcut to run a specific command, but this will be a similar experience on other window managers and desktop environments.

 bash
 
 
 
# i3config file
# The backslash at the end of the line allows us
# to split the line to increase readability

## Cheatsheets

bindsym $mod+Mod1+c exec --no-startup-id \
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

You would usually be able to launch a custom command from your environment through a keyboard shortcut. If passing a direct command such as the above one isn’t an option, you can always store it in a Bash script and run that Bash script instead as the designated custom command. The script would then contain the following:

 bash
 
#!/bin/bash

## Cheatsheets
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

As far as i3 is concerned, that’s all you need to do. You would need to reload the configuration file (by default: i3config) where the previous bindsym command has been set up to apply the changes (default shortcut to reload: mod + Shift + c).

Configuration for cheatsheets.conf

The content of this file is literally what will be shown when dmenu opens it. An excerpt:

 
#---------- Cheat Sheets -------------------------------------------------------
bash st -e nvim path/to/bash.sh
git zathura path/to/github.pdf
vimwiki firefox path/to/vimwiki.html

Here, we have set a maximum of 30 lines to be displayed (-l 30). What follows after an element has been selected with dmenu allows us to parse the content of the line and retrieve only the command we are interested in with sed before passing that filtered content around to sh to execute it as a shell command. With more complex commands requiring multiples arguments to be received, we could add one more pipe between sed and sh like this (or with xargs -I {} to avoid problems with spaces):

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | xargs -r | sh

If the line we want to run only includes a path to a file as in:

myshortcut path/to/file.pdf

We could instead pipe it into an external command of choice if the same program applies to all items presented in the menu, say Firefox:

 bash
 
cat path/to/file.conf \
| dmenu -l 30 | sed 's/.* \+//' | xargs -I {} firefox "{}"

What’s nice with the way pipes work in a Unix-like system is that we can chain harmless commands until the very end so they will simply be printed to the terminal. In this example, if we want to see how to filter our lines before running a command, we can do so as follow.

Pipe 1

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30

If you remember from the menu we saw earlier, there’s a shortcut to open a cheat sheet for Git. Let’s say we selected that one with dmenu. Because our command isn’t doing anything with the result, it will be outputted to the terminal like so (just like in the excerpt of cheatsheets.conf):

bash

git zathura path/to/github.pdf

What sed does here is to cut everything from the beginning of the line up to where the command starts (that’s where we find zathura, which is a powerful document viewer), because we need to isolate that part of the line so it looks like a shell command we could run on its own. Let’s add a new pipe to our command and see what sed does with it*.

* _{We could have used other tools to parse the string like awk, grep, cut, etc.}

Pipe 2

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//'

If we select the same item as before with dmenu to illustrate more clearly what this new addition does, we will get this output:

bash

zathura path/to/github.pdf

If we were to type this in the terminal (assuming the file exists and zathura is installed!), that would do the trick and it would open with the specified document viewer. Pipe 2 and subsequent pipes before we execute something is where the filtering magic happen. In short:

Everything before | dmenu is how our input will look like when we run dmenu;
Everything after | dmenu [options here] | is what we need to do to our input so that it is converted into a working shell command;
Finally, what comes after the last pipe (either xargs, sh or a combination of both) is our way to redirect our string to the shell so it can be executed.

Once we are visually satisfied with how our command is supposed to look like (it has to be something that works when typed directly in the terminal), the next step is to pipe it again so it can be executed.

Pipe 3

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

There we go, the command is launched. If we keep the same simple syntax in all of our .conf files —or whatever extension we choose— where the content of our menus is stored in plain text, we can quickly and painlessly create keyboard shortcuts to run custom lists of commands that can be edited on the fly. Once our shortcuts are active, it’s only a matter of editing one of those .conf files and automatically our lists will be up-to-date when we trigger the shortcut again.

Running a Custom Script

If we want to run custom scripts, we need to indicate a command that would work in the terminal, such as python myscrypt.py or ./myscript.sh. When it comes to shell scripts, we have to make sure they are executable. We can do so through a file manager or within the terminal like this:

bash

chmod +x path/to/script.sh

This will add the necessary permissions for the user to execute the script. As we already know, we would then need to add a keyboard shortcut to launch our custom menu and store our command in a file like scripts.conf that would contain the following:

#---------- scripts.conf -------------------------------------------------------
myscript script.sh

And that’s all there is to know to get piping with dmenu! You may also find this video from Luke Smith on YouTube to be quite helpful as well, which is where the inspiration for this post came from. He also posted a complementary video about adding prompts to your commands which is a nice way to add interactivity to your scripts!

Chaining dmenu prompts

Another useful scenario is when you want to take a specific action based on the output of a previous command. For instance, let’s say you want to read a book but when you choose a pdf with dmenu, you want to be prompted for which reader to use while you want to let the system choose the default application for other types of files (e.g. epub or mobi). This could be achieved with a script similar to the following one:

 bash
 
 
 
#!/bin/bash
FILE=`find ~/Documents/calibre_library -type f -iname "*.pdf" -o \
 -iname "*.epub" -o -iname "*.mobi" | dmenu -l 30`

if [[ "$FILE" == *.pdf ]]
then
 READER=`echo -e "zathura\natril" | dmenu -i -p "Which reader?"`
 $READER "$FILE"
else
 xdg-open "$FILE"
fi

Here’s what’s happening:

We find all the files (-type f)
in the directory ~/Documents/calibre_library
that match a pattern that’s case-insensitive with -iname (here, ending in either pdf, mobi or epub)
matching one file at a time (-o can be interpreted to mean “only” and will keep searching if the previous file extension was not matched)
then presenting 30 lines (-l 30) of results at a time with dmenu
then, if the file is a PDF, prompts whether to use atril or zathura as the file reader and open with the chosen program
otherwise, open the file with the default application.

Customize the Look of dmenu

As they say, “beauty is in the eye of the beholder”. If you would rather make some changes to how dmenu look, you can. dmenu will be searching for the configuration file located at ~/.dmenurc, which could contain something as put below (with this configuration, it will look like the screenshots shown previously):

 bash
 
 
 
#
# ~/.dmenurc
#

# define the font for dmenu to be used
DMENU_FN="NotoSans-10.5"

# background colour for unselected menu-items
DMENU_NB="#161925"

# textcolour for unselected menu-items
DMENU_NF="#fdfffc"

# background colour for selected menu-items
DMENU_SB="#235789"

# textcolour for selected menu-items
DMENU_SF="#fdfffc"

# command for the terminal application to be used:
TERMINAL_CMD="st -e"

# export our variables
DMENU_OPTIONS="-fn $DMENU_FN -nb $DMENU_NB -nf $DMENU_NF -sf $DMENU_SF -sb $DMENU_SB"

Conclusion

Hopefully this introduction to what dmenu has to offer gave you some ideas. I hope you’ll find many ways to adapt the examples so you can benefit from this amazing tool. You can find more configuration details in my dotfiles on GitHub for anything related to i3, dmenu, zathura, st, slock and many more useful programs.

Have a good time automating your digital life!

Bash History Cleaner

Sébastien Lavoie — Sun, 23 Dec 2018 19:35:00 -0600

Introduction

This is a Python 3.6+ script that helps to clean the file containing the Bash history commands. It will remove any line matching a specified regular expression and can also remove any line starting with an alias.

The idea behind this small utility was simple:

The Bash history file (usually located in ~/.bash_history) contains much of the work one ends up doing in the terminal.
The history can grow large over time and it becomes more cumbersome to find interesting information in all that clutter, such as a rarely used command with specific flags.
By removing all superfluous commands that are repeated often and which give no real benefit in certain contexts (such as ls, cd, cat, etc.), the history is much cleaner and easier to navigate and actually becomes much more useful in my opinion.
True, it will be harder to follow the bread crumbs for everything you did, but I haven’t come across a situation where having access to yet another empty ls or cd has proven necessary and reading .bash_history doesn’t make for a great narrative story either.

Make history in a big way

I took advantage of the fact that the history can be cleaned with the script you are about to see and set up what is known as an eternal history which, as it sounds like, can grow infinitely big! All you have to do is append the following lines to the file ~/.bashrc:

 bash
 
 
 
# Eternal bash history.
# ---------------------
# Undocumented feature which sets the size to "unlimited".
# http://stackoverflow.com/questions/9457233/unlimited-bash-history
export HISTFILESIZE=-1
export HISTSIZE=-1
export HISTTIMEFORMAT="[%F %T] "
# Change the file location because certain bash sessions truncate
# .bash_history file upon close.
# http://superuser.com/questions/575479/bash-history-truncated-to-500-lines-on-each-login
export HISTFILE=~/.bash_eternal_history
# Force prompt to write history after every command.
# http://superuser.com/questions/20900/bash-history-loss
PROMPT_COMMAND="history -a; $PROMPT_COMMAND"

Bash History Cleaner

And here is the script in question *. It comes in two files that need to be in the same directory:

One is a Python file that needs to be launched from the terminal with Python 3.
The other file, settings.json, is a JSON file used to store the settings of the script, which will be detailed below.

* _{Improvements to the original script can be found on Github. To keep this
article a bit more readable, the original version is shown.}

`bash_history_cleaner.py`

 python
 
 
 
'''
Python script that helps to clean the file containing the Bash history
commands.

Note: Requires Python 3.6+

It will remove any line matching a specified regular expression and can
also remove any line starting with an alias.

Description of available settings in `settings.json`:

 "home_directory": Absolute path to user's home directory.

 "history_file": Name of file where the history will be cleaned up.

 "aliases_file": Name of file where Bash aliases are set up.

 "ignore_patterns": List of patterns to ignore in `history_file`.
 Each line where a pattern is found will be deleted.
 → Patterns are specified as regular expressions.

 "add_aliases": Boolean. If set to `true`, aliases from `aliases_file`
 will be added to `ignore_patterns`.

 "aliases_match_greedily":
 Boolean. If set to `true`, any line in `history_file`
 starting with an alias in `aliases_file` will be
 deleted. If set to `false`, delete line if the alias is
 the content of the whole line (with optional space at
 the end): `false` matches "^alias$" or "^alias $" only.

 "backup_history": Boolean. If set to `true`, `history_file` will be backed
 up in the same directory with a name ending in .bak
 based on the current date.

 "delete_logs_without_confirming":
 Boolean. If set to `true`, script with flag `-c` will
 automatically delete all the backup files found for
 `history_file`.
'''
from datetime import datetime
from pathlib import Path
import argparse
import fileinput
import glob
import json
import os
import re


def get_current_path():
 '''Returns the current working directory relative to where this script
 is being executed.'''
 return Path(__file__).parents[0]


def user_says_yes(message=""):
 '''Check if user input is either 'y' or 'n'. Returns a boolean.'''

 while True:
 choice = input(message).lower()
 if choice == 'y':
 choice = True
 break
 elif choice == 'n':
 choice = False
 break
 else:
 print("Please enter either 'y' or 'n'.")

 return choice


def delete_logs(settings: dict, history_file: str):
 '''Delete log files in `home_directory` based on `history_file`.'''

 # Retrieve a list of all matching log files
 log_files = glob.glob(f'{history_file}_*.bak')

 if log_files == []:
 print("There is no log file to delete.")
 else:
 print(f'Log files found in {settings["home_directory"]}:')

 for log_file in log_files:
 print(log_file)

 if settings['delete_logs_without_confirming']:
 for log_file in log_files:
 os.remove(log_file)
 print('Log files deleted.')
 return

 message = ("\nDo you want to delete those log files? [y/n] ")

 if user_says_yes(message=message):
 for log_file in log_files:
 os.remove(log_file)
 print('Log files deleted.')
 return

 print('Operation aborted.')
 return


def generate_date_string() -> str:
 '''Return date formatted string to backup a file.'''
 return datetime.strftime(datetime.today(), '_%Y%m%d_%H%M%S.bak')


def load_settings(settings_file: str) -> dict:
 '''Load settings in the script. Return them as a dictionary.'''
 with open(settings_file, "r") as read_file:
 settings = json.load(read_file)
 return settings


def get_list_aliases(bash_aliases_file: str, settings: dict) -> list:
 '''Retrieve the name of all the aliases specified in `bash_aliases_file`.

 Return aliases as a list of strings formatted as regular expressions.'''

 match_whole_line = bool(settings['aliases_match_greedily'])

 with open(bash_aliases_file) as file:
 content = file.read().splitlines() # one alias per line
 aliases_list = []
 for line in content:
 try:
 # Get the actual alias in each line
 # Use negative lookbehind to remove 'alias ' at the beginning.
 # Matches anything after that is a dot, digit, underscore
 # or letter (will stop at the equal sign: alias blah='...')
 alias = re.search(r'(?<!not )alias ([\.\w]*)', line).group(1)

 # If for some reason the alias cannot be extracted, skip it
 # If search doesn't match, it's of type None and won't work
 except AttributeError:
 continue

 if match_whole_line:
 # Match the whole line if it starts with the alias.
 alias = f'^{alias}( )?$|^{alias} .*'
 else:
 # Will match only when alias is the whole content of the line,
 # followed by optional space.
 alias = f'^{alias}( )?$'

 # Escape dots in alias
 alias = alias.translate(str.maketrans({".": r"\."}))

 aliases_list.append(alias)

 return aliases_list


def clean_bash_history(settings: dict, history_file: str):
 '''Modify in place `history_file` by removing every line where
 `ignore_patterns` is found.

 Optionally, add a list of aliases to `ignore_patterns` with
 `aliases` based on the value of `add_aliases` in settings.json.'''

 if settings['backup_history']:
 backup_str = generate_date_string()
 file_input = fileinput.FileInput(history_file,
 inplace=True,
 backup=backup_str)
 else:
 file_input = fileinput.FileInput(history_file,
 inplace=True)

 with file_input as file:
 for line in file:
 has_match = False
 for pattern in settings['ignore_patterns']:
 matched = re.compile(pattern).search
 if matched(line):
 has_match = True
 break
 # If no match is found (nothing to ignore), print the line
 # back into the file. Otherwise, it will be empty.
 if not has_match:
 print(line, end='') # Line already has carriage return


def launch_cleanup(settings: dict, history_file: str, aliases_file: str):
 '''Main function that launches the cleanup process.'''

 bash_aliases = None
 if settings['add_aliases']:
 try:
 bash_aliases = get_list_aliases(aliases_file, settings)

 # add aliases to list of patterns to ignore
 settings['ignore_patterns'].extend(bash_aliases)
 except FileNotFoundError:
 print(f"File not found: {aliases_file}")
 quit()
 try:
 clean_bash_history(settings, history_file)
 except FileNotFoundError:
 print(f"File not found: {history_file}")


if __name__ == '__main__':
 SETTINGS_FILE_PATH = get_current_path() / 'settings.json'
 SETTINGS = load_settings(SETTINGS_FILE_PATH)
 ALIASES_FILE = SETTINGS['home_directory'] + '/' + SETTINGS['aliases_file']
 HISTORY_FILE = SETTINGS['home_directory'] + '/' + SETTINGS['history_file']

 # initiate the parser to check all the arguments passed to the script
 PARSER = argparse.ArgumentParser()
 PARSER.add_argument(
 '-c', '--clear', help='Delete all log files', action='store_true')

 # read arguments from the command line
 ARGUMENTS = PARSER.parse_args()

 if ARGUMENTS.clear:
 delete_logs(SETTINGS, HISTORY_FILE)
 quit()

 launch_cleanup(SETTINGS, HISTORY_FILE, ALIASES_FILE)

`settings.json`

 json
 
 
 
{
 "home_directory": "/home/sglavoie",
 "history_file": ".bash_eternal_history",
 "add_aliases": true,
 "aliases_file": ".bash_aliases",
 "aliases_match_greedily": true,
 "backup_history": true,
 "delete_logs_without_confirming": false,
 "ignore_patterns": [
 "^\\#\\d+",
 "^$",
 "^(\\.\\/)?pip$",
 "^(\\.\\/)?python.*$",
 "^\\.\\.$",
 "^alias",
 "^cd ",
 "^cd$",
 "^cd..$",
 "^fg$",
 "^df( )?",
 "^du( )?",
 "^exit$",
 "^git branch",
 "^git checkout master",
 "^git log$",
 "^git push$",
 "^git status$",
 "^git stauts$",
 "^kill \\d+.*",
 "^ls -a$",
 "^ls$",
 "^make|make install$",
 "^man ",
 "^pelican( )?$",
 "^pip install -r requirements.txt",
 "^pip.* list|pip.* show$",
 "^source ",
 "^sudo apt-get autoclean|sudo apt-get autoremove$",
 "^sudo apt-get dist-upgrade|sudo apt-get update$",
 "^which "
 ]
}

Description of available settings in `settings.json`

Name of setting	Description
`home_directory`	Absolute path to user’s home directory.
`history_file`	Name of file where the history will be cleaned up.
`aliases_file`	Name of file where Bash aliases are set up.
`ignore_patterns`	List of patterns to ignore in `history_file`. Each line where a pattern is found will be deleted. Patterns are specified as regular expressions.
`add_aliases`	Boolean. If set to `true`, aliases from `aliases_file` will be added to `ignore_patterns`. (Default: `true`)
`aliases_match_greedily`	Boolean. If set to `true`, any line in `history_file` starting with an alias in `aliases_file` will be deleted. If set to `false`, delete line if the alias is the content of the whole line (with optional space at the end): `false` matches “^alias$” or “^alias $” only.
`backup_history`	Boolean. If set to `true`, `history_file` will be backed up in the same directory with a name ending in .bak based on the current date. (Default: `true`)
`delete_logs_without_confirming`	Boolean. If set to `true`, script with flag `-c` will automatically delete all the backup files found for `history_file`. (Default: `false`)

Anecdotal evidence of satisfying performances

Performance-wise, this scans ~8,300 lines per second on my modest Intel Core i5 laptop with files of over 200,000 lines long. Not that I type so much stuff in the terminal: I just duplicated many lines.

Conclusion

This is a simple solution to an nonexistent problem, but it was in the end very instructive to me nonetheless. You may even find a use for it! Otherwise, you might use the same functions for other files such as logs! If you would like to take a closer look at the source in a more convenient way, you can find the code available on Github.

Aliases: Also Known as Terminal User's Best Friends

Sébastien Lavoie — Sat, 08 Dec 2018 13:52:00 -0600

Some aliases that I find useful

In all the following examples, the dollar sign $ at the beginning of commands represents the prompt, it should not be typed.

General-purpose

List all aliases

bash

$ alias

Prints all of your aliases. If you have plenty of those, you might prefer to pipe this command with less to get a nice pager that allows you to easily nagivate them:

 bash
 
$ alias | less

Setting an alias in `~/.bash_aliases`

 bash
 
alias c='clear'

This would set c as a shortcut to clear. In order to use the newly created alias, you would have to close the terminal or type the following command in the terminal:

bash

$ source ~/.bash_aliases

Clear the screen

 bash
 
alias c='clear'

I like being absorbed into the emptiness of the terminal, so this one comes in handy to tidy up the work space.

Reset the terminal

 bash
 
alias re='tput reset'

If for some reasons the terminal displays badly or display funky characters, it can usually be reset this way.

Exit from the terminal

 bash
 
alias q='exit'

For exiting the terminal as if you were still in Vim!

Display all file extensions recursively from the current directory

 bash
 
alias allextensions="find . -type f -name '*.*' | sed 's|.*\.||' | sort -u"

It comes in handy to spot if a file shouldn’t be there or to check for lower or uppercase extensions.

Find text inside files, including filenames

 bash
 
alias findinfiles='ag --nobreak --nonumbers --noheading . | fzf'

In this example, the alias is set up with ag, a fast code-searching tool and fzf, a great fuzzy finder.

Reboot and shutdown the system

 bash
 
alias reboot='systemctl reboot'
alias shutdown='systemctl poweroff'

This will reboot or power off the system without needing root privileges in most working conditions.

List and sort files and directories by modification time

 bash
 
alias treeold='tree -hDF | less'

This requires the command tree to be installed. The parameters are (descriptions taken from man tree):

-h: Print the size of files in a human readable way.

-D: Print the date of the last modification time.

-F: Append a ‘/’ for directories, a ‘=’ for socket files, a ‘\*’ for executable files, a ‘>’ for doors (Solaris) and a ‘|’ for FIFO’s, as per ls -F.

Open files quickly with default applications

 bash
 
alias o='xdg-open'

This will open files and URLs specified as argument in the default application detected.

Moving around

If you are going to be working on projects for some time and require to cd into them, I have found the following to be useful:

 bash
 
 
 
$ cdnameOfProject # instead of having to do cd /path/to/project/
$ # More examples:
$ cdcodeabbey # For codeabbey.com
$ cdhackerrank # For hackerrank.com
$ cdeuler # For projecteuler.net
$ cdgit # For all Github repositories

This is not advanced by any means, but it helps quite regularly! Since you can take advantage of tab completion, you can type cd (without adding a space) and then press TAB key to autocomplete the aliases.

 bash
 
alias ...='cd ../..'

Make it easier to navigate into deep directory structures by basically doing cd .. && cd .. to go back up two directories at once.

Listing files

 bash
 
 
 
alias l='ls -CFh'
alias la='ls -Ah'
alias ll='ls -ahlF'
alias ls='ls --color=auto'

Different ways to set up the command ls to quickly see the needed files. The parameters are (descriptions taken from man ls):

-A: Do not list implied . and ...

-C: List entries by columns.

-F: Append indicator (one of \*/=>@|) to entries.

-a: Do not ignore entries starting with .

-h: With -l and/or -s, print human readable sizes (e.g., 1K 234M 2G).

-l: Use a long listing format.

 bash
 
alias aNameOfProject='source /path/to/project/bin/activate'
alias aa='source ~/Programming/anaconda3/bin/activate' # Example using Anaconda distribution

The purpose is to activate a specific virtual environment quickly. The command cd could be added to go to the related project also:

 bash
 
alias gNameOfProject='cd /path/to/project/ && ./.venv/bin/activate'

Where .venv would be the name of the virtual environment.

I like to activate environments starting aliases with a and go and activate at the same time starting aliases with g. This way, it feels like I am speaking the Vim language (cw for change word, for example).

 bash
 
alias da='deactivate'

This will deactivate a virtual environment.

 bash
 
alias p36='python3.6'
alias p='python3.7' # Simply using `p` for main version of Python

Practical way to quickly open the desired Python version.

 bash
 
alias pyclean='find . -regex ".*\(__pycache__\|\.py[co]\)" -delete'

This will delete recursively all files and directories that match one of the following patterns in their name: __pycache__, .pyc or .pyo.

Conclusion

I hope you will find at least one alias to improve your productivity. Of course, you are welcome to chime in with your own suggestions!

sglavoie.com – Tag: Bash

Managing multiple tmux sessions at once

Introduction

What is this all about?

1. Configuring projects to launch tmux sessions

2. Script to open projects

3. Script to close projects

Example workflow

Conclusion

More resources and references

Using dmenu to Optimize Common Tasks

Introduction

Any Simple Example?

How do You Install It?

Debian-based (such as Ubuntu)

Arch-based (such as Manjaro)

Useful Real-World Examples

Cheat sheets

University shortcuts

File manager shortcuts

Setting Up a Custom Command

Configuration for i3 (bind a keyboard shortcut)

Configuration for cheatsheets.conf

Pipe 1

Pipe 2

Pipe 3

Running a Custom Script

Chaining dmenu prompts

Customize the Look of dmenu

Conclusion

Bash History Cleaner

Introduction

Make history in a big way

Bash History Cleaner

bash_history_cleaner.py

settings.json

Description of available settings in settings.json

Anecdotal evidence of satisfying performances

Conclusion

Aliases: Also Known as Terminal User's Best Friends

Some aliases that I find useful

General-purpose

List all aliases

Setting an alias in ~/.bash_aliases

Clear the screen

Reset the terminal

Exit from the terminal

Display all file extensions recursively from the current directory

Find text inside files, including filenames

Reboot and shutdown the system

List and sort files and directories by modification time

Open files quickly with default applications

Moving around

Listing files

Python-related

Conclusion

`bash_history_cleaner.py`

`settings.json`

Description of available settings in `settings.json`

Setting an alias in `~/.bash_aliases`