Shane Anderson

My Django layout refactor skill

Shane Anderson — Wed, 22 Jul 2026 20:00:00 +1000

I've created an agent Skill that automatically implements my preferred Django structure as I posted about previously, you can grab it here - saves me heaps of time when setting up a new Django project!

Fixing Fronius solar inverter connectivity drop outs

Shane Anderson — Sun, 12 Jul 2026 15:01:00 +1000

From the moment my solar installation was completed I started having problems with my Fronius inverter dropping offline every few days, requiring a full hard restart to get it back on the network.

I updated the firmware, etc with no improvement but then I noticed that the dropoff pattern was pretty consistent which got me wondering if it was having an issue renewing its DHCP lease. I updated the settings to use a static IP, reserved the IP on my router so nothing else would obtain it and the inverter has had a stable connection ever since.

Use Super-C & Super-V on Linux to copy & paste like macOS

Shane Anderson — Fri, 07 Nov 2025 09:59:00 +1100

I like Linux, but one long-standing annoyance on the desktop has been that copy and paste in the terminal requires Ctrl-Shift-C and Ctrl-Shift-V as Ctrl-C is reserved for canceling jobs. Recently Omarchy implemented universal copy/paste using Super‑C and Super‑V, which fixes that annoyance, yay!

For those that are unaware the Super key is the “Windows” or “Command” key on most keyboards. Combining Super‑C / Super‑V with swapping Super and Alt in Hyprland makes copy and paste behave the like it does on macOS which resolves a small, but annoying workflow issue for me and allowing me to keep the same muscle memory across MacOS and Linux.

input{
  kb_options = altwin:swap_alt_win
}

Using the Unread RSS reader for YouTube

Shane Anderson — Sat, 13 Sep 2025 15:29:00 +1000

I've been struggling with my YouTube addiction for a fair while now. I try to only use the Subscriptions view to limit myself to the latest videos from the channels I'm subscribed to but inevitably I get pulled down the algorithm rabbit hole and waste hours watching random videos. I've considered dropping YouTube altogether but there is so much great content on there that I don't want to miss out on, luckily I've found a better way.

I've been using the Unread RSS reader for a while now on my MacBook and iPhone and it's a great piece of software, but I recently discovered you can also use it to subscribe to YouTube channels in addition to RSS feeds! After adding my YouTube subscriptions it's definitely become my favourite way to consume YouTube content, and by default I only see a short text description of the video and there's no algorithm trying to cram more videos down my throat - it's great!

EXAPUNKS cheat sheet

Shane Anderson — Sat, 23 Aug 2025 12:21:00 +1000

EXAPUNKS is one of my favourite games, and it's nice to have a cheat sheet up on my second monitor while playing so I can remember the keywords, etc so I created one.

How I structure Django projects for better maintainability 2025

Shane Anderson — Sun, 17 Aug 2025 19:07:00 +1000

When starting a new Django project I've found myself tweaking the default project structure to make it more maintainable and organized. Here's my preferred layout and the small adjustments needed to make it work from an empty directory through to a running project.

The default Django layout works fine, but I prefer using a src directory to cleanly separate the Django application code from project configuration files (pyproject.toml, README.md, etc.).

Why I Prefer This Structure

I make a few organizational changes that help keep larger projects maintainable:

Rename the project directory to config - This makes it immediately clear that this directory contains configuration rather than application logic.
Split settings and URLs into subdirectories - config/settings/ and config/urls/ allow for clean environment-specific configurations (local, staging, production).
Create a dedicated apps directory - This keeps all your Django applications organized in one place, separate from configuration.

Setting Up the Project

These steps assume you have Django installed (for example, via uv add django or pip install django).

1. Create the layout

Create the repository directory and the src/<projectname> directory that will hold your Django project:

mkdir myproject
cd myproject
mkdir -p src/myproject

The outer directory is your repository or project name. The inner config package is what django-admin startproject would normally have named after your project; we rename it to config to make its purpose obvious.

2. Run `django-admin startproject`

Run the startproject command with config as the project name:

django-admin startproject config src/myproject

This creates:

src/myproject/manage.py
src/myproject/config/__init__.py
src/myproject/config/settings.py
src/myproject/config/urls.py
src/myproject/config/asgi.py
src/myproject/config/wsgi.py

3. Create the `apps` directory

Create a directory for your applications:

mkdir -p src/myproject/apps
touch src/myproject/apps/__init__.py

4. Convert `config/settings.py` into a package

Create a settings package and move the generated file into it:

mkdir src/myproject/config/settings
touch src/myproject/config/settings/__init__.py
mv src/myproject/config/settings.py src/myproject/config/settings/default.py

Create a local settings file:

# src/myproject/config/settings/local.py
from .default import *

5. Convert `config/urls.py` into a package

Do the same for URLs:

mkdir src/myproject/config/urls
touch src/myproject/config/urls/__init__.py
mv src/myproject/config/urls.py src/myproject/config/urls/default.py

You can optionally create a local URL file:

# src/myproject/config/urls/local.py
from .default import urlpatterns

6. Update generated files that reference the old settings module

After renaming the project package to config, the settings module is no longer myproject.settings -- it is config.settings.local. The following files were generated by django-admin startproject and still contain the original default:

src/myproject/manage.py
src/myproject/config/wsgi.py
src/myproject/config/asgi.py

In each file, change:

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

to:

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings.local')

Tip: Setting this directly in the generated files means manage.py check and runserver work out of the box without relying on an environment variable or .envrc. The DJANGO_SETTINGS_MODULE environment variable can still be used to override it (for example, in production or staging).

7. Set the `DJANGO_SETTINGS_MODULE` environment variable

If you use direnv, add this to .envrc:

# .envrc
export DJANGO_SETTINGS_MODULE="config.settings.local"

Or set it manually whenever you work on the project:

export DJANGO_SETTINGS_MODULE="config.settings.local"

Required Configuration Changes

A few small changes inside config/settings/default.py are still required.

1. Adjust `BASE_DIR`

Because the config/settings directory is now nested one level deeper, BASE_DIR needs an additional .parent:

# config/settings/default.py
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent.parent

2. Update `ROOT_URLCONF`

Since urls.py was moved into a package, Django needs the new module path:

# config/settings/default.py
ROOT_URLCONF = "config.urls.default"

3. Add the apps directory to the Python path

Also in config/settings/default.py, add the apps directory to the Python path so Django can find your applications with short names:

# config/settings/default.py
import os
import sys

sys.path.insert(0, os.path.join(BASE_DIR, "apps"))

Note: Mutating sys.path is convenient for short app names like myapp, but it is order-sensitive and can cause confusing import errors. An alternative is to avoid sys.path changes and import apps using their full package path (myproject.apps.myapp).

Running the Project

Because manage.py is nested inside src/myproject/, run commands like this:

cd src/myproject
python ./manage.py check
python ./manage.py migrate
python ./manage.py runserver

Example Directory Structure

.
├── Justfile
├── README.md
├── pyproject.toml
├── src
│   └── myproject
│       ├── __init__.py
│       ├── apps
│       │   ├── __init__.py
│       │   └── mycoolapp
│       │       ├── __init__.py
│       │       ├── admin.py
│       │       ├── apps.py
│       │       ├── migrations
│       │       │   └── __init__.py
│       │       ├── models.py
│       │       ├── templates
│       │       │   └── mycoolapp
│       │       │       └── ...
│       │       ├── tests.py
│       │       ├── urls.py
│       │       └── views.py
│       ├── config
│       │   ├── __init__.py
│       │   ├── asgi.py
│       │   ├── settings
│       │   │   ├── __init__.py
│       │   │   ├── default.py
│       │   │   └── local.py
│       │   ├── urls
│       │   │   ├── __init__.py
│       │   │   ├── default.py
│       │   │   └── local.py
│       │   └── wsgi.py
│       ├── db.sqlite3
│       └── manage.py
└── uv.lock

Verification

Run the Django system check:

cd src/myproject
python ./manage.py check

Expected output:

System check identified no issues (0 silenced).

Making Change Text in Vim a bit more sane

Shane Anderson — Sun, 10 Aug 2025 09:05:00 +1000

I've been finding it super annoying that Change Text in Vim yanks the changed text to the default register, overwriting the text I had stored. I wanted something more akin to how copy and paste works on Windows or MacOS where I can have some text stored in the buffer and write on top of the existing text - so I asked Claude.AI and it gave me the following which works perfectly.

return {
  {
    "LazyVim",
    opts = function()
      -- Custom mappings for change command without affecting registers
      vim.keymap.set("n", "c", '"_c', { noremap = true, desc = "Change without yanking" })
      vim.keymap.set("n", "C", '"_C', { noremap = true, desc = "Change to end of line without yanking" })
      vim.keymap.set("n", "cc", '"_cc', { noremap = true, desc = "Change entire line without yanking" })
      vim.keymap.set("x", "c", '"_c', { noremap = true, desc = "Change selection without yanking" })

      -- Keep normal delete/cut behavior unchanged
      -- d, dd, D will still yank to registers as normal
    end,
  },
}

Adding Kagi as the default search engine in Alfred

Shane Anderson — Sat, 09 Aug 2025 12:00:00 +1000

Add Kagi as a custom search following the guide here.
In the Default Results section click on the Setup fallback results button.
Click on the + button, then Custom Search and select Kagi from the list. Drag it to the first position if you want Kagi to be your default.

How to create snippets in LazyVim

Shane Anderson — Sat, 02 Aug 2025 18:53:00 +1000

Took me way too much effort to figure this out and searching for info resulted in a lot of posts with other people asking the same question or outdated information as LazyVim has changed its plugins a bunch of times, hopefully this helps someone else out there.

This example will use the template I'm using for my blog posts and is compatible with the Blink plugin that LazyVim is using for completions (under Extras) in 2025.

mkdir ~/.config/nvim/snippets
touch ~/.config/nvim/snippets/markdown.json

{
  "pelican-post": {
    "prefix": "post",
    "body": [
      "Title: ${1:Post Title}",
      "Date: $CURRENT_YEAR-$CURRENT_MONTH-$CURRENT_DATE $CURRENT_HOUR:$CURRENT_MINUTE",
      "Category: ${2:General, Projects}",
      "Tags: ${3:aws, python, vim}",
      "Status: ${4:draft, published, hidden, skip}",
      "Summary: ${5:Brief description}",
      "",
      "$0"
    ],
    "description": "Pelican blog post"
  }
}

Now you should be able to open up a Markdown file, type post<Tab> and have the snippet appear. You should be able to tab through the fields too.

Introducing S3Fetch

Shane Anderson — Thu, 28 Jan 2021 19:00:00 +1100

Why S3Fetch?

If you've ever tried to download a large number of objects from S3 using the AWS CLI, you've probably noticed it can be painfully slow. The AWS CLI's aws s3 sync or aws s3 cp --recursive commands process objects sequentially and don't start downloading until the complete object listing is finished.

S3Fetch solves this by:

Concurrent operations: Lists objects and downloads files simultaneously in separate threads
Immediate downloads: Starts downloading the first object as soon as it's discovered, while still listing remaining objects
Optimized for prefixes: Only requests objects under your specified prefix, reducing API calls
Configurable threading: Tune performance with adjustable thread counts

Note

I wrote the first version of S3Fetch when I wasn't a very good programmer, and arguably I'm still not, but I have been working on a version 2 which gets rid of the most egregious mistakes such as the God Class, etc. That code has been pushed to main on the GitHub repo and it works, but I haven't gotten around to releasing a new package yet.

How It Works

The basic idea is pretty simple: why wait around?

Most tools (like AWS CLI) do this:

Ask S3 for a list of ALL your files
Wait... and wait... for the complete list
Finally start downloading files one by one

S3Fetch does this instead:

Start asking S3 for your file list in one thread
As soon as S3 mentions the first file, start downloading it in another thread
Keep downloading files in multiple threads while the first thread is still getting the rest of the list

So if you're downloading 1,000 files, S3Fetch is already downloading file #1 (and #2, #3, etc.) in separate threads while the main thread is still figuring out what files #500-1000 even are.

That's basically it - just use separate threads so you don't wait around when you don't have to.

Performance Comparison

For downloading 428 objects from a bucket with 12+ million objects:

AWS CLI: ~2-3 minutes (sequential listing + downloading)
S3Fetch (8 threads): 29 seconds
S3Fetch (100 threads): 8 seconds

S3Fetch is Open Source, written in Python and you can read more detailed instructions and information, raise issues or contribute if that takes your fancy via the GitHub repo.

You can also use the comment section below if you just want to chat about S3Fetch or ask questions.

Installation

Quick and easy install from PyPi. I recommend installation using pipx:

pipx install s3fetch

You can also install using pip:

pip install s3fetch

Usage

Basic usage is simple:

s3fetch s3://bucket/prefix

Common Examples

Download logs from a specific date:

s3fetch s3://my-logs-bucket/application-logs/2021-01-28

Download all files in a subdirectory:

s3fetch s3://my-data-bucket/user-uploads/images/

Download with custom thread count for better performance:

s3fetch s3://large-bucket/big-dataset/ --threads 50

Download to a specific local directory:

s3fetch s3://my-bucket/data/ --output-dir ./downloads/

When to Use S3Fetch

Large file counts: Downloading hundreds or thousands of files
Deep prefixes: When your files are buried deep in a bucket with millions of objects
Bandwidth optimization: Making full use of your connection with parallel downloads

Command Options

--threads N: Number of download threads (default: CPU cores)
--output-dir PATH: Download to specific directory (default: current directory)
--dry-run: Show what would be downloaded without actually downloading

You can find more detailed instructions in the README.

Benchmarks

Downloading 428 objects under the fake-prod-data/2020-10-17 prefix from a bucket containing a total of 12,204,097 objects.

With 100 threads

s3fetch s3://fake-test-bucket/fake-prod-data/2020-10-17  --threads 100

8.259 seconds

With 8 threads

s3fetch s3://fake-test-bucket/fake-prod-data/2020-10-17  --threads 8

29.140 seconds