دانلود کتاب 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