I am making tools to help people read deeply with the help of machines and sometimes AI. If the topic seems interesting check out this subreddit on machineAidedReading. If you like the cut of my jib or want to follow my efforts check out the blog or follow me on X.

When doing development - particularly backend development or devops work you can quickly collect a plethora of ports for different things which start becoming part to remember. I used to do things like try to encode meaning into these port numbers using Lewis Carrol’s phonetic encoding systems and other similar games. So if I had a port for accounts this would map to 7210 - a(.)K(7)(ou)N(2)T(1)S(0). All kind of confusing.

But recently I discovered a fact that I should have known that the localhost host IP address 127.0.0.1 is actually part of an entire subnet 127.0.0.0/24 - all of which are looped back to your machine. This means that instead of using ports for services you can have an entire machine which can be named in /etc/hosts - on unixy machines. This means that all your services can be named.

The only question is what port to use these named services. Unfortunately port 0 is reserved for special IP purposes as is port 1 - though apparently it not used that much. There are also problems with low ports being reserved by port. An issue that can be worked around by asking the kernel to stop reserving ports - but security paranoia suggests this is a bad idea. Instead I’ve opted for using port 1024 for all services and just giving them a name in /etc/hosts.

Makes me life a bit more enjoyable!

I do not like oAuth. I do not want to understand oAuth. I do not want to create an app. I just want a token for a command-line tool which I will personally use for my own purposes. Not everything is an app. Not everyone is an app developer.

2025-04-30 Played with getting PythonFu to work with GIMP to copy the image to the clipboard. Updated to Gimp 3.0 AppImage for this.

2025-05-02 mozeidon CLI, written in Go, to get information out of Chrome from the command-line. It can list history and bookmarks and control tabs.

2025-05-03 brave-history to dump out and search history. Pretty useful for finding links.

2025-05-05 Get CLI control of youtube working with playbackctl - largely just works. Notes.

2025-05-05 Added a bunch of emoji’s to my commandline to feel cool. Using kitty because it supports emoji’s: 🖋️ 25-05-06T2:09:52🗓️ 0❓️0:01⌛️user@thunkpad💻️/home/user/all/books📂⚡️

2025-05-05 Got youtube-dl set up for a little clipping. You can downloads clips you make in youtube. Needed to work out how to get formats working found a decent starting tutorial and various links.

2025-05-05 Shortcut to cycle recently used tabs in brave called CLUT . Found brave://extensions/shortcuts - which allows you to globally change shortcuts.

2025-05-20 Wrote a little script to highlight text in a stream because I didn’t like that you had to explicitly match everything with grep.

2025-05-20 Learned too much about how escape codes for colors work. There are at least three standards: 16 customizable colors, 256 hard-coded colors; or 16 million colors.

I create a lot of command-line tools as part of my work some of them are for collecting statistics about the code I release and displaying them in a dashboard. I list tools for collecting statistics related to code here. I wrote these because they did not exist before I made them.

• gh-views fetches information about the number of pages views and clones for a github repository retaining history information (github only provides a 14 day window.)

• gh-star-timeline fetches and maintains a historic timeline of stars on a github repo or all your repositories. I like to use it to see how many new stars I got each day, or where the stars can from.

• obsidian-plugin-stats fetches and retains a timeline about the number of downloads for an Obsidian plugin.

• pypi-stats-timeline fetches, maintains and queries a timeseries of download statistics from the python package index PyPI used by pip.

I am a programmer so I make my own tools. Sometimes these are mean to to change the world in some way. Some they are tools I mean for getting things done while attempting to change the world. Sometimes a mixture of the two. But where possible, I try to use existing tools for the task I need to get done. Here are some of the tools I use.

At the core of everything I use a keyboard. This lets me write down what I think and try to convince other people to do things. I use my own keymapping (symbolboard) which puts all the modifier controls (control, alt, super) on the number keys so that they are easy to press at the same time. It’s designed to let me swap to any keyboard without having to relearn anything. I’ve implemented this one a view different keybinding systems. At the moment, I’m using keyd which allows you to easily defining keymaps at the kernel - in the past I have used xmodmap and xkb but I eventually had problems with both due to how certain apps interacted with them.

I use X and substack where I try to convince people that what I am doing is interesting, that what I think is true, and that they can change what they are doing and generally interact with the world. I need a browser to do this, so I use Brave . I used firefox for a long time, but they had some bugs related to image pasting and also had some bad policies related to data so I switched to brave. I’ve used Wikipedia for this as well - but there you only get to tell people what is true by making an encyclopedia more correct - you do get to tell a lot of people though.

I am programmer so when something annoys me or I do it a lot I make tools to help me. For this I use the linux command-line quite a bit. I use zsh it’s slightly nicer than bash but probably isn’t too different. I just use it. I’m pretty lazy so I use my own snippet system zshnip that lets me define snippets as I go. I tend to insert a lot of links when I’m writing things so I use xclip to copy things to and from the clipboard for linking. I made a tool called brave-bookmarks to quickly copy links to my bookmarks and also have some tools to interact with my substack pages. I use fzf to select things because it removes the needs to type things. I use FFmpeg together with xclip to quickly take screenshots which I can paste into things. I occasionally use vidir when I want to quickly change a files name.

When note trying to get people’s attention I do make some things! I use Emacs for coding. I use vim bindings via evil-mode. For thinking, learning and planning I use Obsidian. In Obsidian I make lots of use of maps of content based on dataview. I have some plugins to speed up things that I find annoying. I have my own plugin called Plugin REPL which lets me automate commonly used things. I use git a lot. I also use the github command line tool gh a bit because I’m often creating new repositories for tools I share.

I often need to share data between the different tools I use. I use KDE with its windows tiling to quickly switch between applications and let me see two applications at the same time and I have keybindings to switch between apps for this I mostly use wmctrl.

I am command-line power user, I even wrote my own snippet framework. Occasionally I write documentation for the tools I use.

A beginner’s FFmpeg cookbook an introduction to the command-line video editing tool, FFmpeg’s, core functionality through examples that you can run, followed by more specialised tasks that link back to the core recipes.

Obsidian (and Plugin REPL) cookbook a cookbook of various recipes for automating and otherwise making your Obsidian set up easier to use.

A practical primer on Linux desktop files Desktop files are the shell scripts of Desktop Environments like Gnome Shell, Unity or KDE.

Create keyboard shortcuts for KDE from the command-line It can be a pain to always use KDE’s settings dialog to create keyboard shortcuts - and I create a lot of keyboard shortcuts. This describes how to create shortcuts in KDE if you want to keep some of the convenience of prettiness of KDE rather than switch to the command line.

Lists

awesome yt-dlp is an awesome list page for the youtube video downloader yt-dlp.

Other

I have also written a number of blog posts on technical topics which can be found in the Technical Miscellany section of this blog. I’ve written a number of command-line tools.

@readwithai

I used to be a user of tiling window managers. They are good and all, easy-to-configure, fit within the UNIX philosopher. But they can also be a pain, you end up having to use a keyboard for stuff. Desktop environments at their best make things easier, especially when using a mouse, and using a mouse and not having to “control” everything all the time can be relaxing. It’s odd - I will literally see myself going through short periods where everything has to be done efficiently with the keyboard and then a while later I will happily click away at stuff. It probably varies depending on what I’m doing.

For this reason, as well as a feeling that I don’t want to spend too much time updating my desktop I’ve opted for to use KDE. KDE is nice and easy to use but its got some tiling-window-manager-lite features with keybindings and the ability to define your own keybindings to do most of the things you want.

And yet.

The more I use something the more the day-to-day papercuts stuff to build up - and using all these GUI configuration tools with the continuous click-click-click can get annoying. Sure it’s easier first time around - well apart from the annoyance of having to find things. But it quickly gets annoying. I don’t quite know why I find clicking through dialogs so annoying at times - while editing files is easier. I think it is something related to it being hard to find things - whereas in text files you have search and you can’t “save your place” in the same way that you can be programming or editing text files.

And so today I have learned how to set up keyboard shortcuts from the command-line with KDE and I will share this with you.

How shortcuts work in KDE

KDE has a file called ~/.config/kglobalshortcutsrc which contains all your shortcuts. Each shortcuts runs a desktop file these can either live in /usr/share/applications or more likely ~/.local/share/applications. The KDE shortcut setting tool will create these desktop files for you when you create command shortcut as well an entry in kglobalshortcutsrc.

Here is an example .desktop file that KDE created in ~/.local/share/applications called focus-obsidian.desktop which I use to raise and cycle through windows for the note-taking app, Obsidian:

[Desktop Entry]
Exec=/home/alex/bins/windows/focus-obsidian
Name=/home/alex/bins/windows/focus-obsidian
NoDisplay=true
StartupNotify=false
Type=Application
X-KDE-GlobalAccel-CommandShortcut=true

Note the NoDisplay=true which prevents the normal launcher from showing this entry. The X-KDE-GlobalAccel-CommandShortcut=true which says that this entry is for a command. There is then an entry in ~/.config/kglobalshortcutsrc which looks like so:

[focus-obsidian.desktop]
_k_friendly_name=focus-obsidian
_launch=Meta+Shift+N,none,/home/alex/bins/windows/focus-obsidian

Notice that the name of the entry matches the name of the file.

The file gets read by a process called kglobalaccel5

Creating shortcuts by hand

From this, to create a shortcut by hand we need to:

1. Create a desktop file

2. Update kglobalshortcutsrc

3. Restart the shortcut daemon

To create the desktop file I normally copy and adapt an existing file. If you remove the X-KDE-GlobalAccel-CommandShortcut=true the shortcut still works but it is shown as program rather than a command in the shortcut settings.

Let’s do this now. We’ll create a shortcut that says “hello world” with zenity - you may have to install zenity first.

First I add the file hello-world.desktop to the directory /home/alex/.local/share/applications

[Desktop Entry]
Exec=zenity --info --text "hello world"
Name=Hello World
NoDisplay=true
StartupNotify=false
Type=Application

Here I have removed the X-KDE-GlobalAccel-CommandShortcut option. This means, I believe, that the item is shown as a “program” in the shortcuts preferences dialog and KDE does not attempted to update the Name or Exec options.

Then I edit ~/.config/kglobalshortcutsrc to add an entry for this desktop file.

[hello-world.desktop]
_k_friendly_name=Say hello world
_launch=Meta+Ctrl+H,none,This command will say hello

Then I restart kglobalaccel5 . Unfortunately it seems like this kde daemon does not restart when you kill it, show must be restarted by hand.

I use the following command to restart kglobalaccel: killall kglobalaccel5; sleep 1; kglobalaccel5&; disown

I can then use Super+Ctrl+H and see a hello world window pop up. (Note that KDE calls the windows/super key Meta - which is a little confusing since Emacs calls the alt key meta).

You will notice if you open ~/.config/kglobalshortcutsrc that KDE tries to clean up the file on restart. It will reorder entries so that they are in alphabetically order. And add keys that you miss. If you open the settings for shortcuts you will see an entry under programs. The “friendly name” is added to the menu

The third entry of the _launch item in kglobalshortcutsrc is displayed within the details of the shortcut. This key can naturally be longer and provide more details.

Some closing thoughts

This scratches my itch of avoiding clicking too when creating keyboard shortcuts. It’s also a little-bit neater. One downside is that the KDE shortcut settings dialog would have detected collisions between shortcuts. So I need to to do this by hand.

If this is the sort of stuff you find interesting your could:

1. Check out my beginner’s guide to FFmpeg through examples that you can run. It’s got 50-or-so stars on Github in a couple of weeks, so people seem to like it.

2. Follow me on X where I post about this sort of stuff and other things.

If you like the cut of my jib you might like to check out my blog where I am working on tools for research, reading and agency with the Obsidian note taking tool.

This is a quick primer on desktop files for those with a command-line mentality - who are used to running commands from the command-line, adding things to their path, and creating shell scripts. Desktop files are how a number of GUI desktop environments like KDE plasma, Gnome Shell and Ubuntu Unity specify things that are run.

If you want a technical reference you might like to start with the arch wiki page on the topic . If you want a practical quickstart carry on reading.

What is is a desktop file and why should I care?

You don’t need to use desktop files - you could run everything you want from the terminal, but most people at least run their terminals from a GUI desktop environment, probably use a separate browser and a couple of applications, and a lot of desktop environments work with the common standard of .desktop files. In KDE desktop files are used for keyboard shortcuts, items in the launcher and applications that automatically start when you start the desktop environment. If you are going to use a desktop environment you might want to be able to make use of features that use desktop files. But if you are a command-line user your probably want to be able to edit and create these files yourself.

You can to some degree escape desktop files by using certain tiling or simpler window managers like i3 or awesome.

I am @readwithai. I make tools for reading and research using the note taking tool Obsidian. Interesting? Links at the end of the article

What are desktop files used for and why do they exist?

A desktop file specifies something that can be run. They are similar to an executable that you place on your path - but they provide additional information that desktop environments demand. They make things a bit more complicated than exuectable on the command-line in exchange for certain conveniences like icons, documentation, and localization - amongst other things.

You can think of desktop files as like a shell script for GUI desktops A few systems that use .desktop files are: the keyboard shortcut systems, the mime type/ file type system and program launcherps.

Where do desktop files live and what do they look like?

Desktop files are an INI/TOML-like file that provide a number of key value pairs. Like shell scripts and executables, there is a PATH for desktop entries that consists of ~/.local/share/applications and /usr/share/local/applications and /usr/share/applications.

You can explore some open applications files there to see how they work. Desktop files provide various bits of data including localisation of executables to difference file systems, a tooltip describing an executable called Comment, a name calld Name, an executable and arguments to run called Exec amongst other things.

Here is a minimal example of a desktop file:

# ~/.local/share/applications/simple.desktop

[Desktop Entry]
Name=A simple desktop entry
Exec=zenity --info ran desktop entry

If you create this desktop file then you will be able to run it from your desktop environments’s launcher menu. You actually don’t even need the Name entry in the name entry - if omitted the name default to simple.

Some nice things about desktop entries

Desktop entries are a bit of a pain compared to an executable on the path. But they provide some benefits - they work across different systems. The mime system is quite nice, because you can ask what things can open a file in a more data-driven way.

Mime-types and default applications

If you give the Exec parameter of the desktop file an argument using %f as well as one or more MimeTypes, then your desktop will know that your application can handle certain mime types. Your desktop environment can then do useful things like add the application to the “Open with…” menu.

Here is a simple example that when runs on PDFs or PNGs copies the file to a known location.

# /home/alex/.local/share/applications/copy-to-file.desktop
[Desktop Entry]
Exec=cp %f /tmp/file.pdf
MimeType=application/pdf;application/png

Once you create this file, you will notice a copy-to-file item in Open With menu on PDF files (though it should be noted that mime types are handled through other mechanisms as well).

You can query the default desktop file for a mime type with for example

xdg-mime query default application/pdf

In KDE, you can use can use ktraderclient5 to find all the apps that support a given mime type: ktraderclient5 --mimetype application/pdf --servicetype Application.

You could then set (careful!) the default mime handler to be this file with:

xdg-mime default copy-to-file.desktop application/pdf

Keyboard shortcuts

KDE seems to create a new desktop file every time you create a custom shortcut. So if you want to create shortcuts by hand understanding desktop files is helpful.

Autostart

KDE also uses desktop files for the applications that automatically start when KDE starts. These live in $HOME/autostart unfortunately gtk-launch, which can be used to run desktop files does not find these files. If you want to test out an autostart file you can use dex which runs a desktop file based on a path rather htan searching.

Running desktop files from the command-line

When creating desktop files it can be nice to run them in a repeatedly way and the command-line can help here. The best way I found to run desktop files is gtk-launch. This still works with kde. There are other tools like dex, but the nice thing about this is that it searches for the desktop file in different locations like launches rather than requiring a full path. gtk-launch vim.desktop launches vim from the command-line.

@readwithai here. If you are interested in reading, note taking or command-line backs follow me on X, my blog, or learn about Obsidian.

Finishing up

I hope this was useful. I created this because the world seemed to lack some practical documentation on desktop files (even though the reference documentation is pretty good).

I like the command line; I like tools written in the “unix philosophy”; I like creating general tools that do part of a task; I like using a computer efficiently.

I prefer to reuse other tools that people have made, here are some tools that I use. Of course, all of this is in the name of my overarching project of making tools for reading, research and agency.

This is a listing of some tools I have written while serving my whimsy and trying to be efficient at using computers.

Some command-line tools I have made

Web tools

clixpath is a command-line tool to extract elements identified by Xpaths in XML and HTML documents.

curlfire allows you to use firefox cookies from the command line. This can be useful to collection information from pages that use cookies - for example together with clixpath.

profile-fox can be used to open new tabs in a particular firefox profile.

brave-bookmarks let’s you access bookmarks from the Brave browser from the command-line.

brave-history let’s you query your history in Brave browser from the command-line

notionshell is a command line that can used to update a notion page.

Code-hosting statistics

I have written various tools to track statistics related to code hosting sites.

gh-views fetches information about the number of pages views and clones for a github repository retaining history information (github only provides a 14 day window.)

gh-star-timeline fetches and maintains a historic timeline of stars on a github repo or all your repositories. I like to use it to see how many new stars I got each day, or where the stars can from.

obsidian-plugin-stats fetches, maintains and queries a timeseries of the number of downloads for an Obsidian plugin.

pypi-stats-timeline fetches, maintains and queries a timeseries of download statistics from the python package index PyPI used by pip.

Shell productivity tools

tmux-result returns the result of the last command by parsing tmux output, if you are using tmux.

zshnip is a zsh snippet framework that I made (and use almost continually) to type less, make fewer mistakes, and be more happy by defining snippets as I go while I use the command line.

kitty-plotnine (k-nine) is a tool to plot directly in terminals which support the kitty Graphics Terminal Protocol such as kitty, wezterm, konsole (or ghostty - which you shouldn’t use) with shell one-liners.

persist-ssh is a wrapper around ssh which uses dtach to persist your ssh connection while retaining your shell scrollback. I use this so that I can run tmux on my machine while sshing into other machines instead of running tmux remotely.

Sysadmin tools

env-subset is a swiss-army knife of running commands with a different set of environments written in response to the limits of the env command-line tool

killable-sudo runs a process with sudo but in such a way that the process can be killed by the user who spawned it, for example by process managers like circus or supervisord. This is particularly useful for automated users using sudo as a form of limited increased privilege.

Home automation

Home automation allow aspects of your physical life to be made easier, more enjoyable and more productive. I therefore use some home automation technologies - mostly for physical buttons and switching devices on and off.

tuya-tiny-web is a tool to control (though not set up) tuya wifi devices locally through a web service. It can be used over unix domain sockets to limit access. For those seeking customized programmatic control, I would recommend buying zigbee devices - but I bought a number of these devices before understand suck nuances.

LLM tools

I was using LLMs slightly before they were massively trendy.

human-tar is a tool to handle a human-readable format inspired by tar which contains multiple files. llm’s can handle these files.

GUI automation

xclip-json displays all of the targets (types of data) on the X11 clipboard in machine-readable JSON. Tools tend to place multiple things on the clipboard and knowing the complete clipboard can be helpful.

clipboard-many-files is a command-line tool to place multiple files on the clipboard on X11 for linux.

x-open-point will open an application provided on the command line at a particular location and size on the screen.

i3wm tools

I used to use the i3 tiling window manager and wrote a few tools for this. I am mostly using KDE at the moment.

JSON tools

json-wmctrl is command-line tool to display information about Linux X windows in a JSON format that can be searched with jq with other programs. It is named after the program wmctrl that performs similarly functionality but in a less machine readable way. It provides an option to cycle windows

json-xwininfo gets information about a window in X11 from the command-line.

json-leaves reads an object in JSON and outputs all of the values within it along with a “path” to the value suitable for grepping. This can then used in jq, Python or JavaScript. This has lots of flags for varying the output

short_schema is a tool to understand the shape of JSON data without having to read it by creating a easily readable schema of the JSON data with the help of GenSON.

If this is the sort of stuff you find interesting. You might like to follow me on github, or on X where I post about such things. You might also like to read the technical miscellany section of my blog.

Also, let me introduce myself - I’m readwithai when not creating productivity tools I’m interested in agency, research and reading and making tools related to this - sometimes using Obsidian. If this is interested in you might like to read my blog.

I’m using KDE at the moment in which creating these shortcuts is fairly straightforward. In the past, I have used tiling window managers such as i3 and lua where this is equally straight forward.

The keybindings I use

I end up have a shortcut for: Firefox, Obsidian, a terminal, and Emacs. For other things I fall back to using rofi which provides a fuzzy switcher based on window titles

Ensuring that the PATH is set correctly

One consistent annoyance is ensuring that the path is set correctly when an application is launched by the window manager.

I have two tricks here.

First you can use env -i command to run a command with an empty environment from the shell - you can then make sure that your command will work regardless of the environment that your window manager provides.

I also have a wrapper called withbashrc which runs bashrc and then runs a command so that everything I add to my bashrc is still on my path when I run something.

#!/bin/bash

export PATH=$PATH:/usr/bin:~/.extraconfig/bins/pathmerge
export HOME=~

export NO_SSH_AGENT

source ~/.bashrc
"$@"

I use this like withbashrc command

Cycling windows

wmctrl works well enough, provided you have precisely one window. I tend to do this because it makes switching app windows… but I’m experimenting with having a couple of Obsidian windows open at the moment while working on some tools for reading. For this, I have a solution where I order all windows arbitrarily and then cycle to the next unfocused Obsidian if I press the “raise Obsidian keybinding again”.

Because the output of wmctrl didn’t have all the informaion I needed (namely the window class) in its output from wmctrl -l I ended up writing my own link wmctrl that output json information and had an option --next-unfocused to cycle through windows. I put this in pip and on github so it is available everywhere.

I then used the following command:

json-wmctrl  --class "obsidian" --next-unfocused | jq .id  | xargs wmctrl -i -a

Which either raised the first obsidian window or cycles through the windows.

Open that app if it not running

The world is simpler if you have fewer concepts and fewer moving parts, so it can be simpler if you use the same keybinding to both open an app and raise it. I haven’t gotten around to get this working when also cycling between windows, though this wouldn’t take too much work.

If you only have a single window for an app a nice approach is to use the raise-or-run command line-tool, written in Rust. You can install this with:

cargo install run-or-raise

(If you search on github, you will find a lot of different run-or-raise programs!).

I then use the following command to, for example, start or raise the brave browser. I use json-wmtrl as above to get the class for this query.

run-or-raise 'class = "Brave-browser"' brave-browser

Finishing up

So I’ve documented the tricks I use. I have this is useful. If you find this interested you might like to:

1. Have a look at this command-line to list windows in JSON that I made.

2. Look at various other technical hacks on my blog

3. Have a look at my review of how people use Obsidian for note taking. I find maintaining a bit of a “second brain” to hold my hands while doing work quite handy and this summarize some use cases.
   

I am readwithai. I make tools related to reading, agency and productivity often related to Obsidian and write a bit about this.

If any of this seems interesting you can follow me on X where I often post about cli / linux tricks, or follow me on my blog where I intend to post more about work related to Obsidian - part form this selection.

Update: It looks like uv supports per script run time environments specified in file which achieves the same thing as this tool and is more standard. I suggest you use this.

I have a confession to make. I used to use my system Python for a lot of things… and it wasn’t really that much of an issue. Sure for real work I would use virtualenvs but for the day-to-day tools that made my life easier, I would just shove a script on my path, use system Python to run it and things worked okay.

But it seems like these days are over, as Ubuntu has claimed ownership of python3 and told you that you can’t install things with pip . It’s an understandable move, but it does require me to reform my erstwhile ways… a bit.

If I was truly incorrigible, I would just create a virtualenv, link to its python, calling my version something like my-python and then use this for all my scripts. Or even activate a virtualenv in my bashrc. But… I felt like I should at least show a little willing so I’m using a different approach

Using PATH with a few virtualenvs

The approach that I decided to go with is still having Python scripts on my path - but have different directories on my path maintain their own Python. For example I have a directory with tools for command line video processing and in this directory I have version of python called video-python which I use in this directory.

I’ll do a quick tour of how this works. First I create a virtualenv in my directory (importantly, on my path) with this python3 -m venv env. Then I create a shim “python” called video-python which calls the Python in env/bin/python. I need to use a little bash magic here because symlinks appear to break virtualenvs. Here is the contents of

#!/bin/bash

here="$(dirname ${BASH_SOURCE[0]})"
$here/env/bin/python "$@"

I also do the same with pip to create video-pip.

Then in Python scripts that use this Python I have the following shbang (which works because video-python is on my path)

#!/usr/bin/env video-python

Turning this into a tool

Because I have quite a few directories like this, I wrapped up the logic to create these virtualenvs in a little tool called venv-python.

You can install this with pipx.

pipx install venv-python

You can then run this in the directory where you want to create a Python like so

cd bins/video
venv-python video

A note of the “correct” way of doing this

So there is another way of doing this, and it’s what I do when I make “big” tools that either need testing or want to be shared. That to create a Python project with an entry point in setup.py

    entry_points={
        'console_scripts': ['venv-python=venv_python.main:main']
    },
)

You can then install this using pipx with pipx install -f -e . . This allows you to edit the code underlying your script and works well enough. But you need to edit these entry points and rerun this command every thing you want some new scripts.

This is all just wiring so there are probably other tricks you can use.

Finishing up

I hope this is interesting, if it is you might like to follow me on X or my blog where I talk about reading tools and agency and also other technical stuff I do. I might suggest you could also like:

1. This post about sending code to ipython kernel in a virtualenv from Emacs

2. This command-line tool to use numpy from the shell

3. This library that customizes pdb to be more useable by adding custom commands.

Subscribe now

A useful function that I borrowed from a colleague’s emacs.d setup was a shortcut that returned which class or function the cursor is in when programming in Python. I used this quite a lot. I’ve found myself exploring quite a lot of TypeScript while developing some PDF reading features for Obsidian, found myself wanting this sort of feature, and so decided to implement. Hence we now have the tide-nav.el a library in Emacs for navigating an querying TypeScript - based upon the tide TypeScript IDE library.

tide-nav provides a few different functions.

The tide-nav-which-class and tide-nav-which-function show you which class or function you are in. This can be very useful when navigating large files.

Then there are some functions for jumping back to the start of a function or class definition: tide-nav-back-class and tide-nav-back-function.

I may at some point in the future (probably next time I do a lot of TypeScript code reading) add functions to navigate to the next class or function.

Blocks

I also provide some functions which act on “blocks” (namespaces, classes, functions of methods) in case you don’t want to worry about the difference between functions: tide-nav-back-block, tide-nav-which-block.

A little look under the hood

If you are interested in how this works. The function tide-command:navbar returns a complete parsed tree of the file and the rest of the functionality does tree type operations of this tree. I have a big of logic to find the “closest” tide node to the point.

There is a little hacky code to handle TypeScript that looks like this:

const func = () => {

}

Irritatingly, tide does not, as far as I can tell, let you distinguish between these lambda expressions and constants. Because of this, I use the number of lines that the tide node covers as a proxy for whether this is a function of just a constant.

Final thoughts

So that’s that. It’s worth noting that other people might use some sort of code browser for this. I’ve never quite got on with such things - they require too much clicking. imenu does allow you to jump to “nodes” in the tide tree.

If you want to use this library check out the github page.

I am readwithai. I am working on developing tools and writing around for productivity, agency and reading mostly around Obsidian.

If you are an emacs user who is interested in Obsidian you might like to have a look at my plugin Plugin REPL which adds Emacs like features for scripting Obsidian like you can script Emacs. Or you might like to read this page on Obsidian for Org mode users.

If this sounds interesting you can follow me on X or on my blog:

Subscribe now

I’ve made a small command line tool called linux-mouse-record, which records and replays mouse clicks on Linux (and probably most OSs). I found a number of too-complicated-for-me-to-use-now GUI tools for this, and a few command line tools that didn’t work, some that didn’t support linux, and a lot without any real documentation. So I guess I’m adding my tool to the mix.

It is hosted on PyPI and you install it with pipx

pipx install linux-mouse-record

You use it like this:

linux-mouse-record > events.jsonl
linux-mouse-replay < events.jsonl

The main value is really getting screen coordinates. It’s one of command-line tools for GUI automation.

I am @readwithai. I make tools for reading and research often using Obsidian. You can follow me on X or substack

.

Twitter seems to have quite a lot of bots on it. They do things like like your posts when they haven’t even read it, follow people while no actually post things, and tend to mostly be there for the link in their profile.

What’s worse reporting them is an infuriating 5 clicks and a couple of scrolls away - so while I was in a “web scraping mood” I decided to automate this using a bookmarklet - which only requires one click

To use this add this bookmarklet to your browser - then when you want to report and block someone, click on their profile page and run the bookmarklet.

To create the bookmarklet, create a new bookmark and copy and paste this for the URL:

javascript:(function()%7Basync%20function%20run()%20%7B%0Afunction%20sleep(ms)%20%7B%0A%20%20%20%20return%20new%20Promise(resolve%20%3D%3E%20setTimeout(resolve%2C%20ms))%3B%0A%7D%0Adocument.evaluate('%2F%2F*%5B%40data-testid%3D%22userActions%22%5D'%2C%20document).iterateNext().click()%20%20%0Aawait%20sleep(1000)%0Adocument.evaluate('%2F%2F*%5B%40role%3D%22menuitem%22%5D%5Bdescendant%3A%3A*%5Bstarts-with(text()%2C%20%22Report%22)%5D%5D'%2C%20document).iterateNext().click()%20%20%0Aawait%20sleep(1000)%0Adocument.evaluate('%2F%2F*%5B%40role%3D%22dialog%22%5D%2Fdescendant%3A%3A*%5Btext()%3D%22Spam%22%5D%2Fancestor%3A%3Alabel%2Fdescendant%3A%3Ainput'%2C%20document).iterateNext().click()%0Aawait%20sleep(1000)%0Adocument.evaluate('%2F%2F*%5B%40role%3D%22dialog%22%5D%2Fdescendant%3A%3A*%5Btext()%3D%22Next%22%5D'%2C%20document).iterateNext().click()%0Aawait%20sleep(1000)%0Adocument.evaluate('%2F%2F*%5B%40role%3D%22dialog%22%5D%2Fdescendant%3A%3A*%5Bstarts-with(text()%2C%20%22Block%22)%5D%2Fancestor%3A%3AButton'%2C%20document).iterateNext().click()%0A%7D%0Arun()%7D)()%3B

Obvious caveats: only report spam bots - you might be tempted to try this out on a random user but that would be unfair.

Demo

Details for the programmers among you

If you want to know how this works. I use XPaths with document.evaluate and the “.click” method in JavaScript to automate all this code. There is a bit of magic with Xpath axes and the text() method to find the correct element since nothing seems to be labelled in html any more these days.

There are some “race conditions” in the code where things take a long time to run. I work around by sleeping for a period of time. A better way to do this would be to “poll” for elements to be created but this works okay as a hack.

async function run() {
    function sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
    document.evaluate('//*[@data-testid="userActions"]', document).iterateNext().click()  
    await sleep(1000)
    document.evaluate('//*[@role="menuitem"][descendant::*[starts-with(text(), "Report")]]', document).iterateNext().click()  
    await sleep(1000)
    document.evaluate('//*[@role="dialog"]/descendant::*[text()="Spam"]/ancestor::label/descendant::input', document).iterateNext().click()
    await sleep(1000)
    document.evaluate('//*[@role="dialog"]/descendant::*[text()="Next"]', document).iterateNext().click()
    await sleep(1000)
    document.evaluate('//*[@role="dialog"]/descendant::*[starts-with(text(), "Block")]/ancestor::Button', document).iterateNext().click()
}
run()

Related

If you are interested in this you might be interested in how I automated creating twitter posts from within Obsidian.

There is a mode of developing - useful for some things - where you write individuals functions send them to an environment and test them out. This is one of the nice things about Jupyter, and related tools such as org-babel. However sometimes you want to write a script rather than produce a notebook, and force this is can be nice to send code from your editor while you build a script.

Emacs supports this natively with python-shell-send-string but this works with a python shell running natively within emacs - which can be a mess with virtualenvs. Instead I decided to try hacking something up with jupyter/ ipython kernels and it seems to work reasonably well.

With this approach I start an ipython kernel in a virtual env using jupyter kernel then I find the details of this kernel by looking in ~/.local/share/jupyter/runtime/ for the most recent JSON file. I wrote a tiny wrapper in python called jupyter-last-kernel to get this file.

Then I can connect to this from within emacs using emacs-jupyter . This has quite a lot of functionality, but I side-stepped most of this (and the setup that might come with it) by just writing this code:

(defun my-jupyter-connect-last ()
  (interactive)
  (setq jupyter-current-client (jupyter-connect-repl (s-trim (shell-command-to-string "~/bins/jupytertools/jupyter-last-kernel")))))

(evil-define-operator my-jupyter-send (beg end type)
  "Evil operator to replace a region with the current kill"
  :move-point nil
  (interactive "<r>")
  (message (jupyter-eval-string-command (substring-no-properties (buffer-substring beg end)))))
  ; (jupyter-eval-string-command (buffer-substring beg end)))

(define-key evil-normal-state-map "gYY" 'my-jupyter-send)
(define-key evil-normal-state-map "gYc" 'my-jupyter-connect-last)

so that I can select a region and send it to this ipython kernel, and see the result. (I use the evil vim emulator here - but this code is evil adapted to a “vanilla” emacs)

You can also connect up and ipython terminal to the backend as well with jupyter console --existing $(jupyter-last-kernel) if you like. This can be useful for debugging when you want a faster evaluation loop.

Here’s an example of this in use:

Some caveats:

• You don’t actually need jupyter to run the kernel, you can use ipython3 kernel instead, which oddly stores its kernel file in the same place as jupyter

• There used to be an ipython3 console command - but this seems to have been replaced with jupyter console which again, oddly, connects to ipython kernels.

• If you pull up a full jupyter notebook then emacs-jupyter has a command jupyter-server-list-kernels which might be useful.

This blog is mostly about reading, Ai and Obsidian. But if you are interested in emacs org mode you might like to read a bit about Obsidian. And if you are an emacs user who has moved to Obsidian you might like to read about Plugin REPL a plugin I wrote that brings some emacs goodness to Obsidian. Or… if you interested in reading, agency and AI you might like to read the whole blog, but I would suggest this page to get a feel.

Update: I had issues with KDE on X using using the keycode (i.e. the key that gets pressed) rather than the entered keysym which breaks keymaps with layers if there are two shortcuts with the same physical key but in differnt layers. Also wayland, a new protocol which replaces X, does not support xkbcomp as is used here (though wayland does not support many things). Together this has led me to use keyd to reimplement symbolboard at the kernel level. This has various benefits (and some limitiations) which I will discuss in another post.

For a while, I have been using a keyboard mapping I call symbolboard with Linux (I also created a similar key map with Karabiner for macs). This was achieved with a tool called xmodmap. This is an ergonomic keyboard layout for linux that moves all the modifiers onto the number keys.

There are two aims of this keyboard mapping:

1. Being less dependent on the keyboard mapping of laptops by not using the keys that tend to move (symbols and return and backspace)

2. Make the modifier keys easier to press

I achieve this by moving all the modifiers to the number row where they are easy to press with both hands, and add special “shift” keys so that I can map the numbers and symbols to the letter keys with these shift keys.

This xmodmap approach worked pretty well. However I had issues with some programs like Chrome and Obsidian which acted as though I was always holding one of the modifier keys. I have managed to work around this by using xkb. In the process of this the issues seems to be something to do with “groups”, so I don’t use this using “ISO levels instead”.

What this keymap looks like

These are the three “levels” of my keyboard map. One is mostly for symbols and motions another is mostly for numbers, though there is a bit of overlap. I have found this quite convenient to use for a view yeras.

You can use this too

I’ve released this code as on github. It should be fairly straightforward to use and edit.

Interesting practicalities

xkb in practice is quite complicated, and it’s default mode of working is quite magical. setxkbmap interacts with rule files that specify a set of keyboard mappings that run. They are different types of keyboard mapping objects, types, symbol, geometries and compatibility. I tried to fit into this world but when I discovered that I could not unmap existing keymappings, and found it difficult to stop certain keymapping files from loading (specifically the pc keyboard map was always running) I decided to opt out and use xkbcomp

xkbcomp is a lower level system than setxkbmap that is used to compile keyboard maps and load them into the X server. However, it can also dump out the current keyboard map to a text file. So I used this to dump out a complete keymap, edit it, and then reload it.

xkbcomp :0 map.xkb #dump
vim map.xkb #edit
xkbcomp map.xkb :0 # reload

This allowed me to circumvent all the magic setxkbmap logic. The downside this is that my keyboard might not work with a different type of keyboard layout. setxkbmap, while rather big, nested, and monolithic does provide a level of indirection allowing you to support different keyboards models  — but the modifier logic is quite low-level and I could not work out how to override it.

Related work

I’ve found other people trying similar things. I know that levels are quite popular with QMK developers — this loads some keyboard logic onto an external mechanical keyboard. Homerow modifiers are a common approach to make modifiers easier to press and available to both hands (like I do here).