DEV Community: Salvatore Denaro

Capturing Bluesky bookmarked and favorited items via RSS

Salvatore Denaro — Mon, 03 Aug 2026 13:17:00 +0000

Bluesky has become my preferred starting point to check what is trending in the news. Back when I was still using Twitter; way back when it provided a useful free API tier, I had a script that would pull my favorites from Twitter to an RSS feed.

I recently decided to recreate that for Bluesky. While the old script just provided favorites, the new one provided feeds for both favorited and bookmarked items. I also hacked up a way to deal with multiple accounts. This time, I used FastAPI and python rather than Sinatra and ruby for the old one.

Why bother? I enjoy bookmarking things to read later and this mechanism lets me pull my bookmarked items into my RSS reader.

And this time, the code was mostly generated by Gemini 3.1 Pro via Google Antigravity.

You can check it out here.

Using Google Colab for REST API exploration and testing

Salvatore Denaro — Mon, 02 Jun 2025 14:13:00 +0000

New York City's Office of Technology Innovation provides a collection of useful APIs that let you access City data. For the past few weeks I have been playing with the APIs looking for useful application ideas and I've been using Google's colab product for that exploration. These APIs are free to access and you can sign up here.

If you are new to Colab, Google provides an introduction notebook that covers the basics. If you've used jupyter with Python you should be good to go. While Colab is frequently used for data science and AI, I think this is a great platform for building internal tools. For one specific type of user, users with lots of domain specific knowledge who may not know an API or tool, Colab is useful as a way of bundling instructions and code in a way that allows them to be productive.

Minimal code example for connecting to an end point

This is a minimal test script. It connects to an API, uses a secure way of holding the API keys and allows the user to visually set the parameters sent to the API. After execution, the JSON output is displayed. While this is fine, an a step above using CURL from the command line, this isn't what I would send to a user.


import requests

import json

import datetime

import urllib.parse

from google.colab import userdata


from\_date = "2025-05-27" # @param {type: "date"}

to\_date = "2025-06-06"# @param {type: "date"}


url = "https://api.nyc.gov/public/api/GetCalendar?fromdate={}&todate={}"

api\_url = url.format(urllib.parse.quote(from\_date), urllib.parse.quote(to\_date))


subkey = userdata.get('Ocp-Apim-Subscription-Key')

headers = {

"Ocp-Apim-Subscription-Key": subkey,

}


response = requests.get(api\_url, headers=headers)


print(response.text)

This is what it looks like on screen. The left side has the python code while the UI for setting dates is on the right.

Storing secrets outside of notebooks

Colab lets you store API keys outside of the code and use a class for accessing the keys. I highly recommend doing this rather than pasting the keys in code. Sharing a Colab notebook does not share the keys so you will need to work with users to have them install API keys but once you install a key, it is usable in any of the notebooks the user has.

Adding exception handling and extracting out the API call

First step is to extract out a function to call the API and to create a short circuit test in case there is no API key set in secrets. After that, we include error handling and the libraries we will be using below. Normally, this is code you would hide and simply execute to set up.


import requests

import json

import datetime

import urllib.parse

from google.colab import userdata

# fail quick if no API Key 

assert not not userdata.get('Ocp-Apim-Subscription-Key')

def call_api(from_date, to_date):

  try:

    url = "https://api.nyc.gov/public/api/GetCalendar?fromdate={}&todate={}"

    api_url = url.format(urllib.parse.quote(from_date), urllib.parse.quote(to_date))

    subkey = userdata.get('Ocp-Apim-Subscription-Key')

    headers = {

        "Ocp-Apim-Subscription-Key": subkey,

        }

    response = requests.get(api_url, headers=headers)

    response.raise_for_status() # Raise HTTPError for responses 4xx or 5xx

    return response
  except requests.exceptions.RequestException as e:

    print(f"Error fetching API: {e}")


  except Exception as e:

    print(f"Error while fetching API: {e}")

def extract_response(response):

  try:

    json_data = json.loads(response.text)

    return json_data
  except json.JSONDecodeError as e:

    print(f"Error decoding JSON: {e}")

Using a form for data entry

In the same way you want to avoid putting any API keys in code you should avoid having users edit code to set variables. Colab has a really nice form system. When combined with the hide code option, you can build a tool where a domain expert can populate a request and execute it without any knowledge of the internals. Avoid having users put API keys in a form. Users might email screenshots or paste them in a bug tracker and they may not be careful about leaking data.

Below is the block that includes the selection of dates and executes the function call_api.


from_date = "2025-05-27" # @param {type: "date"}

to_date = "2025-06-03" # @param {type: "date"}

# These are the two critical calls
response = call_api(from_date, to_date)

json_data = extract_response(response)

Now that we have a json response, we can figure out what we want to do with it.

Format output data

Colab has a nice data formatter for printing out tables with interactive features. Data can be sorted, filtered and exported via markdown. Overall, it's a pretty good feature set for basic reporting.

At this point the user has a way of executing the set up and then alternating between picking dates and using an interactive table. This is fine assuming all is well.

Build interactive table

from pandas import DataFrame as df

from google.colab import data_table

data_table.disable_dataframe_formatter()

table = []

for day in json_data["days"]:

for item in day["items"]:

item["day"] = day["today_id"]

table.append(item)

df = df(table)

order = ['day', 'type', 'status', 'details', 'exceptionName']

df = df.reindex(columns=order)

You end up with a table like this. While not a full featured spreadsheet, it allows for a fair amount of manipulation of the data.

Building tests

It's nice when things work nicely but that isn't always the case and in almost all cases, the time it

Pytest is a great tool for testing and I use it for most the of the Python scripts I write. And while it is possible to run pytest in Colab, I normally wouldn't bother. The process for using it exceeds the value I get so I normally just use exception handlers for critical code where I need to know the cause of a failure and simple boolean evaluations to "test" the results of my code.

In this notebook I have loud errors for the three blockers that a user might encounter, lack of a security key, the API not responding and the API not returning JSON. In cases where everything runs but the chart can not be populated, I section called Test Results Dump.

Testing and reporting errors

The general form for testing software is Given, When, Expect. I don't remember where I learned that from but whenever I am writing tests, I keep those three words in that order in my head.

If I am given a URL, when I call the URL with these values I expect the following outcomes. In order to follow that best practice I need to rewrite the code to extract out some functions and break the code down into sections that can be executed individually. The section that calls the API and then runs the tests should be able to executed multiple times with different inputs. And it should be possible to export the results in a way that could be attached to a bug tracking system.

Normally I would follow the Right Bicep rules but I am only going to test the three things that would break my use case, which is a script to automatically add exceptions to my calendar.

That there is a collection of items under "days" that is equal to the date range between from and to.
That for any day, there are three items-Alternate Side Parking, Collections and Schools.
If schools are closed, or trash pick up is delayed or suspended or alternate sides parking is suspended, that there is a non empty exception for the item.

Dumping test output

Executing the code in the Test Results Dump results in executing some test code that inspect the JSON that is returned to see if it conforms with the expectations. If a field is renamed or some other data is added then one or more tests will fail and hopefully lead to information that is useful in mitigating any issues.

Dump Out Test Table

This is a row by row test dump, run this if you dont' get the pretty data report

print(f"from_date: {from_date}")

print(f"to_date: {to_date}")

print(test_not_empty(response.text))

print(test_not_empty(json_data))

print(test_date_range(json_data["days"],from_date,to_date))

this should be a parameterized test

for day in json_data["days"]:

print(day)

for item in day["items"]:

print(test_item(item))

This results in a blob of test that can be opened in an editor. While it isn't pretty, it can be read.

The bonus round

This is a list of items that I may not be needed but I think are worth mentioning.

Charts

Colab can make use of matplotlib and Seaborn for charting. While not useful for me in this case, you can quickly create a chart like this.

Working with Google Sheets

Colab can import and export from Google Sheets. I've used this feature to turn Colab into a report generation tool more than once. I've used it to add rows, columns and new workbooks as a way to keep up to date metrics.

The example I am using requires saving a JSON file with Auth information to your Google Drive. If you'd rather not use that approach, I wouldn't blame you as its the equivalent of storing ssh keys in your Google drive.

In those cases, look at the bottom of the data table for this button. It will walk you through creating a live interactive Google Sheet embedded in your notebook.

Using custom runtimes

If you use Google Cloud, you can set up a Compute Engine instance as your back end. This is useful in cases where you have a secure cloud environment and you would like to a access the databases, APIs and other resources while using the same security.

Running a local copy

Colab allows you to export a notebooks to, and import a notebook from, GitHub. You can grab a copy of this example from here.

Both Visual Studio Code and IntelliJ have Python plugins that will execute Python notebooks. You'll have to adjust the way you store keys and remove the Google specific libraries but the notebook would run as expected.

Hope this is useful.

If you found this useful and want to encourage me to write more, feel free to comment either here or where ever you found this.

Setting up Twitter Cards in Blogger

Salvatore Denaro — Sat, 05 Jun 2021 05:25:00 +0000

There are plenty of blog posts explaining how to add Twitter Card integration to your Blogger posts but I haven't seen any that are written for the newer Blogger UI. The code that does the integration hasn't changed since this article in 2013, but the steps to add it to your theme have.

If you haven't logged onto Blogger, do so. You should see this panel on your left.

Pick "Theme" and you will see something that looks like this on the top portion of your screen.

First things first, make a backup. Click on the little arrow

If you are using the classic themes, it will look like this.

After clicking on the arrow, pick Backup. Download the file. It's the same for classic themes.

Pick download. Save the file somewhere just in case you need to recover your theme. While editing your theme will not destroy any of your pages or posts, it can cause problems for the theme you are using if you make a mistake. If you've spent some time editing your blogroll and customizing your colors and fonts, you don't want to lose this so make sure you make a backup.

Now that you have a backup, pick Edit HTML.

If you are using the classic theme, click on EDIT HTML button rather than activate the context menu from the drop down.

You should see some scary looking HTML code in a code editor. Click anywhere in the code editor. Once you do that, you need to activate search. If you are using a Mac, pick command-F to search. On windows it should be control-F.

If you see this search box, you did it correctly.

If you see the browser search box, you didn't click in the code editor. Close the browser's search pop up and then click in the code editor and try the search command again.

Search for by typing that and then hitting enter. This will search for the bottom of the head element.

If you see something like this, you are in the right spot. You should see the tag, which marks the end of the page's head portion and the start of the body of the web page.

Now you need to copy over the text . Copy it from the block below.



/b:if

/b:if

/b:if

Following the instructions from this article in 2013 you need to edit the following.

YOUR-BLOG-URL

This the full URL for the blog.

URL-FOR-IMAGE-YOU-WANT-TO-USE-IF-THERE-IS-NOT-A-THUMBNAIL-PHOTO-IN-THE-POST

This is an image to use when there is no image in the article. You can pick an image previously uploaded to your blog or your Twitter profile image. I removed that block for this blog by deleting this entire section:

/b:if

And lastly, the optionally YOUR-TWITTER-ACCOUNT-NAME

You can remove that line if you do not want to use it.

This is what it looks like on this blog.

The text needs to be inserted before the tag as the code will only work properly in the page header and not in the page body.

When you are done making those edits, click on the floppy icon to save. It is on the top right corner.

Then click on the arrow in the top left to go back to the dashboard screen.

You can now test this by tweeting a URL from your blog. If its is working you should see a tweet card with an image from your post, title and blog URL.