Mastering Web APIs with FastAPI and Flask

Discover how to set up a Flask-based development environment for Python web API projects: clone the GitHub repo, create and activate a virtual environment, install requirements, and prepare starter projects.

Learn to set up a Flask hello API from the starter kit, examine app.py, and implement name-based responses—handling missing first or last names with specific outputs.

Run your first flask api in python and access it at 127.0.0.1:5000 with a greet route. Learn to define routes using app.route and return hello world, and test with curl.

Learn to transfer data into JSON format and structure it for APIs by converting a Python dictionary to a JSON response using a JSON file function in a Flask app.

Expand your api interactivity by passing inputs like a name via the url, returning a json hello message, using curl and flask.

Learn to handle missing query parameters in a Flask API by validating inputs, returning a JSON error with a meaningful message, and testing with curl.

Create a multi-argument api in flask that greets users by first name, last name, or both, using json responses and simple error handling.

Learn what a url is, from protocol and domain to path and query string, and see how query parameters power Google search, with hands-on setup of a Flask API project.

Explore the package contents—the API, templates with the index HTML/XHTML, and CSS with the Google logo—then run a Flask app to render a Google-style search page and implement Python-driven search.

Create a Google search by rendering Google's home page, submitting a get request, and passing a query via q to google.com/search to execute the search.

Build a dictionary API project that returns exact and approximate word matches, with future support for multi-word requests, and learn installation, MVC structure, and a Flask-based app returning JSON.

Learn to handle search queries in a dictionary API by accepting a word from the request, validating it, and returning exact or approximate json results with clear error handling.

Discover how to retrieve a word's definition by connecting to a local dictionary database, querying exact matches and like matches, and returning the word's description via an api endpoint.

Split the query string into a word list and fetch descriptions for each word using exact and approximate matching, then build a list-based api response.

Run a Flask API project from a Jupyter notebook, import requests, and test the local server. Build a web interface with templates to access the dictionary API.

Build a post request image filter API that accepts an image, applies filters, and returns the edited image, with before-and-after comparisons and a Flask project setup.

Define a dual get-post route to apply pillow image filters such as blur, contour, detail, and sharpen, returning the processed image as jpeg via json response with error handling.

Explore testing the filters API by posting an image, applying a chosen filter, and saving and viewing the updated image.

Explore the fast api, its asynchronous programming advantage over flask, and a hands-on hello world example with curl tests to demonstrate fast api's speed and setup.

Build an asynchronous dictionary with fast api from a starter kit. Implement a main file, data and model, and use a json encoder with index usage instructions.

Develop and test a FastAPI dictionary endpoint that returns exact matches or partial matches with JSON responses, using asynchronous queries to data/dictionary.db and SQL like queries.

Harness fast api's automatic, graphical documentation engine at /docs to explore endpoints such as index and dict path, view responses and validation, and test functions interactively.

Adopt the image filter into a FastAPI project and demonstrate asynchronous processing to showcase time savings when uploading images via post requests.

Discover how to convert a synchronous program into an asynchronous one using the async keyword and await, enabling concurrent tasks and boosting Flask scripts by more than 80%.

Run the api with uvicorn to test asynchronous to sequential api calls, then execute ten requests from a Jupyter notebook to measure timing and preview speed gains from asynchronous execution.

Demonstrates moving from sequential to asynchronous api calls using an async http client session, asyncio event loop, and gather to run many requests concurrently, dramatically reducing total time.