70 KiB
Executable scripts
- Presentation
- Autostart
- cli utilities
- Emacs stuff
- Media
- Plock
- Rofi utilities
- Wallpaper utilities
- Wayland
- Weather
Presentation
This file will present all the executable scripts I wrote. It is also their original source code, all the following code snippets are exported and tangled from this file to the actual executables.
Autostart
Because I sometimes switch from window manager to window manager, creating a script that handles by itself autostarting things for me is way easier than rewriting every time the autostart part of my configuration. As you can every instance will be launched asynchronously, and only if there is no other instance of said command running.
Command | Arguments | Run once? |
---|---|---|
pactl |
load-module module-switch-on-connect |
|
mpc |
stop |
no |
xrdb |
-merge "$XDG_CONFIG_HOME"/X11/Xresources |
no |
picom |
yes | |
numlockx |
on |
yes |
xfce-polkit |
yes | |
nm-applet |
yes | |
xwallpaper |
--zoom "$(cat "$HOME"/.cache/wallpaper)" |
no |
xss-lock |
plock |
yes |
/usr/lib/kdeconnectd |
yes | |
dunst |
yes |
(mapconcat (lambda (start-command)
(let* ((clean-string (lambda (str) (replace-regexp-in-string "~" "" str)))
(command (funcall clean-string (nth 0 start-command)))
(arguments (funcall clean-string (nth 1 start-command)))
(oncep (string= "yes" (nth 2 start-command)))
(full-command (replace-regexp-in-string
" +"
" "
(format "%s %s &" command arguments))))
(concat (format "which %s && %s"
command
(if (not oncep)
full-command
(format (concat "if pgrep -x %s ; then\n"
" echo %s already running\n"
"else\n"
" %s\n"
" disown\n"
"fi")
command
command
full-command))))))
table
"\n")
which pactl && pactl load-module module-switch-on-connect &
which mpc && mpc stop &
which xrdb && xrdb -merge "$XDG_CONFIG_HOME"/X11/Xresources &
which picom && if pgrep -x picom ; then
echo picom already running
else
picom &
disown
fi
which numlockx && if pgrep -x numlockx ; then
echo numlockx already running
else
numlockx on &
disown
fi
which xfce-polkit && if pgrep -x xfce-polkit ; then
echo xfce-polkit already running
else
xfce-polkit &
disown
fi
which nm-applet && if pgrep -x nm-applet ; then
echo nm-applet already running
else
nm-applet &
disown
fi
which xwallpaper && xwallpaper --zoom "$(cat "$HOME"/.cache/wallpaper)" &
which xss-lock && if pgrep -x xss-lock ; then
echo xss-lock already running
else
xss-lock plock &
disown
fi
which /usr/lib/kdeconnectd && if pgrep -x /usr/lib/kdeconnectd ; then
echo /usr/lib/kdeconnectd already running
else
/usr/lib/kdeconnectd &
disown
fi
which dunst && if pgrep -x dunst ; then
echo dunst already running
else
dunst &
disown
fi
I also have an external sound card, a Scarlet 2i2 G3, that I would like to use as my default audio output. However, it might not be always connected, hence the following code:
SOUNDCARD=$(pactl list short sinks | grep "Focusrite")
if [[ -n $SOUNDCARD ]]; then
pactl set-default-sink "$(echo "$SOUNDCARD" | awk '{print $2}')"
fi
cli utilities
Backup
backup
is a very simple, oneliner script that will create a local copy of a
file and add the date at which it was copied in the filename. You can see its
source code here:
cp -r $argv[1] $argv[1].bak.(date +"%Y%m%d%H%M%S")
CPU Scaling
As I am using a laptop, maximum performance isn’t always what I want.
Sometimes, it’s just better to have not so great but less
battery-demanding performance. It is possible to achieve this by
modifying the CPU governor with cpupower
. The Arch Wiki has, as usual,
some really good documentation on this.
The following script asks the user through rofi
which governor to
apply, and it relies on askpass
to retrieve the user’s password.
governors=("performance" "powersave" "userspace" "ondemand" "conservative" "schedutil")
governor=$(printf "%s\n" "${governors[@]}" | rofi -dmenu)
sudo -A cpupower frequency-set -g "$governor"
Development
Cnew
cnew
is a small utility script similar to but simpler than cppnew that creates
a CMake template C project from the template that already exists in
~/dev/templateC. If no argument was passed, display an error message and exit.
if ! count $argv > /dev/null
echo "Missing argument: PROJECT" && return -1
end
Pass the first argument to a switch statement.
switch "$argv[1]"
If the argument is -h
or --help
, then display the help message and exit the
script normally.
case -h --help
man ~/dev/fishfunctions/cnew.man
exit 0
Else, the argument is the name of the project the user wants to create.
case '*'
set -g project_name $argv[1]
Let’s close the switch statement.
end
Now, let’s copy the template where the user is executing cnew
from, give it
the name of the project and move to the project.
cp -r ~/dev/templateC $argv[1]
cd $argv[1]
The default files have a placeholder for the name of the project. Let’s replace these placeholders with the project’s name.
sed -i "s/PROJECTNAME/$argv[1]/g" CMakeLists.txt
sed -i "s/PROJECTNAME/$argv[1]/g" README.org
sed -i "s/CPROJECTNAME/$argv[1]/g" doc/Doxyfile
Now, let’s create a git repository and initialize it.
git init
git add .
git commit -m "initial commit"
And we’re done!
Dart Language Server
Spacemacs' recommendations on how to use Dart with LSP is outdated, since
dart_language_server
is obsolete. As recommended by the repo owner, we should
launch instead the following code:
/usr/bin/dart $DART_SDK/snapshots/analysis_server.dart.snapshot --lsp
So, instead of using the obsolete executable, instead we will be calling the analysis server as requested.
UpdateFlutter
This is a simple utility to be ran when the flutter
package is updated.
sudo chown -R :flutterusers /opt/flutter
sudo chmod -R g+w /opt/flutter
sudo chmod a+rw /opt/flutter/version
sudo chown $USER:(id -g $USER) /opt/flutter/bin/cache
mu-unread
mu-unread
is a very simple utility that simply returns the amount of
unread emails I have through the use of mu
.
As you can see, the output string contains two font switchers for StumpWM so I can switch from the main font to Siji for the caracter contained between them: U+E072 (an email icon).
UNREAD=$(mu find "flag:unread AND (maildir:/Inbox OR maildir:/Junk)" | wc -l)
printf "^f2^f0%s" "$UNREAD"
Post scrot script
It is possible to call a script on the resulting image of a scrot
command. Not only do I want to move them to a specific directory, I
also want to be able to see them in nsxiv
(a replacement for sxiv
) in
case I want to edit the image, copy it or simply delete it (sometimes
I take screenshots by accident).
mv "$@" ~/Pictures/Screenshots/
nsxiv -abfs f "$HOME/Pictures/Screenshots/$*"
sshbind
Something that I did not know for quite some time but that is actually crazy
useful about SSH is its ability to bind locally the port of a remote machine,
and vice versa. The syntax is actually very simple, but I prefer a more
intuitive way of writing it. Its usage is sshbind PORT FROMHOST TOHOST
.
ssh -L $argv[1]:$argv[3]:$argv[1] $argv[2] -N
Nsxiv key handler
One thing I like with nsxiv
is you can trigger different behaviors
based on keypresses. For instance, with my current nsxiv configuration,
if I press the space key followed by a character, it can delete to the
trashcan, delete definitively, or open the current image in GIMP. All
of that is done through one script file stored in
$HOME/.config/nsxiv/exec/key-handler
. The fact it reacts to first the
spacebar instead of Ctrl-x is because I use a custom version of nsxiv I
first modified to fit the bépo layout, and then I decided to change
the prefix to fit how I use Emacs and StumpWM. You can read the
PKGBUILD and my nsxiv patch in my dotfiles repo.
<<nsxiv-read-files>>
<<nsxiv-switch-statement>>
Here is a step by step explanation of the source code. First, we want
to store in the variable FILES
all the files marked in nsxiv. This is
done with a while
loop and the read
command.
while read file
set -g FILES "$file" $FILES
end
We can then read from the first member of argv
which key the user
pressed. Depending on it, we can chose what to execute.
switch "$argv[1]"
<<nsxiv-trash>>
<<nsxiv-rm>>
<<nsxiv-gimp>>
<<nsxiv-jpeg>>
<<nsxiv-rotate-clockwise>>
<<nsxiv-rotate-counter-clockwise>>
<<nsxiv-yank>>
end
The first option with the letter d
is to move the file to the trash
can. For this, we use the trash
command from trash-cli
.
case "d"
trash $FILES
In case we want to definitively delete a file without using the trash
can, we can use rm
instead when we press the D
key.
case "D"
rm $FILES
It’s not rare I want to modify an image I have open in nsxiv, especially since screenshots are automatically open in this image viewer aften they are taken. In that case, a simple command will do.
case "g"
gimp $FILES
Often, I use nsxiv to convert an image to a jpeg file, because my
internet connection is not that great and jpeg screenshots are faster
to upload than png screenshots. So what I do is for each file
selected, I take the base name of the file (i.e. remove its
extension), and then I use the convert
command from imagemagik
to
convert it from its original format to a jpg format — imagemagik
detects the formats based on the extension.
case "j"
for f in $FILES
set basename (echo "$f" | sed 's/\.[^.]*$//')
convert "$f" "$basename.jpg"
end
I have two commands to rotate my files, and both only differ by the
angle of rotation. Once again I rely on convert
in both cases. To
rotate clockwise, this is the code needed.
case "r"
for f in $FILES
convert -rotate 90 "$f" "$f"
end
On the other hand, to rotate counter-clockwise, we need this code:
case "R"
for f in $FILES
convert -rotate 270 "$f" "$f"
end
Lastly, when I want to copy a file, I just hit the y
key for “yank”
(that’s a term from Emacs). For that, I rely on file
to tell me the
mimetype of the image, then I can pass it to xclip
along with the
filename to copy it to the clipboard. In this case, we only copy the
first of the selected files since the clipboard cannot hold several
files at once.
case "y"
set FILE "$FILES[1]"
set TYPE (file -i "$FILE" | sed -r 's|.*(image/[a-z]+);.*|\1|')
xclip -sel clip -t "$TYPE" -i "$FILE"
Starwars
This is a one-liner that allows you to watch Star Wars episode 4 in ASCII art in your terminal. Here is the code:
telnet towel.blinkenlights.nl
Toggle touchpad tapping
For some reasons, my firmware does not recognize the function key for toggling
the touchpad. I’m not going to really complain about it since it lets me program
it like I want. Since I often don’t need to completely deactivate the touchpad,
I’ll instead toggle whether tapping is enabled or not when pressing
XF86TouchpadToggle
. And for that, I need this small script that will actually
toggle it, and it will be used in my window manager configuration.
First let’s declare some variables to make this script more personal. With my current computer (a Gazelle by System76), the name of my touchpad is the following:
set TPNAME "ELAN0412:00 04F3:3162 Touchpad"
Let’s now get the identifier of the touchpad for xinput
:
set TPID (xinput list | grep $TPNAME | awk '{print $6}' | sed 's|id=\(.*\)|\1|g')
Now, let’s detect the current status of the touchpad:
set TPSTATUS (xinput list-props $TPID | grep "Tapping Enabled" | \
grep -v "Default" | awk '{print $5}')
This will set TPSTATUS
either to 0
, meaning tapping is disabled, or to 1
,
meaning it’s enabled. I will consider any other value as being disabled.
test [[ $TPSTATUS = "1" ]] && set NEWTPSTATUS 0 || set NEWTPSTATUS 1
Finally, let’s update the touchpad’s options:
xinput set-prop $TPNAME "libinput Tapping Enabled" $NEWTPSTATUS
Wacom setup
I made a small and quick utility to set up my Wacom tablet so it is only bound to one screen. This is quite easy, we simply need to find the Wacom stylus’ ID and assign it to the display we want.
ID=$(xinput | grep -oPi "wacom.+stylus.+id=\K([0-9]+)")
SCREEN=$(xrandr -q --current | \
grep -iPo '^([^ ])+(?= connected)' | \
rofi -dmenu -i -p 'Select your display' | \
tr -d '\n')
xinput map-to-output "$ID" "$SCREEN"
Emacs stuff
Dired
emacsclient -c -a emacs -e "(dired \"$*\")"
Emacsmail
This short script is used in my ~/.local/share/applications/mu4e.desktop
file
in order to send to Emacs any mailto:
requests made in my system.
emacsclient -c -n -a emacs -e "(browse-url-mail \"$*\")"
Media
mp42webm
This function allows me to convert easily an mp4 video to the webm format. Nothing too fancy here.
ffmpeg -i $argv[1] -c:v libvpx -crf 10 -b:v 1M -c:a libvorbis $argv[1].webm
youtube-dl wrappers
ytplay
ytplay
is a simple script I’ve written that allows me to play in mpv any
YouTube video at the desired resolution. The script relies on dmenu
(or rofi
in dmenu-mode), youtube-dl
and of course mpv
itself.
set URL (rofi -dmenu -i -p "Video URL")
if test -n "$URL"
set FORMAT \
(youtube-dl --list-formats "$URL" | \
egrep "webm.*[0-9]+x[0-9]+" | \
awk '{print $3 " " $1}' | \
sort -gu | \
rofi -dmenu -i -p "Resolution" | \
string split " ")
set FCODE $FORMAT[2]
mpv --ytdl-format=$FCODE+bestaudio/best "$URL"
end
I’ll even add a .desktop
entry for this script:
[Desktop Entry]
Type=Application
Version=1.0
Name=ytplay (YouTube in mpv)
Comment=Play YouTube videos in mpv
Exec=/home/phundrak/.local/bin/ytplay
Path=/home/phundrak/.local/bin
Terminal=false
Categories=Media
ytdl - a youtube-dl
wrapper
This script is a wrapper around youtube-dl
which I use mainly for archiving
YouTube videos on my NAS (at the time I’m writing this, I have already 2.1TB
worth of videos archived). The principle behind this script is quite simple: I
want to avoid as much as possible to redownload any video already downloaded in
order to avoid pinging too much YouTube’s servers, 429 Too Many Requests errors
are really annoying, and it comes really early when you have only a couple of
new videos to download among the few 14k videos already downloaded.
Be aware this script was written for the Fish shell (3.1.0 and above), and makes use of youtube-dl 2020.03.24 and above, Fish getopts and ripgrep.
Setting default values
Some variables in this script will have default values, we do not want to have a mile-long command each time we wish to download a single video. We’ll also set some global variables that won’t change:
Variable Name | Default Value | String? |
---|---|---|
YTDL_SHARED_DIR |
$HOME/.local/share/ytdl |
no |
FORMAT_DEFAULT |
%(uploader)s/%(upload_date)s ~- ~%(title)s.%(ext)s |
yes |
DOWNFILE_DEFAULT |
$YTDL_SHARED_DIR/downloaded |
no |
ERRFILE_DEFAULT |
$YTDL_SHARED_DIR/video-errors |
no |
LOGFILE_DEFAULT |
$YTDL_SHARED_DIR/ytdl.log |
no |
PREFFERED_FORMAT |
bestvideo[ext=mp4]+bestaudio[ext=m4a]/bestvideo+bestaudio |
yes |
VERSION |
0.3 |
yes |
There is one more default variable pointing to ytdl’s root directory which depends on whether the videos directory has a French or English name:
if test -d "$HOME/Vidéos"
set -g ROOTDIR_DEFAULT "$HOME/Vidéos" # French name
else
set -g ROOTDIR_DEFAULT "$HOME/Videos" # English name
end
set -g YTDL_SHARED_DIR "$HOME/.local/share/ytdl"
set -g FORMAT_DEFAULT "%(uploader)s/%(upload_date)s - %(title)s.%(ext)s"
set -g DOWNFILE_DEFAULT "$YTDL_SHARED_DIR/downloaded"
set -g ERRFILE_DEFAULT "$YTDL_SHARED_DIR/video-errors"
set -g LOGFILE_DEFAULT "$YTDL_SHARED_DIR/ytdl.log"
set -g PREFFERED_FORMAT "bestvideo[ext=mp4]+bestaudio[ext=m4a]/bestvideo+bestaudio"
set -g VERSION "0.3"
<<ytdl-default-vars-make()>>
<<ytdl-default-vars-root>>
We’ll also create the directory pointed at by YTDL_SHARED_DIR
if it doesn’t
exist already:
mkdir -p $YTDL_SHARED_DIR
Help message
The next step is displaying the help message for the script. For that, just a
long string echo’d will do, wrapped in the function _ytdl_help
.
function _ytdl_help
echo "Usage: ytdl [OPTION]... URL [URL]...
-4, --ipv4
Download with forced IPv4
Default: no
-6, --ipv6
Download with forced IPv6
Default: no
-a, --batch-file <file>
File containing URLs to download, one URL per line. Lines starting with
'#', ';' or ']' are considered as comments and ignored.
Default: None
-c, --id-cache <file>
File containing the video IDs that were already downloaded, one ID per
line.
Default: $DOWNFILE_DEFAULT
-d, --directory <dir>
Root directory in which to download videos.
Default: $ROOTDIR_DEFAULT
-e, --error-file <file>
File containing the IDs of videos that failed to download, one ID per
line
Default: $ERRFILE_DEFAULT
-f, --format <format>
Format name for downloaded videos, including path relative to root
directory
Default: $FORMAT_DEFAULT
-l, --logs <file>
File in which to store logs.
Default: $LOGFILE_DEFAULT
-V, --verbose
Show verbose output
Default: no
-v, --version
Show version of ytdl.
-h, --help
Shows this help message"
end
We also have the function _ytdl_version
to display the current version of
ytdl
:
function _ytdl_version
echo "ytdl 0.3, developped for fish 3.1.0 and youtube-dl 2020.03.24 or newer"
echo "requires Fish getopts <https://github.com/jorgebucaran/fish-getopts>"
echo "and ripgrep <https://github.com/BurntSushi/ripgrep>"
end
Arguments Handling
The function _ytdl_parse_ops
is a little bit trickier: we use getopts
to
parse the arguments passed to the script in order to get some preferences from
the user. Here is a quick reference on what options are available and what they
do:
Short | Long | Takes a value? | Associated Variable | Default Value | What it does |
---|---|---|---|---|---|
4 | ipv4 | no | IPV4 |
None | Force IPv4 |
6 | ipv6 | no | IPV6 |
None | Force IPv6 |
a | batch-file | yes | FILE |
None | Batch file |
c | cache | yes | DOWNFILE |
$DOWNFILE_DEFAULT |
Cache file |
d | directory | yes | ROOTDIR |
$ROOTDIR_DEFAULT |
Root directory |
e | error-file | yes | ERRFILE |
$ERRFILE_DEFAULT |
Error logs |
f | format | yes | FORMAT |
$FORMAT_DEFAULT |
Filename format |
l | logs | yes | LOGFILE |
$LOGFILE_DEFAULT |
Logs |
V | verbose | no | VERBOSE |
1 |
Verbose output |
v | version | command | None | None | Script version |
h | help | command | None | None | Display this message |
We can also pass individual YouTube URLs without any options or switches associated to them, they will be downloaded as part of a single queue.
case 4 ipv4
set -g IPV4
case 6 ipv6
set -g IPV6
case a batch-file
set -g FILE $value
case c cache
set -g DOWNFILE $value
case d directory
set -g ROOTDIR $value
case e error-file
set -g ERRFILE $value
case f format
set -g FORMAT $value
case l logs
set -g LOGFILE $value
case V verbose
set -g VERBOSE
case v version
_ytdl_version && exit
case h help
_ytdl_help && exit
The following shows how getopts
is used to catch the options and switches
passed to the script:
getopts $argv | while read -l key value
switch $key
<<ytdl-arg-handling-gen()>>
case _
for v in $value
set -g VIDEOS $VIDEOS $v
end
end
end
(let* ((clean-string (lambda (str) (replace-regexp-in-string "~" "" str)))
(args (seq-filter (lambda (arg)
(let* ((var (unless (string= "None" (nth 3 arg))
(funcall clean-string (nth 3 arg))))
(default (funcall clean-string (format "%s" (nth 4 arg))))
(default (unless (string= "None" default)
default)))
(and var default)))
args)))
(mapconcat (lambda (arg)
(let* ((var (funcall clean-string (nth 3 arg)))
(default (funcall clean-string (format "%s" (nth 4 arg)))))
(format "if set -q $%s\n\tset -g %s %s\nend"
var var default)))
args
"\n"))
if set -q $DOWNFILE
set -g DOWNFILE $DOWNFILE_DEFAULT
end
if set -q $ROOTDIR
set -g ROOTDIR $ROOTDIR_DEFAULT
end
if set -q $ERRFILE
set -g ERRFILE $ERRFILE_DEFAULT
end
if set -q $FORMAT
set -g FORMAT $FORMAT_DEFAULT
end
if set -q $LOGFILE
set -g LOGFILE $LOGFILE_DEFAULT
end
if set -q $VERBOSE
set -g VERBOSE 1
end
Some values need to be set to their default, so let’s assign them their value if no user value was passed:
<<ytdl-arg-set-default-value-gen()>>
set -g FORMAT "$ROOTDIR/$FORMAT"
Both these code blocks are executed in _ytdl_parse_ops
:
function _ytdl_parse_ops
<<ytdl-getopts>>
<<ytdl-arg-set-default-value>>
end
Logging
_ytdl_log
is a very simple function used for logging information for the user
in the file pointed to by LOGFILE
. The first argument the function should
receive is its log level. I generally use either "INFO"
or "ERR"
. The second
argument is the message to log.
function _ytdl_log
set -l INFOLEVEL $argv[1]
set -l MSG $argv[2]
set -l LOG (printf "[%s] %s %s\n" $INFOLEVEL (date +"%F %T") $MSG)
printf "%s\n" $LOG >> $LOGFILE
if test $VERBOSE -eq 1
echo $LOG
end
end
Download a Single Video
In order to download a single video, a simple function has been written for this
that will display when downloaded how far it is down the list of videos to be
downloaded and it will add its ID to the file listing all videos downloaded. The
script will also try to download the video according to the PREFFERED_FORMAT
variable, but if the download fails it will download the default format selected
by youtube-dl
. If both downloads fail, the ID of the video will be added to
the list of failed videos. If one of the downloads succeeds, it will remove the
ID from the list of failed downloads.
The first argument of the function is the video ID from YouTube, the second argument is the position of the video in the queue, and the third argument is the queue length –can be the amount of videos in a whole YouTube channel, the amount of videos in a playlist, or simply the amount of YouTube URLs passed as arguments to the script.
function _ytdl_download_video
set ID $argv[1]
_ytdl_log "INFO" (printf "Downloading video with ID $ID (%4d/%4d)" $argv[2] $argv[3])
if youtube-dl -f $PREFFERED_FORMAT -ciw -o $FORMAT "https://youtube.com/watch?v=$ID"
echo $ID >> $DOWNFILE
else if youtube-dl -ciw -o $FORMAT "https://youtube.com/watch?v=$ID"
echo $ID >> $DOWNFILE
else
_ytdl_log "ERR" "Could not download $VIDEO"
echo $ID >> $ERRFILE
end
end
Note that this function is not meant to be called without any checks before.
It is meant to be called by _ytdl_download_queue
described below.
Download a Queue of Videos
One of the main goals of this tool is to check if a video has already been
downloaded. This is why, as you will see below, we use ripgrep to check if the
ID of the video we want to download is already present in the list of downloaded
videos. If not, it will then be downloaded though _ytdl_download_video
described above.
function _ytdl_download_queue
for i in (seq (count $argv))
rg -- $argv[$i] $DOWNFILE 2&> /dev/null
if test $status -ne 0
_ytdl_download_video $argv[$i] $i (count $argv)
end
end
end
Download Videos From Arguments
The main aim of this function is to transform the URLs contained in the
arguments passed to the script to a list of IDs usable later on by ytdl
.
function _ytdl_download_arg_urls
set -g IDs
for VIDEO in $argv
_ytdl_log "Info" "Getting video ID for $VIDEO"
set -g IDs $IDs (youtube-dl --get-id $VIDEO)
end
_ytdl_download_queue $IDs
end
Download Videos From a Batch File
The final function to declare before the main body of the script is
_ytdl_download_batch
: it will look for each line, ignoring the ones beginning
by #
, ;
and ]
(just like youtube-dl
) and will download them, assuming
these are channel URLs or playlist URLs, however it should also work with direct
video URLs.
What this function does is for each line, it will fetch the entierty of the
video IDs found in a playlist or channel. Then, it will look each ID up the list
of already downloaded videos and will add all new IDs to a queue of videos to be
downloaded. It will then pass each new video ID to _ytdl_download_video
directly. Beware that if you pass directly the URL of the channel, such as
https://www.youtube.com/user/enyay
if you want to download Tom Scott’s videos,
it will download everything on the main page of their channel, which means it
will even download videos from playlists they decided to put on their channel’s
front page, even if it is not theirs. So in that case, we need to append
/videos
to any channel URL.
function _ytdl_download_batch
set -q $FILE
if test $status -eq 1
set -g NEW
set CHANNELS (cat $FILE | grep -vE "#|;|\]")
for c in $CHANNELS
_ytdl_log "INFO" "Getting IDs for channel $c"
if test (egrep '\/c\/|user|channel' (echo $c |psub))
set -g IDS (youtube-dl --get-id "$c/videos")
else
set -g IDS (youtube-dl --get-id $c)
end
_ytdl_log "INFO" "Fetching new videos from channel"
for i in (seq (count $IDS))
printf "\rsearching (%d/%d)" $IDn (count $IDS)
rg -- $IDS[$i] $DOWNFILE 2&> /dev/null
if test $status -ne 0
set -g NEW $IDS[$i] $NEW
end
end
printf "\n"
end
for i in (seq (count $NEW))
_ytdl_download_video $NEW[$i] $i (count $NEW)
end
end
end
Main Body
Now that we have all our functions declared, let’s call them! First, we need to parse our arguments. We’ll then download all files passed as arguments. Finally, we’ll download videos, playlists and channels specified from a batch file.
_ytdl_parse_ops $argv
_ytdl_download_arg_urls $VIDEOS
_ytdl_download_batch
And that’s all! If you’re interested with a very simple interface for
downloading one video once, I wrote a small rofi-ytdl
script that calls the
rofi
utility to specify a single link and download it.
Plock
plock
is a simple script that locks the screen with i3lock
while setting as
the background image of the locked screen a corrupted screenshot of the screen
before it was locked.
set TMPBG /tmp/screen.png
scrot $TMPBG
corrupter -add 0 $TMPBG $TMPBG
i3lock -t -e -f -i $TMPBG
rm $TMPBG
Rofi utilities
askpass
Askpass is a simple script that invokes rofi
as a way to get from a GUI the
user’s sudo password. It is inspired by this original tool, rewritten in fish
and with rofi support instead of dmenu. As you can see, this is a oneliner if we
ignore the initial shebang. This executable is pointed at by the
rofi -dmenu -password -no-fixed-num-lines -p (printf $argv[1] | sed s/://)
awiki
awiki
is a simple script used with rofi
that relies on the arch-wiki-docs
package in order to provide the user a way to quickly find and display any
English page from the Arch Wiki in a browser. The advantage of using this over
the wiki-search
utility from the arch-wiki-lite
package is you get instant
suggestion in rofi using fuzzy-search. The downside is rofi will only help you
find pages by their title, and it will not help you find keywords in the content
of said pages.
The first step is to create the list of all the pages that are currently stored
on disk. arch-wiki-docs
stores them in /usr/share/doc/arch-wiki/html/en
. A
simple ls
piped in three sed
will give us a list of page titles. We then
pipe that into rofi in dmenu mode in order to choose the page we want to
display. By the way, setting the location of the HTML files will come in handy
later.
set WLOCATION /usr/share/doc/arch-wiki/html/en/
set WPAGE (/bin/ls $WLOCATION | \
sed -e 's/_/ /g' -e 's/\.html$//' -e 's|.*/\(.*\)|\1|' | \
rofi -dmenu -p "Arch Wiki" -i)
set WPAGE (echo $WPAGE | sed -r 's/\s+/_/g')
Now, all I need to do is to send this list into rofi and tell it to open the
result with our favorite browser with xdg-open
.
xdg-open $WLOCATION$WPAGE.html
Emoji picker
The emoji picker is a simple fish script that uses rofi and ~/.config/emoji.txt
to provide a small, local search for emojis. Once the emoji is selected, it is
copied to the clipboard using xclipboard
.
grep -v "#" ~/.config/emoji.txt | rofi -dmenu -p "Select emoji" -i | \
awk '{print $1}' | tr -d '\n' | xclip -selection clipboard
Also, let’s send a notification telling the user the emoji has been copied!
EMOJI=$(xclip -o -selection clipboard | tr -d '\n')
test -z "$EMOJI" && notify-send "No emoji copied" -u low && exit
EMOJI="$EMOJI copied to clipboard"
notify-send -u low "$EMOJI"
It is inspired from this video from Luke Smith, rewritten in Fish.
Partition mounting and unmounting
Rofi-mount
rofimount
is a script inspired by this one, based on dmenu, which
interactively asks the user what to mount, and where to mount it. What I did was
replace dmenu with rofi, and fix a couple of bugs I encountered in the original
script.
Get the mountable elements
begin
What the script does first is detect everything that can be mounted. Between a
begin
and end
, let’s set LFS
as a local variable. This si in order to get
sane variables in the current block.
set -l LFS
Now, let’s detect the amount of mountable Android filesystems, and if any are detected, let’s read them into a global variable.
set -l a (math (jmtpfs -l | wc -l) - 2)
test $a -ge 0 && jmtpfs -l 2> /dev/null | tail -n $a | read -zg anddrives
We’ll do the same for external and internal drives and partitions that can be mounted here.
lsblk -rpo "name,type,size,mountpoint" | \
awk '$2=="part"&&$4==""{printf "%s (%s)\n",$1,$3}' | \
read -zg usbdrives
Finally, we look for any CD drive that could be mounted on our device.
blkid /dev/sr0 | awk '{print $1}' | sed 's/://' | read -z cddrives
And that’s the end of our first block!
end
Alright, we’ll save what kind on drives we can mount in a temporary file called
/tmp/drives
. We’ll make sure it’s blank by erasing it then creating it again
with touch
, like so. The -f
flag on rm
is here so we get no error if we
try to delete a file that doesn’t exist (yet).
set -g TMPDRIVES /tmp/drives
rm -f $TMPDRIVES
touch $TMPDRIVES
Now, let’s write what type of drives we can mount in this temporary file.
test -n "$usbdrives" && echo "USB" >> $TMPDRIVES
test -n "$cddrives" && echo "CD" >> $TMPDRIVES
test -n "$anddrives" && echo "Android" >> $TMPDRIVES
Now, we want to declare where to look for mount directories. For now, we’ll only
look in /media
, but you can add more if you wish.
set -g basemount /media
Get the mount point
Now, let’s declare a function that will allow us to chose the drive we want to mount.
function getmount
First, we want to get our mount point. We’ll run a find
command on each of the
directories listed in $basemount
to look for folders on which our drive could
be mounted. This list will be passed to rofi from which we will chose our mount
point.
set -g mp (for d in $basemount
find $d -maxdepth 5 -type d
end | rofi -dmenu -i -p 'Type in mount point.')
We should verify that something has been actually selected, otherwise we should abort the script.
if test -z $mp || test $mp = ""
return 1
end
Now, if the selected mount point does not exist, we’ll ask the user whether the directory should be created. If no, the script will abort. If yes, an attempt will be made at creating the directory as the user; if that fails, a new attempt will be made as sudo.
if test ! -d $mp
switch (printf "No\\nYes" | rofi -dmenu -i -p "$mp does not exist. Create it?")
case 'Yes'
mkdir -p $mp || sudo -A mkdir -p $mp
case '*'
return 1
end
end
Finally, let’s close the function
end
Mount a USB drive, hard drive or partition
Alright, we want to mount a partition that answers by the name of /dev/sdXX
,
how do we do that? Let’s create first the function mountusb
that will take
care of it for us.
function mountusb
Now, the first thing we want to do is select the partition we want to mount.
Remember, we stored those in $usbdrives
earlier, so let’s pipe them into rofi
so we can chose from it. Also, awk
will get their path in /dev
.
set -g chosen (echo $usbdrives | \
rofi -dmenu -i -p "Mount which drive?" | \
awk '{print $1}')
As usual after a user selection, let’s verify something has actually been selected. If not, let’s abort the script.
test -z $chosen && return 1
Now, let’s select the mount point of our partition. We’ll call the function
getmount
described in Get the mount point to select it.
getmount
Let’s verify the variable mp
set in getmount
is not empty, otherwise abort
the script.
test -z $mp && return 1
Now, let’s mount it! We’ll use a switch which will detect the filesystem used so we know how to mount the partition.
switch (lsblk -no "fstype" $chosen)
We have two named case: vfat
filesystems.
case "vfat"
sudo -A mount -t vfat $chosen $mp -o rw,umask=0000
And ntfs
filesystems.
case "ntfs"
sudo -A mount -t ntfs $chosen $mp -o rw,umask=0000
Else, we’ll let mount
determine which filesystem is used by the partition
(generally ext4
).
case '*'
sudo -A mount $chosen $mp
We’ll also run a chown
on this newly mounted filesystem so the user can access
it without any issues.
sudo -A chown -R $USER:(id -g $USER) $mp
Let’s close the switch block and send a notification the partition has been mounted.
end && notify-send -a "dmount" "💻 USB mounting" "$chosen mounted to $mp."
And let’s close the function.
end
Mount an Android device
The function that manages to mount Android filesystems is mountandroid
. Let’s
declare it.
function mountandroid -d "Mount an Android device"
We’ll select which Android we want to mount. We will be asked through rofi.
set chosen (echo $anddrives | rofi -dmenu -i -p "Which Android device?" | awk '{print $1 $2}' | sed 's/,$//')
Now, we need to get the bus of the Android device we want to mount. It will be useful later, after we authorized mounting from our device, to get the path to our partition.
set bus (echo $chosen | sed 's/,.*//')
Let’s temporarily mount our device.
jmtpfs -device=$chosen $mp
Now, we need to allow our computer to mount our Android device. Depending on the Android version it is running on, we either need to specify our device is USB connected in order to exchange files, or Android will explicitely ask us if it is OK for our computer to access it. Let’s inform the user of that.
echo "OK" | \
rofi -dmenu -i -p "Press (Allow) on your phone screen, or set your USB settings to allow file transfert"
Now, let’s get the actual path of our Android filesystem we wish to mount, and let’s unmount the previous temporary filesystem.
set newchosen (jmtpfs -l | grep $bus | awk '{print $1 $2}' | sed 's/,$//')
sudo -A umount $mp
Now we cam mount the new filesystem and send a notification if everything went well.
jmtpfs -device=$newchosen $mp && \
notify-send -a "dmount" "🤖 Android Mounting" "Android device mounted to $mp."
And now, we can close our function.
end
Mount a CD drive
This part is way easier than the previous functions. As we will see, the
function mountcd
's body is only three lines long. First, let’s declare the
function.
function mountcd
Now, let’s chose the CD drive we want to mount using rofi
.
set chosen (echo $cddrives | rofi -dmenu -i -p "Which CD drive?")
We’ll also get the mountpoint thanks to the getmount
function described
earlier.
getmount
And finally, let’s mount it and send the notification everything went well.
sudo -A mount $chosen $mp && \
notify-send -a "dmount" "💿 CD mounting" "$chosen mounted."
Finally, let’s close our function.
end
Ask what type of drive we want to mount
The first thing we will be asked if different types of drives are detected is
which of these types the user wishes to mount. This is done with the function
asktype
which is declared below.
function asktype
We will use a switch statement which will use our anwser to rofi about what we wish to mount.
switch (cat $TMPDRIVES | rofi -dmenu -i -p "Mount which drive?")
If we chose the option "USB", we’ll mount a hard drive, partition or USB drive.
In which case we’ll call the mountusb
function.
case "USB"
mountusb
If we chose the "Android" option, the mountandroid
function is called.
case "Android"
mountandroid
Else if we chose the "CD" option, we’ll call the mountcd
function.
case "CD"
mountcd
If nothing is selected, the function will naturally exit. Now, let’s close our switch statement and our function.
end
end
Launch the mounting functions
Now that we have declared our functions and set our variables, we’ll read the temporary file described in Get the mountable elements. The amount of lines is passed in a switch statement.
switch (wc -l < $TMPDRIVES)
If the file has no lines, i.e. it is empty, we have no mountable media. Let’s inform our user this is the case.
case 0
notify-send "No USB drive or Android device or CD detected" -a "dmount"
If we only have one line, we have only one type of mountable media. We’ll pass this line to a second switch statement.
case 1
switch (cat $TMPDRIVES)
This will allow the script to automatically detect what type of media it is, and mount the corresponding function.
case "USB"
mountusb
case "Android"
mountandroid
case "CD"
mountCD
Let’s close this nested switch case.
end
If we have more than one line, we’ll have to ask the user what type of media they want to mount.
case '*'
asktype
Now, let’s end our switch statement!
end
Finally, we’ll delete our temporary file.
rm -f $TMPDRIVES
And with that, this is the end of our script!
Rofi-umount
rofiumount
is the counterpart of rofimount
for unmounting our mounted
partitions.
Get the unmountable drives
First, we will need to list all the drives that can be safely unmounted. Let’s run this.
set -g drives (lsblk -nrpo "name,type,size,mountpoint" | \
awk '$2=="part"&&$4!~/\/boot|\/home$|SWAP/&&length($4)>1{printf "%s (%s)\n",$4,$3}')
Now, let’s get the android devices that are mounted.
set -g androids (awk '/jmtpfs/ {print $2}' /etc/mtab)
And let’s get the CD drives that are mounted.
set -g cds (awk '/sr0/ {print $2}' /etc/mtab)
We’ll store all of our information in a temporary file, /tmp/undrives
.
set -g undrivefile /tmp/undrives
Let’s make sure we begin with a clean, empty file.
rm -f $undrivefile
touch $undrivefile
Depending on if the related variables are set, write the different types of mounted drives in the temporary file.
test -n "$drives" && echo "USB" >> $undrivefile
test -n "$cds" && echo "CD" >> $undrivefile
test -n "$androids" && echo "Android" >> $undrivefile
Unmount disk partitions
The function unmountusb
will take care of unmounting any drive we can safely
unmount. First, let’s declare the function.
function unmountusb
Let’s chose the drive to unmount with rofi.
set chosen (echo $drives | \
rofi -dmenu -i -p "Unmount which drive?" | \
awk '{print $1}')
Let’s verify if the user actually selected any drive. If no, let’s abort the script.
test -z "$chosen" && exit 0
Now, let’s unmount the chosen drive and send a notification if it has been done.
sudo -A umount $chosen && \
notify-send "💻 USB unmounting" "$chosen unmounted." -a "dumount"
Now, let’s close the function.
end
Unmount Android device
The function unmountandroid
will take care of unmounting any mounted Android
device. First, let’s declare our function.
function unmountandroid
Let the user choose which Android device to unmount.
set chosen (echo $androids | rofi -dmenu -i -p "Unmount which device?")
We’ll verify the user chose any device.
test -z "$chosen" && exit 0
If a device has been chosen, let’s unmount it and send a notification it has been successfuly unmounted.
sudo -A umount -l $chosen && \
notify-send "🤖 Android unmounting" "$chosen unmounted." -a "dumount"
Finally, let’s close the function.
end
Unmount CD drive
unmountcd
will take care of unmounting any mounted CD drive. Let’s declare
this function.
function unmountcd
As before, let the user chose which CD drive to unmount.
set chosen (echo "$cds" | rofi -dmenu -i -p "Unmount which CD?")
We’ll verify the user chose any device.
test -z "$chosen" && exit 0
If a drive has been chosen, let’s unmount it and send a notification it has been successfuly unmounted.
sudo -A umount -l $chosen && \
notify-send "💿 CD unmounting" "$chosen unmounted." -a "dumount"
Now, let’s close the function.
end
Ask what type of drive to unmount
If several types of unmountable drives are available, let’s ask the user which type to unmount based on the content of the temporary file declared in Get the unmountable drives. First, let’s declare the function.
function asktype
Let’s create a switch statement to which will be passed the selection of the user from rofi.
switch (cat $undrivefile | rofi -dmenu -i -p "Unmount which type of device?")
Three types of values can be returned: "USB", "CD", or "Android". These values will be used to launch their corresponding function.
case 'USB'
unmountusb
case 'CD'
unmountcd
case 'Android'
unmountandroid
Let’s close the switch statement.
end
Let’s now close the function.
end
Launch the unmounting functions
Now back to the body of our script, let’s input in a switch case the number of lines contained in our temporary file.
switch (wc -l < $undrivefile)
If the file containes no lines. i.e. it is empty, nothing is to be unmounted. Let’s inform the user of that.
case 0
notify-send "No USB drive or Android device or CD to unmount" -a "dumount"
Else, if there is only one type of drive, we’ll automatically let our script choose based on the content of this sole line.
case 1
switch (cat $undrivefile)
case 'USB'
unmountusb
case 'CD'
unmountcd
case 'Android'
unmountandroid
end
And if there are more types than one, let’s ask the user.
case '*'
asktype
Let’s close our main switch statement.
end
And finally, let’s delete our temporary file.
rm -f $undrivefile
Rofi-pass
rofi-pass
is a simple utility that gets a password stored in the pass
password manager with rofi as its interface, and then stores the password in the
clipboard.
Let’s parse all the arguments passed to the script. If one of them is --type
,
-t
or type
, the script will attempt to type the password to the text area
already selected without pasting the password to the clipboard.
for arg in $argv
switch $arg
case '--type' '-t' 'type'
set -g TYPE "yes"
case '*'
printf 'Unknown argument: %s\n.' $arg
exit 1
end
end
Now, let’s get the list of the passwords that exist in our pass
repository.
set passwords (find $HOME/.password-store -type f -name "*.gpg" | \
string replace -r ".*.password-store/" "" | \
string replace -r ".gpg" "" | sort)
Let the user choose which password they wish to select.
set password (for elem in $passwords
echo $elem
end | rofi -dmenu -i -p "Select your password")
Let’s verify we actually selected a password and not just exited. If no password was selected, let’s simply exit the script.
if test -z $password
exit
end
Depending on the arguments passed earlier, we might want some different behavior.
if test $TYPE = "yes"
<<rofi-pass-type>>
else
<<rofi-pass-copy>>
end
The default behavior is to copy the password to the clipboard for 45 seconds, so let’s do that.
pass show -c $password 2> /dev/null
Else, if we passed --type
, -t
or type
as an argument of the script, we
want it to attempt to type our password in the currently selected text input.
Let’s do that.
set -l IFS
<<rofi-pass-type-get-password>>
printf %s $pass | xvkbd -file -
To correctly get the password from pass
, we need to parse the output and only
get the first line, hence the following command.
set pass (pass show $password | string split -n \n)[1]
rofi-ytdl
This is just a simple wrapper around ytdl so I can easily download a video from
rofi, which we’ll use first to retrieve the URL of the video we want to
download, be it from YouTube or other website supported by youtube-dl
.
URL=$(echo "Video to download:" | rofi -dmenu -i -p "Video to download:")
Now, if the variable URL
is not empty (i.e. the user specified a link and did
not abort the operation), we’ll proceed to teh download. Before it begins, we’ll
send a notification saying the download is about to begin. When the ytdl
process ends, we’ll also send a notification notifying the user on the success
or failure of the download.
if [ -n "$URL" ]; then
notify-send -u normal "YTDL" "Starting downloading\n$URL"
if [[ $(ytdl "$URL") ]]
then
notify-send -u normal "YTDL" "Finished downloading!"
else
notify-send -u critical "YTDL" "Failed downloading\n$URL"
fi
fi
Wallpaper utilities
pape-update
This little tool sets a random wallpaper using xwallpaper.
PAPESDIR=$HOME/Pictures/Wallpapers
PAPE=$(find "$PAPESDIR" -type f | sort -R | tail -1)
set-pape "$PAPE"
Select wallpaper
This script is based on what nsxiv
can do as an image viewer as well as
xwallpaper.
PAPE=$(nsxiv -orbft ~/Pictures/Wallpapers/*)
set-pape "$PAPE"
Set a wallpaper
This utility is not meant to be called by the user directly, but rather by
scripts that may be written by the user. Its role is simple: check if the
provided wallpaper exists and if it is an image. If both requirements are met,
the path to this image is then stored in $XDG_CACHE_HOME/wallpaper
, or if this
variable is empty in $HOME/.cache/wallpaper
.
CACHEFILE=$([ -n "$XDG_CACHE_HOME" ] && echo "$XDG_CACHE_HOME/wallpaper" || echo "$HOME/.cache/wallpaper")
[[ -f $1 ]] && \
grep image <(file -b --mime-type "$1") && \
echo "$1" > "$CACHEFILE" \
&& xwallpaper --zoom "$1"
Wayland
Wayland Environment Variables Setup
#export GDK_BACKEND=wayland # May cause problems with some xorg applications
export TDESKTOP_DISABLE_GTK_INTEGRATION=1
export CLUTTER_BACKEND=wayland
export BEMENU_BACKEND=wayland
# Firefox
export MOZ_ENABLE_WAYLAND=1
#
# Qt environment
#
export QT_QPA_PLATFORM=wayland-egl #error with apps xcb
export QT_WAYLAND_FORCE_DPI=physical
export QT_WAYLAND_DISABLE_WINDOWDECORATION=1
#
# Elementary environment
#
export ELM_DISPLAY=wl
export ECORE_EVAS_ENGINE=wayland_egl
export ELM_ENGINE=wayland_egl
export ELM_ACCEL=opengl
# export ELM_SCALE=1
#
# SDL environment
#
export SDL_VIDEODRIVER=wayland
#
# Java environment
#
export _JAVA_AWT_WM_NONREPARENTING=1
export NO_AT_BRIDGE=1
export WINIT_UNIX_BACKEND=wayland
export DBUS_SESSION_BUS_ADDRESS
export DBUS_SESSION_BUS_PID
Qtile
export SDL_VIDEODRIVER=wayland
export XDG_SESSION_TYPE=wayland
export XDG_SESSION_DESKTOP=wlroots
export XDG_CURRENT_TYPE=wlroots
export XDG_CURRENT_DESKTOP=wlroots
. /etc/X11/xinit/xinitrc.d/50-systemd-user.sh
. way-env-setup
systemctl --user import-environment DISPLAY WAYLAND_DISPLAY XDG_CURRENT_DESKTOP
exec qtile start -b wayland
Newm
export SDL_VIDEODRIVER=wayland
export XDG_SESSION_TYPE=wayland
export XDG_SESSION_DESKTOP=wlroots
export XDG_CURRENT_TYPE=wlroots
export XDG_CURRENT_DESKTOP=wlroots
. /etc/X11/xinit/xinitrc.d/50-systemd-user.sh
. way-env-setup
systemctl --user import-environment DISPLAY WAYLAND_DISPLAY XDG_CURRENT_DESKTOP
exec start-newm
Weather
A quick and useful script I often use is a curl
request to v2.wttr.in to get a
weather forecast in the terminal. By default, I want the request to be about the
city I live in, but it is also possible for the script to accept as its
arguments a search inquiry.
if count $argv > /dev/null
set -l SEARCH (string join '+' $argv)
curl http://v2.wttr.in/~$SEARCH
else
curl http://v2.wttr.in/Aubervilliers
end