So, I wanted to customize the number of posts displayed per page on my Ghost CMS website using the Dawn theme. The default setting was showing only 5 posts, and I wanted to bump that up to 25.

Here's how I did it, broken down into simple steps, so it's easy to remember and follow along.

Download the theme you are currently using

First, we need to download the current theme to access the file containing the posts' settings.

Go to **Settings -> Design** in your Ghost CMS admin panel.

Edit package.json File

1. Open the downloaded theme directory and locate the `package.json` file.

2. Find the key `posts_per_page` and change its value to your desired number (For Dawn theme, by default, this was set to 5. I  changed mine to 25).

3. Save the changes to the file.

Zip Up the Directory

We need to prepare the modified theme for uploading back to Ghost CMS.

Zip up the entire theme directory, ensuring all necessary files are included (on a Mac, you can right click on the directory, and click "Compress").

Upload the Modified Theme to Ghost CMS

Finally, we need to upload the customized theme back to Ghost CMS.

1. Head back to the **Design** section in your Ghost CMS admin panel.
2. Upload the zipped directory containing the modified theme.

Fin!

So, I got tired of adding `.DS_Store` to every git repo on my Mac. I was pretty sure there would be a better way to handle this on a global way on my Mac, so I don't have to do this for every repo.

Here's what I found: You can create a global `.gitignore` file, add .DS_Store to it, and have git ignore them in all my repositories at once.

1. Create a Global Git Ignore File

Open up your favorite Terminal app, and type the following -

```bash
git config --global core.excludesfile ~/.gitignore_global
```

This command tells Git where the global `.gitignore` file is located or creates it if it doesn't exist.

2. Edit the Global Git Ignore File

Next, I had to edit this file to include the `.DS_Store` pattern.

Open this global git ignore file in your favorite Text Editor (e.g., nano or vim)
```bash
nano ~/.gitignore_global
```

Add the file/folder patterns you would like to ignore for all your repos to `.gitignore_global`
```
.DS_Store
```

By adding this line, I told Git to ignore `.DS_Store` files globally.

3. Apply the Changes

Finally, to apply the changesr run the same configuration command again:

```bash
git config --global core.excludesfile ~/.gitignore_global
```

And that's it! No more manually adding `.DS_Store` to each individual repository's `.gitignore` file. Now, my Mac ignores these files in all Git repositories.

I recently built my very first app using ChatGPT's API.

The thing about ChatGPT is that it's trained on information from the internet, but what if you want it to answer questions using your custom data? Like, let's say you have some data stored on Google Drive, and you want ChatGPT to answer questions based on that.

I ran into this super helpful post by Greg Bagues, explaining how to do just that using Google Drive API and Langchain, and Python. I won't reproduce all the steps here, because he does a phenomenal job at explaining the concepts, and the steps.

I did, however run into some errors, which I want to document here

Greg's instructions worked for the most part, except I ran into some credentials errors from the Google Drive API. Langchain expects the credentials.json file you download from Google's developer console to be located inside ~/.credentials/credentials.json. However, in my case, I had to manually set an environment variable using the Export command (found this fix in the GitHub repo issues for Langchain)

Here's the command I used to set the environment variable:

export GOOGLE_APPLICATION_CREDENTIALS="~/.credentials/credentials.json"

You also need to set up the OPEN AI API key as an environment variable export OPENAI_API_KEY=<YOUR OPEN AI API KEY>

Outside of that, Greg's instructions worked like a champ.

But, it seems to work only for docs. What if I wanted to query CSV?

This setup seems to work fine for documents, but when it comes to CSV files inside Google Drive, things get a little wonky. It looks like it only loads part of the CSV file, and the answers are not accurate. I will look into that in the next Mint!

This was a pretty gratifying and exciting start. Definitely going to play around more with this.

As someone who loves experimenting with Python libraries and APIs, starting new projects quickly is important. Setting up these projects can sometimes be time-consuming, and a bit annoying to be honest.

Wrote this shell script to automate the process and start coding quickly. Here's what it does -

• Prompts the user to provide a project name as a command-line argument, and throws an error message and usage instructions if the project name argument is missing.
• Creates a new project directory with the specified name.
• Sets up a virtual environment within the project directory.
• Installs required Python dependencies using pip or a preferred package manager.
• Creates sub-directories for source code, tests, and documentation.
• Generates essential files like main.py, requirements.txt, and README.md.
• Initializes a Git repository for version control.
• Opens the main.py file in Visual Studio Code in a new window.

Setting up the script

#!/bin/bash

# Check if project name argument is provided
if [ $# -eq 0 ]; then
  echo "Error: Please provide a project name."
  echo "Usage: ./start_python_project.sh <project_name>"
  exit 1
fi

# Get project name as a command-line argument
project_name=$1

# Create project directory
mkdir $project_name
cd $project_name

# Initialize virtual environment
virtualenv -p python3 venv
source venv/bin/activate

# Install dependencies (e.g., requests and numpy)
# pip install numpy

# Create project structure
mkdir src tests docs

# Create main script
touch src/main.py

# Create requirements.txt file
touch requirements.txt

# Create README.md file
touch README.md

# Initialize version control (Git)
git init

# Open main.py in Visual Studio Code in a new window
code --new-window src/main.py

echo "Project setup complete. Happy coding!"

Make the Script Executable

chmod +x start_python_project.sh

Run the Script

./start_python_project.sh my_project

[Optional] Create an alias

Open your shell's configuration file (e.g., .bashrc, .bash_profile) using a text editor,

nano ~/.bashrc

#or if you're using zsh
nano ~/.zshrc

Add the following line at the end of the file, replacing /path/to/start_python_project.sh with the actual path to your shell script:

alias newproject='/path/to/start_python_project.sh'

Using the script to create a new project

In the terminal, you can now start a new Python project by running the following command, replacing my_project with your desired project name:

newproject <project name>

Fin!

I had a bunch of todos in the Things app that I wanted to move to my notes. Manually copying them from the app didn't grab the notes in the todo, which was quite a hassle. So, I ended up writing this quick AppleScript to export all todos from a specific list in the Things app, including the notes.

tell application "Things3"
	set inboxToDos to to dos of list "Inbox"
	repeat with toDo in inboxToDos
		set todoName to name of toDo
		set taskNotes to notes of toDo
		log (todoName & " -> " & taskNotes)
	end repeat
end tell

Update: Turns out Things app provides a way to "Share" each list by right clicking the list -> Share > Copy as text.

Woke up to a 504 error this morning. It's hosted on Digital Ocean, so I reached out to support, which wasn't very helpful. They basically said this, and then dumped a bunch of not-very-helpful-generic-504-articles.

As a self-managed infrastructure as a service (IaaS) provider, we do not have access to your servers so I cannot see your environment. The answer will depend on your webserver and/or database configuration. The system and application error and access logs may include additional details that could provide more insight on this.

I hadn't changed anything on my website, so I knew it probably had nothing to do with webserver/database configurations. Nothing had changed as far as I knew. A lot of the articles pointed me to the console. I couldn't even access the console through digital ocean dashboard though. It threw an error of - "Timed out while waiting for handshake".

I then ran into this post (How to restart your Ghost site on Digital Ocean) from Dan Rowden. That gave me a hint that I should look into forcefully restarting my Ghost site. Another quick google search, and I ran into this post - 2 Ways To Reboot a Droplet on DigitalOcean.

Restarting a Droplet on Digital Ocean

To summarize - There are two ways to reboot a Droplet on DigitalOcean, these are:

1. Gracefully: Similar to that of restarting your machine through the Restart or Shut Down commands.
2. Forcefully: Similar to holding down the power button on your machine and then powering it back on again.

The graceful way wasn't working out in this case, since I couldn't even access the console. So, I went the forceful way.

1. Visit the Power tab in the Droplet.
2. Click the Power Cycle button in the Power Cycle section
3. Wait for confirmation message and wait a few minutes for the Droplet to reboot.

That fixed it. I could access the console, and the website came right back up.

So why did this happen?

During my troubleshooting, I came across this post on Digital Ocean community, pointing to memory issues being one of the causes for a 504 errors.

This reminded me that I was trying to upload a large size image (>6MB) to my Ghost site yesterday. That was taking forever to load, and timed out each time I tried it. I now wonder if that process consumed most of the RAM, and the server essentially ran out of memory. Rebooting the server must have reset the memory. That makes sense to me. I will go with that argument, and vow never to upload a 6MB PNG to my Ghost site!

I've been playing around with warp.dev, which is a new terminal app for Mac (Windows coming soon it looks like) with a focus on improving developer productivity. Looks really good, and has already improved quite a few workflows for me.

Speaking of which, it actually has a feature called Workflows, which is a more flexible and powerful version of alias'. For one they're searchable from within warp, which makes it easier to explore and use them. They're also sharable, so you can create a workflow, and share with your team members.

Here's how I created my first workflow. I wanted to see if I could create a workflow that launches a Flask app with some arguments. It's a pretty simple one, which could easily be an alias too, but I guess it's a good hello world of sorts.

Creating the workflow

Step 1: Create a subdirectory within the ~/.warp folder called worlflows (the .warp doesn't exist by default, so we will have to create this too with the -p parent flag)

mkdir -p ~/.warp/workflows

Step 2: Create a yaml file for your workflow inside this workflows directory. Here's a template

---
# The name of the workflow.
name: Uninstall a Homebrew package and all of its dependencies
# The corresponding command for the workflow. Any arguments should be surrounded with two curly braces. E.g `command {{arg}}`.
command: |-
    brew tap beeftornado/rmtree
    brew rmtree {{package_name}}
# Any tags that the workflow should be categorized with.
tags:
  - homebrew
# A description of the workflow.
description: Uses the external command rmtree to remove a Homebrew package and all of its dependencies
# List of arguments within the command.
arguments:
    # Name of the argument within the command. This must exactly match the name of the argument
    # within the command (without the curly braces).
  - name: package_name
    # The description of the argument.
    description: The name of the package that should be removed
    # The default value for the argument.
    default_value: ~
# The source URL for where the workflow was generated from, if any.
source_url: "https://stackoverflow.com/questions/7323261/uninstall-remove-a-homebrew-package-including-all-its-dependencies"
# The author of the workflow.
author: Ory Band
# The URL of original author of the Workflow. For example, if this workflow was generated from StackOverflow, the `author_url` would be the StackOverflow author's profile page.
author_url: "https://stackoverflow.com/users/207894"
# The valid shells where this workflow should be active. If valid for all shells, this can be left empty. 
# See FORMAT.md for the full list of accepted values.
shells: []

I modifed the command in this file to a python3 file, that essentially launches a flask app with some arguments.

The new workflow immediately shows up in Warp (CTRT+SHIFT+R). Selecting it from the UI pastes the command in the terminal window.

This answer on Reddit helped troubleshoot. I just commented everything, and it made the load lightening fast. Then, on a closer look, I found this mess. No idea how it got to this, but commenting out all but one of them did the trick.

Adding an alias to zshrc file

Wanted to add an alias to quickly open Sublime Text editor from the command line. Here's how -

1. Open the file ~/.zshrc in a text editor
2. Add the following line - alias sub="/Applications/Sublime\ Text.app/Contents/SharedSupport/bin/subl"
3. Close and reopen the command line, or reload by typing source ~/.zshrc

Managing Themes

Make sure you have Package Control already set up for Sublime Text 3.

You can then install and use the Skins package, which provides an easy way to manage your themes for Sublime Text 3.

Install via package manager with CMD+SHIFT+P -> Install Package -> Skins

Using Skins package to select a theme

CMD+SHIFT+P -> Skin

Fixing ohmyzsh theme symbols in Sublime Text's terminal - Terminus package

Sublime Text’s Terminus is not displaying oh-my-zsh icons

I get a generic ? where the icons should be. A similar issue but for Visual Studio Code is documented here:https://dev.to/avantar/how-to-fix-zsh-icons-in-visual-studio-code-terminal-38bbNeedless ...

Stack Overflowctrebbau

Now that I am playing around a bit more frequently with APIs, especially Twitter’s v2 API, and Airtable’s API, I have found myself playing around a lot more with Postman. It’s my new favorite app/service.

I have obviously been living under a huge rock all this while, cause I didn’t realize the power Postman. Not only can you explore APIs, but they also support things like generating docs automatically for your APIs (which I did for greetingsapi.com). They’re also working closely with popular APIs like Twitter, so publicly available endpoints are included by default inside Postman. No need to shuttle back and forth between the docs and where your code is.

Another new thing I am discovering is that they automatically generate code samples for popular languages for each endpoint. So you can essentially just copy/paste these to see them in action. This is pretty huge.

Here’s an example for Python. You can also choose Curl, and several other languages.

I have known of Postman for a while now - it's a tool you can use to explore and test APIs. I just never got down to using it much. That changed quite a bit in the last week or so.

I started playing around with it while exploring the Airtable API, and then the Twitter API this week. I also used it to create the docs for greetingsapi.com. Also, I didn't know Postman could generate docs and sample code for the endpoints automatically. Pretty cool.

Variables

I am still new to this concept in Postman, but it lets you created environment variables of sorts that you can use to make API calls without actually punching the API key etc for each of the endpoints.

Here's an example for Twitter API I was exploring yesterday. More about variables here on Postman's docs.

You then use it in the API call with {{variable_name}}.

Saw this Quick Start guide on Canva's developer portal that walks you through creating a content extension for Canva's users. It uses Node.js and Express.js as the server backend. I wanted to replicate this example using Python and Flask as the server.

What is a content extension?

This is how Canva describes it:

A content extension allows you to import third-party content, such as photos and illustrations, into Canva. Users can access this content via the side panel and add it to their designs.

How content extensions work

1. You visit the Canva Developer Portal and create an app.
2. You provide the endpoint/base URL for your app. This is the endpoint where Canva will send a POST request. One thing to note is that Canva adds "/content/resources/find" to the base URL, so your service should be answering the POST request at - your-service.com/any-custom-route/content/resources/find
3. Your service should then return the content in the following format. The content that your service responds with is used to render the content in the side panel.

{
	"type": "SUCCESS",
    "resources":[
		{
            "contentType": "image/jpeg",
            "id": "0",
            "name": "Alejandro Escamilla",
            "thumbnail": {
                "url": "https://picsum.photos/id/0/5616/3744"
            },
            "type": "IMAGE",
            "url": "https://picsum.photos/id/0/5616/3744"
        },
        {
            "contentType": "image/jpeg",
            "id": "1",
            "name": "Alejandro Escamilla",
            "thumbnail": {
                "url": "https://picsum.photos/id/1/5616/3744"
            },
            "type": "IMAGE",
            "url": "https://picsum.photos/id/1/5616/3744"
        }
       ]
}

Step 1: Build the backend service

If you already have a service that has the content, you can skip this step, and just make sure that it returns data in the format Canva is expecting (see above).

Here's the code you can use to fire up a Flask server -

#inside main.py

from flask import Flask, request, render_template
import requests 
import json

app = Flask(__name__)
app.config["DEBUG"] = True

# Define the route which will receive the POST request from Canva
@app.route("/canva/content/resources/find", methods=['POST'])
def get_content():
	# Gather the content you want to send back. Here we are using picsum.photos, a placeholder API for pictures.
    url = "https://picsum.photos/v2/list"
    r = requests.get(url)
    results = json.loads(r. text)

    resources = []
	
    # Loop through the results received from picsum API, and prepare the content in the format expected by Canva.
    for resource in results:
        content = {
            "type": "IMAGE",
            "id": resource["id"],
            "name": resource["author"],
            "thumbnail": {
                "url": resource["download_url"],
            },
            "url": resource["download_url"],
            "contentType": "image/jpeg"
        }
        resources.append(content)

    print(resources)

    return {"type": "SUCCESS","resources":resources}

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

Run the server with python3 main.py, and expose it to the internet using a tuneling software like ngrok, or you can do what I did, and hosted it on PythonAnywhere.

You can see it in action here - https://ajotwani.pythonanywhere.com/canva/content/resources/find

Step 2: Build the app on Canva developer portal.

Same as step 2 here

Step 3: Configure the content extension

Same as step 3 here

I recently went throught the process to put my side project howbigisthebaby.io on Digital Ocean's new app platform, and wanted to document it in case anyone else found it helpful (or atleast me revisiting this later).

Part 1: Setup the environment for the Flask app

Step 1: Create the virtual environment on your machine

$ virtualenv venv -p Python3

Step 2: Activate the virtual environment

$ source venv/bin/activate

Step 3: Install Flask and gunicorn

$ pip install Flask gunicorn

Step 4: Freeze the requirements in requirements.txt file

Now that you have the flask package installed, you will need to save this requirement and its dependencies so App Platform can install them later. Do this now using pip and then saving the information to a requirements.txt file:

$ pip freeze > requirements.txt

Step 5: Write code for your Flask app in app.py. Here's a simple "hello world" app

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello World!'

Part 2: Setting Up Your Gunicorn Configuration

Since we cannot use Flask's built-in server in production environment, we will use Gunicron web server Why Nginx/Gunicorn/Flask?

While lightweight and easy to use, Flask’s built-in server is not suitable for production as it doesn’t scale well and by default serves only one request at a time.
Source: Flask's docs

Step 1: Create the gunicorn config file

$ touch gunicorn_config.py

Step 2: Add this configuration to gunicorn_config.py file

# inside gunicorn_config.py
bind = "0.0.0.0:8080"
workers = 2

Part 3: Pushing the Site to GitHub

The way the Digital Ocean app platform works is that it syncs with a GitHub repo. Any changes to this GitHub repo will automatically be pushed to your app living on Digital Ocean's app platform.

Step 1: Create a new repo on GitHub.com
Open your browser and navigate to GitHub, log in with your profile, and create a new repository called flask-app.

Step 2: Then, create a .gitignore file, and add .pyc so these files are not pushed to GitHub.

$ git init
$ nano .gitignore

# inside .gitignore
.pyc

Step 3: Add files to your repository, and commit the changes

$ git add app.py gunicorn_config.py requirements.txt .gitignore
$ git commit -m "Initial Flask App"

Step 4: Add the GitHub repo you created earlier as the remote repository

$ git remote add origin https://github.com/your_username/flask-app

example: git remote add origin https://github.com/ajot/hbb-flask-webhook

Step 5: Push to GitHub

$ git branch -M main
$ git push -u origin main

Part 4: Deploying to Digital Ocean's app platform

1. Create a new "app" on Digital Ocean.
2. Choose GitHub as source
3. Choose the GitHub repo you just created
4. Follow the promots to create the app
5. Edit the run command to this - gunicorn --worker-tmp-dir /dev/shm app:app

Bonus Tip: You can also set environment variables in Digital Ocean, and then access them in your code like this -

import OS

airtable_api_key = os.environ.get('airtable_api_key')
airtable_base = os.environ.get('airtable_base')

Resources:
How To Deploy a Flask App Using Gunicorn to App Platform | DigitalOcean