Introduction to Sanic Web Framework – Python

10 May, 2022
WHAT IS SANIC? Sanic is an asynchronous web framework and web server for Python 3.5+ that’s written to go fast. Sanic was developed at MagicStack and is based on their uvloop event loop, which is a replacement for Python asyncio’s default event loop, thereby making Sanic blazing fast. Syntactically Sanic resembles Flask. Sanic maybe used as a replacement for Django or Flask to build highly scalable, efficient and blazing fast performant web applications. BUILDING OUR FIRST SANIC APP! Step 1: It is preferable to use virtual environments in Python to create isolated environments with project-specific dependencies. Since Sanic 19.6+ versions do not support Python 3.5, we will work with Python 3.6+. To install sanic in our Python virtual environment we will execute the following command – pip3 install sanic Step 2: Let us create a directory named sanic_demo & within it a file named main.py with the following lines of code – 
Python3
from sanic import Sanicfrom sanic import response app = Sanic("My First Sanic App")  # webapp path defined used route decorator@app.route("/")def run(request):    return response.text("Hello World !")  # debug logs enabled with debug = Trueapp.run(host ="0.0.0.0", port = 8000, debug = True)
Step 3: We may either run main.py from an IDE, or run the file from Terminal by executing the following command – python3 main.py The Sanic web server is up on 8000 port of our ‘localhost’.  Step 4: Navigating to http://0.0.0.0:8000/ from our web browser renders “Hello World!”.  CONFIGURATION The config attribute of the Sanic app object is used to configure parameters. The app config object can be assigned key-value pairs as follows : 
Python3
from sanic import Sanicfrom sanic import response app = Sanic("My First Sanic App") app.config["SECURITY_TOKEN"] = [{"ApiKeyAuth": []}]
The full list of configuration params is available at the official documentation page – Sanic Config ROUTING AND BLUEPRINTS Sanic supports the route decorator to map handler functions to HTTP requests. We can use an optional parameter called methods in the ‘route’ decorator to work with any of the HTTP methods in the list. Blueprints is a concept used for plugging sub-routes into the Sanic app from sub-modules of a large application. Blueprints must be registered into the Sanic app object. Using blueprints also avoids passing around the Sanic app object all over the application. Let us modify our original main.py file to demonstrate the usage of routes and blueprints – 
Python3
# this is our 'main.py' filefrom sanic import Sanicfrom sanic import responsefrom sanic.log import loggerfrom controller import my_bp app = Sanic("My First Sanic App") # registering route defined by blueprintapp.blueprint(my_bp)  # webapp path defined used 'route' decorator@app.route("/")def run(request):    return response.text("Hello World !")  @app.route("/post", methods =['POST'])def on_post(request):    try:        return response.json({"content": request.json})    except Exception as ex:        import traceback        logger.error(f"{traceback.format_exc()}")  app.run(host ="0.0.0.0", port = 8000, debug = True)
Let us create a new file named controller.py to declare our blueprints – 
Python3
# this is our 'controller.py' filefrom sanic import responsefrom sanic import Blueprint my_bp = Blueprint('my_blueprint') @my_bp.route('/my_bp')def my_bp_func(request):    return response.text('My First Blueprint')
Let us run main.py and check the results when /my_bp endpoint is accessed –  We have used a web client called ‘Insomnia‘ to demonstrate our POST request –  RENDERING CONTENT Sanic routes can serve html files, json content, media files etc. To serve static content like images, pdf, static html files etc we need to use app.static() method which maps the path of a static file to an endpoint specified by a ‘route’. Let us modify our main.py file to demonstrate this – 
Python3
# this is our 'main.py' filefrom sanic import Sanicfrom sanic import responsefrom sanic.log import loggerfrom controller import my_bp app = Sanic("My First Sanic App") # registering route defined by blueprintapp.blueprint(my_bp)# configuring endpoint to serve an image downloaded from the webapp.static('/floral_image.jpg',           '/sanic_demo / ws_Beautiful_flowers_1920x1080.jpg')  # webapp path defined used 'route' decorator@app.route("/")def run(request):    return response.text("Hello World !")  @app.route("/post", methods =['POST'])def on_post(request):    try:        return response.json({"content": request.json})    except Exception as ex:        import traceback        logger.error(f"{traceback.format_exc()}")  app.run(host ="0.0.0.0", port = 8000, debug = True)
Running main.py and accessing http://0.0.0.0:8000/floral_image.jpg renders the image on the browser.  Let us further modify main.py to access some html content – Let us create a sample index.html file – 
html
<html><!DOCTYPE html><html lang="en"><head>    <meta charset="UTF-8">    <title>Render HTML on Sanic</title></head> <body>Gotta go fast!</body></html>
Python3
# this is our 'main.py' filefrom sanic import Sanicfrom sanic import responsefrom sanic.log import loggerfrom controller import my_bp app = Sanic("My First Sanic App") app.blueprint(my_bp)  # registering route defined by blueprint app.static('/floral_image.jpg',           '/sanic_demo / ws_Beautiful_flowers_1920x1080.jpg')  # webapp path defined used 'route' decorator@app.route("/")def run(request):    return response.text("Hello World !")  @app.route("/post", methods =['POST'])def on_post(request):    try:        return response.json({"content": request.json})    except Exception as ex:        import traceback        logger.error(f"{traceback.format_exc()}")  @app.route("/display")def display(request):    return response.file('/sanic_demo / index.html')  app.run(host ="0.0.0.0", port = 8000, debug = True)
Running main.py and accessing http://0.0.0.0:8000/display renders the following on the browser –  EXCEPTION HANDLING Exceptions can be explicitly raised within Sanic request handlers. The Exceptions take a message as the first argument and can also include a status code. The @app.exception decorator can be used to handle Sanic Exceptions. Let us demonstrate by tweaking our main.py file – 
Python3
# this is our 'main.py' file from sanic import Sanicfrom sanic import responsefrom sanic.log import loggerfrom controller import my_bpfrom sanic.exceptions import ServerError, NotFound  app = Sanic("My First Sanic App") app.blueprint(my_bp)  # registering route defined by blueprint app.static('/floral_image.jpg',           '/sanic_demo / ws_Beautiful_flowers_1920x1080.jpg')  # raise Exception@app.route('/timeout')async def terminate(request):    raise ServerError("Gateway Timeout error", status_code = 504)  @app.exception(NotFound)async def ignore_5xx(request, exception):    return response.text(f"Gateway is always up: {request.url}")  # webapp path defined used 'route' decorator@app.route("/")def run(request):    return response.text("Hello World !")  @app.route("/post", methods =['POST'])def on_post(request):    try:        return response.json({"content": request.json})    except Exception as ex:        import traceback        logger.error(f"{traceback.format_exc()}")  @app.route("/display")def display(request):    return response.file('/sanic_demo / index.html')  app.run(host ="0.0.0.0", port = 8000, debug = True)
Exception rendered on browser –  NotFound (thrown when request handler not found for route) and ServerError(thrown due to serve code issues) are most commonly used. ASYNC SUPPORT Web applications characteristically talk to external resources, like databases, queues, external APIs etc to retrieve information required to process requests. Sanic, a Python Web Framework that has Python 3.5+’s asyncio library’s async/await syntax pre-baked into it, is the ideal candidate for designing large scale I/O bound projects which work with many connections. This enables the webapp’s requests to be processed in a non-blocking and concurrent way. Python 3.5 introduced asyncio, which is a library to write concurrent code using the async/await syntax (source: https://docs.python.org/3/library/asyncio.html). The asyncio library provides an event loop which runs async I/O functions. Sanic provides support for async/await syntax, thereby making request handling non-blocking and super fast. Adding the async keyword to request handler functions makes the function handle the code asynchronously, thereby leveraging Sanic’s performance benefits. Instead of asyncio’s event loop, Sanic uses MagicStack’s proprietary uvloop which is faster than asyncio’s event loop, leading to blazing fast speeds. However, on Windows OS, Sanic reverts to asyncio’s event loop under the hood, due to issues with uvloop on Windows. Reference: Sanic Official Docs.
sagartomar9927
Python Framework
Python
Write From Home
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
How to Install PIP on Windows ?
Python Classes and Objects
Python | os.path.join() method
Python OOPs Concepts
How to drop one or multiple columns in Pandas Dataframe
Convert string to integer in Python
How to set input type date in dd-mm-yyyy format using HTML ?
Python infinity
Factory method design pattern in Java
Similarities and Difference between Java and C++