Forem: Nylas

Nylas and AI: Email and Calendaring for the Future

Alvaro (Blag) Tejada Galindo — Mon, 28 Aug 2023 10:25:24 +0000

Yes, we're hosting a Hackathon and you can join today.

What do I need to do?

Just create an application using any of our SDKs (Ruby, NodeJS, Java, Python) or calling our APIs directly and any Artificial Intelligence tool of your choice (ChatGPT, Hugging Face, Midjourney).

Are there any prizes?

Of course, here's the list for the first prize:

$5,000 USD
Virtual meeting with Nylas leadership
Blog post featuring the winning submissions

And here for the 5 runner ups:

$1,000 USD
Virtual meeting with Nylas leadership
Blog post featuring the winning submissions

I just signed up, now what?!

When you sign up, you will receive an started kit email with clear instructions, but, if you don't read it or your forget about it, it's critical that you create a free Nylas account (And mention that you are completing our Hackathon!), that will allow you to connect up to 10 email account.

Can I get some inspiration?

Sure you can, just watch some of our Coding with Nylas livestream episodes

How to Send an email using DearPyGUI, ChatGPT and your voice | Coding with Nylas | Episode 68

How to use AI to generate email responses

Localize your emails with ChatGPT and Python | Coding with Nylas | Episode 59

Python, Sentiment Analysis, Streamlit, and ChatGPT | Coding with Nylas | Episode 74

Nylas + AI Events: WeAreDevelopers Recap & Upcoming Events

Last words

Just follow the foxes advise 😉

A Small Introduction to Functional Programming

Alvaro (Blag) Tejada Galindo — Tue, 03 Jan 2023 20:48:02 +0000

Functional Programming is an old paradigm that’s gained popularity in recent years due to its code conciseness, modularity, and lack of side effects.

Based on Lambda Calculus, developed by Alonzo Church in the 1930s, functional programming has been implemented in mainstream programming languages like JavaScript, Python and Java. Programming languages like Erlang, Haskell or Scala are better suited for functional programming as they are designed to be functional first.

Many developers consider Lisp the first functional programming language. For newer incarnations, we can try Common Lisp or Racket.

What makes functional programming so unique?

Pure functions → The same input always produces the same output, and there are no side effects (no printing into the screen, mutating your input or changing the filesystem).

Function are First Class citizens → Function are treated as data. We can use them as variables, as input for other functions or as return values. Functions are everywhere.

Shorter code → Programs written in functional programming languages tend to be shorter than its counterparts like object oriented or imperative programming.

No loops → There’s no while, for, do while or anything of the sort as recursion is all you need.

What do we need?

In this post, we’re going to explore some key fundamentals of functional programming using examples in two different functional languages and you’re invited to install them both, or just install what you want or need.

Haskell (1990 / Purely Functional) → If we’re on a Mac, the best way is to use homebrew and type on the terminal window:

$ brew install ghc cabal-install

Where ghc is the Glasgow Haskell Compiler and Cabal is Haskell’s package manager.

For other systems, you can refer to the download page.

Erlang (1986 / Concurrent and Functional) → Again, if on a Mac, type:

$ brew install erlang

Or you can refer to the download page.

Immutable variables

In functional programming, once a variable is assigned it can never change. You can think of that as using constants all the time.

Erlang

In Erlang variables begin with an Uppercase letter and once assigned they cannot be changed.

Haskell

In Haskell variables don’t follow any structure. Create a file called variables.hs and type the following:

a = 1
a = 5

Then open a terminal window on the same folder as your file and run ghci, then :l variables to load your program.

Pattern Matching

In short terms, pattern matching allows us to define how the same function will react to different parameters. This means that calling the function myFunction with no parameters will be different from calling myFunction with two parameters and different from calling it with five parameters and even different when calling it with different parameter values.

Let’s create an Erlang example called greetings.erl:

-module(greetings).
-export([greet/2]).
greet(male, Name) ->
    io:format("Good morning Mr. ~s~n", [Name]);
greet(female, Name) ->
    io:format("Good morning Mrs. ~s~n", [Name]);
greet(_, Name) ->
    io:format("Good morning ???. ~s~n", [Name]).

When we run it, we can see that we can call the same function but using different parameters and it will always run as expected.

Anonymous functions

Anonymous functions are functions that do not have a name. We can call them just once. We use them to define functions that are not meant to be called multiple times.

Let’s see an example calling a function to manipulate a list. We’re going to write a file called lambdas.hs:

func :: Integer -> Integer
func num = num * 2 + 10
show_nums :: [Integer] -> [Integer]
show_nums lst = map func lst

We need to call the Haskell compiler to read our file:

$ ghci 
$ :l lambdas.hs

And then call it like this:

$ show_nums [1,2,3,4,5]

While this is simple, we don’t really need the func function, so let’s change the source code like this:

show_lambdas :: [Integer] -> [Integer]
show_lambdas lst = map (\xs -> xs * 2 + 10) lst

And it will yield the same exact result, but with half the code lines:

Closures

A closure is a function inside a function that gets access to its parent function variables. Sounds strange, huh? Let’s see an Erlang example:

We’re going to write this example on a file called closures.erl:

-module(closures).
-export([start/1]).
start(Name) ->
  GreetPerson = fun() ->
    io:format("Hello and welcome ~s.~n", [Name]),
    fun() -> io:format("Goodbye ~s. Nice to meet you.~n", [Name]) end
  end,
  Greet = GreetPerson(),
  Greet().

To run this we need to compile the file first by typing on the terminal:

$ erlc closures.erl

A closures.beam file gets generated, which is a file that will be interpreted by the Erlang VM.

After compilation, we need to open the Erlang VM and run it.

$ erl

$ closures:start(“Blag”).

This will run and execute our code:

Here we can see that by calling Greet = GreetPerson(), we’re assigning the function GreetPerson() to the variable Greet. When we call Greet(), we’re greeting the person, but we’re also running an anonymous function that will say goodbye to the user. Notice that we’re not calling this anonymous function directly.

List Comprehensions

List comprehensions are a way to build or modify lists, and it is worth mentioning that lists are the most used type in functional programming.

Using list comprehensions, we could rewrite the lambdas example. This time, let’s use Erlang and create a file called list_comprehensions.erl with the following code:

-module(list_comprehensions).
-export([start/1]).
start(List) -> 
  [X * 2 + 10 || X <- List].

When we run this, it will return the same result:

Recursion

When using Recursion, a function calls itself multiple times, and this is not a foreign topic on non-functional programming languages, but the way it’s implemented and used is for sure different.

To make more sense of this, let’s see how a factorial source will look like in Ruby:

def fact(n)
  if n == 0
    1
  else
    n * fact(n-1)
  end
end
puts fact(5)

We can write the same on Haskell, like this:

factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

The code is shorter and simpler:

And that’s it for a small introduction to functional programming.

Like what you read but looking for some Nylas content, make sure to check our great selection of blog posts.

Don’t miss the action, watch our LiveStream Coding with Nylas:

Send and Read Emails Using Node-Red and the Nylas APIs

Alvaro (Blag) Tejada Galindo — Fri, 16 Dec 2022 15:54:17 +0000

If you’re a regular reader of our DevRel blogs, you might know that we had published several blogs on how to send and read emails using Nylas SDKs for languages like Python, Ruby, NodeJS and Java. We also have talked about using PHP, C#, and Rust.

Today, we’re going to learn how to send and read emails using Node-Red, a low-code programming environment based on NodeJS, that is mostly used for IoT scenarios.

Installing Node-Red

We can use npm to install Node-Red by typing the following in the terminal window:

$ sudo npm install -g --unsafe-perm node-red

If you’re on Windows, don’t use sudo.

Once installed, we can simply call it from the terminal like this:

$ node-red

And it will run the editor on the following address:

http://127.0.0.1:1880/

The Node-Red environment

Being a visual environment, we can simply drag and drop elements into the canvas, and connect them via wires:

Installing Nodes

In Node-Red, we can install additional Nodes that will help us in making our work easier.

We’re going to install sysmessage, a node that will allow us to create notifications in a simple and easy way.

First, we need to press the menu button on the right hand side:

Then select Manage Palette:

Then, on the Install tab, type sysm (to bring up autocompletion) on the search box and click on Install:

Once installed, a new node will appear on the left section on our canvas:

Sending an email

Now, we’re ready to send our email.

First, we’re going to select an Inject node and drag it into the canvas:

With a double click, we can access its properties. We want to delete the msg.topic message:

We need to choose timestamp and change it for JSON:

Then, select the three points to expand the editor:

And paste the following JSON code:

{
   "subject": "Hello from Node-Red",
   "to": [
       {
           "email": "devrel@nylas.com",
           "name": "Nylas' DevRel Team"
       }
   ],
   "body": "This email was sent using Node-Red and the Nylas APIs."
}

Now, we’re going to drag an http request node:

Here, we need to change the Method to POST and pass the Nylas Send Endpoint which is https://api.nylas.com/send. Then, we need to tick on Use authentication and select bearer authentication and pass our access token. Lastly, we need to add a couple of headers, Accept and Content-Type.

Once that’s done, we need to drag and add the sysmessage node and configure it like this; Choose the type of alert, OSX Alert in this case, and add an appropriate title. Leave the rest as it is.

Connect all the nodes with wires so it will look like this:

Or, you can simply copy and paste the following JSON code.

Paste the JSON code and press Import.

We should have all nodes ready to be pasted. Once we finish, we can press the Deploy button, which is located next to the menu button.

Once deployed, we just need to press the Inject note in order to send the email and get the notification message.

Also, we will get the JSON response back from calling the Nylas API.

With minimal effort and no code, we sent an email using Node-Red and the Nylas APIs.

Reading Emails

Sending email was simple and almost straightforward, but reading email gets a little bit complicated. No worries, it will be fun.

First, we’re going to create an http in node.

And configure it like this:

The method is GET, the URL will include /:limit which is going to how many emails we want to fetch and the Name is actually optional.

We can also add an extra http in node and get the URL but without the /:limit as this will help us to define a default page.

We’re going to add a Change node. This will allow us to read the /:limit parameter from before.

The name is optional, but the SET and to the value are very important. We’re getting the parameter value and assigning it to the payload.

This parameter is going to be a String, but we need an Integer. So, we need to add a Function node and type the following:

if (msg.payload == null){
   msg.payload = "5";
}
msg.payload = Number(msg.payload);
return msg;

This code will simply check if we are passing or not the :limit parameter and if we’re not, pass 5 as the limit, then it will convert the String parameter to an Integer parameter.

The next step will be to add an http request node. It will be the same as Sending an email but the URL would be

https://api.nylas.com/messages?in=inbox&limit={{{payload}}}

and the return will be a parsed JSON object instead of a UTF-8 String.

On the URL,

**https://api.nylas.com/messages?in=inbox&limit={{{payload}}}**

the in=inbox part means that we’re reading mail coming from the inbox only, and the

**limit={{{payload}}}**

means that the amount of emails that we want to fetch would be the same as the number we used as parameter.

We’re going to get back an array of emails, and we need to access them one by one, so our best choice is to use the split node:

This node will grab each item in the array of emails. What we want to do is to change the format of the date field, as it is currently displayed as Epoch (number of seconds since January 01, 1970) and we want something more human readable. The best thing is that we don’t need to modify any property of this node; we can use it just as it comes.

This is the code for the function:

msg.payload.date = new Date(msg.payload.date * 1000).toLocaleString();
return msg;

Once we’re done fixing the dates, it’s time to make the elements an array again, and for that we need to use the join node, which in the same manner as split, can be used without any further modifications.

Once the array is ready and back in place, we need to display the information from the emails, and for that we can use the template node. This node uses the mustache system, which is a logicless template engine for creating dynamic content. In other words, it generates HTML code by using tags that are replaced by code.

This is the code that we will need to use:

<html>
   <head>
       <script src="https://cdn.tailwindcss.com"></script>
   </head>
<body>
<h1 class="font-black" style="text-align:center">Inbox</h2>
<table class="table-auto">
   <tr>
       <th>Subject</th>
       <th>From (Name)</th>
       <th>From (Email)</th>
       <th>Date</th>
       <th>Snippet</th>
   </tr>
   {{#payload}}
   <tr>
   <td>
   {{subject}}
   </td>
   <td>
   {{from.0.name}}
   </td>
   <td>
   {{from.0.email}}
   </td>   
   <td>
   {{date}}
   </td>   
   <td>
   {{snippet}}
   </td>
   </tr>
   {{/payload}}
</table> 
</body>
</html>

This will simply create a table, loop each record of the array and print out the subject, name and email of sender, date and the snippet (email preview).

The last piece is the http response node which will allow us to see the template on the web browser.

We don’t need to change anything on this node.

Once we click on Deploy, we can start testing.

Our canvas should look like this one:

And of course, we can import the following JSON code.

On our browser of choice, we need to navigate to:

http://localhost:1880/GetEmails

And we will get the first five emails in our inbox:

And we can also pass parameters, so calling it this way:

http://localhost:1880/GetEmails/1

This will fetch just one email.

We can choose any number from one to one hundred (as that’s currently the fetch limit).

And that’s it. Hope you like this one. Sending and reading emails using Node-Red and the Nylas APIs is both fast and easy.

If you want to learn more about email management with Nylas, visit our documentation page Email API Overview.

Watch the Coding with Nylas episode 18 - Send and Read emails using Node-Red.

How to Send an Email in Any Language Using the Nylas APIs

Alvaro (Blag) Tejada Galindo — Wed, 14 Dec 2022 08:49:31 +0000

If you’ve been reading our posts, then you know how to send emails using Ruby, Python and Node.

But you may be wondering, can I use something else? Can I use PHP, Rust or C#?

Well, the simple answer is yes, we absolutely can. Nylas provides APIs, not only SDKs, so we can use any available programming language that supports Rest API calls.

We’re going to display some examples and take them more as a proof-of-concept than real applications. There are several ways to consume APIs and the intention of this blog post is just to show one way of doing that.

Sending an Email using PHP and Nylas Apis

First, we need to have PHP installed as well as Composer (A dependency manager for PHP). Using Composer, we need to install dotenv which will allow us to read .env files.

$ composer require vlucas/phpdotenv

Inside the .env file we need to pass our access token that we can easily gather from the Nylas Dashboard.

ACCESS_TOKEN=access_token

Then, we can create our script and call it SendEmail.php:

<!DOCTYPE HTML>
<html>
<head>
</head>
<body>
<?php
# Import your dependencies
require_once('vendor/autoload.php');

# Load env variables
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

# Initialize variables
$result = "";
# If we're working with a POST method
if ($_SERVER["REQUEST_METHOD"] == "POST") {
# Required fields for Email API
$fields = array(
            'subject' => $_POST["subject"],
            'body' => $_POST["body"],
            'to' => array([
                 'name' => $_POST["to_name"],
                 'email' => $_POST["to_email"]
            ]),
        );  

# Headers with Authorization and type
$headr = array();
$headr[] = 'Accept: application/json';
$headr[] = 'Content-type: application/json';
$headr[] = 'Authorization: Bearer ' . $_ENV['ACCESS_TOKEN'];

# Call the Send Email API
$ch = curl_init( "https://api.nylas.com/send" );
# Encode the data as JSON
$payload = json_encode( $fields );
# Submit the Email information
curl_setopt( $ch, CURLOPT_POSTFIELDS, $payload );
# Submit the Headers
curl_setopt( $ch, CURLOPT_HTTPHEADER, $headr);
# We're doing a POST
curl_setopt($ch, CURLOPT_POST, true);
# Return response instead of printing.
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
# Send request.
$result = curl_exec($ch);
# Close request
curl_close($ch);
}
?>

<!-- Create the Form -->
    <h2>Send an Email using PHP and the Nylas APIs</h2>
    <form method="post" action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>">
    To Name: <input type="text" name="to_name">
    <br><br>
    To Email: <input type="text" name="to_email">
    <br><br>    
    Subject: <input type="text" name="subject">
    <br><br>
    Body: <textarea name="body" rows="5" cols="40"></textarea>
    <br><br>
    <input type="submit" name="submit" value="Submit"> 
    </form>

<?php
    echo "$result";
?>  

</body>
</html>

Instead of saving this on our Apache folder, we will keep it where our PHP scripts reside and simply type this on the terminal:

$ php -S 127.0.0.1:8000

This will call PHP’s internal web server. Going to our favourite browser we can pass the following address:

http://localhost:8000/SendEmail.php

And a form will be displayed:

We need to fill in the recipient’s name, the recipient’s email, the subject and the body of the email. Once we press Submit, we will get a raw response indicating that everything was fine.

The email was successfully delivered.

You can check the Github repo here.

You can watch the LiveStream video here.

Sending an Email using Rust and Nylas Apis

Next, let’s use Rust. We’re going to use Cargo (Rust’s Dependency Manager) which is bundled inside Rust.

$ cargo new send_email

This will create two different files. The first one called Cargo.toml:

[package]
name = "send_email"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
reqwest = { version = "0.11", features = ["json"] } # reqwest with JSON parsing support
futures = "0.3" # for our async / await blocks
tokio = { version = "1.12.0", features = ["full"] } # for our async runtime
serde_json = "1.0" #to handle json
dotenv = "0.15.0" # for reading .env file

[profile.release]
opt-level = 'z'     # Optimize for size.
lto = true          # Enable Link Time Optimization
codegen-units = 1   # Reduce the number of codegen units to increase optimizations.
panic = 'abort'     # Abort on panic
strip = true        # Strip symbols from binary*

The second one called main.rs:

// Import your dependencies
use reqwest; //HTTP Client
use std::io;
use serde_json::json; //Json handler
use std::env;

// tokio let's us use "async" on our main function
#[tokio::main]
async fn main() {

// Read the .env file
dotenv::dotenv().expect("Failed to read .env file");

// Add the ACCESS_TOKEN to the Authorization string
let mut _access_token = String::new();
_access_token = "Bearer ".to_owned() +  &env::var("ACCESS_TOKEN").expect("Not found");

// Request the parameters
println!("Enter a subject: ");
let mut _subject = String::new();
io::stdin().read_line(&mut _subject)
             .expect("failed to read");

println!("Enter a name: ");
let mut _name = String::new();
io::stdin().read_line(&mut _name)
              .expect("failed to read");

println!("Enter an email: ");   
let mut _email = String::new();
io::stdin().read_line(&mut _email)
              .expect("failed to read");

println!("Enter the body: ");              
let mut _body = String::new();
io::stdin().read_line(&mut _body)
              .expect("failed to read");

let trim_subject = _subject.trim();
let trim_name = _name.trim();
let trim_email = _email.trim();
let trim_body = _body.trim();

// Create the JSON structure
let _fields = json!({
    "subject": &trim_subject,
    "to": [
    {
      "email": &trim_email,
      "name": &trim_name
    }
  ],
  "body": &trim_body,
});

    let client = reqwest::Client::new(); //Create HTTP client
    let response = client //Call API passing parameters
        .post("https://api.nylas.com/send")
        .header("Authorization", _access_token.to_string())
        .header("Content-type", "application/json")
        .header("Accept", "application/json")
        .json(&_fields)
        .send()
        .await
        .unwrap() // Give the back the result of panic if it fails
        .text() // Convert it to plain text
        .await;

    println!("{:?}", response);
}

We must not forget to create the .env file:

ACCESS_TOKEN=access_token

Once we have everything, we need to release our application by typing on the terminal:

$ cargo build --release

Once it’s has been built:

$ ./send_email

Just like in the PHP example, the email was successfully delivered.

You can check the Github repo here.

You can watch the LiveStream video here.

Sending an Email using C# and Nylas Apis

Finally, we’re going to use C#. And for this, we’re going to need to install Visual Studio Code.

To start, let’s head to our Terminal and type the following:

$ mkdir send_email && cd send_email

Once we created a new folder and entered that folder, we need to type:

$ dotnet new console

That will create the following files: Program.cs and send_email.csproj

Now, we need to open Visual Studio Code and press Open:

Then, choose your folder send_email and open it:

This will open up the editor and your files.

On send_email.csproj we need to include the following code:

<Project Sdk="Microsoft.NET.Sdk">

 <PropertyGroup>
   <OutputType>Exe</OutputType>
   <TargetFramework>net6.0</TargetFramework>
   <ImplicitUsings>enable</ImplicitUsings>
   <Nullable>enable</Nullable>
 </PropertyGroup>

 <ItemGroup>
   <PackageReference Include="DotNetEnv" Version="2.3.0" />
   <PackageReference Include="RestSharp" Version="106.15" />
 </ItemGroup>

</Project>

The RestSharp package will help us to consume REST APIs and the DotNetEnv will help us read .env files

This is the code for the Program.cs file:

// Import packages
using RestSharp;
using System;

// Load .env file
DotNetEnv.Env.Load();
DotNetEnv.Env.TraversePath().Load();

// Ask via the user via console
Console.WriteLine("Enter subject:");
string _subject = System.Console.ReadLine();
Console.WriteLine("Enter name:");
string _name = System.Console.ReadLine();
Console.WriteLine("Enter email:");
string _email = System.Console.ReadLine();
Console.WriteLine("Enter body:");
string _body = System.Console.ReadLine();
// Create a new Rest Client and call the Nylas API endpoint
var client = new RestSharp.RestClient("https://api.nylas.com/send");
// Wait until the connection is done
client.Timeout = -1;
// We want a POST method
var request = new RestSharp.RestRequest(Method.POST);
// Adding header and authorization
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer " + System.Environment.GetEnvironmentVariable("ACCESS_TOKEN"));

// Formatting the body of our request
var body = @"{"
   + "\n"
   + $@"    ""body"" : ""{_body}"","
   + "\n"
   + $@"    ""subject"": ""{_subject}"","
   + "\n"
   + $@"    ""to"": ["
   + "\n"
   + @"        {"
   + "\n"
   + $@"            ""name"": ""{_name}"","
   + "\n"
   + $@"            ""email"": ""{_email}"""
   + "\n"
   + @"        }"
   + "\n"
   + @"    ]"
   + "\n"
   + @"}";

// Adding the body as a parameter
request.AddParameter("application/json", body, ParameterType.RequestBody);
// We send the request
IRestResponse response = client.Execute(request);
// Print the response
Console.WriteLine(response.Content);
// Wait for user input before closing the terminal
Console.Read();

We must not forget to create the .env file:

ACCESS_TOKEN = access_token

Once we have everything, we need to release our application by running it without debugging:

This will generate an executable file that we can execute by going to:

$ cd bin/Debug/net6.0

And running the application:

$ ./send_email

Just like in the PHP and Rust examples, the email was successfully delivered:

You can check the Github repo here.

If you want to learn more about our Email API, please go to our Email API documentation.

Grouping Email Threads with Ruby and Nylas

Alvaro (Blag) Tejada Galindo — Fri, 09 Dec 2022 11:56:52 +0000

Looking for emails is straightforward, however, trying to get them all in a single place with less noise can be a difficult task. Thanks to the Nylas Ruby API, we can make email threading possible.

If you want to learn more about Email Threads, read the blog post Stay Threaded: How to Manage and Control Email Threads

Is your system ready to group email threads?

If you already have the Nylas Ruby SDK installed and your Ruby environment is configured, then continue along with the blog.

Otherwise, I would recommend that you read the post How to Send Emails with the Nylas Ruby SDK where the basic setup is explained.

What are we going to talk about?

What does our application look like?
Installing the Sinatra package
Running our Email Threading application

What does our application look like?

Before we jump into the code, let’s see how our application actually works. We will have a single input field accepting the email address to get all the related email threads and messages included in those threads:

We’re going to list all email threads related to the address we used, as long as they have at least two messages:

The email threads are presented in an accordion, and when we open one, we will get the emails in a sequence, with the contact image and with the noise removed. So no emails, phone numbers or reply texts.

As we can see, both simple and nice.

Installing the Sinatra package

To create a Ruby web application, our best option is to use Sinatra, one of the most popular Micro Frameworks in the Ruby world. We might need to install some additional gems:

$ gem install sinatra $ gem install puma $ gem install nokogiri

Once installed, we’re ready to go:

First, we’re going to create a folder called EmailThreading, and inside we’re going to create two folders, one called views and other called public.

Let’s create a file called EmailThreading.rb in the EmailThreading folder, and add the following code:

# Import your dependencies
require 'dotenv/load'
require 'nylas'
require 'sinatra'
require 'nokogiri'
require 'date'

# Initialize your Nylas API client
nylas = Nylas::API.new(
    app_id: ENV["CLIENT_ID"],
    app_secret: ENV["CLIENT_SECRET"],
    access_token: ENV["ACCESS_TOKEN"]
)

# Use the Nokogiri gem to clean up the email response
def clean_content(raw_html)
    html = raw_html.encode('UTF-8', invalid: :replace, undef: :replace, 
                         replace: '', universal_newline: true).gsub(/\P{ASCII}/, 
                         '')
    parser = Nokogiri::HTML(html, nil, Encoding::UTF_8.to_s)
    parser.xpath('//script')&.remove
    parser.xpath('//style')&.remove
    parser.xpath('//text()').map(&:text).join('<br> ')
end

# Get the contact associated to the email address
def get_contact(nylas, email)
    contact =  nylas.contacts.where(email: email)
    if contact[0] != nil
        return contact[0]
    end
end

# Download the contact picture if it's not stored already
def download_contact_picture(nylas, id)
    if id != nil
        contact = nylas.contacts.find(id)
        picture = contact.picture
        file_name = id + ".png"
        File.open("public/" + file_name,"wb") do |f|
            f.write File.open(picture, 'rb') {|file| file.read }
        end
    end
end

# When calling the application for the first time
get '/' do
    _threads = []
    # Call the page
    erb :main, :layout => :layout, :locals => {:threads => _threads}
end

# When asking for the email threading
post '/search' do
    # Get parameter from form
    search = params[:search]
    # Search all threads related to the email address   
    threads = nylas.threads.where(from: search,in: 'inbox') 

    _threads = []

    # Loop through all the threads  
    threads.each{ |thread|
        _thread = []
        _messages = []
        _pictures = []
        _names = []
        # Look for threads with more than 1 message     
        if thread.message_ids.length() > 1
            # Get the subject of the first email        
            _thread.push(thread.subject)
            # Loop through all messages contained in the thread
            thread.message_ids.each{ |message|
                # Get information from the message          
                message = nylas.messages.find(message)
                # Try to get the contact information                
                contact = get_contact(nylas, message.from[0].email)
                if contact != nil and contact != ""
                    # If the contact is available, downloads its profile picture
                    download_contact_picture(nylas, contact.id)
                end
                # Remove extra information from the message, like appended 
                #  message, email and phone number
                _messages.push(clean_content(message.body).
                    gsub(/(\bOn.*\b)(?!.*\1)/,"").
                    gsub(/[a-z0-9._-]+@[a-z0-9._-]+\.[a-z]{2,3}\b/i,"").
                    gsub(/(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}/,"").
                    gsub(/twitter:.+/i,""))
                    # Convert date to something readable
                    datetime = Time.at(message.date).to_datetime
                    date = datetime.to_s.scan(/\d{4}-\d{2}-\d{2}/)
                    time = datetime.to_s.scan(/\d{2}:\d{2}:\d{2}/)
                    if contact == nil or contact == ""
                        _pictures.push("NotFound.png")
                        _names.push("Not Found" + " on " + date[0] + " at " + 
                                    time[0])
                    else
                        # If there's a contact, pass picture information, 
                        # name and date and time of message
                        _pictures.push(contact.id + ".png")
                        _names.push(contact.given_name + " " + contact.surname + 
                                    " on " + date[0] + " at " + time[0])
                    end
            }
            _thread.push(_messages)
            _thread.push(_pictures)
            _thread.push(_names)
            _threads.push(_thread)
        end
    }

    # Call the page and display threads 
    erb :main, :layout => :layout, :locals => {:threads => _threads}
end

Inside the views folder, we need to create two different files, let’s start with layout.erb:

<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- Call the TailwindCSS and Flowbite libraries -->
<script src="https://cdn.tailwindcss.com"></script>
<link rel="stylesheet" href="https://unpkg.com/flowbite@1.5.3/dist/flowbite.min.css" />
<title>Nylas’ Email Threading</title>
<body>
<%= yield %>
<script src="https://unpkg.com/flowbite@1.5.3/dist/flowbite.js"></script>
</body>
</html>

We’re calling both the TailwindCSS and Flowbite libraries to handle CSS.

We need to create then the file main.erb:

<div class="grid bg-green-300 border-green-600 border-b 
           p-4 m-4 rounded place-items-center">
<p class="text-6xl text-center">Email Threading</p><br>
<!-- Create the form-->
<form method = "post" action="search">
<div class="flex bg-blue-300 border-blue-600 border-b p-4 m-4 rounded place-items-center">
<input type="text" name="search" value="" size="50"></input>&nbsp;&nbsp;
<button type="submit" class="block bg-blue-500 hover:bg-blue-700 
  text-white text-lg mx-auto py-2 px-4 rounded-full">Search</button>
</div>
</form>
<!-- Do we have any threads? -->
<% if threads != [] %>
<div id="accordion-collapse" data-accordion="collapse">
<!-- Counter to generate accordion elements -->
  <% counter = 1 %>
<!-- Loop through each thread -->  
  <% threads.each do |thread| %>
<!-- Define values for the accordion elements -->  
    <% heading = "accordion-collapse-heading-" + counter.to_s  %>
    <% body = "accordion-collapse-body-" + counter.to_s  %>
    <% _body = "#accordion-collapse-body-" + counter.to_s  %>
  <h2 id=<%= heading %> >
    <button type="button" class="flex items-center justify-between w-full p-5 font-medium 
                                 text-left text-gray-500 border border-b-0 border-gray-200 
                                 focus:ring-4 focus:ring-gray-200 dark:focus:ring-gray-800 
                                 dark:border-gray-700 dark:text-gray-400 hover:bg-gray-100 
                                 dark:hover:bg-gray-800" data-accordion-target=<%= _body %> 
                                 aria-expanded="false" aria-controls=<%= body %>>
<!-- Title of the thread -->
      <span><%= thread[0] %></span>
      <svg data-accordion-icon class="w-6 h-6 shrink-0" fill="currentColor" 
        viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd"    
        d="M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 
        4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z" clip-rule="evenodd"></path></svg>
    </button>
  </h2>     
  <div id=<%= body %> class="hidden" aria-labelledby=<%= heading %>>
  <div class="p-5 font-light border border-b-0 border-gray-200 dark:border-gray-700">
  <!-- Get size of thread array -->
  <% count = thread[1].length() %>
  <!-- Define amount of elements on the grid -->    
  <% count_str = "grid-rows-" + count.to_s %>
  <div class="grid <%= count_str %> grid-flow-col gap-4">
  <!-- Counter to access array elements --> 
    <% counter = 0 %>
    <!-- Loop through each email -->        
    <% thread[1].each do |message| %>
      <div class="col-span-2 ...">
      <!-- Display image and date/time of email -->             
    <img class="mx-auto" src="<%= thread[2][counter] %>"><b>
        <p class="text-center"><%= thread[3][counter] %></p></b><br>
        <!-- Display the email message -->
    <%= message %>
      </div>
    <% counter = counter + 1 %>
        <% end %>
    </div>
    </div> 
  </div>    
  <% end %>
</div>
<% end %>
</div>

If you wonder about the public folder, it will only hold the contact profile picture, so there’s nothing we need to do there.

And that’s it. We’re ready to roll.

Running our Email Threading application

In order to run our application, we just need to type the following on the terminal window:

$ ruby EmailThreading.rb

Our application will be running on port 4567 of localhost, so we just need to open our favourite browser and go to the following address:

http://localhost:4567

If you want to learn more about our Email APIs, please go to our documentation Email API Overview as well Threads and Messages.

Python, Sentiment Analysis, R and Shiny

Alvaro (Blag) Tejada Galindo — Tue, 21 Jun 2022 03:12:42 +0000

Knowing how your customers feel about your product is as important as creating a good product. Wouldn’t it be great if we could determine in a simple way how our customers feel by analyzing the feedback they provide via email messages? With Nylas Neural API’s Sentiment Analysis, we can do that. Sentiment Analysis is a way of computationally analyzing a writer’s work to determine how they feel about a selected topic. With basic sentiment analysis, you can check if the writer feels positive, negative, or neutral about something.

For this post, we’re going to create a simple feedback web page using Python. The sentiment information we gather will be analyzed and stored locally in a SQLite Database to be later picked up and displayed in a Shiny Dashboard using the R Programming Language. (Shiny is an R package that lets you easily display data with a variety of charts and graphs in your own dashboard.) We’re keeping everything local just for the sake of simplicity.

Is your system ready?

If you don’t have the Nylas Python SDK installed and your environment isn’t configured, I would recommend you to read the post How to Send Emails with the Nylas Python SDK where everything is clearly explained.

To complete this project you will need:

Nylas developer account and credentials
Nylas Python SDK installed
Gmail account (we will use Gmail to label and sort emails)
We will install R and Shiny later in this post, so you don’t need to worry about it now

What are we going to do?

Let’s pretend that we are the owners of a small company that produces vegan eggs called “VeggiEggs”. We want to build a Flask application that will collect feedback from our customers and send it to us via email, so that we can store the information and also reply back as a follow up. Then we want a Python script that will read and analyze every email using Sentiment Analysis and finally create an R Shiny Script that will display a dashboard with the information we gathered.

Working on the application

What we need to do first is set up a Label so that the emails are easy to find.

Creating a Label

On Gmail, we can do the following:

On the search bar, press the “Show Search Options” button.

Then, use the “veggieggs” and “feedback” words.

When we create the filter, we can assign the messages to an existing label or create a new one.

We don’t need to nest it, so just enter the label name.

Once we create it, we can apply some extra filters

Now, every email that we receive containing those words “VeggieEggs” and “Feedback” will go into our label and skip the inbox.

Installing the Flask package

As we want to create a Python web application, our best option is to use Flask, one of the most popular Micro Frameworks in the Python world.

To install it, we can type the following command on the terminal:

$ pip3 install flask

Once installed, we’re ready to go.

Creating the Flask application

As we’re going to develop this application locally and not deploy it anywhere else. We’re going to create a file called config.json which will hold our Nylas Tokens information. This comes with Flask, so why not use it?

{
  "NYLAS_OAUTH_CLIENT_ID": "<YOUR_CLIENT_ID>",
  "NYLAS_OAUTH_CLIENT_SECRET": "<YOUR_CLIENT_SECRET>",
  "SECRET_KEY": "<YOUR_SECRET_KEY>"
}

Now, we’re going to create a file called FeedbackForm.py which will handle getting the feedback and sending the email.

# Import your dependencies
from flask import Flask,render_template,json,request,flash,redirect,url_for
from nylas import APIClient

# Create the app and read the configuration file
app = Flask(__name__)
app.config.from_file("config.json", json.load)

# Initialize your Nylas API client
def load_nylas():
    nylas = APIClient(
        app.config["NYLAS_OAUTH_CLIENT_ID"],
    app.config["NYLAS_OAUTH_CLIENT_SECRET"],
    app.config["SECRET_KEY"]
    )
    return nylas

# This the landing page
@app.route("/", methods=['GET','POST'])
def index():
# If we are reading the page, show the feedback form
    if request.method == 'GET':
        return render_template('FeedbackForm.html')
# If we are submitting feedback, read the form
    else:
        name = request.form['name']
        email = request.form['email']
        rating = request.form['rating']
        comments = request.form['comments']

# Check for required fields
        if not name:
            flash('Name is required!')
            return redirect(url_for('index'))
        elif not email:
            flash('Email is required!')
            return redirect(url_for('index'))
        elif not comments:
            flash('Comments are required!')
            return redirect(url_for('index'))           
        else:
# If everything is Ok, send the email with the feedback information
            nylas = load_nylas()
            draft = nylas.drafts.create()
            draft.subject = "VeggiEggs Feedback - {} - {} - {}".format(name, email, rating)
            draft.body = comments
    draft.to = [{"name": "<YOUR_NAME>", "email": "<YOUR_EMAIL>"}]

    draft.send()            
    return render_template('ConfirmationForm.html', 
                   name = name, email = email, 
                   rating = rating, comments=comments),            
                                                  {"Refresh":"5;url=/"}

# Run our application       
if __name__ == "__main__":
    app.run()

For this to work properly, we need to create a file called FeedbackForm.html and we’re going to use TailwindCSS to provide a quick look and feel.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script src="https://cdn.tailwindcss.com"></script>
    <title>Nylas</title>
</head>
<body>
    <div class="bg-green-300 border-green-600 border-b p-4 m-4 rounded">
    {% block content %}
    {% with messages = get_flashed_messages() %}
        {% if messages %}
            {% for message in messages %}
                {{ message }}
            {% endfor %}
        {% endif %}
    {% endwith %}
    <h1 class="font-black">We hope you enjoyed VeggiEggs. Please take some time to leave a review</h1>
    <br>
    <form method="post">
        <label for="name" class="font-bold">* Name</label>
        <input type="text" name="name"
               placeholder="Your name"
               value="{{ request.form['name'] }}"></input>
        <br><br>
        <label for="email" class="font-bold">* Email</label>
        <input type="email" name="email"
               placeholder="Your email"></input>
        <br><br>
        <label for="rating" class="font-bold">Choose a rating:</label>
        <select name="rating">
            <option value="1">Poor</option>
            <option value="2">Fair</option>
            <option value="3">Ok</option>
            <option value="4">Good</option>
            <option value="5" selected>Great</option>
        </select><br><br>
        <p class="font-bold">* Comments</p>
        <textarea name="comments"
               placeholder="Your comments"
               rows=5
               cols=50></textarea>        
        <br><br>
        <button type="submit" class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded-full">Submit</button>
    </form>
    <p class="font-bold">* Required</p>
    {% endblock %}
    </div>
</body>
</html>

And we’re going to need a confirmation page as well, so that people know that their responses were recorded correctly.

We're going to create a page called ConfirmationForm.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script src="https://cdn.tailwindcss.com"></script>
    <title>Nylas</title>
</head>
<body>
    <div class="bg-green-300 border-green-600 border-b p-4 m-4 rounded">
    {% block content %}
    <h2 class="font-semibold">Thanks {{name}} - {{email}}</h2>
    <h2 class="font-semibold">Your rating was: {{rating}}</h2>
    <h2 class="font-semibold">Your comments were:<br><br> {{comments}}</h2>
    <p class="font-semibold">You will be automatically redirected. 
    If it doesn't work, follow the <a href="{{url_for('index')}}">link</a></p>
    {% endblock %}
    </div>
</body>
</html>

We can execute this script from the terminal by typing:

$ python3 FeedbackForm.py

Now, we need to open localhost:5000 on our favourite browser.

NOTE: If you are using Flask on a Mac that has Monterey or higher, you may have trouble accessing localhost. You can solve this by disabling the Airplay Receiver in your Sharing folder. (Airplay Receiver uses port 5000.) Follow these instructions: How to disable Airplay Receiver.

Once we hit submit, we will get instant feedback.

We use redirection, so it will go back to the main page after 5 seconds. And here we’re displaying the information entered by the user.

If we check our mailbox, we will find this:

We have all the information we need on this email. So we’re ready for the next stage.

Creating a Python script

In this step, we’re going to read all the emails with the label “VeggiEggs”, in order to analyze them with the Sentiment Analysis endpoint as well as to gather important information like the rating and the date the email was sent.

We’re going to create a file called NeuralFeeback.py. It looks like this:

# Load your env variables
from dotenv import load_dotenv
load_dotenv()

# Import your dependencies
import os
from nylas import APIClient
import subprocess

# Initialize your Nylas API client
nylas = APIClient(
    os.environ.get("CLIENT_ID"),
    os.environ.get("CLIENT_SECRET"),
    os.environ.get("ACCESS_TOKEN"),
)

# Gather all messages from the label “VeggiEggs”
messages = nylas.messages.where(in_="VeggiEggs")
# Create variables to hold the information to be passed to R
rating = []
sentiment = []
score = []
date = []
sRating = ""
sSentiment = ""
sScore = ""
sDate = ""

# Read all messages
for message in messages:
# Split the title in order to get the rating value
    line = message.subject.split(" - ")
    rating.append(line[3])
# Send each message to the Sentiment Analysis endpoint
    message_analysis = nylas.neural.sentiment_analysis_message([message.id])
# Extract the Sentiment Analysis result
    sentiment.append(message_analysis[0].sentiment)
    score.append(str(message_analysis[0].sentiment_score))
    date.append(str(message.received_at.date()))    

# Turn the information into a long string separated by commas
sRating = ','.join(rating)
sSentiment = ','.join(sentiment)
sScore = ','.join(score)
sDate = ','.join(date)

# We want to know when R is getting called
print("Calling R")
# Call R as a subprocess and launch Shiny in the browser
subprocess.run(["RScript", "-e", "shiny::runApp('<path_to_your_python_env>', launch.browser = TRUE)", sRating, sSentiment, sScore, sDate])

Setting up R

Installing R

As we’re going to use Shiny to create our dashboard, we need to create a R script. If you don’t have R installed on your computer you can do it like this.

Here’s the latest version of R for the Mac R-4.1.3. Also, while optional, we need to install XQuartz as it is not bundled with Mac by default.

Installing RStudio

While it’s not mandatory, we should install RStudio which is by far the best R IDE.

Installing the necessary packages

We will need to install some packages in order to have our Shiny application running. Open up RStudio and click on “Tools → Install packages”. Type the following packages separated by a comma:

shiny → Makes it incredibly easy to build interactive web applications with R

tidyverse → The tidyverse is an opinionated collection of R packages designed for data science

treemap → Displays hierarchical data as a set of nested rectangles

imager → Fast image processing for images in up to 4 dimensions

plyr → Tools for Splitting, Applying and Combining Data

We need to make sure to leave “Install dependencies” checked and press Install.

Once everything is installed, we can create the script.

Creating the Shiny script

We need to press File → New → R Script and save the file as App.r then type the following

# Load packages
library("shiny")
library("tidyverse")
library("treemap")
library("imager")
library("plyr")

# UI Section of our Shiny app
ui <- fluidPage(
# Dashboard headline
  tags$div(
    HTML("<h1 style='color:blue;text-align:center;'>VeggiEggs Dashboard!</h1>")
  ),  
# Dashboard title
  title = "VeggiEggs Dashboard!",
# Define how our plots are going to be laid off
                 fluidRow(
                   column(width=5, plotOutput(outputId = "distPlot")),
                   column(width=5,offset=2, plotOutput(outputId = "distPlot2"))
                 ),
                 fluidRow(
                   column(width=5, plotOutput(outputId = "distPlot3")),
                   column(width=5,offset=2, plotOutput(outputId = "distPlot4"))
                 )) 

# Server part, here is where the plots are defined
server <- function(input, output) {

# We receive the information coming from Python
  args = commandArgs(trailingOnly=TRUE)
  ratings<-as.integer(strsplit(args[1], ",")[[1]])
  sentiments<-strsplit(args[2], ",")[[1]]
  scores<-as.integer(strsplit(args[3], ",")[[1]])    
  dates<-as.Date(strsplit(args[4], ",")[[1]])

# We create a Data.Frame to better handle the data
  entries = data.frame(ratings, sentiments, scores, dates=as.Date(dates))  

# First plot. Summarize the ratings
  output$distPlot <- renderPlot({
    Ratings <- count(entries, 'ratings')
    names(Ratings)<-c("Ratings","Count")
    Count <- Ratings$Count
    Ratings %>%
      ggplot( aes(x = Ratings, y = Count, fill = Count)) + 
        geom_bar(stat="identity")
  })

# Second plot. How many feedbacks per day
  output$distPlot2 <- renderPlot({
    Freq <- count(entries, 'dates')
    names(Freq)<-c("Dates","Entries")
    Freq %>% 
      ggplot( aes(x=Dates, y=Entries)) +
      geom_line(color="green") +
      geom_point()
  })

# Third plot. Frequency of sentiment analysis
  output$distPlot3 <- renderPlot({
    Sentiment <- count(sentiments)
    group <- paste(Sentiment$x,Sentiment$freq)
    sentiment<-Sentiment$freq
    data <- data.frame(group,sentiment)
    treemap(data,
            index="group",
            vSize="sentiment",
            type="index"
    )
  })

# Fourth Plot. Display an image for each score range  
  output$distPlot4 <- renderPlot({
    Score<-mean(entries$scores)
    if (Score < -0.5){
      image_filename<-"angry-emoji.png"
    }
    if (Score > -0.5 && Score < 0.5){
      image_filename<-"neutral-emoji.png"
    }
    if (Score > 0.5){
      image_filename<-"happy-emoji.jpeg"
    }

    image <- load.image(image_filename)
    plot(image)
  })

}

shinyApp(ui = ui, server = server)

As we are calling this script from Python, there’s nothing more to do here.

Here are the images we’re using, and they need to be in the same folder as our script.

Calling the Dashboard

In order to call the Dashboard, the only thing we need to do is run our Python script by typing this into the terminal window:

$ python3 NeuralFeedback.py

The Dashboard will be opened automatically on the default browser.

That’s it. Hope you like this post! You can get more information on Sentiment Analysis on the Nylas Documentation page.

Join our technical demo to see the Nylas Platform in action

FinTech Platforms Use Email API to Power Communications

Serena — Thu, 06 Dec 2018 15:30:00 +0000

FinTech is evolving at the speed of light thanks to blockchain, cryptocurrencies, AI, and one technology you might not expect: an email API. They’re disrupting an industry that’s riddled by legacy systems and processes using APIs to build better software and meet the needs of modern consumers.

With the help of an email API, FinTech companies are able to focus and execute on automation, customization, and personalization with more agility than legacy companies who are often constrained by more traditional systems. As a result, FinTech products are going to market faster with embedded communications that enable users to communicate with context.

The Nylas Email API saves financial organizations months of development time by providing the most comprehensive out of the box email integration available. The Nylas Email API acts as a layer of abstraction on top of all email providers including Gmail, Outlook.com, IMAP, and the rest. With just a few lines of code, developers can add full-featured, bi-directional email sync to their applications with ease.

Email APIs Increase User Engagement in Financial CRMs

The average financial advisor serves about 156 customers on a rolling basis. With an email API, financial CRMs save advisors hours of time each week by centralizing communications (and syncing them between users’ inboxes and the financial CRM), task management, and automation of manual data entry.

Financial CRM Wealthbox decided to build an embedded email client called Wealthbox Mail for the Wealthbox platform to send email and sync with users’ email services- and they turned to the Nylas Email API to do it. Nylas powers email sending, analytics, and templates within Wealthbox, and provides two-way email, calendar, and contacts sync between every Wealthbox users’ inbox and the Wealthbox CRM.

Email APIs Improve Client Communication for Tax Professionals

FinTech companies are also leveraging APIs to build email features for CPAs and other tax professionals that help them keep a record of all email communications with a given client in one central location. This helps tax professionals make informed decisions about their clients’ filing needs and enables them to be more efficient with their time.

Tax professionals handle documents filled with important data and often have several touchpoints of communication with each client they serve. Every invoice, paystub, and financial legality document is imperative to their overall filing process.

Companies like Canopy, a leading tax resolution platform that provides practice management software, save their users time through file sharing and storage, online payments, client intake surveys, requests and reminders to improve communication and information sharing.

With just a few lines of code, the Nylas Email API helped Canopy build features that allow their users to send, receive, and track emails all from within the Canopy platform. This system of record helps tax professionals organize their clients information and saves them the headache of having to save each communication into an associated file on a computer. With this feature, Canopy users can manage their work more efficiently, giving them more time focus on more creative tasks that require human touch.

The Bull Market Goes Beyond Email APIs

FinTech is making big leaps to meet consumer demands, and using more than just the Nylas API to do it. Many modern finance platforms use Stripe for payments, Twilio for text messages, Plaid to connect to bank accounts, and many other APIs that help companies go to market faster with features consumers love.

With these APIs, everyone from the developers building the apps to the end-users wins.

5 Python Libraries We Love

Maria Moy — Thu, 29 Nov 2018 15:30:00 +0000

Nylas is a Python shop, and while we use a lot of the Python libraries you’d expect to see in an email API codebase, like datetime, imaplib, and xml parsers, we also use a ton of open-source Python tools outside the standard library. These crucial libraries have saved us from reinventing the wheel time and time again, and we’ve gotten a lot of mileage out of them.

Open-source code isn’t just developed and left standing; it’s regularly maintained and extended by talented and dedicated Python developers. The Nylas Sync Engine, our core service for syncing data from Gmail, Microsoft, and IMAP email providers, started as an open-source project, which gives us a unique appreciation for the Python maintainers who are responding to issues, merging pull requests, and iterating on the open-source tools we use every day.

Here are 5 of our favorite Python libraries, and how we use them:

1. ptpython for Fast & Easy Internal Tooling

When you’re running as many services as we do (a sync service, an API, a developer dashboard, and a webhooks service, to name a few!), with hundreds of customers all using your platform in unique ways, and a database distributed across 200 shards, iterating on interconnected systems and debugging issues becomes a complex problem.

The ptpython REPL brings autocomplete, syntax highlighting and multiline editing to the Python shell, creating a robust and customizable Python environment. We use it to enhance the Python console with pre-loaded text, helper functions and objects for our developers and our developer success engineers to use. If an error pops up in our logs, we can quickly load the buggy object in a Python REPL, debug the root cause, and experiment with solutions directly in the Python shell.

And just for fun, we made it pretty:

2. exchangelib for Syncing Data from Microsoft

We work with lots of different email protocols when we’re syncing data. For Microsoft accounts, we sync data with Exchange ActiveSync (EAS) and Exchange Web Services (EWS), and we use exchangelib in our EWS integrations. Microsoft documentation is hard to find via Google search, and not intuitively organized, and exchangelib is especially good about commenting code to include links back to the relevant documentation, so it’s easy for us to track down descriptions of more obscure attributes.

3. tldextract for Parsing URLs

If you’ve ever tried to write a regular expression to define a valid url, you know it’s not as trivial as it sounds. The normal .com, .org and .net top-level domains are easy enough to codify, but these days .limo, .pizza and .duck are all valid suffixes as well. In our code, we need to parse urls to validate emails and server addresses, so we use tldextract to separate the protocol from the domain, subdomain(s) and suffix in a given url.

4. vcr for Fast, Reusable Test Fixtures

At Nylas, we work with a lot of APIs, which means we make a lot of HTTP requests. To simplify and speed up testing, we use vcr to record the responses from the HTTP interactions in our test code and save them to a flat file in our codebase, called a cassette.

After the initial response has been recorded, it is “replayed” by later tests, so we don’t have to make live requests to external APIs in our test code. This makes our tests fast (no real HTTP requests anymore), deterministic (the test will continue to pass, even if you are offline) and accurate (the response will contain the same headers and body you get from a real request).

5. expiringdict for Ordered Caches

Mailgun’s expiringdict is a great example of a library that does one thing, and does it really well. Their data structure, based off collections’ OrderedDict, creates a dictionary with a max length, and items that “expire” after a certain amount of time, to be used as a cache.

We have a ton of data in our databases, and caching the results of queries we know are executed frequently lets us serve up faster results, with less load on the database. To prevent the cache from getting too big, which impacts performance, we like to cap the size, and it’s convenient to set an expiration date on the data, so that our cache doesn’t get stale.

Python is at the heart of what we do, and our love for Python isn't limited to just our work; you can also find us building Python side projects, giving talks at PyCon and attending our local meetups. Have a fun Python library you want to share? We’d love to hear about it!

For more information on how to get started with the Nylas APIs, Click here.

HR Software Companies Use The Nylas Calendar API to Accelerate Time to Market

Serena — Thu, 15 Nov 2018 16:30:00 +0000

Automation is all around us, from self-driving cars to automatic payments, from virtual assistants like Alexa and Echo to check-in kiosks at the airports. Automation has fundamentally changed how businesses operate: it has increased efficiency, transparency, and work-life balance by handling tedious and repetitive tasks and leaving the more human tasks to humans. Which is why automation for HR software is so prevalent, and so important.

Companies like Beamery, Lever, and CATS (an applicant tracking system) all provide streamlined recruiting and HR processes to their users - and for a good reason. According to WorkMarket’s 2020 In(Sight) Report, 53% of employees state that automation can help save them up to 2 work hours a day which accounts to six weeks (240 hours) of time per year, while 78% of business leaders could save up to 3 work hours a day which totals up to nine weeks (360 hours) of time per year.

You can build scheduling sync between your HR software application and your user’s calendars using the Nylas Calendar API. Save your end-users hundreds of working hours by automating scheduling tasks for them.

Empower Users to Streamline Recruiting with Calendar Sync

Recruiting is a complex, multi-faceted process with multiple variables and little room for error: from creating job postings to resume screening, conducting interviews, vetting candidates, gathering feedback - and it can take up to weeks to nail them down if not months. Automation can help make recruiting a seamless process.

With the Nylas calendar API, developers can build full calendar CRUD (create, read, update and delete capabilities), and bi-directional calendar sync to expedite and improve the hiring process for recruiters. The faster the hiring process, the better the chances are of recruiting the best candidate.

Users can schedule interviews and calls all from within your HR software’s interface. Multiple interviews can be arranged in just one click, free/busy schedules are shown, and the event is added to the calendars of all the attendees.

Empower Users to Organize Meetings with Calendar Sync

Meetings are a great way to get the team on the same page, discuss strategies, and plan for the future. If meetings are not appropriately managed, they can take up 31 hours of the work time per month.

Even though organizing a meeting can be simple, the difficulty level increases as the number of attendees grow - sending emails, getting everyone's schedule, making phone calls, finding a room, arranging the resources.

The more time is spent organizing a meeting, that's less time spent towards a higher priority task.

Adding calendar sync to meeting room booking software eradicates the need to book everything individually. Meeting organizers save hours, giving them more time to spend on meeting preparation.

Fountain is an applicant tracking and recruiting platform which helps companies around the world hire hourly workers at scale using self-service interview booking, automation, machine learning, and customizable workflows.

When Fountain users book meetings, the choose a block of time surrounded by other work meetings or personal plans. With the help of Nylas Calendar API, Fountain's scheduling system work in harmony with their users’ whole schedule.

In a nutshell, it will keep records of every meeting in one place. Every time you create a new place to store data, you give yourself more to maintain and more chances for details to slip through the cracks.

Throughout the hiring process, candidates will go through different stages. The Nylas Calendar API will track the journey of your applicant and will also keep track of any schedule change of either the organization or the candidate.

Next Steps

Above all, automating any function within your business frees up time, reduces human error and creates more efficiency. These are just a handful of the ways the Nylas calendar API can create better experiences for businesses and employees.

For more information and to get started with a free trial, click here.

How to Get Full Calendar Sync & CRUD with the Nylas Calendar API

Serena — Thu, 08 Nov 2018 15:03:00 +0000

Need to build a calendar integration? Power your application with real-time, secure calendar sync with as little as four lines of code. Find out how the Nylas Calendar API can help.

We have several meetings and appointments to keep track of on a daily basis, be it personal or professional. We heavily rely on our calendars to track our events. Come to think of it, all of the events in our lives are actually scattered between different calendar providers.

All these calendars have their own systemic features that process data in different ways. We would need to build independent connections for individual providers. On top of that, we’d also have to maintain those connections and ensure the software works with past, present, and future versions of every provider’s API updates (sometimes they introduce breaking changes that hinder their functionality).

You have the choice to build unique connections with every individual calendar provider, or you can use the Nylas Calendar API and save months of developer time through one simple integration.

This way, you can spend more time focusing on the features you love to build.

Our Calendar API powers your application with real-time, secure calendar sync. Why is it important you ask? It's important because building scheduling and calendar sync features are mission-critical for many software companies.

Without Nylas, developers could easily take 12 months or more to build these connections with each calendar provider where the infrastructure varies between Gmail, Outlook.com, Exchange, Office 365 and the rest.

In this post, we will see how you can avoid all that by diving into some of the features and functionality of our Calendar API.

The Nylas Calendar API

The Nylas Calendar API acts as a layer of abstraction on top of all the calendar providers. You can streamline the scheduling process and updates in real-time.

When an account authenticates to Nylas, one of our sync servers will claim the account and automatically start syncing calendar data into Nylas' database. Each account connected to Nylas can have multiple calendars, and each calendar can have a collection of individual events.

The calendar API accesses all of the information to secure a time that fits everyone's schedule. It can also give the person you're meeting with access to your calendar and lets them choose the time that works best.

Once the appointment slot is reserved, the calendar is updated instantly, so there is never a chance of double booking or missing a meeting.

Outlook.com Calendar Connectivity

If you’re building a software that needs calendar connectivity with Outlook.com, the APIs, services, and templates often end up causing more dependencies than solutions.

The Nylas Calendar API abstracts away all of the complexity of building an app that integrates with Outlook.com calendars and handles all product changes and API modifications, so you don’t experience outages or service disruptions.

Nylas streamlines calendar sync from Outlook.com and every other calendar provider (Gmail, Exchange, Office 365, and the rest) giving you a dependable API that intelligently adapts to any changes the calendar providers introduce.

Using the API, you have full CRUD (Create, Read, Update, and Delete) capabilities through powerful API primitives. In addition to these, Nylas powers all the calendar features your customers require.

Booking and Cancellation

By having access to all the synced calendars and real-time updates, reservations and cancellations become easily manageable. From single events on team calendars to custom recurring events, the Nylas Calendar API handles it all.

You can update your plans from your calendar, and the changes will be reflected on the schedules of everyone affected in real-time.

Appointment Reminders and Task Scheduling

Whatever the reason behind a missed appointment, it can get expensive for your company. With Nylas, everyone gets automated appointment reminders to remind all parties of scheduled meetings.

The integration also has access to all the calendars which makes it easier to schedule tasks and makes deadline management a breeze.

Productivity Analytics

The API also receives productivity data by analyzing cross-team availability. It pulls data from the calendar and calculates the open rate, the click-through rate, the email usage (how many emails were sent and received) and the calendar meetings (how frequently the meetings were scheduled). It collects all this data to determine how time is being spent and helps provide a solution for how it can be improved.

Quick-start SDKs

With Nylas, you don’t have to build a calendar integration from scratch. We offer a suite of SDKs to get you started quickly so you can spend more time iterating features to your users’ exact specifications.

We offer SDKs in three core languages: Ruby, Node JS, and Python. With just a few lines of code, you can integrate Nylas into your app faster, maintain higher code quality, and free up time for building core features.

Security and Privacy

Enterprise-grade security and privacy controls have always been at the heart of what we do. The Nylas Calendar API encrypts 100% of data with military-grade security standards.

Here are some of the ways we protect and secure data in our infrastructure:

Transparency and Compliance - Certified: Nylas is SOC2 Certified, GDPR compliant, EU Privacy Shield Certified, and HIPAA ready.
Encryption and Access Control: User data is encrypted at rest using enterprise-grade standards.
Network Transport and Storage: Nylas systems enforce TLS for public and private networks, and only support certificates signed by well-known CAs.
Infrastructure and Physical Security: Our products run on AWS in a secure facility with active monitoring, total system logging, and security.

Ready to Get Started?

The Nylas Calendar API was built by developers, for developers, allowing you to share team calendars, link to specific meetings, schedule recurring meetings, and more.

Our Calendar API helps you develop connectivity into your application with ease.

For more on how to get started, click here.

The API Advantage for Android and iOS Application Developers

Serena — Thu, 25 Oct 2018 18:29:04 +0000

In the mobile application world, going to market quickly with the core features your users need is critical. That's why we created the Nylas API, to help developers build the mobile application of their dreams without having to worry about the communications layer.

Developers building mobile applications use the Stripe API for payments, the Twilio API for SMS, and the Nylas API for email, calendar and contacts. Nylas's email API, contacts API, and calendar API power Android and iOS applications for companies like Voiply (the cloud-based phone system) and Haystack CRM.

So what can you build with the Nylas API? Let's dive in.

Scheduling & Calendar Sync for Android and iOS applications

Ensure the end-users of your mobile app never miss a meeting by powering your application with calendar sync. The Nylas Calendar API connects to 100% of calendar providers, enabling scheduling and calendar sync features between your mobile application and your user's specific calendar provider (Google Calendar, Exchange Calendar, Outlook.com Calendar, and the rest).

HaystackCRM, a mobile-first CRM for contact and sales pipeline management, built scheduling & calendar sync into their application with the Nylas API.

Now users can choose to connect their calendar accounts to view and schedule events within HaystackCRM.

(Haystack Calendar Sync)

Build Calendar Sync in Weeks, Not Months

In just one internal hackathon, it took one engineer a single day to build out their powerful scheduling tool by simply using the Nylas Calendar API as their framework. The result was a powerful scheduling tool that united all users’ calendar synching, regardless of platform.

Feature-Rich Calendar Functionality

They also built out feature-rich functionality that provided everything a user would want in to schedule meetings. Users can fully create, read, update, and delete calendar events in real time. As a result, all users are able to quickly book and cancel appointments, set appointment reminders, and even view cross-platform productivity analytics — all within the iOS app.

Key Takeaway: With a powerful calendar API, your team gets a headstart building other core features while reducing devops hours.

Email Sync on Android for iOS Devices

HaystackCRM also uses the Nylas API to remove friction from their CRM-to-email integration. They needed to find a way to integrate their CRM within Office365, Outlook.com, Exchange, and IMAP email providers in a way that scaled with their business. Using the Nylas API has given HaystackCRM more options of email management beyond the initial offering. Features powered by the Nylas API allow HaystackCRM users to maintain a level of comfort of using previous email addresses, email clients and calendars while moving forward with HaystackCRM.

(Haystack Email sync)

Two-Way Email Sync

The Nylas email API provides seamless two-way email, calendar, and contacts sync between a single user’s inbox and the customer’s CRM. From there, users could compose and send emails from within the app — saving a wealth of time by minimizing the need for context switching and eliminating any need for manual data entry between the CRM and the app.

Group Email Accounts

The customer’s app was also better able to create more sophisticated email-to-CRM synching features. For instance, with the aid of the Nylas email API, CRM users could great group email accounts to enable quicker and more efficient collaboration across the team. For instance, if a team member was on vacation or out sick, any team member can simply log into the app and see recent customer interactions right within the app.

Key Takeaway: While there is often a great deal of complexity when it comes to developing features for cross-platform CRM integrations, an intuitive API allows developers to build powerful, new CRM features on the fly.

Contacts Sync for Android and iOS apps

VoIPLy provides simple and reliable phone solutions to help businesses serve their clients and customers better. Their cloud-based unified communication system is packed with more than 60 powerful phone features, enabling users to do business anywhere, anytime.

When customers click on contacts, the application integrates with Nylas to sync all of their contacts. VoIPLy has also created a Calendar App for their phone system, in which enables the system to read off events on calendars to callers.

(Users Authenticate Contacts Sync via the Nylas API)

Up-to-date Contact Profiles with Contact Sync

The Nylas Contacts API syncs profile information from user's contacts books to mobile applications and back. If a profile photo, email address, physical address, phone number, or any other critical information is updated in the user's address book, your mobile application is updated immediately as well.

Quick and Friction-Free Integration

Using Nylas docs, integrating the API was virtually instant. Within a week, the developer team was able to pull together a proof-of-concept and deploy the API into their production environment.

Key Takeaway: The right contacts API dramatically shortens your feature development time, ensuring that you are building the most dynamic contacts-syncing functionality possible — and quickly.

These are just a few of the many use cases our customers are using to evolve their email and calendar functions within their applications. Are you ready to transform your Android or iOS application with Nylas? Get started here.

Improve Customer Support Efficiency with Calendar Sync

Tasia Potasinski — Thu, 18 Oct 2018 17:46:14 +0000

Whether you call it customer service, customer support, customer care, or something else, the goal is the same: Increase your customer satisfaction score (CSAT) while increasing customer support representative's efficiency. As any team in a customer facing support role knows, this is easier said than done.

Which is why we're excited to announce a partnership between Nylas and Freshdesk that enables support teams to help their customers get to resolutions faster and with more direct support.

The Freshdesk Scheduling Application (powered by the Nylas Calendar API) allows Freshdesk agents to schedule meetings between users and the first available agent, all without leaving the Freshdesk platform. The calendar sync API offers your agents the ability to seamlessly integrate with all calendar services, including Gmail and Outlook from within Freshdesk, so customers receive native event invites.

When agents spend less time on administrative work like scheduling meetings, they have more time for human to human support interactions. The calendar sync features include:

Seamless Integration with 100% of Calendars

The Nylas API connects 100% of email service providers to the Freshdesk application, allowing users to sync their calendars from Gmail, Outlook.com, Microsoft Exchange, Outlook.com and the rest.

Schedule Meetings With Context

Context is crucial to excellent customer support. By scheduling calls between customer support agents and users within the Freshdesk app, you can easily copy and paste all of the context of a support ticket in to the call agenda so both teams have full context.

Route Customers to the Right Team Faster

Save Customer Support Agents’ Time

The Nylas app saves agents from bouncing out of Freshdesk, to a CRM platform, to another scheduling platform, and back to Freshdesk just to schedule a customer call. Now, with a few clicks, agents can tag the appropriate teams to handle an issue as well as schedule a date, time, and medium for the meeting.

Ready to get started?

Anyone with a Freshdesk account can download and use the Freshdesk Scheduler. Simply download the app from the Freshdesk marketplace.

The next time your customer writes in you’ll be fully equipped to deliver support that feels like magic.

Download the Freshdesk Scheduling application here.