Gain insights into building REST APIs with FastAPI, explore parallel processing in Python, and discover how to deploy APIs on Microsoft Azure with a CI/CD pipeline using GitHub.

Build a REST API Using Python and Deploy It to Microsoft Azure.png

fastapi-docker.tar.gz

FastAPI-test

Python3

In this course, you will learn how to build a REST API using a lighter web framework for Python, i.e., FastAPI. You will learn the basics of FastAPI and learn how to implement parallel processing in Python APIs.

Finally, you will deploy your API on Microsoft Azure and build a Continuous Integration/Continuous Development (CI/CD) Pipeline using Github.

Build a REST API Using Python and Deploy it to Microsoft Azure

# Define the `analyze_text()` function 
In the previous lesson, we have already created the structure of the `API`. We are only left with writing the function that will handle the `POST` route. Let us see the code now.

from fastapi import FastAPI
from pydantic import BaseModel
import utils

app = FastAPI()

# headers = {
#     "Ocp-Apim-Subscription-Key": <SUBSCRIPTION_KEY>,
#     "Content-Type": "application/json",
#     "Accept": "application/json"
# }

class Model(BaseModel):
    text_to_analyze: list

@ app.post("/")
def analyze_text(text: Model):
    response = {"sentiment": [], "keyphrases": []}
    no_of_text = len(text.text_to_analyze)
    for i in range(no_of_text):
        document = {"documents": [{"id": i+1, "language": "en", "text": text.text_to_analyze[i]}]}
        
        sentiment = utils.call_text_analytics_api(headers, document, endpoint='sentiment')
        keyphrases = utils.call_text_analytics_api(headers, document, endpoint='keyPhrases')
        
        response["sentiment"].append(sentiment["documents"][0])
        response["keyphrases"].append(keyphrases["documents"][0])
    return response

import requests as req

def call_text_analytics_api(headers, document, endpoint):
    response = req.post("https://text-analytics-using-fastapi.cognitiveservices.azure.com//text/analytics/v3.0/" +
                        endpoint, headers=headers, json=document)
    return response.json()

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

**Explanation**
* All the code is the same. We will only understand the function `analyze_text()`.

* On **line 18**, we define the structure of the response. The structure of the response is going to be:
   ```a
   {
      "sentiment": 
          [
            All the sentiment-related responses.
          ],
      "keyphrases":
         [
           All the keyphrase extraction responses.
         ]
   }
   ``` 
* On **line 19**, we find out the number of texts sent in the *request body*.
* On **line 20**, we run a loop for processing each text one by one.
* On **line 21**, we restructure the text in the format that is acceptable by our text analytics service. (*Note that we have already discussed the format in an earlier lesson.*)
* On **line 23**, we call the text analytics service to perform the sentiment operation (*by passing the value of `endpoint = 'sentiment'`*).
* Similarly, on **line 24**, we call the text analytics service to perform the keyphrases extraction (*by passing the value `endpoint = 'keyPhrases'`*).
* On **lines 26 and 27**, we store the result in our `response` variable in the desired format.
* Finally, on **line 28**, we return the response.


# Test the `API`
Now that we have our `API` ready, let's go and test it using the UI docs. So, when you visit the URL:
```
http://localhost:8000/docs
```
You can view something similar to the image shown below:

Create your REST API using the Azure Text Analytics Service.

Overview of the Course

Building Blocks of an API in Python

Learn the Basics of FastAPI

Optical Character Recognition API Using Tesseract - Project 1

Cloud and Microsoft Azure Services

Text Analytics API Using Azure Cognitive Services - Project 2

Deploy the REST API on Microsoft Azure

Pop Quiz

Appendix

Implement Azure Text Analytics Service - 2

Define the `analyze_text()` function

Pop Quiz

Implement Azure Text Analytics Service - 2

Define the analyze_text() function

Define the `analyze_text()` function