book

Building Data Science Applications with FastAPI - Second Edition

by François Voron

July 2023

Intermediate to advanced

422 pages

9h 48m

English

Packt Publishing

Read now

Unlock full access

About the authorAbout the reviewers
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Technical requirementsInstalling a Python distribution using pyenvCreating a Python virtual environmentInstalling Python packages with pipInstalling the HTTPie command-line utilitySummary
Technical requirementsBasics of Python programmingRunning Python scriptsIndentation mattersWorking with built-in typesWorking with data structures – lists, tuples, dictionaries, and setsPerforming Boolean logic and a few other operatorsControlling the flow of a programDefining functionsWriting and using packages and modulesOperating over sequences – list comprehensions and generatorsList comprehensionsGeneratorsWriting object-oriented programsDefining a classImplementing magic methodsReusing logic and avoiding repetition with inheritanceType hinting and type checking with mypyGetting startedType data structuresType function signatures with CallableAny and castWorking with asynchronous I/OSummary
Technical requirementsCreating a first endpoint and running it locallyHandling request parametersPath parametersQuery parametersThe request bodyForm data and file uploadsHeaders and cookiesThe request objectCustomizing the responsePath operation parametersThe response parameterRaising HTTP errorsBuilding a custom responseStructuring a bigger project with multiple routersSummary
Technical requirementsDefining models and their field types with PydanticStandard field typesOptional fields and default valuesValidating email addresses and URLs with Pydantic typesCreating model variations with class inheritanceAdding custom data validation with PydanticApplying validation at the field levelApplying validation at the object levelApplying validation before Pydantic parsingWorking with Pydantic objectsConverting an object into a dictionaryCreating an instance from a sub-class objectUpdating an instance partiallySummary
Technical requirementsWhat is dependency injection?Creating and using a function dependencyGetting an object or raising a 404 errorCreating and using a parameterized dependency  with a classUsing class methods as dependenciesUsing dependencies at the path, router, and global levelUsing a dependency on a path decoratorUsing a dependency on a whole routerUsing a dependency on a whole applicationSummary
Technical requirementsAn overview of relational and NoSQL databasesRelational databasesNoSQL databasesWhich one should you choose?Communicating with a SQL database with SQLAlchemy ORMCreating ORM modelsDefining Pydantic modelsConnecting to a databaseCreating objectsGetting and filtering objectsUpdating and deleting objectsAdding relationshipsSetting up a database migration system with AlembicCommunicating with a MongoDB database using MotorCreating models that are compatible with MongoDB IDConnecting to a databaseInserting documentsGetting documentsUpdating and deleting documentsNesting documentsSummary

Technical requirementsSecurity dependencies in FastAPIStoring a user and their password securely in a databaseCreating modelsHashing passwordsImplementing registration routesRetrieving a user and generating an access tokenImplementing a database access tokenImplementing a login endpointSecuring endpoints with access tokensConfiguring CORS and protecting against CSRF attacksUnderstanding CORS and configuring it in FastAPIImplementing double-submit cookies to prevent CSRF attacksSummary
Technical requirementsUnderstanding the principles of two-way communication with WebSocketsCreating a WebSocket with FastAPIHandling concurrencyUsing dependenciesHandling multiple WebSocket connections and broadcasting messagesSummary
Technical requirementsAn introduction to unit testing with pytestGenerating tests with parametrizeReusing test logic by creating fixturesSetting up testing tools for FastAPI with HTTPXWriting tests for REST API endpointsWriting tests for POST endpointsTesting with a databaseWriting tests for WebSocket endpointsSummary
Technical requirementsSetting and using environment variablesUsing a .env fileManaging Python dependenciesAdding Gunicorn as a server process for deploymentDeploying a FastAPI application on a serverless platformAdding database serversDeploying a FastAPI application with DockerWriting a DockerfileAdding a prestart scriptBuilding a Docker imageRunning a Docker image locallyDeploying a Docker imageDeploying a FastAPI application on a traditional serverSummary
Technical requirementsWhat is machine learning?Supervised versus unsupervised learningModel validationManipulating arrays with NumPy and pandasGetting started with NumPyManipulating arrays with NumPy – computation, aggregations, and comparisonsGetting started with pandasTraining models with scikit-learnTraining models and predictingChaining preprocessors and estimators with pipelinesValidating the model with cross-validationSummary
Technical requirementsPersisting a trained model with JoblibDumping a trained modelLoading a dumped modelImplementing an efficient prediction endpointCaching results with JoblibChoosing between standard or async functionsSummary
Technical requirementsUsing a computer vision model with Hugging FaceImplementing a REST endpoint to perform object detection on a single imageImplementing a WebSocket to perform object detection on a stream of imagesSending a stream of images from the browser in  a WebSocketShowing the object detection results in the browserSummary
Technical requirementsGenerating images from text prompts with Stable DiffusionImplementing the model in a Python scriptExecuting the Python scriptCreating a Dramatiq worker and defining an image-generation taskImplementing a workerImplementing the REST APIStoring results in a database and object storageSharing data between the worker and the APIStoring and serving files in object storageSummary
Technical requirementsConfiguring and using a logging facility with LoguruUnderstanding log levelsAdding logs with LoguruUnderstanding and configuring sinksStructuring logs and adding contextConfiguring Loguru as the central loggerAdding Prometheus metricsUnderstanding Prometheus and the different metricsMeasuring and exposing metricsAdding Prometheus metrics to FastAPIAdding Prometheus metrics to DramatiqMonitoring metrics in GrafanaConfiguring Grafana to collect metricsVisualizing metrics in GrafanaSummary
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Content preview from Building Data Science Applications with FastAPI - Second Edition

6 Databases and Asynchronous ORMs

The main goal of a REST API is, of course, to read and write data. So far, we’ve solely worked with the tools given by Python and FastAPI, allowing us to build reliable endpoints to process and answer requests. However, we haven’t been able to effectively retrieve and persist that information: we don’t have a database.

The goal of this chapter is to show you how you can interact with different types of databases and related libraries inside FastAPI. It’s worth noting that FastAPI is completely agnostic regarding databases: you can use any system you want and it’s your responsibility to integrate it. This is why we’ll review two different approaches to integrating a database: using an object-relational mapping ...