Forem: Sreeram Venkitesh

Getting Started with Twitter APIs using Deta

Sreeram Venkitesh — Wed, 29 Jul 2020 11:47:40 +0000

You must have seen Tom Scott's YouTube video where he uses the YouTube API to automatically update the title of the video. I had written a tutorial for the same in a previous article (Check it out here)

After doing the YouTube project, I was thinking if I could do the same with my Twitter account. I tried reading through the Twitter API docs and it turned out doing this was actually pretty easy! I was able to completely write and deploy the code in an hour.

In this post, I'll walk you through how I did it and how you can easily get started with the Twitter API to automate processes like updating your profile, posting tweets etc.

Creating an app with Deta

Create an empty folder for your project
From the folder, run deta new --node twitter-update to create a new Deta Micro.
Once the app is created, you will get some details including the endpoint web address. We will use this to create an app from the Twitter Developer Console.

Setting up the Twitter App

Log in to your Twitter Developer account and navigate to your dashboard.
Create a new app and give it a suitable name. Use the endpoint that you got when creating the Micro as the website url for your app
Go to the keys and tokens tab to find your API Key and API Secret Key.
Under the API keys, click the option to generate your access token and secret. Copy and store these keys somewhere safe as you will only get to see it once.

Before writing the code

Now that we have the necessary keys, lets get to writing the code that actually does the work. But we need to import the API keys and access tokens inside our code inorder to use it.

Create a .env file inside your project and copy the credentials you got from the Twitter App Dashboard into it, as shown

consumer_key=blah
consumer_secret=blahblah
access_token_key=blahblahblah
access_token_secret=blahblahblahblah

Now that you have a .env file, you can access these from inside your code (You might have to install the dotenv package and set require('dotenv').config() inside your js file. I assume you've done this already.)

Writing the code

We are going to use the Twitter for Node.js package for making requests to the API.
Install the package with npm install twitter
Import the twitter package and create a client object

const twitter = require('twitter')

const client = new twitter({
    consumer_key: process.env.consumer_key,
    consumer_secret: process.env.consumer_secret,
    access_token_key: process.env.access_token_key ,
    access_token_secret: process.env.access_token_secret
})

Now you can call the get and post functions of the client object to use the Twitter APIs however you want.

You can refer to the docs to choose an api and study about its parameters and such.

In our example, we need to read the profile details from our account - the name, the number of followers and so on and use it to update a part in the profile, the name.

Let's see how to read the profile first. We can use account/verify_credentials to fetch the details from our Twitter account.

client.get('account/verify_credentials',(err,res)=>{
  if(!err){
    const followerCount = res.followers_count
    console.log(followerCount)            
  }
})

Here we retrieve only the followers_count from the response, but you can try printing the entire response object to see what all information we are fetching.

Now we need to update the profile details. For this we can use account/update_profile.

client.post('account/update_profile',{name: 'New Name'}, (err,res)=>{
  if(err) throw error
  console.log('Updated')
})

This piece of code above will update the name parameter in your profile to whatever value you give it. You can even create a params object with all the stuff you want to change and pass it to the function.

const params = {name : 'New Name'}

client.post('account/update_profile', params, (err,res)=>{
  if(err) throw error
  console.log('Name has been updated')
})

Now that you have the two pieces of the puzzle, you can use the updation inside the function where you fetch the data.

client.get('account/verify_credentials',(err,res)=>{
  if(!err){
    const cnt = res.followers_count

    const params = {name : 'Sree has ${cnt} followers!'}

    client.post('account/update_profile',params,(err,res)=>{
      if(err) throw error
      console.log('Name has been updated')
    })            
  }
})

Now if you run npm start and start the server locally, your Twitter profile name will be updated. But we need this to happen in the background, in real time. This is where Deta Cron comes in.

A cron is a piece of code that has been scheduled to run at a certain interval, and it keeps running again and again. With Deta you can easily deploy a cron with just a few lines of code and a few commands.

For setting a cron with Deta, you can import App from Deta as

const { app } = require('deta')

And set the function to run as the cron inside app.lib.cron like this

app.lib.cron(event => {
    // The code here will be executed repeatedly      
});

So you can bundle up all the above code we used to call the API into a function and call the function from inside here.

Now from your project directory, run deta update -e .env to update your environment variables.
Run deta deploy to deploy your code to production.
Run deta cron set '1 minute' to set the code to run every minute.

Checkout Deta, the cloud for the next billion ideas

Get the code to this project at my GitHub

See the name updation effect live on my Twitter profile

How to use the YouTube API to create a self-updating video title based on views

Sreeram Venkitesh — Tue, 21 Jul 2020 10:31:56 +0000

Link to my video tutorial

You might have seen Tom Scott's video where he uses the YouTube API to automatically update the title of his video in real time to say 'This video has n views'. Sometime after, another YouTuber, Mr.Beast did the same thing with the thumbnail of his video to show how much money he donated.

One of my favourite dev channels, Fireship had posted a video explaining how these people are doing this, explaining how APIs work and how they can be used to automate such tasks.

Although Tom Scott never went into the intricacies of the code behind this process, Fireship explained how to acheive this to a fair degree of detail.

Basically we need to use the YouTube Data API provided by Google to fetch the details of a video. We have two ways to do this

Use an API key to do read-only processes (Like retrieving the number of views)
Use an OAuth 2.0 credential to sign in to your YouTube account and be able to retrieve and update the data.

We would need to use OAuth since we need to update the title of our video.

Fireship's video, although really well made and interesting to watch, is not a tutorial. You can definitely get a head start but not a walkthrough. But I decided to give it a try nonetheless in the hope to being able to document the process and create a more concise tutorial.

Step 1 - Using the YouTube Data API

The API that we're gonna use is has an extensive documentation along with an in-browser API Explorer that you can use to test an API before actually using it in your project.

This can be really handy to test the API while writing the code. Notice how there are two options for selecting the credentials. If you checked Google OAuth and select a scope within it (different scopes have different access levels), you'll be prompted to login to your Google account to authenticate the API request. This way the API can make sure that you are requesting to edit the details of a video posted from your account which you have the access to update.

For the title we are going to need the list and the update functions of the API, both of which you can test from the explorer.

Step 2 - Creating a project with Deta

Being able to call the API and change the video title is not enough. You should be able to do this periodically as the views get updated in real time.

Using Deta makes setting up all of this really easy with their Micros and Cron. You can write a piece of code, deploy it, set a cron and it will keep running periodically after a time period that you specify.

Using Deta Micros and Crons to deploy your code

Create a new Micro

Inside your project directory, run

deta new --node my-project-name

This will create a new directory with the name of your project and it will have a .deta folder inside, with all the information regarding your micro. (If you haven't used Deta before, you'll need to install the CLI and login from your machine. Check out a tutorial here). Once the project is created, you can npm init inside the directory to initialise a node project.

Install the node package for using Google APIs

From your project directory, once you've initialised the node project, run

npm install googleapis

Using the APIs

Once you have the package installed, you can easily access all of Google's APIs for say, YouTube or Drive or whatnot.

const google = require('googleapis')

const youtube = google.youtube('v3')

Here v3 represents DataAPI v3 of YouTube.

You can now use the list function to fetch the video details and the update function to update the details of your video.

youtube.videos.list({
    auth: auth,
    id: 'YOUR_VIDEO_ID',
    part: 'snippet,statistics',
},function(err, result) {
    if (err) {
      console.log('The API returned an error: ' + err);
      return;
    }else{
      //Do something here with the data
      console.log(result.data)
    }
})

OK, so you might be confused with two things I didn't talk about yet.

The auth object we pass to the function are our credentials. This will be the API Key if you only need to read the data or it'll be the access token and refresh token linked to your Google account that has the access to edit the title of the video.

The other arguments for the function are the video ID, which is just the unique string present in the url of every video. The part argument specifies what all types of detail we need to fetch. snippet stands for all the details of the video like the title, categoryId, description, tags etc. statistics is information like the number of views, likes, dislikes and all. Since we need both the title and the view count, we can retrieve both the snippet and statistics of the video.

The Updation

Once you get the details of a video, you can take the view count, create a string saying whatever you want with the view count and send it back to update it as the new title of the video.
Here's how we can do it with code

const video = result.data.items[0]

const { viewCount } = video.statistics

const newTitle = `This video has got ${viewCount} views!`

video.snippet.title = newTitle

youtube.videos.update(
{
    auth: auth,    
    part: "snippet", //since we only need to update the title
    resource: {
       id: 'YOUR_VIDEO_ID',
       snippet : {
          "title": newTitle,   //set title as new title
          "categoryId": 'categoryId'   
       }
},(err, response) => {
    if (err) {
      console.log(`There was an error updating ${err}`)
      return
    }
    if (response.data.items) {
      console.log("Done")
    }
  }
)

You can set the new title from the details collected from the list function and use it with the update function. YouTube also wants us to set the Category ID of the video while updating the details. The complete list of category IDs can be found here

The update function can be called from inside the list function if you want to, to directly access the data in the response of the API.

The Google Developer Console

Now let's look at the auth object that we pass in the function calls. auth is an oauth2client object that has our credentials and information like the access token and refresh token and all.

Remember how when using the API explorer Google asked us to select an account and approve all the permissions? We generate access tokens and store it and pass it to our function calls so that we do not need to do this confirmation every single time the function is called. And since we need to update the title in real time, we will need to call the function frequently.

To generate the access tokens, first create a project in your Google Developer Console.
Add the YouTube Data API v3 to your project from the API library
Go to the credentials tab and create a new OAuth Client ID from the Create Credential menu
You will need to create an OAuth consent screen for this, which you can do easily from the side menu bar in the console.
Once created, download the clien_secret.json file and keep it in yoru project directory. Don't forget to add it to .gitignore if you are going to push your code to a public repository.

There are a few function that we need to run to generate the access token for the first time. This involves running the code from our local machine and confirming the use of the app we created with our Google account.

For doing this, you can clone the repo I made here

After cloning, run npm install inside the directory with the package.json file
Copy the client_secret.json file downloaded from your Google Developer Console into the project directory.
Create a new micro inside the cloned project with deta new. This will create a Micro for you based on the existing files. Once created you can go on and run deta deploy, but we'll wait until everything is done to deploy it.
Run npm start to start the local server on your machine.
You will be given a url in the terminal. Go there and you will get a code in the address bar after you select your Google account and accept the terms. (If it says the app is not trustable, its because we haven't verified it. Don't worry, you are the only person who can access the app.)
Paste this code back into your terminal and this will generate a directory named .credentials in your project folder with your access tokens.
Run

deta deploy

to deploy your micro

deta cron set '5 minutes'

(or however frequent you want the code to run) from the terminal to set the cron

Deta Cron will schedule the running of whatever piece of code you put inside app.lib.cron(event => { });. You can use it to automate whatever routine tasks that you might have.

This blog post was meant to be a tutorial for a use-case for Deta Cron. Hope this gave you some insight into using Deta in your next project!

Check out my GitHub repo for this project here

BTW, I use Arch! 😂

Sreeram Venkitesh — Thu, 09 Jul 2020 16:38:53 +0000

This is the story of how I installed Arch Linux. This is also the story of overcoming the challenges we face and why getting into sticky situations that get you scratching your head is actually a good thing.

This post is actually based on one of my Twitter threads.

So it had been a long time since I wanted to clean up my hard drive. I had been dual-booting with Windows alongside for design work and whatnot. Then one day I accidentally wiped the windows boot file and made it inaccessible. Needless to say my partition table was pretty messed up.

Then a few days before Christmas 2019 (Ahh, good times), my desktop environment crashed. (I had been using Manjaro with Plasma for around the last 6 months) This was the best chance to clean my machine and start fresh for 2020 (Little did I know back then that 2020 would end up like this)

The boring part was copying all my files 🤦‍♂️ Spoiler alert - I found more it difficult than installing Arch. I had installed xfce as my makeshift DE for now. I once deleted the copied folder thinking it was the older one. Luckily, I checked before deleting the original one.

After copying the files, I decided to practice the installation process in a virtual machine first. I cannot mess this up right now :P So with a virtual machine set up, I set out to install Arch! The Arch Wiki is really cool if you have the patience to read it thoroughly!

After two tries, I got bare bones Arch installed! The first time it didn't install properly, second time I forgot to create the grub config and it booted into the grub command line, and the third time I finally got it. Exciting!

But I soon realised that I didn't enable dhcpcd and hence couldn't access the internet to download further packages or anything! Shucks!

I tried a fourth time and this time, got everything correct and installed Plasma as my desktop environment 😁 (No wonder the K in KDE stood for Kool!) The satisfaction when you finally reach this point is really worth the effort.

And within two days after my DE first crashed, I started the installation in my actual hard drive, wiping all data and the messy mixture of windows and linux partitions.

Its good to have a book to read while it downloads the packages as it may take time..

And finally everything was installed perfectly! All the mistake I had made upto now made me sure to check for everything and it went smooth

And this is how my drive looks now!

So why Arch? I had been using Manjaro for some time now and was really familiar with the pacman package manager. Also I wanted to take up something to challenge myself, hopefully learning something new and interesting in the process!

In that regard, this has been a true nerd-out experience for me.

Now I can proudly say 'BTW, I use Arch'

Making prompts - an app that gets you out of writer's blocks using Reddit APIs and Deta

Sreeram Venkitesh — Sun, 05 Jul 2020 19:21:59 +0000

As developers we know best that sometimes the best way to avoid an idea block is to just start coding (Weeks of coding can save hours of planning, but that's for another story)

Here we are talking about writer's blocks. Coming up with an enjoyable piece of literature can be as challenging as programming, sometimes even more so.

Prompts (live at prompts.deta.dev) is a simple app that I made for writers to exercise their brains hopefully recover from a writer's block.

Prompts works by fetching story prompts from the r/WritingPrompts subreddit and presenting them to you in a minimalistic editor where you can complete the rest of the story.

There are several options to spice up the challenge - you can set yourself a timer and see how much you can write in a fixed amount of time and also calculate your typing speed

Once you are done, you can keep the story you wrote for yourself by exporting it as a document. If you didn't like the prompt you got you can always load another prompt from the menu.

Prompts is hosted with Deta Micros. Deta's Micros or Micro Servers lets you host your Python and Node.js apps in seconds with just their CLI tool. Check out more about them at deta.sh

The code for prompts is open-source at my GitHub here. Any contributions are welcome! (If you are planning to run it locally, the instructions to set up your own Deta Micros is given in the repo's README.md file)

Prompts is also featured in ProductHunt. You can check it out here

What do you think about prompts? What all features would you like to add to prompts? Share your feedback in the comments!

How I built my quarantine project (Thanks to Node.js and Deta Base)

Sreeram Venkitesh — Wed, 01 Jul 2020 09:38:20 +0000

Deta is a cloud platform or a cloud computer as devs call it, and it is built with developer and user experience as the first priority.

Deta Base, the production grade NoSQL database provided by Deta is super easy to use that you can go from nothing to a fully working database for your project in literally minutes!

This post is about how I used Base as the database for one of my side projects and how setting up Base was the easiest part of the project

How does it work?

Once you create account at deta.sh, you'll be taken to your dashboard and will be able to see your projects.

When you are first logging in, you'll have a default project with which you can play around. On opening the default project, you'll get a project key. Copy this and save it somewhere safe because you won't get to see this again!

Once you've got the project key setting up a database is just a few lines of code!

Using Deta in your projects

As of now, you can use Deta Base with you Node.js or Python apps, or as an HTTP API

Based on the stack you are using, you can install the relevant Deta packages -

For Node.js, you can use npm to install Deta

npm install deta

Deta also has a Python SDK that you can get from here

Creating a Base

The app I was working on was a resume builder. The user could login and create a resume of all the things they did while being in quarantine or lockdown during the pandemic.

For this I needed to store the data of the users once they login and their resumes once they create them. I did this by creating two Bases within the same project.

One awesome thing about Deta is that you can have infinite number of 'Bases' or databases within a single project

For achieving this, I referred to the amazing docs and referring to the examples give there.

Steps to create a Base and read/write data

Setting up a Base is as simple as creating a deta object with your project key! You can start writing into and reading from your database right away. Here I'm showing how you can do it with Javascript

In your JavaScript file, first import the package

const Deta = require("deta")

Add your project key to a Deta object

const deta = new Deta("your_project_key")

Now you can create a new database using deta.Base(). Let’s create a sample Base and write some values into it.

const db = deta.Base("users")

Since I need to keep a record of all the users who sign up into my site, I need a users database to store their usernames and email addresses and so on.

I can easily write into the Base once I collect user infotmation from the frontend of my app.

db.put({     
  name: "Sreeram",     
  email: "abc@xyz.com",
  key: "user1"
})

Since Base is a flexible NoSQL database, we can store the data in whatever schema we need or by passing a JSON object we get from the user's input.

db.put({     
  name: "Sreeram Venkitesh",     
  email: "abc@xyz.com",
  socialLinks: [{...}],
  projects: [{...}],
  key: "resume1"
})

One thing to note is that if you do not give a key element manually, Deta will autogenerate a key for the entry. The key can be used to later retrieve the entry from the database.

For my resume project, I used a string made from the email addresses of the users as the key so I can easliy retrieve the users' data from the db once I get the email addresses with which they are signing in the next time (See I told you, setting up Base was the easiest part of this project!)

Reading from the Base

So once I wrote all the code to retrieve the resume from the user and write it into the db, I created a custom link to the user's profile which they can share to show off their resume.

In the backend of this process, I needed to get the user's unique key and search it in Base and retrieve the data stored there.

I could do this easily with the db.get() function

const user_resume = await db.get('user_key');

I can then easily use the returned object to display the data in the user's profile.

quarantineresu.me was the first real Node.js application that I made. I literally had no idea how I could set up a database either. Deta made it really easy for me to get up going with the database so that I could concentrate on other aspects of building my app.

Check out Deta at Twitter or join the wonderful Slack community to meet other developers or for help with coding!