How to quickly turn your Python code into an API

When it comes to API development, you may think of Django REST Framework, Flask, and FastAPI. Yes, they can be used to write APIs. However, the framework shared today can allow you to convert existing functions into API, it is Sanic.

Sanic Introduction

Sanic[1], is a Python3.7 web server and web framework designed to improve performance. It allows the use of the async/await syntax added in Python 3.5, which can effectively avoid blocking and improve response speed. Sanic is committed to providing a simple and fast method that integrates creation and startup to implement an HTTP service that is easy to modify and expand. Sanic has out-of-the-box functions that can be used to write, deploy and expand production-level Web application. Currently it has 16.3k stars on Github and has extensive community support.

Has the following features:

• Built-in extremely fast web server
• Production ready
• Extremely high scalability
• Support ASGI
• Simple and intuitive API design
• Community guarantee
• How to quickly convert existing code into an API

Now let’s see, how Convert the code to API, if there are two functions already written in functions.py:

import datetime


def get_datetime():
return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")


def sum_x_y(x, y):
return x + y

To convert to API, just write another sanic_app.py:

from sanic import Sanic, json
from functions import get_datetime, sum_x_y

app = Sanic("CodeToAPI")
HOST = "localhost"
PORT = 8000

@app.route("/getdatetime")
async def getdatetime(request):
return json({"now": get_datetime()})

@app.get('/sumxy')
async def sumxy(request):
parameters = request.args
result = sum_x_y(int(parameters['x'][0]), int(parameters['y'][0]))
return json({'result': result})


if __name__ == "__main__":
app.run(host=HOST, port=PORT, debug=False)

Then, just Execute python sanic_app.py to start the API service:

From the running results, we can know that sanic is already running in the production environment mode, which is different from other web frameworks. Comes with a built-in development server and makes it clear that it is for development only. The situation with Sanic is exactly the opposite. The built-in server can be used directly in production environments.

You can use curl for interface testing:

❯ curl "http://localhost:8000/getdatetime"
{"now":"2022-07-25 06:34:25"}%❯ curl "http://localhost:8000/sumxy?x=12&y=34"
{"result":46}%

If you use post and use json to pass parameters, it is also simple:

@app.post('/sumxy')
async def sumxy(request):
parameters = request.json
print(parameters)
result = sum_x_y(int(parameters['x']), int(parameters['y']))
return json({'result': result})

curl tests like this:

❯ curl -X 'POST' 'http://localhost:8000/sumxy' -H "Content-Type: application/json" -d '{"x":10,"y":20}'
{"result":30}%

Deployed in other places

In addition to its own server (in most cases it is recommended that its own server be used for production), Sanic is also compatible with ASGI. This means you can use your favorite ASGI server to run Sanic. There are now three mainstream ASGI servers, Daphne, Uvicorn (this is what FastAPI uses), and Hypercorn.

Can also be deployed on Gunicorn:

gunicorn myapp:app --bind 0.0.0.0:1337 --worker-class sanic.worker.GunicornWorker

Static file processing and request access log recording. If you want to get better performance, you can consider using Nginx as a proxy and let Nginx handle the access. Logs and static files are much faster than processing them in Python.

The above is the detailed content of How to quickly turn your Python code into an API. For more information, please follow other related articles on the PHP Chinese website!