Skip to content

Blog

  • in Python
  • 3 min read

Silver Saucer Update

Now that I have the ability to pick a random record to play using the Discogs API, I’ve completed one of the two big features.

I’m now debating what to do next. I have a few options, all still focused on the random album feature. (I may have to cancel the “On This Day” future, but that’s a different discussion for a different time).

Learn CSS

I need to learn CSS as the theme I’m using needs to be updated. The text colors in the theme are too dark and I had to use a hack to show the text in white. This also means that the link colors are also appearing as white and you can’t tell that they are links. In the past I’ve been able to get away with just poking at a CSS file to get done what I want, but I really should take the time to learn it. The CSS file for Silver Saucer is huge and there are parts of it when I look at it that I have no idea what it does.

Bootstrap

I think I need to learn CSS before I tackle Bootstrap. Right now when the album results are returned, everything is centered on the page. I played around with trying to justify it left and right and it doesn’t work at all visually. I need to create a Bootstrap container to put the text in so I can justify it correctly.

Release Date

The Release Date returned is when that particular version of an album was released. If it’s a re-release or repressing, that date can be very different from when the album was originally released. I think I can use the master release number to go get a list of all releases and then look at the first release in that list to get the “real” release date. It doesn’t always work in some random testing I did, but it’s a start. My idea to look at the Musicbrainz API doesn’t look like it’s any better. The other challenge with this feature is working with datetime objects, which can be frustrating. Especially considering Discogs might return the release date in multiple different formats, including just the month, month and year, or date / month / year. That will be fun to standardize.

Miscellaneous

I also need to fix the data returned in Genre. It’s a list that I currently show as a list of bullets, each on its own line. It doesn’t look quite right and I need to probably update the CSS or when iterating over the list, put it on one line. I haven’t quite figured out what to do with it yet.

I also, in theory, could deploy what I have now. But I think I'll wait just a bit.

Next Steps

I’m leaning towards tackling CSS first. I've started the Responsive Web Design class on Free Code Camp, and it's good content, but the way they have you practice I don't feel as if the information is sticking in my head. I’ve also signed up for a free (to audit) five week course on Coursera to learn HTML, CSS, and Javascript. Part of me really wants to learn just a little Javascript, but most of me doesn’t - I’d rather focus on getting better at Python as I don’t feel like I’m anywhere close from transition from novice Python to intermediate Python. But if I’m going to continue to focus on using Python for web development, which is where my passion seems to lie at the moment, I need to get better at HTML and CSS. The structure of an actual class is helpful, so I’ll probably move forward with the Coursera class for the time being.

  • in Python
  • 3 min read

Play Singles Part 2

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!

The Decemberists - Long LIve the King

  • in Python
  • 2 min read

Wiring Up Play Singles

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!

  • in Python
  • 4 min read

Displaying the Album Information

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:

Japandroids - Massey Fucking Hall

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.

Debbie Gibson - Electric Youth

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.)
  • in Python
  • 2 min read

Silver Saucer Random Play Progress

I’ve made some good progress over the last few days on being able to pick an album at random out of a given folder and get information about it.

All of the work has focused on the back-end. Once I know I’m getting the right data out of Discogs, I’ll hook up the front-end to display it, but for now, this has been a little more complex than I expected. (It always is, isn’t it?)

One thing that’s jumped out at me was I don’t understand how people do TDD (Test Driven Development). The amount of trial and error I do, even on “simple” things like building the right URL for the API call is ridiculous. I know it’s because I’m a novice at Python and I don’t do this for a living all day every day, but I have a lot of respect for those that do TDD. One of my original goals was to do this in TDD, but I have my excuses.

You can tell I’m a novice by how procedural my code is. Do this, then do that. It was working well in a very procedural manner, so yesterday I refactored it all. Yup, I ripped it up and started over. Well, not from scratch. I could visualize in my head how to make the code more Pythonic and I was able to re-use some of the code, but most of it was refactored in the play_service. A good example is going back to the folder example. I had hard coded each folder ID and each folder had it’s own method to get a random album release ID and its data.

I’ve been able to take the folder selected by the user (LP, EP or single) and just pass variable that to the method in play_service.py. This allowed me to use the same method to get the release ID information and the method doesn’t care if it’s a single or full album.

I still need to fix the loop I’m iterating through in the JSON, but I’m really close. This is one of the downsides to being a hobbyist - so much I don’t remember, including basic things, like how to iterate through a dictionary.

Practice makes perfect and I needs lots of practice. I told myself I need to think of some more projects to work on, but one project at a time. In the meantime, I should sign up for something like Python Morsels and keep up with it.

This weekend I’m hoping to fix looping over the list in the dictionary and also fix API call that deals with the pagination of results from Discogs. You can see what a mess it is in the play_service.py file and I know there has to be a better way to programmatically determine the pagination than a long if / else statement. (And if I ever get over a 1000 records it will break! Or my wife will break me when I have that many…)

  • in Python
  • 3 min read

Discogs Authentication

I was ready this morning to write a new blog post chronicling all the problems I had yesterday trying to authenticate against the Discogs API. After finding the motivation to sit down and code for a few hours, I ended the day with almost nothing done. I could access the parts of my collection that were public, but the parts that required authentication I couldn’t figure out.

I sat down with my copy of coffee this morning, re-read the Discogs API authentication documentation, and voila! It just clicked. Sometimes you just need a good night’s sleep.

You have two options for authentication when building an app with the Discogs API: full Oauth that allows users to login and validate their login, or pass a user token as part of the API query. Since my app is just going to use my Discogs information, the user token is perfect. Both authentication options give you options for a higher rate limit and the ability to return an image - and this last one will be important later.

I thought I would tackle what would be the easiest part first - have the app pick a random album for me to play.

It was a lot harder than I expected, but I’ve made good progress.

Now that I could get back details of my collection via authentication, I had Discogs return a list of all the folders I’ve organized my music into. I put each of the following into its own folder, as when I hit the random button, I don’t want it to pick a 45 or 7” record with only two songs on it. I have 10 folders, with 0 and 9 included by default:

  • 0 - all
  • 1 - 10” (10” records, mostly EPs)
  • 2 - 12” (12” singles or EPs)
  • 3 - 7” (7” or 45 rpm singles)
  • 4 - Autographed (currently empty, but you can have a release in more than one folder)
  • 5 - Cassette
  • 6 - CD
  • 7 - Digital
  • 8 - LP
  • 9 - Uncategorized

The JSON returned looks like this:

{
    "folders": [
        {
            "id": 0,
            "name": "All",
            "count": 799,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/0"
        },
        {
            "id": 2162486,
            "name": "10\"",
            "count": 19,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/2162486"
        },
        {
            "id": 2198941,
            "name": "12\"",
            "count": 30,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/2198941"
        },
        {
            "id": 2162483,
            "name": "7\"",
            "count": 76,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/2162483"
        },
        {
            "id": 2162485,
            "name": "Autographed",
            "count": 0,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/2162485"
        },
        {
            "id": 2162487,
            "name": "Cassette",
            "count": 1,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/2162487"
        },
        {
            "id": 2162488,
            "name": "CD",
            "count": 6,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/2162488"
        },
        {
            "id": 2198943,
            "name": "Digital",
            "count": 1,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/2198943"
        },
        {
            "id": 2162484,
            "name": "LP",
            "count": 666,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/2162484"
        },
        {
            "id": 1,
            "name": "Uncategorized",
            "count": 0,
            "resource_url": "https://api.discogs.com/users/prcutler/collection/folders/1"
        }
    ]
}

I then got stuck for a while before I realized I should be using the folder IDs in the resource_url and not the JSON number of 0-9.

That - plus authentication - are challenges for someone like me still learning. But progress is being made. Lots of trial and error with string concatenation to get the URLs and tokens right. The next thing to solve for: Discogs only returns 100 items in a list, making you interact with pagination to go deeper. I’ll need to do this to take the random number generated of while album to play to get its data, including the image to show, when a random album is chosen.

  • in Python
  • 1 min read

Pre-Commit Git Hooks

It was a pleasant surprise recently to get an email from Michael Kennedy at Talk Python. As a previous buyer of one of the Talk Python Everything Bundle which includes a number of different Python training courses, I was eligible for the “Pro” Talk Python podcast subscription, which doesn’t included ads.

Going through the backlog, I added a bunch of episodes, and the timing of Episode 282: Pre-Commit Framework was perfect. Just as I’m getting back into working on my projects, now is a perfect time to set up Black to help format my code. The documentation was easy to follow as well as other walk throughs on the web, and now every time I check in code, it runs black to format it Pythonically, isort to automatically sort my imports in each of my files, and I’ll be adding flake8 this weekend, too.

Thanks again for the Pro podcast subscription, Talk Python!

  • in Python
  • 4 min read

The one piece of data Discogs doesn’t have

As a record collector, Discogs is invaluable. What started as a crowd sourced website to catalog electronic music, it now has a catalog of almost every piece of recorded music. They’ve also added robust e-commerce abilities so it makes buying and selling easy - whether it’s for something popular or a rare record only made in Greece.

It can take a little work to figure out which record you have, especially if it’s something popular like Fleetwood Mac’s Rumours, which has literally hundreds of different releases, some of which come down to figuring out the engraving on the inside of the record to figure out which pressing plant made it.

The other thing that makes Discogs great is they have a Developer API available, making it easy to interact with all of the data they have stored programmatically. All of the data is available in JSON and there is also a Python library available, making it even easier.

The amount of data about each album and each of its variants is amazing. I won’t go through all of it and you can get an overview here , but it includes almost everything you could probably think of off the top of your head.

Each album release has a “master” release, that represent a set of similar releases. If an album is released this Friday, for example, and comes out on CD, cassette and vinyl, the master release would catalog each of these individually. Each individual one is a “release”. (And here’s to hoping Discogs changes the word master sometime in the near future).

Here is the master release page for Pearl Jam’s Ten, released in 1991:

Pearl Jam Ten Master Release

You can also see there are 251 different versions (or releases) of Ten on different formats. The list is currently sorted by chronological year of release and if we scroll all the way down to 2009, we can find the repress I own on vinyl. You can click through each individual release to see how it’s unique or find that particular version for sale. Clicking through we see:

Pearl Jam Vinyl Repress Release

There is one thing I am looking for to build one part of my app: What date was an album released? Neither the master release or the release of the album I own supplies anything but the year, not the full date, which is what I want to know to celebrate an album’s anniversary.

That’s by design. If you check out Discogs' Submission Guidelines , only the year is required. If you know the actual date, great, if you know the year and month, you can also input that.

I also found a forum post from a few years ago, which I can’t find now, where the Discogs developers stated they wouldn’t change the release date field to require a full year / month / day and they didn’t want to change the database schema to support that (which I don’t blame them).

But that doesn’t help me in building a web app that shows which albums were released today in history.

In addition to my pandemic induced loss of motivation, this has blocked me from moving forward. I have a couple of potential ideas to move forward.

The first is interfacing with the MusicBrainz API in addition to Discogs. MusicBrainz is a full open and free music database licensed under Creative Commons. They even link back to Discogs to make it easy to link releases. My thought is if Discogs returns a date field that doesn’t include the month and day, to then query MusicBrainz to see if they have it. I’m a little worried about responsiveness in making two queries like that, plus dealing with two different JSON schemas and matching.

The second idea may work for the majority of releases, but there is a catch at the end. Doing a random check of albums, when you look at a master release, the very first release chronologically almost always has the full date attached. I could query the API, and slice the list returned and use the date provided in the first entry in the list. But I checked one random album I had that I knew is an obscure release (Maggie’s Dream if you’re curious) and there is no date.

So I think what I’m going to do - as I need to get going and do something - is to build out and test the second option. This keeps me with just one API to learn in the short term and I can probably build a query pretty easily that will sort all of my releases by chronological order (using the trick above) that will show me how many albums don’t have a full release date. 10%? More? Less? Might as well build it out and get something done!

  • in Python
  • 1 min read

Stupid Pandemic

The COVID-19 pandemic has changed a lot of things for a lot of people. One of the things it’s done to me is made it harder to focus on my coding projects. (Part of that is I’m very deadline driven, and well, no deadlines on personal projects…)

Looking back on this year, I’ve actually accomplished a lot, but just not on the coding side. I’m just getting back to it and I have two projects I’m going to make progress on. The first one is my music centric web app built with Pyramid that interacts with my Discogs profile via the Discogs API. The second project involves a Raspberry Pi, but I’m much better at the coding side of that than I am on the hardware side. (And that’s saying something with my novice coding skills).

  • in Python
  • 3 min read

Introducing Silver Saucer

I’ve started my next Python project: Silver Saucer, which will be hosted at silversaucer.com. I originally bought the domain about ten years ago when I was thinking of going into business for myself, which never happened and I hung onto the domain name because I liked it. It was inspired by Neil Gaiman’s poem, The Day The Saucers Came, which I also have a framed art print of:

{{< figure src="day-the-saucers-came.jpg" title="The Day the Saucers Came" link="day-the-saucers-came-original.jpeg" >}}

Once upon a time, I was also a big fan of The X-Files, so it seems fitting.

With the pandemic here, I’ve had a little time to work on some long dormant projects, this being one of them. I’m stuck on another Python project (more because of the hardware than the coding), so I thought I’d find some time to work on this.

I have a few different goals of things I want to learn and practice:

Pyramid

It’s my third project using the Pyramid web framework. I don’t have an urge to learn Flask or another framework - I would like to get better at Pyramid, which I know a little. I also really like the Pyramid community. The few times I’ve become stuck and asked for help in the Pyramid IRC channel, they’ve been both welcoming and helpful. My first two Pyramid projects were based on the first training Talk Python offered for Pyramid, which used a package called pyramid_handlers which is no longer the recommend way to build a web app in Pyramid. I’m doing it the recommended way this time, using a class based approach.

Bootstrap and CSS

I know a little of HTML, enough to get by. But CSS and Bootstrap, not so much. I’ve already integrated a Bootstrap theme and tweaked it where it’s almost working, but I’m just hacking at it - I don’t really know what I’m doing and it’s something I want to get better at. I should probably find some good HTML / CSS tutorials and go through those.

Discogs API Integration

The goal for Silversaucer.com is to integrate with the Discogs API). Discogs.com is a website that lets you catalog your record collection and also includes community features and a marketplace where you can buy and sell records (or CDs or almost any kind of media). There are two things I want to build using the Discogs API:

Play a random record

I know that Discogs already has a feature on their website where you can have it randomly choose an item in your collection and if you shake the mobile app it will also show you a random item in your collection. I want to take that to the next level and sort by type (record, 45, CD, etc.).

On this day

The second things I want to build is a page that shows all records released for today’s date. This one is going to be more complicated and I’ll share more in a separate blog post.

Testing

I’ve blogged about it before, but I struggle to learn pytest. I’m going to continue to try and learn more about software testing, starting with this app.

Infrastructure

I’ve already hooked up Silver Saucer to Azure Pipelines to automatically do continuous integration. I want to integrate pytest and code coverage next. After that I may look into continuous delivery, but there’s is a lot about Azure that I don’t know.

Plenty of things to learn and keep me busy during these interesting times. Here's a teaser for making it to the end:

{{< figure src="silversaucer.png" title="Silver Saucer screenshot" link="silversaucer.png" >}}