Building Data Science Applications with FastAPI: Develop, manage, and deploy efficient machine learning applications with Python

Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Section 1: Introduction to Python and FastAPI
Chapter 1: Python Development Environment Setup
	Technical requirements
	Installing a Python distribution using pyenv
	Creating a Python virtual environment
	Installing Python packages with pip
	Installing the HTTPie command-line utility
	Summary
Chapter 2: Python Programming Specificities
	Technical requirements
	Basics of Python programming
		Running Python scripts
		Indentation matters
		Working with built-in types
		Working with data structures – lists, tuples, dictionaries, and sets
		Performing Boolean logic and checking for existence
		Controlling the flow of a program
		Defining functions
		Writing and using packages and modules
	Operating over sequences – list comprehensions and generators
		List comprehensions
		Generators
	Writing object-oriented programs
		Defining a class
		Implementing magic methods
		Reusing logic and avoiding repetition with inheritance
	Type hinting and type checking with mypy
		Getting started
		The typing module
		Type function signatures with Callable
		Any and cast
	Asynchronous I/O
	Summary
Chapter 3: Developing a RESTful API with FastAPI
	Technical requirements
	Creating the first endpoint and running it locally
	Handling request parameters
		Path parameters
		Query parameters
		The request body
		Form data and file uploads
		Headers and cookies
		The request object
	Customizing the response
		Path operation parameters
		The response parameter
		Raising HTTP errors
		Building a custom response
	Structuring a bigger project with multiple routers
	Summary
Chapter 4: Managing Pydantic Data Models in FastAPI
	Technical requirements
	Defining models and their field types with Pydantic
		Standard field types
		Optional fields and default values
		Field validation
		Validating email addresses and URLs with Pydantic types
	Creating model variations with class inheritance
	Adding custom data validation with Pydantic
		Applying validation at a field level
		Applying validation at an object level
		Applying validation before Pydantic parsing
	Working with Pydantic objects
		Converting an object into a dictionary
		Creating an instance from a sub-class object
		Updating an instance with a partial one
	Summary
Chapter 5: Dependency Injections in FastAPI
	Technical requirements
	What is dependency injection?
	Creating and using a function dependency
		Get an object or raise a 404 error
	Creating and using a parameterized dependency with a class
		Use class methods as dependencies
	Using dependencies at a path, router, and global level
		Use a dependency on a path decorator
		Use a dependency on a whole router
		Use a dependency on a whole application
	Summary
Section 2: Build and Deploy a Complete Web Backend with FastAPI
Chapter 6: Databases and Asynchronous ORMs
	Technical requirements
	An overview of relational and NoSQL databases
		Relational databases
		NoSQL databases
		Which one should you choose?
	Communicating with a SQL database with SQLAlchemy
		Creating the table schema
		Connecting to a database
		Making insert queries
		Making select queries
		Making update and delete queries
		Adding relationships
		Setting up a database migration system with Alembic
	Communicating with a SQL database with Tortoise ORM
		Creating database models
		Setting up the Tortoise engine
		Creating objects
		Updating and deleting objects
		Adding relationships
		Setting up a database migration system with Aerich
	Communicating with a MongoDB database using Motor
		Creating models compatible with MongoDB ID
		Connecting to a database
		Inserting documents
		Getting documents
		Updating and deleting documents
		Nesting documents
	Summary
Chapter 7: Managing Authentication and Security in FastAPI
	Technical requirements
	Security dependencies in FastAPI
	Storing a user and their password securely in a database
		Creating models and tables
		Hashing passwords
		Implementing registration routes
	Retrieving a user and generating an access token
		Implementing a database access token
		Implementing a login endpoint
	Securing endpoints with access tokens
	Configuring CORS and protecting against CSRF attacks
		Understanding CORS and configuring it in FastAPI
		Implementing double-submit cookies to prevent CSRF attacks
	Summary
Chapter 8: Defining WebSockets forTwo-Way Interactive Communication in FastAPI
	Technical requirements
	Understanding the principles of two-way communication with WebSockets
	Creating a WebSocket with FastAPI
		Handling concurrency
		Using dependencies
	Handling multiple WebSocket connections and broadcasting messages
	Summary
Chapter 9: Testing an API Asynchronously with pytest and HTTPX
	Technical requirements
	Introduction to unit testing with pytest
		Generating tests with parametrize
		Reusing test logic by creating fixtures
	Setting up testing tools for FastAPI with HTTPX
	Writing tests for REST API endpoints
		Writing tests for POST endpoints
		Testing with a database
	Writing tests for WebSocket endpoints
	Summary
Chapter 10: Deploying a FastAPI Project
	Technical requirements
	Setting and using environment variables
		Using a .env file
	Managing Python dependencies
		Adding Gunicorn as a server process for deployment
	Deploying a FastAPI application on a serverless platform
		Adding database servers
	Deploying a FastAPI application with Docker
		Writing a Dockerfile
		Building a Docker image
		Running a Docker image locally
		Deploying a Docker image
	Deploying a FastAPI application on a traditional server
	Summary
Section 3: Build a Data Science API with Python and FastAPI
Chapter 11: Introduction to NumPy and pandas
	Technical requirements
	Getting started with NumPy
		Creating arrays
		Accessing elements and sub-arrays
	Manipulating arrays with NumPy – computation, aggregations, comparisons
		Adding and multiplicating arrays
		Aggregating arrays – sum, min, max, mean…
		Comparing arrays
	Getting started with pandas
		Using pandas Series for one-dimensional data
		Using pandas DataFrames for multi-dimensional data
		Importing and exporting CSV data
	Summary
Chapter 12: Training Machine Learning Models with scikit-learn
	Technical requirements
	What is machine learning?
		Supervised versus unsupervised learning
		Model validation
	Basics of scikit-learn
		Training models and predicting
		Chaining pre-processors and estimators with pipelines
		Validating the model with cross-validation
	Classifying data with Naive Bayes models
		Intuition
		Classifying data with Gaussian Naive Bayes
		Classifying data with Multinomial Naive Bayes
	Classifying data with support vector machines
		Intuition
		Using SVM in scikit-learn
		Finding the best parameters
	Summary
Chapter 13: Creating an Efficient Prediction API Endpoint with FastAPI
	Technical requirements
	Persisting a trained model with Joblib
		Dumping a trained model
		Loading a dumped model
	Implementing an efficient prediction endpoint
	Caching results with Joblib
		Choosing between standard or async functions
	Summary
Chapter 14: Implement a Real-Time Face Detection System Using WebSockets with FastAPI and OpenCV
	Technical requirements
	Getting started with OpenCV
	Implementing an HTTP endpoint to perform face detection on a single image
	Implementing a WebSocket to perform face detection on a stream of images
	Sending a stream of images from the browser in a WebSocket
	Showing the face detection results in the browser
	Summary
Other Books You May Enjoy
Index