1945 lines
64 KiB
Org Mode
1945 lines
64 KiB
Org Mode
#+TITLE: Executable scripts
|
||
#+setupfile: headers
|
||
#+OPTIONS: auto-id:t
|
||
#+HTML_HEAD_EXTRA: <meta name="description" content="Phundrak’s custom scripts" />
|
||
#+HTML_HEAD_EXTRA: <meta property="og:title" content="Phundrak’s custom scripts" />
|
||
#+HTML_HEAD_EXTRA: <meta property="og:description" content="Source code of Phundrak’s custom scripts" />
|
||
#+PROPERTY: header-args :exports code
|
||
#+PROPERTY: header-args:emacs-lisp :exports none :tangle no
|
||
|
||
* Presentation
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Presentation-721f3cc4
|
||
:END:
|
||
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
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/autostart
|
||
:CUSTOM_ID: Autostart-a99e99e7
|
||
:END:
|
||
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.
|
||
~set-screens~ is a custom script declared [[*set-screens][below]].
|
||
#+NAME: autostart-table
|
||
| Command | Arguments | Run once? |
|
||
|-------------+-------------------------------------+-----------|
|
||
| ~mpc~ | ~stop~ | no |
|
||
| ~picom~ | | yes |
|
||
| ~set-screens~ | | no |
|
||
| ~numlockx~ | ~on~ | yes |
|
||
| ~pumopm~ | | yes |
|
||
| ~xfce-polkit~ | | yes |
|
||
| ~nm-applet~ | | yes |
|
||
| ~xwallpaper~ | ~--zoom (cat $HOME/.cache/wallpaper)~ | no |
|
||
| ~xss-lock~ | ~plock~ | yes |
|
||
| ~xrdb~ | ~-merge $HOME/.Xresources~ | no |
|
||
|
||
#+NAME: autostart-gen
|
||
#+BEGIN_SRC emacs-lisp :var table=autostart-table :cache yes
|
||
(mapconcat (lambda (start-command)
|
||
(let* ((command (s-replace "~" "" (nth 0 start-command)))
|
||
(arguments (s-replace "~" "" (nth 1 start-command)))
|
||
(once? (string= "yes" (nth 2 start-command))))
|
||
(if once?
|
||
(format "pgrep -x %s 2&>/dev/null || echo (%s) 2&>/dev/null"
|
||
command
|
||
(s-collapse-whitespace (format "%s %s & && disown"
|
||
command
|
||
arguments)))
|
||
(format "%s %s &" command arguments))))
|
||
table
|
||
"\n")
|
||
#+END_SRC
|
||
|
||
#+RESULTS[6bdde37274cbbcce2fcd7e86690ce9ce7f32c62f]: autostart-gen
|
||
: xrdb -merge $HOME/.Xresources &
|
||
: mpc stop &
|
||
: set-screens &
|
||
: pgrep -x picom 2&>/dev/null || echo (picom & && disown) 2&>/dev/null
|
||
: pgrep -x pumopm 2&>/dev/null || echo (pumopm & && disown) 2&>/dev/null
|
||
: pgrep -x xfce-polkit 2&>/dev/null || echo (xfce-polkit & && disown) 2&>/dev/null
|
||
: pgrep -x nm-applet 2&>/dev/null || echo (nm-applet & && disown) 2&>/dev/null
|
||
: pgrep -x numlockx 2&>/dev/null || echo (numlockx on & && disown) 2&>/dev/null
|
||
: xwallpaper --zoom (cat $HOME/.cache/wallpaper) &
|
||
|
||
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:
|
||
#+NAME: default-soundcard
|
||
#+BEGIN_SRC fish :tangle no
|
||
set SOUNDCARD "alsa_output.usb-Focusrite_Scarlett_2i2_USB_Y8KJ6NH094EF1C-00.analog-stereo"
|
||
pactl list short sinks | grep $SOUNDCARD 2&> /dev/null && pactl set-default-sink $SOUNDCARD
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC fish :noweb yes
|
||
set -l PATH $PATH /usr/lib/xfce-polkit
|
||
<<autostart-gen()>>
|
||
<<default-soundcard>>
|
||
#+END_SRC
|
||
|
||
* Screen utilities
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Screen-utilities-f237c566
|
||
:END:
|
||
** set-screens
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/set-screens
|
||
:CUSTOM_ID: set-screens-01bd989a
|
||
:END:
|
||
~set-screens~ is a small script that allows the user to automatically set up an
|
||
external monitor. First, let’s set some variables so we don’t have to type in
|
||
hidden places some values that should be easily modifiable.
|
||
#+BEGIN_SRC fish
|
||
set internal "eDP1"
|
||
set external "HDMI1"
|
||
#+END_SRC
|
||
|
||
Now, let’s set the ~DETECTEDSCREEN~ variable with a simple ~grep~. If the
|
||
variable turns out to be empty, this means the display was not detected.
|
||
However, if it’s not, then it will be an array with its second value that holds
|
||
the maximum resolution the display can handle. It needs to be passed through
|
||
~awk~ in order to get only the resolution itself and not the refresh rate, but
|
||
once we’ve got that, we can set our external monitor as the main monitor with
|
||
its maximum resolution. i3 is also restarted in order to properly display the
|
||
wallpaper and Polybar on the new screen.
|
||
#+BEGIN_SRC fish
|
||
set externaldisplay (xrandr -q --current | grep -A 1 -i "$external connected")
|
||
if test -n "$externaldisplay"
|
||
set resolution (echo $externaldisplay[2] | awk '{$1=$1;print $1}')
|
||
xrandr --output "$external" --primary --auto --mode "$resolution" --right-of "$internal"
|
||
end
|
||
#+END_SRC
|
||
|
||
* cli utilities
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: cli-utilities-ec2120b0
|
||
:END:
|
||
** Backup
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/backup
|
||
:CUSTOM_ID: Backup-68c7c63e
|
||
:END:
|
||
~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:
|
||
#+BEGIN_SRC fish
|
||
cp -r $argv[1] $argv[1].bak.(date +"%Y%m%d%H%M%S")
|
||
#+END_SRC
|
||
|
||
** Development
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: cli-utilities-Development-baec808a
|
||
:END:
|
||
*** Cppnew :noexport:
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :tangle no
|
||
:CUSTOM_ID: Cppnew-964e697b
|
||
:END:
|
||
=cppnew= is a small utility that helps you create a new C++ project. Several
|
||
templates are available, the default one using CMake, and three others that are
|
||
a bit more advances, based on:
|
||
- CMake + [[https://conan.io/][Conan]]
|
||
- [[https://mesonbuild.com/][Meson]] + [[https://ninja-build.org/][Ninja]]
|
||
- Meson + Ninja + Conan
|
||
There is also a default [[http://doxygen.nl/][Doxygen]] file included for your documentation, ready to
|
||
go. I even made it so that you can execute it as an executable file, like
|
||
=./doc/Doxyfile= from the project root.
|
||
|
||
The choice is given to the user which of them to use with options that will be
|
||
given to =cppnew=.
|
||
|
||
First of all, if no arguments were passed, return an error.
|
||
#+begin_src fish
|
||
if ! count $argv >/dev/null
|
||
echo "Missing argument: PROJECT" && return -1
|
||
end
|
||
#+end_src
|
||
|
||
Now, let’s set a couple of variables which will prove useful later on when
|
||
trying to set up our project.
|
||
|
||
*** Cnew
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/cnew
|
||
:CUSTOM_ID: Cnew-d9ec9cc4
|
||
:END:
|
||
=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
|
||
[[file:~/dev/templateC][~/dev/templateC]]. If no argument was passed, display an error message and exit.
|
||
#+BEGIN_SRC fish
|
||
if ! count $argv > /dev/null
|
||
echo "Missing argument: PROJECT" && return -1
|
||
end
|
||
#+END_SRC
|
||
|
||
Pass the first argument to a switch statement.
|
||
#+BEGIN_SRC fish
|
||
switch "$argv[1]"
|
||
#+END_SRC
|
||
|
||
If the argument is =-h= or =--help=, then display the help message and exit the
|
||
script normally.
|
||
#+BEGIN_SRC fish
|
||
case -h --help
|
||
man ~/dev/fishfunctions/cnew.man
|
||
exit 0
|
||
#+END_SRC
|
||
|
||
Else, the argument is the name of the project the user wants to create.
|
||
#+BEGIN_SRC fish
|
||
case '*'
|
||
set -g project_name $argv[1]
|
||
#+END_SRC
|
||
|
||
Let’s close the switch statement.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
cp -r ~/dev/templateC $argv[1]
|
||
cd $argv[1]
|
||
#+END_SRC
|
||
|
||
The default files have a placeholder for the name of the project. Let’s replace
|
||
these placeholders with the project’s name.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
Now, let’s create a git repository and initialize it.
|
||
#+BEGIN_SRC fish
|
||
git init
|
||
git add .
|
||
git commit -m "initial commit"
|
||
#+END_SRC
|
||
|
||
And we’re done!
|
||
|
||
*** Dart Language Server
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/dart_language_server
|
||
:CUSTOM_ID: Dart_Language_Server-18c256b1
|
||
:END:
|
||
Spacemacs' recommendations on how to use Dart with LSP is outdated, since
|
||
[[https://github.com/natebosch/dart_language_server][=dart_language_server=]] is obsolete. As recommended by the repo owner, we should
|
||
launch instead the following code:
|
||
#+BEGIN_SRC fish
|
||
/usr/bin/dart $DART_SDK/snapshots/analysis_server.dart.snapshot --lsp
|
||
#+END_SRC
|
||
|
||
So, instead of using the obsolete executable, instead we will be calling the
|
||
analysis server as requested.
|
||
|
||
*** UpdateFlutter
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/UpdateFlutter
|
||
:CUSTOM_ID: UpdateFlutter-1e8fbeb7
|
||
:END:
|
||
This is a simple utility to be ran when the ~flutter~ package is updated.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
** Pinfo :noexport:
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :tangle no
|
||
:CUSTOM_ID: Pinfo-f3644596
|
||
:END:
|
||
~pinfo~ is a utility that shows system information
|
||
|
||
** sshbind
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/sshbind
|
||
:CUSTOM_ID: sshbind-756fabb1
|
||
:END:
|
||
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~.
|
||
#+BEGIN_SRC fish
|
||
ssh -L $argv[1]:$argv[3]:$argv[1] $argv[2] -N
|
||
#+END_SRC
|
||
|
||
** Starwars
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/starwars
|
||
:CUSTOM_ID: Starwars-654f8637
|
||
:END:
|
||
This is a one-liner that allows you to watch Star Wars episode 4 in ASCII art in
|
||
your terminal. Here is the code:
|
||
#+BEGIN_SRC fish
|
||
telnet towel.blinkenlights.nl
|
||
#+END_SRC
|
||
|
||
** Toggle touchpad tapping
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/tttapping
|
||
:CUSTOM_ID: Toggle_touchpad_tapping-23348b00
|
||
:END:
|
||
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:
|
||
#+BEGIN_SRC fish
|
||
set TPNAME "ELAN0412:00 04F3:3162 Touchpad"
|
||
#+END_SRC
|
||
|
||
Let’s now get the identifier of the touchpad for ~xinput~:
|
||
#+BEGIN_SRC fish
|
||
set TPID (xinput list | grep $TPNAME | awk '{print $6}' | sed 's|id=\(.*\)|\1|g')
|
||
#+END_SRC
|
||
|
||
Now, let’s detect the current status of the touchpad:
|
||
#+BEGIN_SRC fish
|
||
set TPSTATUS (xinput list-props $TPID | grep "Tapping Enabled" | \
|
||
grep -v "Default" | awk '{print $5}')
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
test [[ $TPSTATUS = "1" ]] && set NEWTPSTATUS 0 || set NEWTPSTATUS 1
|
||
#+END_SRC
|
||
|
||
Finally, let’s update the touchpad’s options:
|
||
#+BEGIN_SRC fish
|
||
xinput set-prop $TPNAME "libinput Tapping Enabled" $NEWTPSTATUS
|
||
#+END_SRC
|
||
|
||
** Wacom setup
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/wacom-setup
|
||
:CUSTOM_ID: Wacom_setup-331fb024
|
||
:END:
|
||
I made a small and quick utility to set up my Wacom tablet so it is only bound
|
||
to one screen.
|
||
|
||
*** Set our variables
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Wacom_setup-Set_our_variables-3cb6d58e
|
||
:END:
|
||
We need some variables in order to correctly set our tablet. First, let’s get
|
||
declare what the name of our tablet is, and what the name of its touchpad is.
|
||
#+BEGIN_SRC fish
|
||
set -g DEVICE "Wacom USB Bamboo PAD Pen stylus"
|
||
#+END_SRC
|
||
|
||
To get the correct values for the area it can cover, we’ll need to reset our
|
||
tablet.
|
||
#+BEGIN_SRC fish
|
||
xsetwacom set "$DEVICE" ResetArea
|
||
#+END_SRC
|
||
|
||
Now we can get the X and Y areas.
|
||
#+BEGIN_SRC fish
|
||
set -g AREATOT (xsetwacom get "$DEVICE" Area)
|
||
set -g AREAX (echo $AREATOT | awk '{print $3}')
|
||
set -g AREAY (echo $AREATOT | awk '{print $4}')
|
||
#+END_SRC
|
||
|
||
*** Select our screen
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Wacom_setup-Select_our_screen-7822c0c3
|
||
:END:
|
||
This function will allow us to select the screen on which the tablet will be
|
||
active. We can also select the option “desktop” so that all screens are
|
||
selected. Let’s declare our function.
|
||
#+BEGIN_SRC fish :noweb yes
|
||
function set_screen
|
||
<<wacom-screen-get-displays>>
|
||
<<wacom-screens-select-screen>>
|
||
<<wacom-screen-get-position>>
|
||
<<wacom-screen-get-dimensions>>
|
||
end
|
||
#+END_SRC
|
||
|
||
First, let’s set what screens are available, including the desktop option.
|
||
#+NAME: wacom-screen-get-displays
|
||
#+BEGIN_SRC fish :tangle no
|
||
set CONNECTED_DISPLAYS (xrandr -q --current | \
|
||
sed -n 's/^\([^ ]\+\) connected .*/\1/p') desktop
|
||
#+END_SRC
|
||
|
||
Now, let’s select the one we wish to use using rofi.
|
||
#+NAME: wacom-screens-select-screen
|
||
#+BEGIN_SRC fish :tangle no
|
||
set -g SCREEN (for d in $CONNECTED_DISPLAYS
|
||
echo $d
|
||
end | rofi -dmenu -i -p "Select your dispaly" | tr -d '\n')
|
||
#+END_SRC
|
||
|
||
We can now get the position of our screen.
|
||
#+NAME: wacom-screen-get-position
|
||
#+BEGIN_SRC fish :tangle no
|
||
set -g POSITION (xrandr -q --current | sed -nr "s/^$SCREEN connected (primary )*([0-9x\+]+).*/\2/p")
|
||
#+END_SRC
|
||
|
||
We’ll also get the width and height of the screen so we can set correctly the
|
||
drawing area of the tablet.
|
||
#+NAME: wacom-screen-get-dimensions
|
||
#+BEGIN_SRC fish :tangle no
|
||
set -g HEIGHT (echo $POSITION | sed -nr 's/[0-9]+x([0-9]+).*/\1/p')
|
||
set -g WIDTH (echo $POSITION | sed -nr 's/([0-9]+)x.*/\1/p')
|
||
#+END_SRC
|
||
|
||
*** Adjust the tablet
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Wacom_setup-Adjust_the_tablet-342acaf3
|
||
:END:
|
||
This function will take care of adjusting our tablet to our screen. Let’s
|
||
declare our function.
|
||
#+BEGIN_SRC fish :noweb yes
|
||
function adjust_device
|
||
<<wacom-tablet-set-ration-area>>
|
||
<<wacom-tablet-set-new-area>>
|
||
<<wacom-tablet-set-device-area-and-screen>>
|
||
end
|
||
#+END_SRC
|
||
|
||
If our screen is too high or too wide for our tablet, we will have to adjust the
|
||
height or width of the area used by the tablet. So let’s get the theoretical new
|
||
height and width of the area.
|
||
#+NAME: wacom-tablet-set-ration-area
|
||
#+BEGIN_SRC fish :tangle no
|
||
set RATIOAREAY (math ceil \($AREAX \* $HEIGHT \/ $WIDTH\))
|
||
set RATIOAREAX (math ceil \($AREAY \* $WIDTH \/ $HEIGHT\))
|
||
#+END_SRC
|
||
|
||
Now, if the current height of the tablet’s area is greater than the theoretical
|
||
new area, it means the current area is too high. Otherwise, it should be the
|
||
other way around. Let’s set =NEWAREAX= and =NEWAREAY= that will be used to set
|
||
the new area for the tablet.
|
||
#+NAME: wacom-tablet-set-new-area
|
||
#+BEGIN_SRC fish :tangle no
|
||
if test $AREAY -gt $RATIOAREAY
|
||
set -g NEWAREAX $AREAX
|
||
set -g NEWAREAY $RATIOAREAY
|
||
else
|
||
set -g NEWAREAX $RATIOAREAX
|
||
set -g NEWAREAY $AREAY
|
||
end
|
||
#+END_SRC
|
||
|
||
Alright, now let’s set the new area with these new variables.
|
||
#+NAME: wacom-tablet-set-device-area-and-screen
|
||
#+BEGIN_SRC fish :tangle no
|
||
xsetwacom set "$DEVICE" Area 0 0 $NEWAREAX $NEWAREAY
|
||
#+END_SRC
|
||
|
||
*** Lauch the functions
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Wacom_setup-Lauch_the_functions-2ab8b4d9
|
||
:END:
|
||
Back to the main body of the script, we can now launch the functions
|
||
sequencially.
|
||
#+BEGIN_SRC fish
|
||
set_screen
|
||
adjust_device
|
||
#+END_SRC
|
||
|
||
* Emacs stuff
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Emacs-stuff-8e76efd4
|
||
:END:
|
||
** Dired
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Emacs-stuff-Dired-2eeca9da
|
||
:HEADER-ARGS: :shebang "#!/bin/bash" :mkdirp yes :tangle ~/.local/bin/dired
|
||
:END:
|
||
#+BEGIN_SRC bash
|
||
emacsclient -c -a emacs -e "(dired \"$@\")"
|
||
#+END_SRC
|
||
|
||
** Emacsmail
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/bin/bash" :mkdirp yes :tangle ~/.local/bin/emacsmail
|
||
:CUSTOM_ID: Emacsmail-afffb7cd
|
||
:END:
|
||
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.
|
||
#+BEGIN_SRC bash
|
||
emacsclient -c -n -a emacs -e "(browse-url-mail \"$@\")"
|
||
#+END_SRC
|
||
|
||
* Media
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Media-f869f942
|
||
:END:
|
||
** mp42webm
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/mp42webm
|
||
:CUSTOM_ID: mp42webm-aeacca58
|
||
:END:
|
||
This function allows me to convert easily an mp4 video to the webm format.
|
||
Nothing too fancy here.
|
||
#+BEGIN_SRC fish
|
||
ffmpeg -i $argv[1] -c:v libvpx -crf 10 -b:v 1M -c:a libvorbis $argv[1].webm
|
||
#+END_SRC
|
||
|
||
** youtube-dl wrappers
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Media-youtube-dl-wrappers-8d8f5f71
|
||
:END:
|
||
*** ytplay
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/ytplay
|
||
:CUSTOM_ID: Weather-4ed00bb0
|
||
:END:
|
||
~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.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
I’ll even add a ~.desktop~ entry for this script:
|
||
#+BEGIN_SRC conf-desktop :tangle ~/.local/share/applications/ytplay.desktop :mkdirp yes
|
||
[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
|
||
#+END_SRC
|
||
|
||
*** ytdl - a ~youtube-dl~ wrapper
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/ytdl
|
||
:HEADER-ARGS:EMACS-LISP: :exports none :tangle no
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-03bd63e0
|
||
:END:
|
||
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, [[https://github.com/jorgebucaran/fish-getopts][Fish getopts]] and [[https://github.com/BurntSushi/ripgrep][ripgrep]].
|
||
|
||
**** Setting default values
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Setting-default-values-da404639
|
||
:END:
|
||
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:
|
||
#+NAME: ytdl-default-vars
|
||
| 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:
|
||
#+NAME: ytdl-default-vars-root
|
||
#+BEGIN_SRC fish :tangle no
|
||
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
|
||
#+END_SRC
|
||
|
||
#+NAME: ytdl-default-vars-make
|
||
#+BEGIN_SRC emacs-lisp :var vars=ytdl-default-vars
|
||
(mapconcat (lambda (var)
|
||
(let ((varname (car var))
|
||
(varvalue (cadr var))
|
||
(string? (string= (nth 2 var) "yes")))
|
||
(format "set -g %-16s %s" varname (if string? (format "\"%s\"" varvalue)
|
||
varvalue))))
|
||
vars
|
||
"\n")
|
||
#+END_SRC
|
||
|
||
#+RESULTS: ytdl-default-vars-make
|
||
: 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"
|
||
|
||
#+BEGIN_SRC fish :noweb yes
|
||
<<ytdl-default-vars-make()>>
|
||
<<ytdl-default-vars-root>>
|
||
#+END_SRC
|
||
|
||
We’ll also create the directory pointed at by ~YTDL_SHARED_DIR~ if it doesn’t
|
||
exist already:
|
||
#+BEGIN_SRC fish
|
||
mkdir -p $YTDL_SHARED_DIR
|
||
#+END_SRC
|
||
|
||
**** Help message
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Help-message-3773aacd
|
||
:END:
|
||
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~.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
We also have the function ~_ytdl_version~ to display the current version of
|
||
~ytdl~:
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
**** Arguments Handling
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Arguments-Handling-1daebbe8
|
||
:END:
|
||
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:
|
||
#+NAME: ytdl-table-arguments
|
||
| 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.
|
||
|
||
#+NAME: ytdl-arg-handling-gen
|
||
#+BEGIN_SRC emacs-lisp :var args=ytdl-table-arguments
|
||
(mapconcat (lambda (arg)
|
||
(let* ((short (format "%s" (nth 0 arg)))
|
||
(long (nth 1 arg))
|
||
(arg? (string= "yes" (nth 2 arg)))
|
||
(var (unless (string= "None" (nth 3 arg))
|
||
(nth 3 arg))))
|
||
(format "case %s %s\n\t%s"
|
||
short long
|
||
(if var (format "set -g %s %s" var
|
||
(if arg? "$value" ""))
|
||
(format "_ytdl_%s && exit"
|
||
(if (string= "h" short) "help" "version"))))))
|
||
args
|
||
"\n")
|
||
#+END_SRC
|
||
|
||
#+RESULTS: ytdl-arg-handling-gen
|
||
#+begin_example
|
||
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
|
||
#+end_example
|
||
|
||
The following shows how ~getopts~ is used to catch the options and switches
|
||
passed to the script:
|
||
#+NAME: ytdl-getopts
|
||
#+BEGIN_SRC fish :noweb yes :tangle no
|
||
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
|
||
#+END_SRC
|
||
|
||
#+NAME: ytdl-arg-set-default-value-gen
|
||
#+BEGIN_SRC emacs-lisp :var args=ytdl-table-arguments
|
||
(let* ((args (-filter (lambda (arg)
|
||
(let* ((var (unless (string= "None" (nth 3 arg)) (nth 3 arg)))
|
||
(default (format "%s" (nth 4 arg)))
|
||
(default (unless (string= "None" default) default)))
|
||
(and var default)))
|
||
args)))
|
||
(mapconcat (lambda (arg)
|
||
(let* ((var (nth 3 arg))
|
||
(default (format "%s" (nth 4 arg))))
|
||
(format "if set -q $%s\n\tset -g %s %s\nend"
|
||
var var default)))
|
||
args
|
||
"\n"))
|
||
#+END_SRC
|
||
|
||
#+RESULTS: ytdl-arg-set-default-value-gen
|
||
#+begin_example
|
||
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
|
||
#+end_example
|
||
|
||
Some values need to be set to their default, so let’s assign them their value if
|
||
no user value was passed:
|
||
#+NAME: ytdl-arg-set-default-value
|
||
#+BEGIN_SRC fish :noweb yes :tangle no
|
||
<<ytdl-arg-set-default-value-gen()>>
|
||
set -g FORMAT "$ROOTDIR/$FORMAT"
|
||
#+END_SRC
|
||
|
||
Both these code blocks are executed in ~_ytdl_parse_ops~:
|
||
#+BEGIN_SRC fish :noweb yes
|
||
function _ytdl_parse_ops
|
||
<<ytdl-getopts>>
|
||
<<ytdl-arg-set-default-value>>
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Logging
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Logging-f4b9815e
|
||
:END:
|
||
~_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.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
**** Download a Single Video
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Download-a-Single-Video-afedf321
|
||
:END:
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
/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
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Download-a-Queue-of-Videos-6ef8d51f
|
||
:END:
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
**** Download Videos From Arguments
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Download-Videos-From-Arguments-57a5dac1
|
||
:END:
|
||
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~.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
**** Download Videos From a Batch File
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Download-Videos-From-a-Batch-File-0f1382c4
|
||
:END:
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
**** Main Body
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ytdl-a-youtube-dl-wrapper-Main-Body-8a06cb9e
|
||
:END:
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
_ytdl_parse_ops $argv
|
||
_ytdl_download_arg_urls $VIDEOS
|
||
_ytdl_download_batch
|
||
#+END_SRC
|
||
|
||
And that’s all! If you’re interested with a very simple interface for
|
||
downloading one video once, I wrote a small [[#rofi-ytdl-ff8f789d][~rofi-ytdl~]] script that calls the
|
||
~rofi~ utility to specify a single link and download it.
|
||
* Plock
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/plock
|
||
:CUSTOM_ID: Lock-635fcb38
|
||
:END:
|
||
~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.
|
||
#+BEGIN_SRC fish
|
||
set TMPBG /tmp/screen.png
|
||
scrot $TMPBG
|
||
corrupter -add 0 $TMPBG $TMPBG
|
||
i3lock -t -e -f -i $TMPBG
|
||
rm $TMPBG
|
||
#+END_SRC
|
||
|
||
* Polybar-launch (Deprecated) :noexport:
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/polybar-launch
|
||
:CUSTOM_ID: Polybar-launch-36789edc
|
||
:END:
|
||
This scripts allows the user to kill polybar and relaunch it, or to simply
|
||
launch it if polybar isn’t launched yet. First thing to do is kill all polybar
|
||
processes.
|
||
#+BEGIN_SRC bash
|
||
killall -q polybar
|
||
#+END_SRC
|
||
|
||
Now we have to wait untill all polybar processes have been shut down.
|
||
#+BEGIN_SRC bash
|
||
while pgrep -u $UID -x polybar >/dev/null; do sleep 1; done
|
||
#+END_SRC
|
||
|
||
Now that our system isn’t running polybar anymore, we’ll launch it again on all
|
||
of our screens. By the way, I have two bars, so I’ll have to lauch them both.
|
||
#+BEGIN_SRC bash
|
||
if type "xrandr"; then
|
||
for m in $(xrandr --query | grep " connected" | cut -d" " -f1); do
|
||
MONITOR=$m polybar --reload top &
|
||
MONITOR=$m polybar --reload bottom &
|
||
done
|
||
else
|
||
polybar --reload top &
|
||
polybar --reload bottom &
|
||
fi
|
||
#+END_SRC
|
||
|
||
And we’re done! Let’s just launch a notification polybar has been relaunched.
|
||
#+BEGIN_SRC bash
|
||
notify-send "Polybar restarted!" -a "polybar-launch"
|
||
#+END_SRC
|
||
|
||
* Rofi utilities
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-utilities-650338d1
|
||
:END:
|
||
** askpass
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/askpass
|
||
:CUSTOM_ID: Askpass-d0d7a8c0
|
||
:END:
|
||
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 [[https://github.com/ODEX-TOS/tools/blob/master/rofi/askpass][this original tool]], rewritten in fish
|
||
and with [[https://wiki.archlinux.org/index.php/Rofi][rofi]] support instead of [[https://wiki.archlinux.org/index.php/Dmenu][dmenu]]. As you can see, this is a oneliner if we
|
||
ignore the initial shebang. This executable is pointed at by the
|
||
#+BEGIN_SRC fish
|
||
rofi -dmenu -password -no-fixed-num-lines -p (printf $argv[1] | sed s/://)
|
||
#+END_SRC
|
||
|
||
** awiki
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/awiki
|
||
:CUSTOM_ID: awiki-7ac5e1d5
|
||
:END:
|
||
~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.
|
||
#+BEGIN_SRC fish
|
||
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')
|
||
#+END_SRC
|
||
|
||
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~.
|
||
#+BEGIN_SRC fish
|
||
xdg-open $WLOCATION$WPAGE.html
|
||
#+END_SRC
|
||
|
||
** ConnectWifi :noexport:
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/connect-wifi
|
||
:CUSTOM_ID: ConnectWifi-16e5e24a
|
||
:END:
|
||
~connect-wifi~ is a small utility tool that allows the user to connect to
|
||
available WiFi networks. The first thing to do is to select the WiFi we want to
|
||
connect to. We’ll use the ~nmcli c s~ command to get the list of the available
|
||
networks, and we’ll chose one with ~rofi~.
|
||
#+BEGIN_SRC fish
|
||
set SELECTEDWIFI (nmcli d w l | \
|
||
egrep -o '([0-9A-F]{2}:){5}[0-9A-F]{2}\s*(.*)Infra' | \
|
||
egrep -o '\s+(.*)\s+' | awk '{$1=$1}1' | \
|
||
rofi -dmenu -p "Select your WiFi network")
|
||
#+END_SRC
|
||
Now, if a network was selected, let’s attempt to connect to it. Otherwise, let’s
|
||
just send a notification no network was selected.
|
||
#+BEGIN_SRC fish
|
||
if test -z $SELECTEDWIFI
|
||
notify-send "No WiFi network selected" -u low && exit
|
||
end
|
||
nmcli c u $SELECTEDWIFI
|
||
#+END_SRC
|
||
|
||
*** TODO fix it
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: ConnectWifi-fix_it-a4b11503
|
||
:END:
|
||
|
||
** dmenu
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/dmenu
|
||
:CUSTOM_ID: Dmenu-527edf04
|
||
:END:
|
||
I wrote this very simple script in order to replace =dmenu= with rofi’s
|
||
emulation of dmenu, since I prefer rofi’s appearance. It basically calls rofi’s
|
||
dmenu emulation with the arguments initially passed to dmenu.
|
||
#+BEGIN_SRC fish
|
||
rofi -dmenu $argv
|
||
#+END_SRC
|
||
|
||
** Emoji picker
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/rofi-emoji
|
||
:CUSTOM_ID: Emoji_picker-a1c374ec
|
||
:END:
|
||
The emoji picker is a simple fish script that uses rofi and [[file:~/.config/emoji.txt][~/.config/emoji.txt]]
|
||
to provide a small, local search for emojis. Once the emoji is selected, it is
|
||
copied to the clipboard using =xclipboard=.
|
||
#+BEGIN_SRC fish
|
||
grep -v "#" ~/.config/emoji.txt | rofi -dmenu -p "Select emoji" -i | \
|
||
awk '{print $1}' | tr -d '\n' | xclip -selection clipboard
|
||
#+END_SRC
|
||
|
||
Also, let’s send a notification telling the user the emoji has been copied!
|
||
#+BEGIN_SRC fish
|
||
set emoji (xclip -o -selection clipboard | tr -d '\n')
|
||
test -z "$emoji" && notify-send "No emoji copied" -u low && exit
|
||
set -a emoji "copied to clipboard"
|
||
notify-send -u low $emoji
|
||
#+END_SRC
|
||
|
||
It is inspired from [[https://www.youtube.com/watch?v=UCEXY46t3OA][this video]] from [[https://lukesmith.xyz/][Luke Smith]], rewritten in Fish.
|
||
|
||
** Partition mounting and unmounting
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-utilities-Partition-mounting-and-unmounting-9492ff60
|
||
:END:
|
||
*** Rofi-mount
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/rofi-mount
|
||
:CUSTOM_ID: Rofi-mount-ebbebf68
|
||
:END:
|
||
=rofimount= is a script inspired by [[https://github.com/ihebchagra/dotfiles/blob/master/.local/bin/dmount][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
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-mount-Get_the_mountable_elements-24db7834
|
||
:END:
|
||
#+BEGIN_SRC fish
|
||
begin
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
set -l LFS
|
||
#+END_SRC
|
||
|
||
Now, let’s detect the amount of mountable Android filesystems, and if any are
|
||
detected, let’s read them into a global variable.
|
||
#+BEGIN_SRC fish
|
||
set -l a (math (jmtpfs -l | wc -l) - 2)
|
||
test $a -ge 0 && jmtpfs -l 2> /dev/null | tail -n $a | read -zg anddrives
|
||
#+END_SRC
|
||
|
||
We’ll do the same for external and internal drives and partitions that can be
|
||
mounted here.
|
||
#+BEGIN_SRC fish
|
||
lsblk -rpo "name,type,size,mountpoint" | \
|
||
awk '$2=="part"&&$4==""{printf "%s (%s)\n",$1,$3}' | \
|
||
read -zg usbdrives
|
||
#+END_SRC
|
||
|
||
Finally, we look for any CD drive that could be mounted on our device.
|
||
#+BEGIN_SRC fish
|
||
blkid /dev/sr0 | awk '{print $1}' | sed 's/://' | read -z cddrives
|
||
#+END_SRC
|
||
|
||
And that’s the end of our first block!
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
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).
|
||
#+BEGIN_SRC fish
|
||
set -g TMPDRIVES /tmp/drives
|
||
rm -f $TMPDRIVES
|
||
touch $TMPDRIVES
|
||
#+END_SRC
|
||
|
||
Now, let’s write what type of drives we can mount in this temporary file.
|
||
#+BEGIN_SRC fish
|
||
test -n "$usbdrives" && echo "USB" >> $TMPDRIVES
|
||
test -n "$cddrives" && echo "CD" >> $TMPDRIVES
|
||
test -n "$anddrives" && echo "Android" >> $TMPDRIVES
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
set -g basemount /media
|
||
#+END_SRC
|
||
|
||
**** Get the mount point
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-mount-Get_the_mount_point-6c4bac06
|
||
:END:
|
||
Now, let’s declare a function that will allow us to chose the drive we want to
|
||
mount.
|
||
#+BEGIN_SRC fish
|
||
function getmount
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
set -g mp (for d in $basemount
|
||
find $d -maxdepth 5 -type d
|
||
end | rofi -dmenu -i -p 'Type in mount point.')
|
||
#+END_SRC
|
||
|
||
We should verify that something has been actually selected, otherwise we should
|
||
abort the script.
|
||
#+BEGIN_SRC fish
|
||
if test -z $mp || test $mp = ""
|
||
return 1
|
||
end
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
Finally, let’s close the function
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Mount a USB drive, hard drive or partition
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-mount-Mount_a_USB_drive,_hard_drive_or_partition-f5431dbe
|
||
:END:
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
function mountusb
|
||
#+END_SRC
|
||
|
||
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=.
|
||
#+BEGIN_SRC fish
|
||
set -g chosen (echo $usbdrives | \
|
||
rofi -dmenu -i -p "Mount which drive?" | \
|
||
awk '{print $1}')
|
||
#+END_SRC
|
||
|
||
As usual after a user selection, let’s verify something has actually been
|
||
selected. If not, let’s abort the script.
|
||
#+BEGIN_SRC fish
|
||
test -z $chosen && return 1
|
||
#+END_SRC
|
||
|
||
Now, let’s select the mount point of our partition. We’ll call the function
|
||
=getmount= described in [[#Rofi-mount-Get_the_mount_point-6c4bac06][Get the mount point]] to select it.
|
||
#+BEGIN_SRC fish
|
||
getmount
|
||
#+END_SRC
|
||
|
||
Let’s verify the variable =mp= set in =getmount= is not empty, otherwise abort
|
||
the script.
|
||
#+BEGIN_SRC fish
|
||
test -z $mp && return 1
|
||
#+END_SRC
|
||
|
||
Now, let’s mount it! We’ll use a switch which will detect the filesystem used so
|
||
we know how to mount the partition.
|
||
#+BEGIN_SRC fish
|
||
switch (lsblk -no "fstype" $chosen)
|
||
#+END_SRC
|
||
|
||
We have two named case: =vfat= filesystems.
|
||
#+BEGIN_SRC fish
|
||
case "vfat"
|
||
sudo -A mount -t vfat $chosen $mp -o rw,umask=0000
|
||
#+END_SRC
|
||
|
||
And =ntfs= filesystems.
|
||
#+BEGIN_SRC fish
|
||
case "ntfs"
|
||
sudo -A mount -t ntfs $chosen $mp -o rw,umask=0000
|
||
#+END_SRC
|
||
|
||
Else, we’ll let =mount= determine which filesystem is used by the partition
|
||
(generally =ext4=).
|
||
#+BEGIN_SRC fish
|
||
case '*'
|
||
sudo -A mount $chosen $mp
|
||
#+END_SRC
|
||
|
||
We’ll also run a =chown= on this newly mounted filesystem so the user can access
|
||
it without any issues.
|
||
#+BEGIN_SRC fish
|
||
sudo -A chown -R $USER:(id -g $USER) $mp
|
||
#+END_SRC
|
||
|
||
Let’s close the switch block and send a notification the partition has been
|
||
mounted.
|
||
#+BEGIN_SRC fish
|
||
end && notify-send -a "dmount" "💻 USB mounting" "$chosen mounted to $mp."
|
||
#+END_SRC
|
||
|
||
And let’s close the function.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Mount an Android device
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-mount-Mount_an_Android_device-5321f9cd
|
||
:END:
|
||
The function that manages to mount Android filesystems is =mountandroid=. Let’s
|
||
declare it.
|
||
#+BEGIN_SRC fish
|
||
function mountandroid -d "Mount an Android device"
|
||
#+END_SRC
|
||
|
||
We’ll select which Android we want to mount. We will be asked through rofi.
|
||
#+BEGIN_SRC fish
|
||
set chosen (echo $anddrives | rofi -dmenu -i -p "Which Android device?" | awk '{print $1 $2}' | sed 's/,$//')
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
set bus (echo $chosen | sed 's/,.*//')
|
||
#+END_SRC
|
||
|
||
Let’s temporarily mount our device.
|
||
#+BEGIN_SRC fish
|
||
jmtpfs -device=$chosen $mp
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
echo "OK" | \
|
||
rofi -dmenu -i -p "Press (Allow) on your phone screen, or set your USB settings to allow file transfert"
|
||
#+END_SRC
|
||
|
||
Now, let’s get the actual path of our Android filesystem we wish to mount, and
|
||
let’s unmount the previous temporary filesystem.
|
||
#+BEGIN_SRC fish
|
||
set newchosen (jmtpfs -l | grep $bus | awk '{print $1 $2}' | sed 's/,$//')
|
||
sudo -A umount $mp
|
||
#+END_SRC
|
||
|
||
Now we cam mount the new filesystem and send a notification if everything went
|
||
well.
|
||
#+BEGIN_SRC fish
|
||
jmtpfs -device=$newchosen $mp && \
|
||
notify-send -a "dmount" "🤖 Android Mounting" "Android device mounted to $mp."
|
||
#+END_SRC
|
||
|
||
And now, we can close our function.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Mount a CD drive
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-mount-Mount_a_CD_drive-27278199
|
||
:END:
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
function mountcd
|
||
#+END_SRC
|
||
|
||
Now, let’s chose the CD drive we want to mount using =rofi=.
|
||
#+BEGIN_SRC fish
|
||
set chosen (echo $cddrives | rofi -dmenu -i -p "Which CD drive?")
|
||
#+END_SRC
|
||
|
||
We’ll also get the mountpoint thanks to the =getmount= function described
|
||
earlier.
|
||
#+BEGIN_SRC fish
|
||
getmount
|
||
#+END_SRC
|
||
|
||
And finally, let’s mount it and send the notification everything went well.
|
||
#+BEGIN_SRC fish
|
||
sudo -A mount $chosen $mp && \
|
||
notify-send -a "dmount" "💿 CD mounting" "$chosen mounted."
|
||
#+END_SRC
|
||
|
||
Finally, let’s close our function.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Ask what type of drive we want to mount
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-mount-Ask_what_type_of_drive_we_want_to_mount-0c15cffa
|
||
:END:
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
function asktype
|
||
#+END_SRC
|
||
|
||
We will use a switch statement which will use our anwser to rofi about what we
|
||
wish to mount.
|
||
#+BEGIN_SRC fish
|
||
switch (cat $TMPDRIVES | rofi -dmenu -i -p "Mount which drive?")
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
case "USB"
|
||
mountusb
|
||
#+END_SRC
|
||
|
||
If we chose the "Android" option, the =mountandroid= function is called.
|
||
#+BEGIN_SRC fish
|
||
case "Android"
|
||
mountandroid
|
||
#+END_SRC
|
||
|
||
Else if we chose the "CD" option, we’ll call the =mountcd= function.
|
||
#+BEGIN_SRC fish
|
||
case "CD"
|
||
mountcd
|
||
#+END_SRC
|
||
|
||
If nothing is selected, the function will naturally exit. Now, let’s close our
|
||
switch statement and our function.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Launch the mounting functions
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-mount-Launch_the_mounting_functions-218ad001
|
||
:END:
|
||
Now that we have declared our functions and set our variables, we’ll read the
|
||
temporary file described in [[#Rofi-mount-Get_the_mountable_elements-24db7834][Get the mountable elements]]. The amount of lines is
|
||
passed in a switch statement.
|
||
#+BEGIN_SRC fish
|
||
switch (wc -l < $TMPDRIVES)
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC fish
|
||
case 0
|
||
notify-send "No USB drive or Android device or CD detected" -a "dmount"
|
||
#+END_SRC
|
||
|
||
If we only have one line, we have only one type of mountable media. We’ll pass
|
||
this line to a second switch statement.
|
||
#+BEGIN_SRC fish
|
||
case 1
|
||
switch (cat $TMPDRIVES)
|
||
#+END_SRC
|
||
This will allow the script to automatically detect what type of media it is, and
|
||
mount the corresponding function.
|
||
#+BEGIN_SRC fish
|
||
case "USB"
|
||
mountusb
|
||
case "Android"
|
||
mountandroid
|
||
case "CD"
|
||
mountCD
|
||
#+END_SRC
|
||
Let’s close this nested switch case.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
If we have more than one line, we’ll have to ask the user what type of media
|
||
they want to mount.
|
||
#+BEGIN_SRC fish
|
||
case '*'
|
||
asktype
|
||
#+END_SRC
|
||
|
||
Now, let’s end our switch statement!
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
Finally, we’ll delete our temporary file.
|
||
#+BEGIN_SRC fish
|
||
rm -f $TMPDRIVES
|
||
#+END_SRC
|
||
|
||
And with that, this is the end of our script!
|
||
|
||
*** Rofi-umount
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/rofi-umount
|
||
:CUSTOM_ID: Rofi-umount-ddde1667
|
||
:END:
|
||
~rofiumount~ is the counterpart of ~rofimount~ for unmounting our mounted
|
||
partitions.
|
||
|
||
**** Get the unmountable drives
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-umount-Get_the_unmountable_drives-89c71040
|
||
:END:
|
||
First, we will need to list all the drives that can be safely unmounted. Let’s
|
||
run this.
|
||
#+BEGIN_SRC fish
|
||
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}')
|
||
#+END_SRC
|
||
|
||
Now, let’s get the android devices that are mounted.
|
||
#+BEGIN_SRC fish
|
||
set -g androids (awk '/jmtpfs/ {print $2}' /etc/mtab)
|
||
#+END_SRC
|
||
|
||
And let’s get the CD drives that are mounted.
|
||
#+BEGIN_SRC fish
|
||
set -g cds (awk '/sr0/ {print $2}' /etc/mtab)
|
||
#+END_SRC
|
||
|
||
We’ll store all of our information in a temporary file, =/tmp/undrives=.
|
||
#+BEGIN_SRC fish
|
||
set -g undrivefile /tmp/undrives
|
||
#+END_SRC
|
||
|
||
Let’s make sure we begin with a clean, empty file.
|
||
#+BEGIN_SRC fish
|
||
rm -f $undrivefile
|
||
touch $undrivefile
|
||
#+END_SRC
|
||
|
||
Depending on if the related variables are set, write the different types of
|
||
mounted drives in the temporary file.
|
||
#+BEGIN_SRC fish
|
||
test -n "$drives" && echo "USB" >> $undrivefile
|
||
test -n "$cds" && echo "CD" >> $undrivefile
|
||
test -n "$androids" && echo "Android" >> $undrivefile
|
||
#+END_SRC
|
||
|
||
**** Unmount disk partitions
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-umount-Unmount_disk_partitions-0d425a47
|
||
:END:
|
||
The function =unmountusb= will take care of unmounting any drive we can safely
|
||
unmount. First, let’s declare the function.
|
||
#+BEGIN_SRC fish
|
||
function unmountusb
|
||
#+END_SRC
|
||
|
||
Let’s chose the drive to unmount with rofi.
|
||
#+BEGIN_SRC fish
|
||
set chosen (echo $drives | \
|
||
rofi -dmenu -i -p "Unmount which drive?" | \
|
||
awk '{print $1}')
|
||
#+END_SRC
|
||
|
||
Let’s verify if the user actually selected any drive. If no, let’s abort the
|
||
script.
|
||
#+BEGIN_SRC fish
|
||
test -z "$chosen" && exit 0
|
||
#+END_SRC
|
||
|
||
Now, let’s unmount the chosen drive and send a notification if it has been done.
|
||
#+BEGIN_SRC fish
|
||
sudo -A umount $chosen && \
|
||
notify-send "💻 USB unmounting" "$chosen unmounted." -a "dumount"
|
||
#+END_SRC
|
||
|
||
Now, let’s close the function.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Unmount Android device
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-umount-Unmount_Android_device-ae1d5904
|
||
:END:
|
||
The function =unmountandroid= will take care of unmounting any mounted Android
|
||
device. First, let’s declare our function.
|
||
#+BEGIN_SRC fish
|
||
function unmountandroid
|
||
#+END_SRC
|
||
|
||
Let the user choose which Android device to unmount.
|
||
#+BEGIN_SRC fish
|
||
set chosen (echo $androids | rofi -dmenu -i -p "Unmount which device?")
|
||
#+END_SRC
|
||
|
||
We’ll verify the user chose any device.
|
||
#+BEGIN_SRC fish
|
||
test -z "$chosen" && exit 0
|
||
#+END_SRC
|
||
|
||
If a device has been chosen, let’s unmount it and send a notification it has
|
||
been successfuly unmounted.
|
||
#+BEGIN_SRC fish
|
||
sudo -A umount -l $chosen && \
|
||
notify-send "🤖 Android unmounting" "$chosen unmounted." -a "dumount"
|
||
#+END_SRC
|
||
|
||
Finally, let’s close the function.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Unmount CD drive
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-umount-Unmount_CD_drive-369a2f61
|
||
:END:
|
||
=unmountcd= will take care of unmounting any mounted CD drive. Let’s declare
|
||
this function.
|
||
#+BEGIN_SRC fish
|
||
function unmountcd
|
||
#+END_SRC
|
||
|
||
As before, let the user chose which CD drive to unmount.
|
||
#+BEGIN_SRC fish
|
||
set chosen (echo "$cds" | rofi -dmenu -i -p "Unmount which CD?")
|
||
#+END_SRC
|
||
|
||
We’ll verify the user chose any device.
|
||
#+BEGIN_SRC fish
|
||
test -z "$chosen" && exit 0
|
||
#+END_SRC
|
||
|
||
If a drive has been chosen, let’s unmount it and send a notification it has been
|
||
successfuly unmounted.
|
||
#+BEGIN_SRC fish
|
||
sudo -A umount -l $chosen && \
|
||
notify-send "💿 CD unmounting" "$chosen unmounted." -a "dumount"
|
||
#+END_SRC
|
||
|
||
Now, let’s close the function.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Ask what type of drive to unmount
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-umount-Ask_what_type_of_drive_to_unmount-6287af48
|
||
:END:
|
||
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 [[#Rofi-umount-Get_the_unmountable_drives-89c71040][Get the
|
||
unmountable drives]]. First, let’s declare the function.
|
||
#+BEGIN_SRC fish
|
||
function asktype
|
||
#+END_SRC
|
||
|
||
Let’s create a switch statement to which will be passed the selection of the
|
||
user from rofi.
|
||
#+BEGIN_SRC fish
|
||
switch (cat $undrivefile | rofi -dmenu -i -p "Unmount which type of device?")
|
||
#+END_SRC
|
||
|
||
Three types of values can be returned: "USB", "CD", or "Android". These values
|
||
will be used to launch their corresponding function.
|
||
#+BEGIN_SRC fish
|
||
case 'USB'
|
||
unmountusb
|
||
case 'CD'
|
||
unmountcd
|
||
case 'Android'
|
||
unmountandroid
|
||
#+END_SRC
|
||
|
||
Let’s close the switch statement.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
Let’s now close the function.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
**** Launch the unmounting functions
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Rofi-umount-Launch_the_unmounting_functions-7c48a928
|
||
:END:
|
||
Now back to the body of our script, let’s input in a switch case the number of
|
||
lines contained in our temporary file.
|
||
#+BEGIN_SRC fish
|
||
switch (wc -l < $undrivefile)
|
||
#+END_SRC
|
||
|
||
If the file containes no lines. i.e. it is empty, nothing is to be unmounted.
|
||
Let’s inform the user of that.
|
||
#+BEGIN_SRC fish
|
||
case 0
|
||
notify-send "No USB drive or Android device or CD to unmount" -a "dumount"
|
||
#+END_SRC
|
||
|
||
Else, if there is only one type of drive, we’ll automatically let our script
|
||
choose based on the content of this sole line.
|
||
#+BEGIN_SRC fish
|
||
case 1
|
||
switch (cat $undrivefile)
|
||
case 'USB'
|
||
unmountusb
|
||
case 'CD'
|
||
unmountcd
|
||
case 'Android'
|
||
unmountandroid
|
||
end
|
||
#+END_SRC
|
||
|
||
And if there are more types than one, let’s ask the user.
|
||
#+BEGIN_SRC fish
|
||
case '*'
|
||
asktype
|
||
#+END_SRC
|
||
|
||
Let’s close our main switch statement.
|
||
#+BEGIN_SRC fish
|
||
end
|
||
#+END_SRC
|
||
|
||
And finally, let’s delete our temporary file.
|
||
#+BEGIN_SRC fish
|
||
rm -f $undrivefile
|
||
#+END_SRC
|
||
|
||
** Rofi-pass
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/rofi-pass
|
||
:CUSTOM_ID: Rofi-pass-8335357f
|
||
:END:
|
||
=rofi-pass= is a simple utility that gets a password stored in the [[https://www.passwordstore.org/][=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.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|
||
|
||
Now, let’s get the list of the passwords that exist in our =pass= repository.
|
||
#+BEGIN_SRC fish
|
||
set passwords (find $HOME/.password-store -type f -name "*.gpg" | \
|
||
string replace -r ".*.password-store/" "" | \
|
||
string replace -r ".gpg" "" | sort)
|
||
#+END_SRC
|
||
|
||
Let the user choose which password they wish to select.
|
||
#+BEGIN_SRC fish
|
||
set password (for elem in $passwords
|
||
echo $elem
|
||
end | rofi -dmenu -i -p "Select your password")
|
||
#+END_SRC
|
||
|
||
Let’s verify we actually selected a password and not just exited. If no password
|
||
was selected, let’s simply exit the script.
|
||
#+BEGIN_SRC fish
|
||
if test -z $password
|
||
exit
|
||
end
|
||
#+END_SRC
|
||
|
||
Depending on the arguments passed earlier, we might want some different
|
||
behavior.
|
||
#+BEGIN_SRC fish :noweb yes
|
||
if test $TYPE = "yes"
|
||
<<rofi-pass-type>>
|
||
else
|
||
<<rofi-pass-copy>>
|
||
end
|
||
#+END_SRC
|
||
|
||
The default behavior is to copy the password to the clipboard for 45 seconds, so
|
||
let’s do that.
|
||
#+NAME: rofi-pass-copy
|
||
#+BEGIN_SRC fish :noweb yes :tangle no
|
||
pass show -c $password 2> /dev/null
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+NAME: rofi-pass-type
|
||
#+BEGIN_SRC fish :noweb yes :tangle no
|
||
set -l IFS
|
||
<<rofi-pass-type-get-password>>
|
||
printf %s $pass | xvkbd -file -
|
||
#+END_SRC
|
||
|
||
To correctly get the password from ~pass~, we need to parse the output and only
|
||
get the first line, hence the following command.
|
||
#+NAME: rofi-pass-type-get-password
|
||
#+BEGIN_SRC fish :tangle no
|
||
set pass (pass show $password | string split -n \n)[1]
|
||
#+END_SRC
|
||
|
||
** rofi-ytdl
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env bash" :mkdirp yes :tangle ~/.local/bin/rofi-ytdl
|
||
:CUSTOM_ID: rofi-ytdl-ff8f789d
|
||
:END:
|
||
This is just a simple wrapper around [[#ytdl-a-youtube-dl-wrapper-03bd63e0][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~.
|
||
#+BEGIN_SRC bash
|
||
URL=$(echo "Video to download:" | rofi -dmenu -i -p "Video to download:")
|
||
#+END_SRC
|
||
|
||
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.
|
||
#+BEGIN_SRC bash
|
||
if [ -n "$URL" ]; then
|
||
notify-send -u normal "YTDL" "Starting downloading\n$URL"
|
||
ytdl "$URL" \
|
||
&& notify-send -u normal "YTDL" "Finished downloading!" \
|
||
|| notify-send -u critical "YTDL" "Failed downloading\n$URL"
|
||
fi
|
||
#+END_SRC
|
||
|
||
* Wallpaper utilities
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Wallpaper-utilities-5c05d470
|
||
:END:
|
||
** pape-update
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env sh" :mkdirp yes :tangle ~/.local/bin/pape-update
|
||
:CUSTOM_ID: pape-update-bdecbadf
|
||
:END:
|
||
This little tool sets a random wallpaper using xwallpaper.
|
||
#+BEGIN_SRC sh
|
||
PAPESDIR=$HOME/Pictures/Wallpapers
|
||
PAPE=$(find $PAPESDIR -type f | sort -R | tail -1)
|
||
set-pape $PAPE
|
||
#+END_SRC
|
||
|
||
** Select wallpaper
|
||
:PROPERTIES:
|
||
:CUSTOM_ID: Wallpaper-utilities-Select-wallpaper-42f477a9
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env sh" :mkdirp yes :tangle ~/.local/bin/select-pape
|
||
:END:
|
||
This script is base on what ~sxiv~ can do as an image viewer as well as
|
||
xwallpaper.
|
||
#+BEGIN_SRC sh
|
||
PAPE=$(sxiv -orbft ~/Pictures/Wallpapers/*)
|
||
set-pape $PAPE
|
||
#+END_SRC
|
||
|
||
** Set a wallpaper
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env sh" :mkdirp yes :tangle ~/.local/bin/set-pape
|
||
:CUSTOM_ID: Wallpaper-utilities-Set-a-wallpaper-27eda9e6
|
||
:END:
|
||
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~.
|
||
#+BEGIN_SRC sh
|
||
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
|
||
#+END_SRC
|
||
|
||
* Weather
|
||
:PROPERTIES:
|
||
:HEADER-ARGS: :shebang "#!/usr/bin/env fish" :mkdirp yes :tangle ~/.local/bin/we
|
||
:CUSTOM_ID: Weather-4ed00bb0
|
||
:END:
|
||
A quick and useful script I often use is a ~curl~ request to [[http://v2.wttr.in/][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.
|
||
#+BEGIN_SRC fish
|
||
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
|
||
#+END_SRC
|