I tried and joined Hashnode couple of months ago and i am really in love with this awesome platform. I was visiting the Hashnode public APIs to create mobile application for https://djangotherightway.com which is hosted on hashnode as well. Upon visiting and playing with the Hashnode Public APIs i created a mobile application which i am planning to open source soon. But for this article/tutorial i will be using same public APIs to create a simple console based Python script/application to read articles on terminal.
I will be trying to divide up this article into multiple sections so that it will help you understand
- Hashnode Public APIs
- Consuming external APIs with Python
- Creating a real world Python Application
Hashnode Public APIs
You can find Hashnode Public APIs here at : https://api.hashnode.com/. The best part is it consist of a playground where you can test GraphQL API easily in the browser. Upon playing with the APIs i found two useful APIs useful for our requirement
- API to fetch post list of a user
Query looks like:
query {
user(username: "pydj") {
username,
name,
tagline,
publicationDomain,
publication{
title,
meta,
posts(page:0){
slug,
title,
brief
}
}
}
}
Try this in your browser to see the response:
- API to fetch detail of a post
Query Looks like:
query{
post(slug:"django-setup-architecture-and-hello-world",
hostname:"djangotherightway.com")
{
dateAdded,
content
}
}
Try this in your browser to see the response:
You can always change the query and get more details on the response, but for our requirements the query i just mentioned above would be enough.
let's start Python integration
First of all, before creating a python file we will use a simple library called requests to query the Hashnode api
Install it using pip.
pip install requests
Learn more about requests library from https://docs.python-requests.org/en/master/
- Base function to request Hashnode API
This python function will take Query as an argument and return the response
def request_hashnode_dot_com(query):
return requests.post("https://api.hashnode.com/",
json={'query': query})
- Craft query for Post list
For our requirement, Post list Query would basically take two dynamic parameters
username and page number. So let's create a python functions which takes username and page as an argument
def create_query_for_post_list(username, page):
return """{
user(username: "%s") {
username,
name,
tagline,
publicationDomain,
publication{
title,
meta,
posts(page:%d){
slug,
title,
brief
}
}
}
}""" % (username, page)
- Craft query for post detail
For our requirement, Post detail Query would consist of two dynamic arguments
post slug and hostname. Don't worry, we will get slug and hostname from the Post List API and we will use it here
def create_query_for_post_detail(slug, hostname):
return """{
post(slug:"%s",hostname:"%s"){
dateAdded,
content
}
}""" % (slug, hostname)
- Creating a plain text from HTML
The post detail Query will return us HTML version of our post on hashnode. Its difficult to parse the HTML and show it on the terminal so we will be using python native functions to basically parse the HTML to normal Text.So, lets create up a python function which takes HTML as an input and returns normal text which can be printed out in the terminal/console
def create_plain_text_from_html(html):
from html.parser import HTMLParser
class _CustomHTMLParser(HTMLParser):
normal_text = ""
def handle_data(self, data):
self.normal_text += data
f = _CustomHTMLParser()
f.feed(html)
return f.normal_text
We could have used the markdown format of your Post provided by the Hashnode post detail Query, but we used HTML version for simplicity and easy parsing through python internal functions
def show_post_detail(article, publication_domain):
q = create_query_for_post_detail(
article['slug'], publication_domain
)
post_detail_reponse = request_hashnode_dot_com(q)
if post_detail_reponse.status_code == 200:
content = post_detail_reponse.json()['data']['post']['content']
date_added = post_detail_reponse.json()['data']['post']['dateAdded']
print(article['title'].upper())
print("Added on:", date_added)
print(create_plain_text_from_html(content))
else:
print("Error")
exit(1)
def main():
import sys
username = sys.argv[1] if len(sys.argv) == 2 else "pydj"
current_page = 0
articles = {}
while True:
query = create_query_for_post_list(username, current_page)
response = request_hashnode_dot_com(query)
if response.status_code == 200:
if not response.json()['data']["user"]["username"]:
print("Invalid User")
exit(1)
re_data = response.json()['data']["user"]
print("Welcome to:", re_data['publication']['title'])
print("----List of Articles----")
if not re_data['publication']['posts']:
print("***No Articles Available, try changing page number***")
else:
for index, article in enumerate(re_data['publication']['posts'], 1):
articles[index] = article
print(f"[{index}]", article['title'])
print("Current Page:", current_page + 1)
print("-----------------")
print(f"Type: n for next page\n"
f" p for previous page\n"
f" 1-{len(articles)} for article detail")
print("-----------------")
user_input = input("Enter your input: ")
valid_inputs = ["n", "p"] + [str(i) for i in articles.keys()]
if user_input not in valid_inputs:
print("Invalid choice")
exit(1)
if user_input == "n":
current_page += 1
continue
if user_input == "p":
if current_page == 0:
print("Cannot go to previous page")
exit(1)
else:
current_page -= 1
continue
show_post_detail(articles[int(user_input)], re_data['publicationDomain'])
break
else:
print("error")
exit(1)
Here to understand python and its ways, i created two functions main and show_post_detail. Actually show_post_detail was not important and on the other hand main function looks so messy and long.
The real thing i wanted to show you on the main function is to make you feel functions and code splits are important because according to my experience in software engineering Code Readability/Reusability is the most important factor, So feel free to play and work around it to make it more readable.
But, here i will try to write some steps that will make you feel easy to understand the messy long main function
- Takes username from CLI arguments
python hn.py pydj
- prepares and runs query to grab posts of the supplied
username
- Displays list of blog post [paginated data]
- creates up a simple menu bar
- Pagination functionality
- Post detail functionality
How does this look ?
Tested on
- Python 3.9.1
- requests==2.26.0
Complete source code
Find the complete source code at: https://github.com/shrawanx/hashnode-terminal
