PaulCutler.org

HyperHDR Part 5 - LEDs

Paul Cutler — Tue, 15 Sep 2026 20:38:44 +0000

If there is one part of this project that scares the hell out of me, it’s the LEDs. This is the part of the project I’ve researched the most about and still feel I know the least about.

The HyperHDR developers recommend the SK6812 5v LEDs over WS2812B, commonly known as Neopixels. The SK6812 LEDs are RGBW and add an extra white channel that Neopixels don;t have.

My TV measures 39” tall x 76” or approximately or 99cm x 193cm, so I’m going to need just under 6 meters of LEDs. And of course they come in 5 meter reels.

So not only am I going to need to solder the microcontroller and the power to the LEDs, I now have to solder two LED strips together. I will also need to add a second power run and inject power either at the end or the middle of the LED strip to make sure the LEDs have enough power to stay bright. And let’s just say my soldering skills aren’t that great.

This is where this topic being the most research of anything I’ve done yet. I’ve read articles and learn guides, I’ve watched YouTube videos, I even consulted with Claude. And I still don’t feel like I have all the information I need to start this part.

If I’ve understood everthing correctly:

I’m going to install the 3 prong AC cable into the power supply.
I’m then going to cut the LED strip along the cut line. One YouTube video suggested sacrificing one of the LEDs so you solder together two half-pads, giving you a full pad and more space. (But if I do that, I need to keep track of how many LEDs I’m using in total, as HyperHDR wants to know the total number LEDs used. That includes adding the second strip as well.)
I solder power and ground from the power supply to the LED strips.
I solder the ground and data pads to the Adafruit Scorpio GPIO16 (HyperHDR’s Scorpio firmware comes with GPIO16 as the default) and the ground goes to the power supply and the data cable goes to the data in on the LED
I’m then going to cut the LED strip again and solder ground, data, and power.
Somewhere around the 3 meter mark I’m going to solder only power and ground from the power supply into the LED strip.

I should have bought another Scorpio as backup for when I screw this up.

HyperHDR Part 4 - Space Constraints

Paul Cutler — Sat, 12 Sep 2026 15:57:46 +0000

One of the goals of the project is not to take my TV off the wall. It's a 75" Sony, and you can see from the photo there is some space to work with:

I need to find a way to mount:

HDMI Splitter
Ugreen USB Video Capture device
Raspberry Pi 5
300w power supply
Adafruit rp2040 Scorpio

..all without taking the TV down and hidden behind the TV. The power supply is the one giving me the most anxiety - I'm concerned about heat and I'm not quite sure how to mount it to the wall. There are DIN rails, but I have a feeling that's not what I want. I've found 3D printed clips that screw into the wall / studs, or I'm wondering if command velcro strips will work. I'm also worried about getting the placement just right since I need two electrical runs to the SK6812 LEDs.

I am planning on using the command velcro strips on everything else, including the Pi, the Ugreen, etc. I've printed a 3D case for the Scorpio, but I need to take another look at how it's wired and if it will work in that case.

Lastly, I need to mount a power strip behind the TV. If you look really close you can see there is apower outlet behind the TV next to a conduit run. Right now the TV and the plain white LED strip are plugged in. I'll have to figure out a way to wriggle my hands behind it to swap out what's plugged in. (More than likely it will be my wife's hands.)

Next up: LEDs

HyperHDR Part 3 - The HDMI Splitter

Paul Cutler — Fri, 11 Sep 2026 19:20:46 +0000

One of the keys to the HyperHDR setup is the splitting the video source, usually HDMI, so it goes to both the display and to the USB video capture device which is plugged into a Raspberry Pi. The Raspberry Pi analyzes the colors and it runs HyperHDR to match those colors on the screen to the LEDs.

If you still haven't watched this 30 second video, it's a great example, especially with the flashlight:

The key to splitting the HDMI signal is the abilty to bypass HDCP, high definition copy protection. Most game consoles come with HDCP off for streaming, but devices like a 4K Blu-Ray Players and the AppleTV require it.

Luckily, they make HDMI splitters with HDCP bypass, but the trick is finding one that works with your system. The first one I ordered, the HBAVLink HB-S102B looked like it would work, and it split the HDMI signal successfully, but there was no HDR output when playing a 4K Blu-Ray. HDR is high dynamic range, and it's more important than the amount of pixels (4k) - it's what makes the colors pop, and the lights bright, and the color black a deep black. Luckily, I noticed that the colors looked washed out and, sure enough, there was no HDR.

That led to me swapping out HDMI cables, eventually buying 2 new 3' cables just to make sure I had compatible ones. I emailed the company and while I waited to hear back from them, I bought the CORSAHD 4K@60Hz HDMI Splitter 1x2. That worked like a champ - HDR came right through.

But then I heard back from HBAVLink right away and they shipped me an upgraded model - and shipped it overnight! Now that's customer service, kudos to them for the quick responses via email and fast shipping. Plugged that one in and I'm good to go. If you look at the Amazon page, you'll notice it doesn't explicitly say HDCP bypass, but it worked right away.

Next up: Space requirements

HyperHDR Part 2 - Bill of Materials

Paul Cutler — Thu, 10 Sep 2026 18:39:39 +0000

Have you ever looked at a project in the Adafruit Learn Guide system and thought, "That's way too expensive for a project, but it looks cool". This is one of those projects. Though 2 items make up almost a third of the cost, it does add up. And I'm not including the Raspberry Pi 5 I just happened to have laying around not doing anything. But I was lucky and got an unexpected bonus at work, so here we go.

I've spent the better part of the week researching all of these parts. When I decide to do a project like this, I go down the rabbit hole and try to learn as much as I can. I'll have more on that when it comes time to talk about the LEDs.

The total cost, excluding the Raspberry Pi, comes in at around $350. (Gulp). The USB capture card ($100) and 2 strips of LEDs ($88) make up the bulk of the cost.

Item	Price	Notes
Pi5 power supply	$15	I've had a Pi 5 for a couple years, but just powered it off USB-C. Need to fix that.
USB capture card - UGREEN 4K@60Hz Video Capture Card	$100	Recommended by the HyperHDR team, this makes up almost a third of the cost
LEDs - 60 LED 5v - BTF-LIGHTING RGB+Cool White SK6812	$88 (2 × $44)	Of course I need roughly 6 meters and they come in 5 meter strips, so I'll need two. Again, almost a third of the total project cost. The RGBWs are recommended for the extra white channel, so choosing the Sk6812s over WS2812 Neopixels.
300w BTF-Lighting Power supply	$33	Beefy, should be more than enough. I'm worried about heat, but I'll mount it on the DIN rails below.
Pinfox 6ft 16 Gauge 3 Prong Power Supply Cord Cable	$11
Adhesive Cable Clips - 60 PCS XHF 5/8" Clear Clips	$7	Going to go with these instead of sticking the LEDs right onto the back of the TV.
3' HDMI cables	$18 (2 × $9)	Already bought, had to test the HDMI splitter.
Power supply mount / DIN rails	$10
2 USB-C to USB-A cables - Hrbzo USB-C Cable 3-Pack	$7	Can't believe I don't have a couple of these laying around.
CORSAHD 4K@60Hz HDMI Splitter 1x2	$30	More on this in the next blog post.
Adafruit rp2040 Scorpio	$15	Again, recommended by the HyperHDR team.

Next: The HDMI splitter

HyperHDR Part 1 - An Introduction

Paul Cutler — Thu, 10 Sep 2026 17:01:18 +0000

I was recently reminded of HyperHDR when they popped up in my GitHub feed after releasing version 22 last week. I had starred the project late last year when Liz Clark of Adafruit wrote up a Learn Guide for installing HyperHDR using a Raspberry Pi 5 and a Trinkey.

HyperHDR is an ambient lighting system you install behind your TV and it uses a video capture device to match the LED colors to the colors playing on your television.

Check out this 30 second video which does a great job of showing HyperHDR in action:

To contrast that, today I just have some white LEDs behind my television, this is what it looks like with the lights off:

I only have LEDs on the sides and the top, nothing along the bottom, which is something I’m looking to fix.

Over the next weeks I’ll be blogging my progress in installing HyperHDR behind my television.

Next up: Bill of Materials

100 episodes!

Paul Cutler — Mon, 07 Sep 2026 13:19:43 +0000

With the release of today's episodes of The CircuitPython Show and The Bootloader, it marks my 100th episode between the two shows. If you ever look into starting a podcast, most of the articles out there mention that the average podcaster doesn't make it past episode 7, and here we are four and a half years later.

I've had the opportunity to interview a lot of great people, I've made some friends, and made a good friend in my co-host Tod Kurt. I'm grateful to everyone who has been a guest on an episode, listened to the show, or shared it with a friend.

Here's to many more episodes!

Moviebuff

Paul Cutler — Sat, 15 Aug 2026 23:35:05 +0000

Moviebuff is a Django application originally written by retiolus that was released last August. I’m not sure how I originally came across it, but I remember it being demonstrated on Mastodon. Moviebuff allows you to track and rate the movies you watch and share them on the Fediverse.

I already have a music site and I’ve been tracking what I watch manually, so I was kind of excited for Moviebuff. I forked it right away, but there wasn’t any installation instructions and I’ve never used Django. I was able to reverse the first few things needed in the .env file, such as the Django secret key, an API key from The Movie Database, but I couldn’t figure out how to get Federation working. The code to add Federation didn’t appear to be in the original repository or any of its branches.

So there it sat. I debated a few times about opening an issue in the Moviebuff repository asking for help, but I didn’t want to bug the maintainer and I was just grateful that anything had been shared and open sourced.

After successfully using Claude Code to help create the circuitpython-bambulabs library, I pointed Claude at Moviebuff and away it went. It surprised me again when it was able to add Federation to the project based on the scaffolding that was already there, no database changes needed.

I’ve done a few projects in Pyramid and FastAPI, so Python based web frameworks weren’t totally new to me. Partnered with Claude, I went to work.

Things I’ve updated and changed:

Added dark mode and made it the default with a toggle to change light or dark mode on the home page
Added working Federation based on the buiding blocks present in the app
Changed Federation to only post when a movie is rated. Also added a Share to Fediverse button using HTMX that appears when a movie is added to the Watched Movies list
Added an environment variable and code to enable or disable registration (to avoid spammers)
Disabled the registration pages if the user is unauthenticated and registration is disabled
Updated the home page to show a legend, the five most recent movies rated, movie posters for the four most recent movies rated, and HTMX to page through the rated movies
In the Dashboard, added HTMX to page through all the Watched Movies
In each movie card, added the star ratings for the movie
Updated the datetime fields to be MON/DAY/YEAR and added commas to the movie's budget
Added a Font Awesome film icon in the upper left and made it and Moviebuff clickable to return to the home page
Added a custom footer that matches silversaucer.com
Added a CONTRIBUTING.md and CODE_OF_CONDUCT.md
Added installation instructions in the README

You can see it in action at https://moviebuff.silversaucer.com. I’ve added most of the movies I watched in Feburary and March and I’m still debating about adding earlier movies.

The code lives at Codeberg and I’ve made a synchronized mirror on GitHub. If you like it, give it a star! And if you really want to know what I’ve watched, you can follow me on Mastodon at @prcutler@moviebuff.silversaucer.com.

I’m so grateful to retiolus for creating the app and releasing it under an open source license. I’m looking forward to rating, cataloging, and sharing the movies I watch.

ListenBrainz All the Things

Paul Cutler — Sat, 13 Jun 2026 17:28:54 +0000

In the last two episodes of The Bootloader, I've covered Parachord, the cross-platform music player, and Achordion, it's accompanying music commuity. Achordion is built on top of ListenBrainz, which, per its website, keeps track of the music you listen to and provides insights into your listening habits. Looking at various ListenBrainz tools, I ended up creating (or re-creating) my own, with some help from Claude.

For the last few years, I've maintained a Now Spinning page, which I update monthly with the records that are on the turntable. ListenBrainz offers a widget you can embed in a web page, but I wanted something a little more stylish to add to my Now Spinning page. That led me to create listenbrainz-widget. It includes two widgets, the first being a "Now Playing" widget that I've embedded on my Now Spinning page that looks like this:

Using GitHub Pages, you host the HTML there and then you can embed it on any web page.

The second widget is a "Top 5 Albums" image generator that you can then share on social media. It creates a 1200x1200 PNG of the top five albums you listened to based on the data range you choose.

I even created a cool landing page for the widgets. The README in the repository has all the details on how to install and run it.

listenbrainz-autoposter

Inspired by the scrobble-blue project, listenbrainz-autoposter posts your top 5 album listens from the previous week to Bluesky and / or Mastodon. This uses GitHub Actions to automate the widget above instead of Cloudflare, like the original project.

I have it set to share my top every Tuesday, giving ListenBrainz enough time to process the previous week.

listenbrainz-to-bluesky

Another project inspired by someone else, this time it is again scrobble-blue by Will Manduffy. listenbrainz-to-bluesky adds one line to your Bluesky profile with a "Listening to" and the name of the song and the artist of your most recent scrobble. This one is self-hosted and runs via a cron job every few minutes.

Too much oversharing? Probably, but I know a few folks have liked some of the music recommendations, so I'm going to share for now.

Bambu Labs CircuitPython Library

Paul Cutler — Wed, 01 Apr 2026 15:44:13 +0000

I follow a number of people on GitHub and one of them is my good friend todbot. I noticed in my feed he he had starred an Arduino program called Bambu Helper that displays information and statistics from your Bambu Labs printer, such as the percentage progress of the current print, nozzle temperature, fan speed, and more.

That got me thinking - if it can be done in Arduino, it can be done in CircuitPython. It's been a couple years since I had a good CircuitPython project, so away I went. I started researching the Bambu API and more GitHub repositories than I can count, mostly Python projects that connect to a Bambu Printer using MQTT.

I then used MQTTX to connect to my printer and test the various MQTT methods. I was able to successfully connect to my P1P printer both through Bambu Cloud and locally over my network.

And then I cheated - I used Claude to bootstrap the project by pointing it at the API Docs and the BambuHelper Arduino app to create a proof of concept in CircuitPython. (I know, I know... the AI skeptic just used AI) It got pretty close - it did get the MQTT command to request a full status update wrong, but that was an easy fix.

I had the proof of concept working on my S3 Qualia board and 4" display:

One thing I learned, though I'm waiting to confirm, is that CircuitPython only uses MQTT 5.0, and not 3.1.1. Connecting via Bambu Cloud will connect on both MQTT standards, but the local connection only will connect using 3.1.1, which CircuitPython doesn't appear to use that I could figure out. That means you have a few extra hoops to jump through to get a token and user ID, but it wasn't that hard and I've documented the process.

Unfortunately I appear to have fried both my S3 and S2 Reverse TFTs (thanks macOS) which I wanted to prototype with. Using a $50 worth of equipment is a bit much for a project like this. But that got me thinking - what if I could create a library so people could just get the info from the printer and then build their own UI on top of it to match their choice of microcontroller and screen?

So that's what I did next, by creating the CircuitPython_bambulabs library. This is the first time I've ever created a library and I'm following along with both the Learn Guide and the design reference. Parts of the Learn Guide are outdate (hello Ruff), but overall it hasn't been bad, though I loathe writing reStructured Text and much prefer Markdown. At least the cookiecutter setup makes it easy to edit.

Assuming you've got all the settings correct in settings.toml, the library handles the MQTT setup and querying the printer to get the JSON response and breaking down that response into individual methods.

It is also possible to send commands to your printer, for example to set the bed temperature or turn the light on or off. I purposefully did not include commands, this library is only for viewing the various status messages available from the printer.

I created a simpletest that connects to the printer and prints to serial a nicely formatted list of all the information returned from the printer and a raw dump of the JSON.

The GitHub Actions for the library are currently failing as it doesn't import the bambulabs library or the wifi module. I'm not sure why yet and have asked for some help. If you want to test it out, you can clone the repo and copy the bambulabs.py file to your /lib directory or the root directory of your CircuitPython microcontroller.

When the library is finally published and is available via circup, I'll post an update to the blog. And if you have any feedback, please let me know by dropping me an email or leaving an issue or comment in the repository.

circuitpython-bambulabs Published!

Paul Cutler — Wed, 01 Apr 2026 15:44:13 +0000

Following up on my blog post from yesterday, I spent Sunday preparing the circuitpython-bambulabs library to be published.

Unfortunately, I ran into an issue with the CI where it was failing to build. Thanks to some pointers from todbot, I was able to refactor the library and move the MQTT setup into the BambuPrinter class. This makes me happy as the user doesn't have to set up MQTT, assuming they've entered their printer settings in settings.toml, the library handles connecting for you.

I also heard from Brent Rubell at Adafruit who confirmed that the MQTT library for CircuitPython uses MQTT 3.1.1 - which is odd, because while MQTTX would connect locally using 3.1.1 (and not 5.0), CircuitPython would not connect locally. I'll investigate this more as I'm guessing some people would rather connect locally instead of through Bambu Cloud.

Other things I learned:

The Creating and sharing a CircuitPython library Learn Guide needs some updates. The process to create docs on ReadtheDocs has changed, libraries use ruff now for linting instead of Pylint and black, and sharing in the Library bundle needs some updates.
The Learn Guide doesn't cover publishing to PyPi, though the cookiecutter template does include the GitHub Actions to publish the library. It took me longer than it probably shoudl to figure out how to enter the secrets in GitHub to allow it to build and upload. This would be helpful to add to the Learn Guide.
The section in the Learn Guide on Sharing in a Bundle also needs an update. The section on verifying didn't work for me, though Updating the Library list did.

Lastly, a big thank you to Foamyguy who merged my pull request to add the library to the Community Libraries right away! You can find more about the library by:

Install via circup: circup install bambulabs to install on your microcontroller. (Just tested it and it's so cool to see that work!)
PyPi
ReadtheDocs
GitHub repository (And if you like it, give it a ⭐️)

What I'm Watching - Q1 2026

Paul Cutler — Wed, 01 Apr 2026 15:39:12 +0000

It's a new year and I'm still tracking what I'm watching. I have a number of television shows still in progress. I don't write them down until the season I'm watching has finished.

Highlights include finally getting around to For All Mankind season 4 with season five having just started. I highly recommend this show if you haven't seen it. I also enjoyed Predator: Badlands, Have Fun, Don't Die, Good Luck, and The Rip. Whatever you do, don't watch Mercy. I still need to catch up on some of the Oscar nominees.

Legend

The Criterion Channel = *
4K UHD = +
AppleTV+ = ^
Netflix = ~

January

Predator: Badlands (2025)
Boogie Nights+ (1997)
The Rip~ (2026)
Dust Bunny (2025)
Landman S2
What Lies Beneath~ (2000)
For All Mankind S4^
If I Had Legs, I’d Kick You (2025)

February

Loot S3^
The Wrecking Crew (2026)
The Ballad of Wallis Island (2025)
The Assessment (2025)
The Lazarus Project S2
Is This Thing On? (2026)
Mercy (2026)
The Housemaid (2025)
Eternity (2026)^
Industry S1
Honey Don’t (2025)~

March

Crazy Stupid Love (2011)~
Mission: Impossible 2 (2001)+
Dracula (2027)
A Man on the Inside S2~
Good Luck, Have Fun, Don’t Die (2027)
Pacific Rim (2013)+
Firefly (2001)
Serenity (2005)+
Send Help (2026)
How to Make a Killing (2026)

What I'm Watching - Q4 2025

Paul Cutler — Wed, 01 Apr 2026 15:25:13 +0000

Wrapping up the year, here's everything I watched in October, November, and December, excluding sports. Because there is a lot of football that isn't accounted for, which is why my total watchlist is down. Well, that and a bit of gaming took out a chunk in November and I was traveling half of December.

I plan on continuing to track my watchlist monthly, though I'm unsure if I'll keep blogging it. A small part of me is tempted to do what Steven Soderbergh does, and track everything. But I probably really don't want to know how much time I spend watching baseball and football.

Highlights include K-Pop Demon Hunters, Peacemaker S2, Task, Wake Up Dead Man, One Battle After Another, and Pluribus. I was disappointed with A House of Dynamite, The Roses, Relay, and Good Fortune.

Legend:

The Criterion Channel = *
4K UHD = +
AppleTV+ = ^
Netflix = ~

October

Peacemaker S2
K-Pop Demon Hunters~
Task
The Parallax View (1974)*
Punch Drunk Love (2002)*
Mission: Impossible (1996)+
A House of Dynamite (2025)~
Platonic S2
The Roses (2025)

November

The Toxic Avenger (2025)
Chad Powers S1
Panic Room (2002)*

December

Tron: Ares (2025)
A Man on the Inside (2024) S1~
Parish (2024)~
Fatman (2020)~
Good Fortune (2025)
One Battle After Another (2025)
Relay (2024)
Mayor of Kingstown S1
The Running Man (2025)
Wake Up, Dead Man (2025)~
F1
Pluribus (S1)
The Copenhagen Test S1
Dogma (2000)+

Wiring Up Play Singles

Paul Cutler — Wed, 01 Apr 2026 11:56:02 +0000

Earlier this year when I finished cataloging all my records in Discogs, I then put each one into a “folder”, a way for Discogs to separate different kinds of records. It’s setup by the user, so I created a folder for each type of music I have, and the number is the ID that Discogs assigned to each one:

all_folder = 0 lp_folder = 2162484 twelve_inch_folder = 2198941 ten_inch_folder = 2162486 seven_inch_folder = 2162483 cd_folder = 2162488 tape_folder = 2162487 digital_folder = 2198943

CD, Digital and Tape don’t currently have any items in them, but I hope to at least catalog my CD collection some day, but that’s a different story.

In the music controller, the method to get an album’s information looks like this:

@view_config(route_name="play", renderer="silversaucer:templates/play/play.pt") def play(_):

album_release_id = RandomRecordService.get_folder_count(2162484) release_data = RandomRecordService.get_album_data(album_release_id) return {"release_info": release_data}

Here I’ve hard coded the folder ID (2162484) from Discogs in the method as I only want to use the folder that has only full albums (no singles, 45s, etc.).

Now it’s time to wire up the code to play a single from one of three folders:

7” or 45
10” EPs
12” singles / remixes

It looks similar to the method above, but I’ve added a random method to pick one of the three folders for me and pass the folder ID to the play service that I’ve already written for full albums:

def play_single(_):

random_folder = randint(0, 2) if random_folder == 0: single = 2162483 elif random_folder == 1: single = 2162486 else: single = 2198941 album_release_id = RandomRecordService.get_folder_count(single) print(album_release_id) release_data = RandomRecordService.get_album_data(album_release_id) print(release_data) return {"release_info": release_data}

This is where I appear to have outsmarted myself. I thought I had blogged about this, but apparently not. At one point I had refactored the first play method above - I had added the play service to accept the folder ID and pass that. I was pretty proud of myself because after the refactoring, I figured this would work for exactly what I’m trying to do now - pass the folder ID of other folders. But no, it wasn’t meant to be as it errors out:

File "/Users/prcutler/workspace/silversaucer/silversaucer/controllers/music_controller.py", line 35, in play_single release_data = RandomRecordService.get_album_data(album_release_id) File "/Users/prcutler/workspace/silversaucer/silversaucer/services/play_service.py", line 178, in get_album_data discogs_main_id = release_json["master_id"] KeyError: 'master_id'

There is no master_id returned because singles don’t have a master release! Only full albums have a master release to track all the regional releases and special pressings.

I need to think through this and decide if I’m going to write a new method in play_service to handle getting back the release information for the single or if I should write an if statement to account for the Key Error and return a different dictionary without the master_id.

I was so proud of myself for doing something I thought was Pythonic, too!

Play Singles Part 2

Paul Cutler — Wed, 01 Apr 2026 11:56:02 +0000

I was talking to my wife yesterday about my progress and she agreed that I should update my existing method used for albums to also work for singles - and that I shouldn’t just re-use that method and to avoid code duplication. It’s good to get confirmation that I’m on the right path.

But I’m stuck on how to do this.

If we look at the route to play a full album:

@view_config(route_name="play", renderer="silversaucer:templates/play/play.pt") def play(_):   album_release_id = RandomRecordService.get_folder_count(2162484)  release_data = RandomRecordService.get_album_data(album_release_id)  return {"release_info": release_data}

Here I’m manually passing the folder ID for my Discogs Folder that contains full albums (2162484). That ID is passed to a method that gets a count of how many items are in that folder to pick one at random. Once that happens, it passes the release ID of the pick to get the album’s information.

Works great for full albums. As mentioned in my last blog post, it bombs if it’s a single, because there’s no concept of a main (or “master”) release associated with EPs and singles.

So how do I refactor my code to account for this?

I started by updating the route to play a full album, adding a folder parameter to the get_folder_count method instead of passing the folder number manually:

@view_config(route_name="play", renderer="silversaucer:templates/play/play.pt") def play(_):   folder = 2162484  album_release_id = RandomRecordService.get_folder_count(folder)  release_data = RandomRecordService.get_album_data(folder, album_release_id)  return {"release_info": release_data}

And I tell that method to now return both the release ID and the folder:

def get_folder_count(folder):   discogs_api = folder_url + "?=" + api_token   # TODO Add an if statement to check for a 200 or 404 response code and redirect on 404 to error page   response = requests.get(discogs_api)   record_json = response.json()  return random_album_release_id, folder

Keeping with my goal of only using one method and passing the folder to it, I added an if statement to check if it’s the folder with full albums. If it is, get the data I know is working. If not, don’t get the data that’s not included in an EP or single.

@staticmethod def get_album_data(folder, album_release_id):   if folder == 2162484:   release_api = (  config.discogs_url  + "releases/"  + str(album_release_id)  + "?"  + config.discogs_user_token  )  print(release_api)  response = requests.get(release_api)  print(response)

But now my method to get the release information on an album broke, when it was working before:

 File "/Users/prcutler/workspace/silversaucer/silversaucer/controllers/music_controller.py", line 14, in play  release_data = RandomRecordService.get_album_data(folder, album_release_id)  File "/Users/prcutler/workspace/silversaucer/silversaucer/services/play_service.py", line 114, in get_album_data  release_uri = release_json["uri"] KeyError: 'uri'

Digging into it with another print statement, I see that the value for album_release_id is now returning the folder ID correctly, but `album_release_id is returning a tuple:

```Folder ID = 2162486 Album = (3200538, 2162486)

Which is why the API call below is screwed up:  ``` python  File "/Users/prcutler/workspace/silversaucer/silversaucer/services/play_service.py", line 114, in get_album_data  release_uri = release_json["uri"] KeyError: 'uri' https://api.discogs.com/releases/(1366279, 2198941)?&token=

But it’s a tuple! I can work with that. The folder number is always returned as the second part of the tuple and the album_release_id is always the first index. So let’s update the release_api first to use the first index:

release_api = (  config.discogs_url  + "releases/"  + str(album_release_id[0])  + "?"  + config.discogs_user_token )

And now everything works! I updated the else statement to go get the data I need and not include the values that were returning a KeyError and now with one method - that includes an if / else statement, I can get back the release information for any record in my collection, no matter what folder it’s in. If and when I add other media - especially CDs or tapes that have a main release, I’ll need to update the if statement, but future me can deal with that. I don’t even have that stuff cataloged yet. (But I made sure to add a TODO to my code so I don’t forget.

And here’s a screenshot of a random 10” EP that was returned. Yay!

June 2022 SilverSaucer Update

Paul Cutler — Wed, 01 Apr 2026 11:56:02 +0000

As usual, I haven’t blogged my progress on SilverSaucer and I’ve had some major progress since January.

First, I did follow-up on that blog post by switching from a MatrixPortal with a 64x64 LED to a PyPortal Titano.

In FastAPI, I did two things. I added a service that uses the Pillow library to convert the image from the Discogs image URL to a small bitmap that the PyPortal can use.

The second thing is that sends a message using the MQTT protocol. The PyPortal is watching for that message, and when received displays the Bitmap like above.

async def get_discogs_image(release_image_url): image_dl = requests.get(release_image_url, stream=True).raw download = Image.open(image_dl) download.save('static/img/album-art/image_600.jpg')

img = Image.open('static/img/album-art/image_600.jpg') img.quantize(colors=16, method=2) smol_img = img.resize((320, 320)) convert = smol_img.convert(mode="P", palette=Image.WEB) convert.save('static/img/album-art/image_300.bmp')

async def publish_image(image_url): client = mqtt.Client() client.username_pw_set(config.mqtt_user, config.mqtt_pw) client.connect("mqtt.silversaucer.com", 1883) client.publish("albumart", "Ping!") client.disconnect()

That was a pretty big breakthrough to get hardware working with the website back in April or May.

I then spent early last week playing with a command-line tool called discotools. I help with a little of the documentation in the python3-discogs-client library and one of the co-maintainers wrote discodos for DJs to catalog their collection. It also has the ability to match Discogs Release ID to MusicBrainz ID and using it I was able to get about half (or 400) of my MusicBrainz IDs assigned into the database. (Which is a different story about doing unnatural things with tables).

Then in the last week or so, everything has started to come together. Last week I was struggling with understanding the different kind of objects database queries could return. I was having a hard time understanding and differentiating between scalar, scalars, one_or_none, and lists. That finally clicked and in a couple of days I had re-written the random results page to mostly use the database and the page load time went from about 10 seconds down to about 2 seconds, a huge improvement. After the initial database import, which takes forever as Discogs rate limits you to one request per second, the play-album page uses the database for all information except the genres and tracklist, which are still called using the Discogs API. It turns out that the Discogs API is very slow when querying an object in your personal collection. If you do a general query on a public release object, it’s way faster. The combination of those two things led to the speed improvement.

From there I was able to quickly re-factor the play-single method to match the play-album, so I can randomly return an EP or single to play. Understanding the database query, I also added a list result to the admin page showing a list of all releases that don’t have an associated MusicBrainz ID. Last night in just hours I created the template with form and the get and post methods to manually enter the ID and store it in the database.

I also wrote a method that for the existing database entries that have the MusicBrainz ID, to query the MusicBrainz API and get the release date for that album. It worked, but the dates the API has stored include the year, year and month, and year, month and date, which is what I really want. But just like that, over half the work to build the “On this Day” feature has been done and I just need to manipulate the dates above to get the one I want.

The finish line is in site.

SilverSaucer completed!

Paul Cutler — Wed, 01 Apr 2026 11:56:02 +0000

Just like that, I crossed the finish line and SilverSaucer.com is finished. I wasn’t planning on finishing it so quick after my blog post, but on Friday it just clicked and the “On this day” feature was completed in just a few hours.

I always thought the “On this Day” feature was a pipe dream. I had no idea how I was going to tie a Discogs release to MusicBrainz and then import that date. But after discovering the discodos app a few weeks ago and working with the database having clicked last week, I was able to finish it up after discovering a key feature: the LIKE operator in SQL and SQLAlchemy.

``` today = pendulum.today(tz="America/Chicago") print("Today: ", today, today.month, today.day)

if today.month < 10: search = "0" + str(today.month) + "-" + str(today.day) else: search = str(today.month) + "-" + str(today.day)

async with db_session.create_async_session() as session: query = ( select(Album) .filter(Album.mb_release_date.like(“%” + search)) .order_by(Album.mb_release_date) ) print(query)

results = await session.execute(query) query_results = results.scalars()

The Pendulum library comes to the rescue again as it is still my favorite way to work with datetime objects.

This returns a list of rows from the database where the results are today’s date, not including the year. (There is one bug related to 6/18 I can’t track down where it displays a different result - but not both - when an order_by is added to the query).

I’m pretty happy with how everything has turned out. I’ll probably do a couple more blog posts about the project, including reviewing the project goals.

It feels weird to be done. Not necessarily elation, not relief, just weird.

Talk Python Training - Consuming HTTP Services in Python Review

Paul Cutler — Tue, 31 Mar 2026 20:14:09 +0000

Summary / tl;dr: Consuming HTTP Services in Python is a great addition to the training courses from Talk Python and Michael Kennedy. You'll come away with a thorough knowledge of the best way to get data from the internet using the requests module; you'll use real world examples and APIs from Basecamp, Github and a custom API Michael built just from the course; Michael will explain and show the concepts in an easy to learn manner with a little humor and recap each concept to make sure you understand.

In addition to being host of the well known Talk Python podcast, Michael Kennedy has also created a number of Python training courses. The first, Python Jumpstart by Building 10 Apps, launched its Kickstarter exactly a year ago this month, and was quickly followed later in the year with Python for Entrepreneurs on Kickstarter and Write Pythonic Code Like a Seasoned Developer.

I started and finished Python Jumpstart by Building 10 Apps late last year and loved it. It was a very different learning experience than the University of Michigan's Python for Everybody class on Coursera. There is an assumption with the Talk Python training courses that you have some basic understanding of computer science or programming. I don't, so I typically go a little slower and take my time with the courses.

Looking back. there are a few things I liked about the Jumpstart by Building 10 Apps course and I was glad to see continue in this latest course:

Michael makes it very easy to follow along in the beginning of the courses. Everyone learns differently, but one of the ways I learn best is to follow along by typing the code as he does in the video, helping me commit it to memory.
After teaching you a core concept and coding it into one of the apps, Michael recaps what you've just learned in its own "Concept" video. This summarizes the concept you just put into practice and reinforces what you've learned.
Compared to some of the other online courses I've taken, I really like that I know I'm learning from someone well known in the community and I believe I'm not just learning how to code, but coding best practices. I don't know if I'm explaining this right, but as an example: A few of the online classes I've taken haven't had me put the code into functions and then call them in a main(): function, for example.
The source code to the examples Michael teaches you is on Github. You can download it, star it, fork it ; but it's available if you want to follow along, code along as the course goes, or just save it for reference for the future.

I've shared my enthusiasm for the Talk Python training courses here and on Twitter and when Michael reached out to me last week asking if I was interested in having a sneak peek at his latest course, Consuming HTTP Services in Python, I jumped at it (after making sure he knew I was still a novice early in my Python learning curve). I took a look at the course overview and this is right in my wheelhouse of what I need to learn. A core part of the app I want to build is exactly what this course is about ; using the requests module to download at least a half dozen JSON feeds and then building my app around that. (My app is to build the scoring for a custom NFL Pool league ; it's not a fantasy league, it's different. All of the data comes from MySportsFeeds, who provides sports data via JSON or XML which I will consume, store in a database, and then write a Python program to calculate the league and player scores to be displayed on the league website.)

What I really liked about this course was that it was focused on one thing: consuming services. I've taken a few different Python courses online as I try and learn Python, and most are throwing all the basics that you need to know ; everything you'd expect in a beginner course, but it does get overwhelming. This was the first course I've taken that was focused on getting you really good at one thing, and in a few different ways that you might need to do it.

Immediately, I learn something new. I only knew of requests from I learned using Google and Stack Overflow. When I started playing around and putting together the building blocks of my app, I wrote the following code. MySportsFeed currently using HTTP Basic Authentication, so I have a separate file called secret.py that stores my username and password ; I may be new to Python, but I'm smart enough to have created that, import it and add it to my .gitignore file!

This code polls the Playoff Team Standings feed on MySportsFeeds and then I have some (ugly) Python code that runs a for loop to rank each of the two NFL Conferences teams from 1 to 16.

It's not a lot, it's just one line of code, but it's these little things. I had no idea the power of requests ; this is just one specific example of something I learned from this course. Another thing I learned? I should be taking the URL in the above eample, create a base_url variable and then append the feed name as another variable. This is covered in a later chapter of the course ; Consuming RESTful HTTP services. This chapter has a ton of great examples I'm going to be referencing when writing my app and using.

The Consuming RESTful HTTP services chapter is where the course really starts to take off. I ran into this with the Jumpstart course as well ; Michael does a great job in teaching you the building blocks and then the course seems to go from 0-60. This is where having previous programming experience is helpful as that jump from learning what each puzzle piece does to how you put the puzzle together clicks. For someone like me, without any programming experience, it's a big jump, but possible.

With that said, this chapter is fantastic. While I had a cursory knowledge of HTTP commands like GET and PUT, the API Michael built for the course is awesome. You have the opportunity to create your own examples and interact with the API and blog explorer app ; this isn't something you see with most online courses out there.

I also learned that I only want to use requests, and not built-ins. Though I do now have an understanding of the urlib built-in for Python 3.x if I'm ever cornered and have to use it.

I will admit to skipping the chapter on SOAP. I'm a hobbyist, not an enterprise developer who may encounter SOAP. But it's great this available for those who may need it as part of this course. This, combined with learning how to use JSON, XML, and screen scraping makes it a complete course.

The last chapter is on screen scraping. There are a ton of of tutorials and classes available on the web about screen scraping. I've taken a few of them ; one of the challenges I have with my app is figuring out the playoff seeding and I thought about scraping NFL.com, but that's a different story. This chapter kicks off with an example of using a site's sitemap.xml ; an example I've never seen before that makes so much sense once you learn about it. And if a website you want to scrape doesn't have a sitemap.xml, shame on them for not being search engine friendly. But if they don't, Michael goes through other ways to scrape a website using Beautiful Soup and does it in the most Pythonic way I've seen yet in a course.

I enjoyed Consuming HTTP Services in Python. With the requests module and JSON being a cornerstone of the app I hope to write, it was great to learn about everything I need to know to make that happen. Michael's delivery is conversational and he makes it easy to follow along and do the code examples with him, if you choose to. If you have programming experience or are coming from a different language, the videos themselves will probably teach you what you need to do in Python. If you're like me, a complete novice to Python, you'll be able to follow along, but be prepared for the jump the course will make in the Consuming RESTful HTTP Services chapter ; this moves pretty quickly, but if you've forked the Github repo you'll have access to the program Michael has written and you can (and should) write your own examples to interact with the API on the blog explorer. For $39, you're getting a well developed course from someone well known in the Python community teaching you the Pythonic way interact with services. While other online training sites might have "sales" that are cheaper, as someone new to Python who has taken some of those courses, trust me ; the Talk Python courses are well worth the money.

I'm still early in my Python journey and the two courses I've finished from Talk Python have been the best learning resources I've used out of all the books and training I've purchased (and it's a lot). I'm still working my way through Python for Entrepreneurs and am really looking forward to two of the upcoming courses using SQLAlchemy as this database stuff is way over my head right now. Thanks again to Michael for allowing me to have a preview of the Consuming HTTP Services course ; now it's time for me to take his advice from the last chapter of the course and write some code ; the best way to actually learn.

Introducing MLBPool2

Paul Cutler — Tue, 31 Mar 2026 20:14:09 +0000

After learning Python and creating NFLPool, it was time for another project. This time it was building the site for MLBPool2, which inspired NFLPool. MLBPool was the brain child of former commissioner Jason Theros who created the league and rules. Sadly, MLBPool came to an end after the 2011 season. The original site was written in ASP and none of the code was available and for the last few years after my friend resurrected the league he did almost everything by hand. I had created a Google spreadsheet / form to get all of the player’s pool picks, but scoring was a manual process and he was only able to do it a handful of times throughout the season. I had a WordPress site but as I wasn’t playing in MLBPool2, I never really updated it. (It’s still up for another week or so ; and if you’re curious, you can look at the rules on how to play).

That all changes with MLBPool2. Like NFLPool, the app is written in Python (3.6) and Pyramid. I debated about starting from scratch or just modifying NFLPool and opted for the latter. I’ve been hip deep in development for the last two months and the finish line is almost in sight. I should have been writing about the development more, but that takes away from my coding time. (Shame on me!)

The major difference from NFLPool is that players have the ability to change up to 14 of their picks at baseball’s All-Star Break. This was much more complex than I thought it would be and I realized if I was going to do it, I might as well add more and more functionality to make it easier for the player. This included:

Players can change their picks before the season starts without penalty
When changing a pick, the drop down menu defaults to the original pick a player made
I added a column when changing a pick that shows if the original pick was unique or not

The hardest part was all of the datetime calculations around changing picks. If the season hadn’t started, let the user change their picks; if the season has started, redirect the user that it’s too late to change a pick; if it’s during the All-Star Break, let them change their pick and then have the system make that pick worth half the points; and if it’s after the All-Star Break, redirect them again that it’s too late to change anything.

For whatever reason, I have a hard time working with Python’s datetime module. I had planned to use Kenneth Reitz’s Maya ; Datetime for Humans, but unfortunately the documentation is offline. I ended up going with the Pendulum module, which has been fantastic to work with and has excellent documentation. (It’s so good I emailed the developer a couple weeks ago with a thank you note). I even created a service just to deal with the date and time manipulations, rather than have Pendulum instances throughout the code. A great side benefit is that it makes testing so much easier.

As you can see in the code above, I can just create one instance for testing and change the date to before the season starts, the All-Star Break or after the break. This also fixes an issue I had with NFLPool where I did not do the datetime manipulation correctly because of timezone differences with my web server and a user was locked out of submitting picks before the deadline. This worked out so well I even added an alert to the page where you submit picks showing how much time is left until picks are due:

There are two major pieces of functionality that need to be finished. There are two complex SQL queries. One to update the unique picks and one to calculate the scoring. I couldn’t figure out how to do this in SQLAlchemy and my wife Kelly wrote direct SQL statements in the code. I was able to re-write the first one to calculate unique picks after the season started but haven’t figured out how to update it for after the All-Star Break. I don’t have the patience to learn SQL right now, so she is going to help me with those when she’s on spring break from the University of Minnesota next week. From there, it will be time for deployment ; and just in time, as players will have about ten days from deployment to when picks are due and the Major League Baseball season starts.

Pyramid is just a joy to work with and I’m so thankful for the Talk Python course that taught me to use it. (I wish Pyramid had 20% of mindshare that Flask does. Maybe it does where it matters, but there is just so much on the web about Flask that it feels like it doesn’t).

The best part about writing MLBPool2 though is my confidence level in coding in Python has increased greatly. I’m doing things in MLBPool2 that I didn’t do in NFLPool ; from manipulating datetimes, string manipulation, a lot more if / else statements, Slack integration, and more advanced Chameleon templates. I’m sure there are lot of areas that are still not Pythonic enough, but I feel more confident and I know the learning won’t stop. I’ll try and write some more blog posts about what I’ve learned and how MLBPool2 differs from NFLPool (and what I want to add back into NFLPool.)

MLBPool2 & MySQL / MariaDB

Paul Cutler — Tue, 31 Mar 2026 20:14:09 +0000

When I wrote yesterday introducing MLBPool2, I buried the lede. One of the biggest changes between NFLPool and MLBPool2 is the fact I’m now using MariaDB and MySQL as the backend instead of SQLite, which NFLPool uses. (I did look at PostgreSQL since so many Python developers seem to prefer it, but I’ve never been able to get a PostgreSQL server up and running on Linux or Mac. My sysadmin skills are nonexistent.)

Since I’m using SQLAlchemy for 90% of the SQL interactions, setting it up was pretty easy, I just needed to make sure when creating the tables I added things like string length where needed. A basic example that shows the difference between the two is the table that stores the division information. In football, it’s the NFC East, AFC North etc, and in baseball it’s the AL East, NL Central, etc.

In NFLPool it was:

class DivisionInfo(SqlAlchemyBase):  __tablename__ = 'DivisionInfo'  division_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)  division = sqlalchemy.Column(sqlalchemy.String)

And in MLBPool2:

class DivisionInfo(SqlAlchemyBase):  __tablename__ = 'DivisionInfo'  division_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)  division = sqlalchemy.Column(sqlalchemy.String(8))

Easy enough. But since SQLite is a persistent database, I learned the hard way that I need to close each session in MySQL with a session.close() statement or I see lots of fun errors like this:

OperationalError: (pymysql.err.OperationalError) (1040, 'Too many connections') (Background on this error at: http://sqlalche.me/e/e3q8)

It’s taken a lot of trial and error figuring out where I need these. I’ve learned they have to go before any return statements and even when I think I have them in all the right places, it turns out I don’t. Yesterday I was entering all of the picks for everyone who played in 2017 to do some testing (to see if the app’s results and scores match what was done by hand) and after entering six player’s picks, I ran into it again. Sure enough, in the PlayerPicks service, I didn’t have any session.close() statements when I returned all of the lists that make up the picks. I had just added Rollbar functionality to the site to keep track of errors and I was pleasantly surprised to learn that when you connect Rollbar to your Github repo, it automatically opens an issue for you on Github with the error. (Pretty cool, Rollbar!)

I’m still a little worried that after I deploy and the site has been up for a while that the “Too many connections” error is going to happen.

The other thing I forget to share was a link to the Github repo for MLBPool2. It’s open source under the MIT X11 license. I originally had NFLPool under the GPL but changed it to MIT as well. I liked the idea of it being under the GPL in case anyone ever used it and I could have access to the changes, but let’s be honest, the chances that anyone is going to use the codebase is slim to none and I’d rather be more permissive (and I have issues with the Free Software Foundation, but no need to get into that.) The key takeaway is I’m a big believer in open source and I think making it more permissive is the right thing to do.

I’m undecided if I’m going to port NFLPool to MySQL. I think it’s probably a better option, but the few how-to’s I’ve read give me pause on how to import the data from SQLite to MySQL. I’m not sure if it’s worth the effort considering all of the features I want to back port and / or add to NFLPool. (But that’s a different discussion for a different blog post).

MLBPool2 – Letting a Player Change their Picks

Paul Cutler — Tue, 31 Mar 2026 20:14:09 +0000

I’ve been blogging a little bit about MLBPool2 the last couple of weeks and now the last three months of work is complete.

I already touched on two of the biggest differences between NFLPool and MLBPool2 (the time service using Pendulum and using MySQL / MariaDB instead of SQLite).

The biggest difference between NFLPool and MLBPool2 though is players have the ability to change their picks. At the All-Star Break, MLBPool2 players can change up to 14 of their 37 picks, but those changes are only worth half points.

This required a major re-write in the way I capture and store each player’s picks. I also figured, based on how NFLPool went when I launched it, if a player was going to be able to change their picks at the All-Star Break, I might as well let them change their picks before the season starts. (I had a couple NFLPool players request to make a change, which required me to delete all their picks from the database and I just told them to do it again. But I hate touching the database.). I wrote a new service (gameday_service.py) that the app uses to figure out a few different things:

Season start
When picks are due
The All-Star Break (48 hours before and after the All-Star Game)
Season end

I already was using two methods and one for the initial picks submission and one for changes in the PlayerPicks service. If the player was changing their picks, I used an if / else statement that compared the current time to when the season started:

now_time = TimeService.get_time()  if GameDayService.season_opener_date() > now_time: """Update the picks passed from change-picks. If the season start date is later than the current time, make the new changed picks equal to the original picks, making original_pick equal to the new pick."""  Update Pick Type 1 Update the AL East Winner Pick - check to see if it has been changed if al_east_winner_pick != session.query(PlayerPicks).filter(PlayerPicks.user_id == user_id) \ .filter(PlayerPicks.season == season) \ .filter(PlayerPicks.pick_type == 1) \ .filter(PlayerPicks.rank == 1) \ .filter(PlayerPicks.league_id == 0) \ .filter(PlayerPicks.division_id == 1): session.query(PlayerPicks).filter(PlayerPicks.user_id == user_id).filter(PlayerPicks.pick_type == 1) \ .filter(PlayerPicks.season == season) \ .filter(PlayerPicks.rank == 1) \ .filter(PlayerPicks.league_id == 0) \ .filter(PlayerPicks.division_id == 1) \ .update({"team_id": al_east_winner_pick, "date_submitted": now_time, "original_pick": al_east_winner_pick})

And do a session.update to update the database.

But if it’s during the All-Star Break we need to capture that the pick has been changed (changing the value in the PlayerPicks table from 0 to 1) where the UniquePicks service will credit the player with half points:

else: """If the season has started, update picks at the All-Star Break. Do not change the original pick column and update the changed column to 1."""  Update the AL East Winner Pick for pick in session.query(PlayerPicks.team_id).filter(PlayerPicks.user_id == user_id) \ .filter(PlayerPicks.season == season) \ .filter(PlayerPicks.pick_type == 1) \ .filter(PlayerPicks.rank == 1) \ .filter(PlayerPicks.league_id == 0) \ .filter(PlayerPicks.division_id == 1).first():  if pick != int(al_east_winner_pick): session.query(PlayerPicks).filter(PlayerPicks.user_id == user_id) \ .filter(PlayerPicks.pick_type == 1) \ .filter(PlayerPicks.rank == 1).filter(PlayerPicks.league_id == 0) \ .filter(PlayerPicks.division_id == 1) \ .update({"team_id": al_east_winner_pick, "date_submitted": now_time, "changed": 1, "multiplier": 1})

When the change picks form is submitted, all 37 picks are sent from the form to the POST and viewmodel. In the controller, I checked if the number of changes was greater than 14 and would redirect them to an error page. But if there were 14 or less changes, the above code would run. If the new pick was not equal to the pick stored in the database, we’d update the pick, capture the time the player submitted changes and flag that the pick was changed. The code works, but there are 36 blocks like the one above and I couldn’t figure out a method that would work where I could pass it parameters. (36, not 37 as the tiebreaker pick can never be changed). But the key is that it works.

The multiplier is reset to 1 and if their original pick had qualified for the double points bonus, it needs to reset back to one as the UniquePicks service is re-run after the All-Star Break and then will assign a multiplier of 2 if the new pick qualifies for the double points bonus.

I plan on porting the code to allow a player to change their picks before the season starts to NFLPool to make the player’s life easier. But really, it’s to make mine easier as I don’t want to have to manually delete their picks from the database.

PaulCutler.org

HyperHDR Part 5 - LEDs

HyperHDR Part 4 - Space Constraints

HyperHDR Part 3 - The HDMI Splitter

HyperHDR Part 2 - Bill of Materials

HyperHDR Part 1 - An Introduction

100 episodes!

Moviebuff

ListenBrainz All the Things

ListenBrainz Widget

listenbrainz-autoposter

listenbrainz-to-bluesky

Bambu Labs CircuitPython Library

circuitpython-bambulabs Published!

What I'm Watching - Q1 2026

Legend

January

February

March

What I'm Watching - Q4 2025

October

November

December

Wiring Up Play Singles

Play Singles Part 2

June 2022 SilverSaucer Update

SilverSaucer completed!

Talk Python Training - Consuming HTTP Services in Python Review

Introducing MLBPool2

MLBPool2 & MySQL / MariaDB

MLBPool2 – Letting a Player Change their Picks