DEV Community: jahwi

AI Newsie: Building a Serverless News Aggregator Bot with Rust, GPT-3, AWS Polly, and Sendgrid's API

jahwi — Sun, 02 Apr 2023 19:36:02 +0000

This weekend's project is a news aggregator bot that pulls articles from the New York Times, summarizes them with OpenAI's GPT-3, makes a text-to-speech recording with AWS Polly, and finally sends the email-recording combo via Sendgrid's API-- All written in Rust. I call it AI Newsie. The GitHub repo is here.

Here's how to set it up, and get it running on your very own AWS account (among other things) all for free!

Configuring and Deploying AI Newsie

To use the bot, one would need the following:

A Sendgrid API key - for sending emails
A NYT API key - For grabbing news stories
An OpenAI API Key - For processing and summarizing the news stories
An AWS account:
For access to AWS Polly (text-to-speech) and
AWS Lambda (deploying the bot)

1. Setting up Sendgrid

Sign up for Sendgrid and setup a sender identity and take note of your sendgrid sender email address. The most straightforward verfication route is Single Sender Verification.
After setting up a sender identity, create an API key by navigating to Settings -> API Keys -> Create API Key. Take note of this API key (not to be confused with the API Key ID) as it is hidden soon after generation.

2. Setting up NYT API

Create a NYT developer account here.
Navigate to the My Apps page by clicking the dropdown at the upper left corner of the page and selecting "Apps".
Create an API key in the "API Keys" section by clicking "Add Key". Copy the API Key under the "Key" header.
Under the "APIs" section, ensure "Article Search API" is enabled.
Below that, hit the "Save" Button.

3. Setting up OpenAI API

Create an account here.
Navigate to the API Keys page by clicking your account in the top left corner of the page and selecting "View API Keys".
Create a new API key by clicking the "Create new secret key" button. Take note of the newly generated key.

4. Setting up AWS

If you haven't already, setup an AWS account here.
Navigate to the AWS Lambda service page by searching "Lambda" in the search bar at the top of the page.
Click "Create Function" and select the "Author from scratch" option.
Create a name for the new function, e.g. "NewsBot".
For the "Runtime" section, select "Provide your own bootstrap on Amazon Linux 2", and under "Archictecture", select "arm64".
Under the "Change Default Execution Role" section, make sure "Create a new role with basic Lambda permissions" is selected.
Click "Create Function".
Add AWS Polly permissions for the bot by navigating to the "Configuration" section -> clicking "Permissions", then clicking the link under Role Name in the "Execution Role" header.
In the "Permissions" tab, click the "Add Permissions" button, then select "Attach Policy".
Search for and select "AmazonPollyReadOnlyAccess" in the permissions search bar, then click "Add Permissions".
Back to the Lambda Functions page, under the "Configuration" tab, select "Environment Variables".
Configure the environment variables as follows, by clicking the "Edit" button:
Click the "Save" button after setting environment variables.
Under the "General Configuration" menu, click "Edit" and change the timeout to "2min 0sec", and save.
Grab a pre-built bootstrap from here, and download bootstrap.zip from the latest version. Alternatively, you can build your own bootstrap from the repository, but that is beyond the scope of this post.
Back to your AWS Lambda function, in the "Code" section, scroll down and click "Upload From" -> ".zip file".
Once the zip has been uploaded, test your function works by navigating to the "Test" tab and clicking the "Test" button. The function should send your AI-generated email to your desired destination, via your sendgrid sender email.
Check the Log Output to confirm the bot ran as expected.
Finally, you can schedule the bot to run daily by navigating to the "Triggers" section of the "Configuration" tab and clicking "Add Trigger".
Then, select EventBridge, -> "Create a new rule" and configuring "Rule Name" as "Daily_Newsletter", "Rule Description" as "Run the newsbot daily", and "Schedule Expression" as "rate(1 day)", then click "Add".

Conclusion

The services used in this project are offered under freemium/capped payment models, and so as long as your usage of these services (as the AI Newsie does) is under the stated limits, it will cost nothing to run the bot monthly. OpenAI gives $18 in free credits on creating a new account for three months, for example.

Thanks for reading. Comments and PRs welcome!

Skipping to the Good Parts: Implementing Netflix's Skip Intro Feature with Python Video Processing

jahwi — Sun, 05 Feb 2023 13:42:11 +0000

Netflix’s Skip Intro feature is about as iconic as the service itself, allowing subscribers to skip past intro and outro portions of tv shows. Since then, other streaming services have adopted this feature, making it a staple of the streaming world.

Recently, I began thinking about implementing this feature and this led me to make a small library to find similar portions in videos. It does this by hashing videos into frames, hashing these frames, and comparing similar frames between each comparison video and a reference video.

I decided to test this library on my favourite recently-cancelled Netflix show, Inside Job:


# Import the library
from similar_vid.similar_secs import Similar, save

# Load the file paths
file1 = "videos//inside_job//01.mkv"
file2 = "videos//inside_job//02.mkv"
file3 = "videos//inside_job//03.mkv"
file4 = "videos//inside_job//04.mkv"
file5 = "videos//inside_job//05.mkv"


if __name__ == "__main__":
    # Hash the videos
    inside_job = Similar(ref=file1, comp_arr = [file2, file3, file4, file5])

    # Match the videos
    inside_job.match(threshold=15)

    for match in inside_job.matches:
        print(match)

    # use the library's save function to save class fields as JSON for further use
    save(inside_job.matches, "outs//matches.json")

In the above, we import the Similar class from my similar-vid library and pass it the reference video and an array of comparison videos. We then use the match method to speficy that we only want matches that are at least 15 seconds long. The library then hashes and matches the videos as such:

Description: A screenshot of the console showing the hashing and matching process.

These hashes are then stored in the matches field of the class instance as a list of dictionaries. Below that, we print the matches and use the library’s save method to save the matches to a json file:

The returned arrays of the “matches” key, if any, are the beginning and ending matching seconds of the comparison video, respectively.

We can then pass this as context to the frontend. Using Javascript to modify the video’s currentTime property, we can skip the intro portion:

As can be seen in the above gif, the Skip Intro button appears over the intro portion.

The similar_vid library can be found here: https://github.com/jahwi/similar-vid

Thanks for reading.

A Simple user input collection, validation, and conversion library in Rust

jahwi — Thu, 13 May 2021 15:56:44 +0000

Writing a CLI program often requires reading and parsing user input. Today, we will create a Rust library that allows us to read and convert String input from STDIN into a number of primitive types such as i32, u32, usize, etc.

This article is suitable for new and prospective Rust programmers.

Setting Up

We begin, as most projects do, with Cargo - Rust's package manager.

In the command line, Initialize a new project directory named get_input as shown below:



cargo new --lib get_input

The --lib flag tells Cargo that we're creating a new library, instead of a binary. If all went well, you should see output similar to the below:



C:\Users\rusty>cargo new --lib get_input
     Created library `get_input` package

Note: If there's an existing folder of the same name in the current directory, change the project name to something else, like get_input_tutorial

Library Design

Before we write our first line of code, we need to determine, on a high level, how our code will function. What are the requirements and goals of this small library?

Overall, we want our code to:

Collect user input from STDIN,
Validate that input,
Optionally, convert that input to another type, and finally
Perform some logic with the collected input.

The Crate Root

When creating libraries, Cargo creates a special file called the crate root in the project's src directory. Packages in Rust are called crates, and one of the most important files in a library crate is the root, named lib.rs

We'll be working with the crate root today, located at [project_path]\get_input\src\lib.rs

In the lib.rs file, Cargo automatically generates a sample test module. This is one of Rust's several nudges towards writing robust, well-tested software. Ultimately, we should all aim to write well-tested code.

So anyway, go ahead and CTRL+A, DEL the tests till you are left with a blank page.

Bringing Libraries Into Scope

With the use keyword, we'll bring the required libraries into scope. For now, we only need a module from Rust's standard library: the io module. This library is one that provides Input/Output functionality, which we'll be using to read user input from STDIN.



use std::io;

src\lib.rs

Function Definition

Let's go ahead and create the function definition. We'll call it get_input as well.



use std::io;

pub fn get_input() {}

src\lib.rs

pub stands for 'public' because we are allowing others to use our get_input function. Rust's functions and other objects are usually private by default, which means that we have to explicitly mark them as public before outside code can call into them.

For now, our function doesn't take any input parameters, neither does it return any output.

Reading Input from STDIN

Remember that we want our function to read user input from STDIN. This is where the previously imported IO module comes into play.



use std::io;

pub fn get_input() {
    let mut input = String::new();

    // Reads the input from STDIN and places it in the String named input.
        println!("Enter a value:");
    io::stdin().read_line(&mut input)
        .expect("Failed to read input.");

    print!("'{}'", input);
}

In the above, we declare a new String variable named input and use the Stdin struct's read_line method to place the collected input into it. The expect method allows us to display a message on encountering an error, before crashing the program. This is called panicking in Rust. On the last line, we print the collected input for illustrative purposes.

To call our library, create a main.rs file (which is a binary crate root as opposed to lib.rs' library crate root) in the src directory, right alongside lib.rs like so:



use get_input::get_input;

fn main() {
    get_input();
}

src\main.rs

In the above, we import the get_input function from our get_input library crate and call it from main.rs' main function. To run the program, execute cargo run in the get_input project directory.

Enter 23 into the terminal, and the result should be similar to the below:

Notice that the closing quote is on a new line. This is because of the newline character (\n) appended when we read from STDIN. We'll need to remove this before we can convert our input to other types.

The trim method from the standard library trims leading and trailing whitespace, and this includes the newline character:



use std::io;

pub fn get_input() {
    let mut input = String::new();

    // Reads the input from STDIN and places it in the String named input.
    println!("Enter a value:");
    io::stdin().read_line(&mut input)
        .expect("Failed to read input.");

    let input = input.trim();

    print!("'{}'", input);
}

src\lib.rs

Running the above should produce the following:

Much better.

Converting Strings to Other types

Rust's parse is a useful method that parses a string slice into another type. Using this, we can trivially convert our collected input into an integer, for example.



use std::io;

pub fn get_input() {
    let mut input = String::new();

    // Reads the input from STDIN and places it in the String named input.
    println!("Enter a value:");
    io::stdin().read_line(&mut input)
        .expect("Failed to read input.");

    // Convert to an i32.
    let input: i32 = input.trim().parse().unwrap();

    print!("'{}'", input);
}

src\lib.rs

In the above, we use type annotation to specify that we want the parse method to convert our input to an i32. We use the unwrap method because parse returns a Result type. This is a compound type that represents either success or failure of an operation. You can read more about Result by clicking that link. unwrap allows us to access the underlying value if the operation was successful. If it wasn't, it panics.

Run the program again and input 23 once again:

The usefulness of parsing might not be immediately apparent, but this conversion means that we can now perform integer maths with it:



// Same as above

print!("'{}'", input * 3);

src\lib.rs

In the above, we multiply the input-String-turned-integer by three.

Nice.

Error handling using match

We can convert to integers and multiply them, excellent. But what happens when we enter input that isn't easily converted to an integer?

We get this:

In the above, the highlighted part of the error message clues us into its cause: parse failed to convert the input "dev.to" into an integer, and it proceeded to panic because we used unwrap.

There are a number of ways to better handle this error. One method is using match and loop. This provides pattern-matching control flow while making sure the user enters valid input before exiting the loop. Let's add a loop-match implementation to get_input:



use std::io;

pub fn get_input() {

    loop {
        let mut input = String::new();

        // Reads the input from STDIN and places it in the String named input.
        println!("Enter a value:");
        io::stdin().read_line(&mut input)
            .expect("Failed to read input.");

        // Convert to an i32.
        // If successful, bind to a new variable named input.
        // If failed, restart the loop.
          let input: i32 = match input.trim().parse::<i32>() {
            Ok(parsed_input) => parsed_input,
            Err(_) => continue,
        };

        print!("'{}'", input * 3);
        break;
    }
}

src\lib.rs

In the above, we place the contents of the function body into Rust's infinite loop implementation: loop. This ensures the loop doesn't end unless we use the corresponding break keyword.

Back to the input trimming and parsing code block, there are a few things going on here. We use the let keyword to shadow the previously-declared String variable input with a new one of our desired type: i32.

We then use match to pattern-match the output of the trimming and parsing. Remember that parse returns a Result type? We can then use match to address Result's possible variants, which are two in number. The Ok(value) variant indicates success, and it contains the successfully parsed value. Err(error) on the other hand contains the information on the error encountered.

Match's arms can be read from left to right. On the left side are the possible scenarios/cases, called match arms, and on the right side are the conditional code blocks to be run.

In summary, we've told the match expression to evaluate the return value of trimming and parsing the String input, then bind the trimmed & parsed output to the variable input if successful. If the operation is not successful, i.e. if an error occurs, we've specified, via the continue keyword, that the function should continue to the next iteration of the infinite loop: forever looping until the user enters valid input.

(I have never heard of Ctrl + C. What's that?)

Generalizing the function

Now, we have a function that doesn't get bogged down by trivial things such as incorrect input. What next?

Although converting Strings to integers is a useful feature for our library, we still need get_input to convert our String input to other types. Suppose we also wanted to convert to a u32. How would we do that? We could do the following:



use std::io;

pub fn get_input_u32() {

    loop {
        let mut input = String::new();

        // Reads the input from STDIN and places it in the String named input.
        println!("Enter a value:");
        io::stdin().read_line(&mut input)
            .expect("Failed to read input.");

        // Convert to a u32.
        // If successful, bind to a new variable named input.
        // If failed, restart the loop.
        let input: u32 = match input.trim().parse::<u32>() {
            Ok(parsed_input) => parsed_input,
            Err(_) => continue,
        };

        print!("'{}'", input * 3);
        break;
    }
}

src\lib.rs

However, one needn't be told that this would soon become quite tedious. A better solution would be to utilize Rust's useful generics. This would allow us to convert into many types without duplicating code.

Let's modify get_input to take advantage of generics. We'll also modify the function so it now returns output:



use std::io;

pub fn get_input<U: std::str::FromStr>() -> U {

    loop {
        let mut input = String::new();

        // Reads the input from STDIN and places it in the String named input.
        println!("Enter a value:");
        io::stdin().read_line(&mut input)
            .expect("Failed to read input.");

        // Convert to another type.
        // If successful, bind to a new variable named input.
        // If failed, restart the loop.
        let input = match input.trim().parse::<U>() {
            Ok(parsed_input) => parsed_input,
            Err(_) => continue,
        };
        return input;
    }
}

src\lib.rs

In the above, we introduce generics in our function. This allows us to convert to any type that implements the FromStr trait bound. Trait bounds allow us specify exactly what types of values can be substituted by the generic U.

The FromStr Trait, in particular, is implemented by types that can be constructed from a String. This, thankfully, includes the primitive types.

With trait bounds, we're saying: "you can only substitute U for any type that implements FromStr".

Notice that we've altered the return type of the function as well. Now, we specify that get_input should only parse and return, by way of the generic U, any type that implements FromStr as previously discussed.

Over in main.rs, we modify our caller to take advantage of the flexibility provided by generics:



use get_input::get_input;

fn main() {
    let input: i32 = get_input();
    print!("'{}'", input * 3);
}

src\main.rs

We use type annotation to specify that we want an i32 returned. This means that get_input will substitute i32 for the previously-mentioned generic U in this case. We can also just as easily ask for a u32 or an isize simply by changing the type annotation.

Extra Functionality

Custom Prompts

Now that we've implemented our small library's core functionality, we're ready to move on to some extras. Now, we want get_input to display custom prompts when asking for user input, instead of the default "Enter a value:". We can achieve this by modifying the function definition to accept parameters:



use std::io;

pub fn get_input<U: std::str::FromStr>(prompt: &str) -> U {

    loop {
        let mut input = String::new();

        // Reads the input from STDIN and places it in the String named input.
        println!("{}", prompt);
        io::stdin().read_line(&mut input)
            .expect("Failed to read input.");

        // Convert to another type.
        // If successful, bind to a new variable named input.
        // If failed, restart the loop.
        let input = match input.trim().parse::<U>() {
            Ok(parsed_input) => parsed_input,
            Err(_) => continue,
        };
        return input;
    }
}

src\lib.rs

In the above, we've made it so that get_input accepts input in form of a string slice, and displays it to the user before asking for input.

Having STDIN on the Same Line as STDOUT

Using functionality provided by the Write trait, we can display the input and output streams on the same line like in the image below:

We can achieve that by flushing STDOUT[1]:



use std::io::{self, Write};

pub fn get_input<U: std::str::FromStr>(prompt: &str) -> U {

    loop {
        let mut input = String::new();

        // Reads the input from STDIN and places it in the String named input.
        print!("{}", prompt);
        let _ = io::stdout().flush().expect("Failed to flush stdout.");

        io::stdin().read_line(&mut input)
            .expect("Failed to read input.");

        // Convert to another type.
        // If successful, bind to a new variable named input.
        // If failed, restart the loop.
        let input = match input.trim().parse::<U>() {
            Ok(parsed_input) => parsed_input,
            Err(_) => continue,
        };
        return input;
    }
}

src\lib.rs

In the above, we flush STDOUT so that it and STDIN can be displayed on the same line.

Conclusion

There are other ways to convert string slices to other types. For example, using the from_str function is a common way of achieving this.
The most structurally sound design decision would've been to use structs to more easily manage our code. I decided against this because this example library meets a very specific use case: the need to collect and parse input using a simple function. Typing get_input("Prompt: "); is preferable to typing get_input::new().with_prompt("Prompt: ").get() as in other more sophisticated libraries for this narrow use case.
Well-documented input collection crates already exist. Dialoguer and read_input are two great libraries that come to mind.
Rust's Book is the definitive introduction to Rust. Here's a link.