PaulCutler.org

Moviebuff

Paul Cutler — Tue, 07 Apr 2026 12:52:44 +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.

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.

NFLPool - The Work Continues

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

For once in my life, I’m not procrastinating. With the NFL season just over four and a half months away, I’ve already started on working to update NFLPool.

I’m really enjoying working with Python and don’t want to let the few things I’ve learned get rusty. This includes back porting a number of updates from MLBPool2.

I've updated the Standings page to display all seasons played (before it defaulted to just the current season). This uses traversal in Pyramid to create a GET request based on the season year and automatically creates the links. This feature within Pyramid is so cool, I guess I should expand on it:

I have a standings_controller.py that creates all of the routes for the pages in Standings:

I call the StandingsService to get a list of all the seasons that exist in the database to create the index page and it shows a bullet list of each season. (Currently, this returns the one season that has been played, 2017). You can see it in action here.

You can then click on the 2017 bullet to see the player standings for the 2017 season. The code for the player standings in each season looks like:

The cool thing is season = self.request.matchdict['id'] above - when the user clicks on 2017, that’s passed to this method, that passes 2017 and makes season equal to whatever bullet the user clicked on in the list on the Standings index page, which is 2017 in this example and returns the 2017 Standings. The rest of the code passes the season variable (which is now 2017) to the database to show all of the players and their score for the 2017 season. I also updated the template that if the week is 17 or greater (there are only 17 weeks in an NFL season), the header on the page now says 2017 Final Standings, otherwise it would return 2017 Week x Standings, where x is equal to whatever week the standings have been updated through. This was helpful as last year there was an issue with how division standings were pulled from MySportsFeeds because they don’t calculate the tiebreakers in their API and they had to fix it - after they fixed it, I updated the stats from their API, but now it was “Week 18”, which technically doesn’t exist in the NFL. Now it just says final.

I also added Slack messaging that is present in MLBPool2. When a new user registers or submits their picks, I get a message in my NFLPool Slack channel.

A minor thing, but when players are selecting the NFL player they think will win in a category (such as who has the most passing yards), the dropdown box that shows a list of all NFL players now includes the player’s team and position in addition to the player’s name. Another small thing is the site administrator can update when a player has paid the annual league fee and when the admin updates to a new season the list players who have paid is reset.

Last, but not least, I’ve been working on documentation. I had already written the User Guide on how to play and make your picks, and over the last week I’ve added an Administrator’s Guide, including how to install, first time setup, how to update to a new season and how to manage NFLPool players. This is all written in reStructured Text and uses Sphinx to create the documentation and is hosted on ReadTheDocs. I still need to write the developer documentation - I have no idea how to write developer docs and am still looking for some good examples of developer documentation to crib from.

It’s a good thing I’m using Github’s issue tracker - a couple of those fixes above I had added last September after NFLPool launched and probably would have forgotten about. Between that and the documentation, it’s almost like I’m running a real open source project!

The work doesn’t end there, though. The big one I need to add the TimeService and GamedayService to make datetime management easier, especially for calculating when picks are due and displaying it on the pick submission page. I also have a couple of more bug fixes to get to and I’d like to add Twitter support to the app as well. The journey never ends.

Password Validation in NFLPool and MLBPool2

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

When I first learned to work with Pyramid thanks to the Talk Python course Python for Entrepreneurs, I used the account registration system directly from the course for NFLPool. When I wrote MLBPool2, I augmented it to require the user to use a much stronger password than the course taught. (You can see the original code from NFLPool here).

In MLBPool2, I required the user to use a password between 8 and 24 characters and it must have at least one lowercase letter, at least one upper case letter, a number, and a symbol:

A nice error message is shown each time the user doesn’t do it correctly. I was pretty proud of myself for figuring this out (and for using Stack Overflow to get some tips on how to do it).

But…. It hit me a couple weeks ago that it works great for user registration, but if they lose their password or want to reset it, none of that functionality is there. When resetting a password, the user clicks the reset password link which emails them a one-time link to reset their password. And none of the password requirements I was so proud of are in the methods for resetting a password.

It’s going to require a big re-write - right now it only has one input field for the new password. I’ll need to add a second field to require the user to enter the new password twice (similar to registration) and then add all of the requirements and the error messages to the viewmodel. So I’ll be working on that over the next week or so.

Learning pytest using continuous integration with Azure Pipelines (or SSH key hell) - Part 1

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

Introduction

I’m still on my quest to learn more Python and at the top of that list is learning pytest. I just can’t wrap my head around testing and I know my two Pyramid apps aren’t “complete” until there are tests. (I did write docs, so I have that going for me).

A couple months ago I (very easily) added continuous integration to NFLPool using Microsoft’s Azure Pipelines. I, like many other people, have been blown away by the right turn Microsoft made a few years back to embrace open source, and wanted to give Azure Pipelines a try. Every time I make a commit or Pyup.io submits a pull request to update a Python package, Azure Pipelines builds NFLPool. Of course it fails, because the tests I’ve written so far fail. To end this cycle, I really need to learn how to write tests!

I have a domain I don’t use, silversaucer.com. I have a few different ideas for some projects for the domain. I’m going to build another web app using Pyramid to start, with a goal of properly using classes in Pyramid (and not Pyramid handlers) to start. I’ve also been reading Test-Driven Development with Python, 2nd Edition, that I received from a recent Humble Bundle filled with Python books.

I was thinking that this was a perfect opportunity to learn pytest. I would create a new project in Pyramid and use TDD to write my tests as I write my code. If I’m going to do that, I might as well set up continuous integration right away and pretend I’m a real developer.

Setting up Pyramid

Since I’m going to be using a Test Driven Development philosophy, all I’m going to do is create a Pyramid project and not make any changes to it yet. I used Pyramid’s cookiecutter to create the project and then committed it to my Github repository. That’s it!

Hooking up Azure Pipelines

Here is where the fun starts. I’m not going to go through this process as Microsoft has great documentation for Azure and set up.

Walk through the setup and connect to your repository on Github. Azure Pipelines will create the needed YAML file, commit it and run your first build.

Here is where my build failed for Silver Saucer. I was getting the following error:

Obtaining silversaucer from git+git@github.com:prcutler/silversaucer.git@75932f389536b59993fa780b281170849ff92238#egg=silversaucer (from -r requirements.txt (line 38)) Cloning git@github.com:prcutler/silversaucer.git (to revision 75932f389536b59993fa780b281170849ff92238) to ./src/silversaucer Running command git clone -q git@github.com:prcutler/silversaucer.git /home/vsts/work/1/s/src/silversaucer Host key verification failed. fatal: Could not read from remote repository.

Here is where I first lost hours over the course of a few days. Azure is pulling my repository using git, not https. I would compare this to my Azure Pipeline for NFLPool, which for some reason pulls my repository using https and works fine. I know a little bit about SSH keys. I’m no expert, but all of my Digital Ocean and servers at home use SSH key authentication to log in and not passwords (yay me for good opsec!) and I have my SSH key on multiple computers without any issues.

Lots of search queries later, I learned how you can change a git repository’s remote URL, but this appears just to be on your local machine. I’m sure I’m missing something simple to make it a global change, but I never figured it out.

Ok, let’s add my SSH key to Azure Pipelines. Again, Microsoft has good developer documentation on how to do this.

Step 1: Add your public key to your Azure profile.
Step 2: In your projects in Azure Pipelines, go to Pipelines -> Library and choose Secure files. Add your private key (usually id_rsa).
Step 3: Add the SSH Task to Azure Pipelines and make sure you authorize the private key - follow Microsoft’s developer documentation for the SSH Task. Update your YAML file:

Install SSH Key

Install an SSH key prior to a build or release

task: InstallSSHKey@0 inputs: hostName: sshPublicKey: #sshPassphrase: # Optional sshKeySecureFile:

The hostname input confused me at first, but here you’re going to go into your ~/.ssh directory and copy and paste the Github entry in your known_hosts file. (This is a hidden directory in your home folder on macOS or Linux. I’m not sure where it is on Windows, sorry!) Paste your public key in sshPublicKey: and the name of your private key that you uploaded in Step 2 above. If your repository is public on Github, you are not going to want to add your sshPassphrase to your YAML file.

My SSH key fails

Again, I lost hours here. I have no idea why, but the SSH key I’ve been using for the last couple of years will not work. I had to create a second SSH key for Azure Pipelines and delete my known_hosts file, clone the repository again (which then updated known_hosts) and paste in the new fingerprint from known_hosts to the YAML file. The new key works fine, but I’ll be damned if I can figure out why my normal key doesn’t work. I’ve compared the fingerprint of my usual key, used it to clone other repositories, but Azure Pipelines refuses to work with it as I would just receive the above error over and over again.

I’m not thrilled with having a second SSH key, and now I have to go to the other two computers I work with and copy it over and add it to my keyring. But it works.

What’s next

Coming up in Part 2: Pytest works in Azure Pipelines in Python 3.6 (but not Python 3.7!)

Displaying the Album Information

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

In my last blog post, I was able to pass the folder to Discogs to get a list of albums, and then pick one at random and give me information back about the album picked. That information was returned as a dictionary and now it is time to wire it up to the Chameleon template in Pyramid that will display the HTML.

It was way easier than expected. (And if you know me, you know that the random record picked above is perfect, as I'm a huge Japandroids fan.) The first thing I did was connect the image URI that the Discogs API passes in the Chameleon template:

<img class="mb-5" src="${release_info.release_image_uri}" alt="${release_info.release_title}" />

That worked, which was awesome. The whole image is shown, and I don't have to worry about parsing any of the URL.

I quickly added the values to show the Artist, Album, and Release Date information:

Artist: ${release_info.artist_name} Album: ${release_info.release_title} Released: ${release_info.release_date}

It looks like this:

Looking at Debbie Gibson's Electric Youth, the Genre key in the dictionary returns a list:

'genres': ['Electronic', 'Pop']

With some trial and error I was able to display the list, but it showed up as code, looking like: ['Electronic', 'Pop']. No one wants to see that. The challenge is that Chameleon templates use something like a shorthand for Python code. I revisited two of my former projects where I would iterate over a list and show the results, but after lots of trial and error I felt like I was going backwards. Some more search engine queries and Stack Overflow searching I did what I always do when I get stuck: I asked my wife. It took her about 15 minutes to figure out how to loop over the list and show it in bullets:

<p><li tal:repeat="item release_info.genres" tal:content=item/>

I was so close - she pointed out the mistake I made with having two tal:repeat methods in the template. That’s what’s hard about the trial and error method of finding the solution, especially as I wasn’t writing down the methods that kind of worked. (Oops. Usually I have a note going in Bear to capture things like this, but sometimes you get in the zone and just keep trying things as you get closer. Documentation is good!)

Lastly, I changed the image size of the album image returned from Discogs, shrinking it from 400x400 to 300x300 and it seems to fit in the Bootstrap container better. You can see the difference with Debbie Gibson's Electric Youth below at 400x400 and Japandroids at 300x300 above.

Now I have lots of cleanup to do. I need to turn the text into links, for example if you click on the artist, Japandroids, it takes you to their page on Discogs. I also need to fix how it justifies and draws the bullets. I think almost all of this is done in CSS and I don't know CSS at all... (I had to cheat to make the text color white to show up on the page already.)

Random thoughts and musings:

Every time the page loads, it refreshes the API call. So if you click a link to the artist page on Discogs, for example, and then click the back button, that album data has been replaced. Not sure how to work around that, though I have some ideas. Probably a good question in IRC with the Pyramid team.
I like Chameleon templates. Not only is it the first template language I've learned, I've looked at Jinja templates and they look harder to use. They're used much more widely and that seems to lead to better documentation, but I don't have plans to change from Chameleon.
I had more thoughts, but I'm finishing up this blog post almost a week later as my internet went out.
The Release Date returned from Discogs has the same problem I've already talked about for the future "On This Day" feature I want to add. It could be just the year or the full release date, you never know what you're going to get. Look at the two screenshots above! I don't know if I want to add all the functionality to return the "correct" release date yet. I'm worried about how long the API calls take to load the page. (Even if it's just for me and I know how long it takes, I don't want it taking long.)

Next class up - Python Jumpstart by Building 10 Apps

Paul Cutler — Mon, 30 Mar 2026 23:20:12 +0000

I’ve completed the Python For Everybody course taught by Dr. Charles Severance at the University of Michigan on Coursera. All that’s left is the capstone project to put into practice what I’ve learned, but as I’m doing this to learn Python and not for the official certificate, I’m going to skip it. The course is taught in Python 2.7 and I want to shift to Python 3.x.

Python For Everybody was great. The pace and the exercises were perfect for the class. I wish I had realized sooner that there were additional exercises in the textbook that were not part of the required Coursera class. The fourth class, Python and Databases, was intense. The speed of the class was accelerated with teaching you SQL and how Python connects to databases (SQLlite specifically). The homework was much more simple in Python for Databases compared to the first three sessions. You usually had to only make some minor changes in the SQL syntax to complete the grade.

The two things I’m going to need to focus on to have success in building the two apps I want to build are dictionaries (from importing statistics via JSON) and databases. If I walked away from one thing from the Python for Databases class is that I’m going to need to spend some time with paper and pencil and plan my information architecture and database models if I’m going to be successful.

Next I’m going to start Python Jumpstart by Building 10 Apps by Michael Kennedy of the Talk Python podcast. I supported the Kickstarter earlier this year and am excited now that I hope I have enough of a base understanding of Python to tackle this. This will be taught in Python 3.x (yay!) and I’m hoping now that I have that base knowledge, building these apps along with the tutorials included will give the practice I need to later build a real app. It’s also going to go into a little more detail than what I’ve learned so far on list comprehension (which makes my head hurt), BeautifulSoup for web scraping, and Classes.

I also supported Mr. Kennedy’s next Kickstarter, Python for Entrepreneurs. This also has me excited as the second phase of building my fantasy sports app will be deploying it on the web. The description looks perfect for what I’ll need, in addition to learning the web framework Pyramid:

You will learn to build and design your web app

This course will teach you how to build a data-driven web application in Python.

We will:

Build our web app with the Pyramid web framework, "the Python web framework that supports your decisions, by artisans for artisans."

Create and connect to our database using SQLAlchemy, the most popular data access layer in Python**
Learn the core elements of web design including CSS and front-end frameworks such as Bootstrap.

Time to get to work.

On this one, I'm with Colin Powell

Paul Cutler — Mon, 30 Mar 2026 22:51:37 +0000

Last Thursday, the Minneapolis Star-Tribune ran an article saying Sen. Mark Dayton, with Sen. Coleman, would support the Amendment to ban flag-burning.

I am absolutely outraged that Sen. Dayton, would change his mind on this topic.

So Sen. Mark Dayton has hopped on the flag-burning-amendment bandwagon (Star Tribune, May 30).

Ben Seymour, in a letter to the editor in the Star Tribune, put it best:

Dayton is echoing the rhetoric used to stifle criticism of our government. “There’s something in this country that ought to be above government and all the debates in the parties,” he says.

In a democracy, no idea with broad support is above debate. We should question the motives of these politicians.

It’s pathetic when they return from their dead soldier pilgrimages with “patriotic” epiphanies, which in reality are ill-reasoned, American-ideal-desecrating attempts at popularity boosting, at best.

As you can see here on the ACLU’s page against this amendment, even Secretary of State Colin Powell, former Chairman of the Joint Chief’s of Staff, agrees with me on this one:

“The First Amendment exists to insure that freedom of speech and expression applies not just to that with which we agree or disagree, but also that which we find outrageous,” he said. “I would not amend that great shield of democracy to hammer a few miscreants. The flag will be flying proudly long after they have slunk away.”

Cuba jails dissidents over flag desecration. Is this what we have sunk to in the name of “patriotism”?

Email, fax, or write your members in Congress.

Favorite Albums of 2025

Paul Cutler — Wed, 31 Dec 2025 14:26:49 +0000

Like 2022, 2023, and last year, here’s my favorite albums and releases of 2025 in no particular order:

Album of the year: Haim, I Quit: This album was released at the perfect time and became my go to album of the summer. Fantastic from start to finish.
Best reissue: Mother Love Bone's Shine and Apple. Not only are they newly remastered, they sounded great streaming and then the records came out and sounded just as good. If you don't know the history of Pearl Jam, look up Mother Love Bone and give them a listen.
Best Soundtrack: Nine Inch Nails, Tron: Ares. It was like peanut butter and chocolate - NIN and Tron go perfectly together and they nailed (no pun intended) the soundtrack.
Favorite Surprise: Craig Finn, Always Been. As much as I love, love, love The Hold Steady, I've never been able to get into Craig Finn's solo work. But this album - Craig's stories combined with The War on Drugs as his backing band was really something special.
Favorite throwback: Momma, Welcome To My Blue Sky. Every review you read of Momma's first album or this follow-up mentions their throwback sound to the 90s indie scene. And they're right - and it works.
Favorite local release: Poliça, Dreams Go. The band's seventh record, and final album with bassist Chris Bierden, who is unable to play with his brain cancer diagnosis, did not disappoint.

That's just a few of my favorite albums and releases of 2025. Here's to 2026.