python falcon, a nimble web framework, simplifies the process of building web apis by efficiently managing incoming requests, which are messages asking for something from your api, and providing an easy way to create structured responses that falcon then sends back to the requester, making it a swift and scalable choice for api development in python.

python falcon - request & response

in falcon, handling requests is achieved through resource classes. these classes, responsible for specific routes, define methods for various http methods like get, post, etc. let's discuss a basic example:

example 1:

in this example, the on_get method retrieves the name query parameter from the request, defaulting to guest if absent. the below code sets up a falcon web api with a single resource, `hellonameresource`, responding to get requests at '/hello'. it retrieves a 'name' parameter from the request, defaulting to 'guest' if absent, and returns a personalized greeting. the server runs on http://127.0.0.1:8000, allowing users to access personalized greetings by appending a name to '/hello'.

python3

import falcon

class hellonameresource:
    def on_get(self, req, resp):
        # retrieve the 'name' parameter from the request, defaulting to 'guest' if not present
        name = req.params.get("name", "guest")

        # build the response body with a personalized greeting
        resp.text = f"hello, {name}!"

# create a falcon api instance
api = falcon.app()

# add the hellonameresource to the api, associating it with the endpoint '/hello'
api.add_route("/hello", hellonameresource())

if __name__ == "__main__":
    from wsgiref import simple_server

    # set the host and port for the falcon application
    host = "127.0.0.1"
    port = 8000

    # create a simple wsgi server using wsgiref and serve the falcon application
    httpd = simple_server.make_server(host, port, api)
    print(f"serving on http://{host}:{port}")

    # serve requests indefinitely
    httpd.serve_forever()

run the server

python script_name.py

output

second- in falcon `response` is an object representing the http response, allowing customization of status codes, headers, and body content in a falcon api endpoint. it is used to define what the api should return to the client.

example 2:

in this example, when a get request is sent to the '/course-cart' endpoint, it returns an html response with information about geeksforgeeks courses such as name, level, interest, and rating. the html response is an html document that includes a title, header, and list of courses. falcon's response object attributes are then set to define the http status as 200 (ok), the response text as the generated html, the content type as 'text/html', and a 'cache-control' header to prevent caching. the falcon application is created, and the '/course-cart' endpoint is linked to the coursecartresource class.

python3

import falcon

# geeksforgeeks courses data in json format
course_data = [
    {
        "name": "dsa to development: a complete guide",
        "level": "beginner to advance",
        "interest": "125k+ interested geeks",
        "rating": "5",
    },
    {
        "name": "full stack development with react & node js - live",
        "level": "beginner to advance",
        "interest": "195k+ interested geeks",
        "rating": "4.7",
    },
]


# define a falcon resource class named coursecartresource
class coursecartresource:
    def on_get(self, req, resp):
        # convert the list of courses to an html response
        html_data = (
            "<html>\n<head><title>geeksforgeeks course cart</title></head>\n<body>\n"
        )
        html_data += "<h1>geeksforgeeks course cart</h1>\n<ul>\n"
        for course in course_data:
            html_data += (
                f"<li><strong>{course['name']}</strong><br>"
                f"level: {course['level']}<br>"
                f"interest: {course['interest']}<br>"
                f"rating: {course['rating']}</li>\n"
            )
        html_data += "</ul>\n</body>\n</html>"

        # set response attributes for html format
        resp.status = falcon.http_200
        resp.text = html_data
        resp.content_type = "text/html"
        resp.set_header("cache-control", "no-cache")


# create a falcon app instance
app = falcon.app()

# add the coursecartresource to the app, associating it with the '/course-cart' endpoint
app.add_route("/course-cart", coursecartresource())

if __name__ == "__main__":
    from wsgiref import simple_server

    # set the host and port for the falcon application
    host = "127.0.0.1"
    port = 8000

    # create a simple wsgi server using wsgiref and serve the falcon application
    httpd = simple_server.make_server(host, port, app)
    print(f"serving on http://{host}:{port}")
    # serve requests indefinitely
    httpd.serve_forever()

run the server

python script_name.py

output:

single

handle request & response ( feedback form )

python.py: this python code uses the falcon framework to create a simple api for handling feedback submissions. it begins by importing the necessary modules, including falcon for building the api and falcon cors for enabling cross-origin resource sharing (cors). the falcon api instance is created, and cors middleware is added to allow all origins, headers, and methods. the code defines a feedbackresource class with a single method, on_post, which handles post requests to the "/feedback" endpoint. the method extracts json data from the request body, processes the feedback (in this case, printing it to the console), and constructs an html response indicating successful feedback submission.

python3

import falcon
from falcon_cors import cors

# create a falcon api instance
app = falcon.app()

# enable cors
cors = cors(allow_all_origins=true, allow_all_headers=true, allow_all_methods=true)
app.add_middleware(cors.middleware)


class feedbackresource:
    def on_post(self, req, resp):
        # parse the json data from the request body
        feedback_data = req.media

        # process the feedback (in a real application, you might save it to a database)
        print(f"received feedback: {feedback_data}")

        # construct html response
        html_response = """
        <!doctype html>
        <html lang="en">
        <head>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>feedback response</title>
            <style>
                body {
                    font-family: arial, sans-serif;
                    background-color: #f4f4f4;
                    margin: 0;
                    padding: 0;
                    display: flex;
                    justify-content: center;
                    align-items: center;
                    height: 100vh;
                    flex-direction: column;
                }

                h1 {
                    color: green;
                }

                #response {
                    font-size: 18px;
                    color: #333;
                    display: flex;
                    align-items: center;
                }

                .tick {
                    margin-right: 10px;
                    color: #4caf50;
                }
            </style>
        </head>
        <body>
            <h1>geeksforgeeks</h1>
            <div id="response">
                <span class="tick">&#10004;</span> feedback received successfully
            </div>
        </body>
        </html>
        """

        # set the html response
        resp.content_type = falcon.media_html
        resp.text = html_response
        resp.status = falcon.http_200


# add the feedbackresource to the api
app.add_route("/feedback", feedbackresource())

if __name__ == "__main__":
    from wsgiref import simple_server

    # run the falcon api
    httpd = simple_server.make_server("127.0.0.1", 8000, app)
    print("serving on http://127.0.0.1:8000")
    httpd.serve_forever()

creating gui

index.html : this html code represents a simple feedback form webpage. the document includes standard metadata, such as the document type declaration, character set, and viewport settings. it links an external stylesheet ("styles.css") for styling. the inline styles define the layout and appearance of the form, with a flex container setting for centering content and specific styling for various form elements. the form collects user feedback, including their name and a message. upon submission, the form sends a post request to the "http://127.0.0.1:8000/feedback" endpoint. the form includes a title ("geeksforgeeks") and is styled with a clean and responsive design, making use of a green color theme. the response section, with an id of "response," is styled to display a success tick icon and a response message.

html

<!doctype html>
<html lang="en">

<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>feedback form</title>
    <link rel="stylesheet" href="./styles.css">
</head>
  <style>
    
    body {
    font-family: arial, sans-serif;
    background-color: #f4f4f4;
    margin: 0;
    padding: 0;
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
    flex-direction: column;
}

h1 {
    color: green;
}

form {
    background-color: #fff;
    padding: 20px;
    border-radius: 8px;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
    max-width: 400px;
    width: 100%;
    margin-bottom: 20px;
}

label {
    display: block;
    margin-bottom: 8px;
}

input,textarea {
    width: 100%;
    padding: 8px;
    margin-bottom: 16px;
    box-sizing: border-box;
}

button {
    background-color: #4caf50;
    color: #fff;
    padding: 10px;
    border: none;
    border-radius: 4px;
    cursor: pointer;
}

#response {
    font-size: 18px;
    color: #333;
    display: flex;
    align-items: center;
}

.tick {
        margin-right: 10px;
        color: #4caf50;
}
    
  </style>

<body>
    <h1>geeksforgeeks</h1>
    <form id="feedbackform" action="http://127.0.0.1:8000/feedback" method="post">
        <label for="name">your name:</label>
        <input type="text" id="name" name="name" required>
        <label for="message">feedback message:</label>
        <textarea id="message" name="message" rows="4" required></textarea>
        <button type="submit">submit feedback</button>
    </form>
</body>
</html>

run the server

python script_name.py

output:

conclusion

understanding request handling and response crafting is fundamental in falcon development. falcon's simplicity and the power of its request and response objects make it a compelling choice for building robust and efficient web apis. as you progress with falcon, you'll discover additional features enhancing your ability to create powerful and scalable web applications.

Save or share this article