book

Speed Up Your Python with Rust

Name: Speed Up Your Python with Rust
Author: Maxwell Flitton
ISBN: 9781801811446

by Maxwell Flitton

January 2022

Intermediate to advanced

384 pages

7h 30m

English

Packt Publishing

Read now

Unlock full access

Speed Up Your Python with Rust
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchShare Your Thoughts
Section 1: Getting to Understand Rust
Chapter 1: An Introduction to Rust from a Python Perspective
Technical requirementsUnderstanding the differences between Python and RustWhy fuse Python with Rust?Passing strings in RustSizing up floats and integers in Rust Managing data in Rust's vectors and arraysReplacing dictionaries with hashmaps Error handling in RustUnderstanding variable ownership CopyMoveImmutable borrowMutable borrowKeeping track of scopes and lifetimesBuilding structs instead of objects Metaprogramming with macros instead of decoratorsSummaryQuestionsAnswersFurther reading
Chapter 2: Structuring Code in Rust
Technical requirementsManaging our code with crates and Cargo instead of pipStructuring code over multiple files and modules Building module interfaces Benefits of documentation when coding Interacting with the environmentSummaryQuestionsAnswersFurther reading
Chapter 3: Understanding Concurrency
Technical requirementsIntroducing concurrency Threads Processes Basic asynchronous programming with threads Running multiple processes Customizing threads and processes safelyAmdahl's law DeadlocksRace conditions SummaryQuestionsAnswersFurther reading
Section 2: Fusing Rust with Python
Chapter 4: Building pip Modules in Python
Technical requirementsConfiguring setup tools for a Python pip moduleCreating a GitHub repositoryDefining the basic parametersDefining a README fileDefining a basic modulePackaging Python code in a pip moduleBuilding our Fibonacci calculation codeCreating a command-line interfaceBuilding unit testsConfiguring continuous integrationManually deploying onto PyPIManaging dependenciesSetting up type checking for PythonSetting up and running tests and type-checking with GitHub ActionsCreate automatic versioning for our pip packageDeploying onto PyPI using GitHub ActionsSummaryQuestionsAnswersFurther reading
Chapter 5: Creating a Rust Interface for Our pip Module
Technical requirementsPackaging Rust with pipDefine gitignore and Cargo for our packageConfiguring the Python setup process for our package Installing our Rust library for our packageBuilding a Rust interface with the pyO3 crateBuilding our Fibonacci Rust codeCreating command-line tools for our packageCreating adapters for our packageBuilding tests for our Rust packageComparing speed with Python, Rust, and NumbaSummaryQuestionsAnswersFurther reading
Chapter 6: Working with Python Objects in Rust
Technical requirementsPassing complex Python objects into RustUpdating our setup.py file to support .yml loadingDefining our .yml loading commandProcessing data from our Python dictionaryExtracting data from our config fileReturning our Rust dictionary to our Python systemInspecting and working with custom Python objectsCreating an object for our Rust interfaceAcquiring the Python GIL in RustAdding data to our newly created PyDict structSetting the attributes of our custom objectConstructing our own custom Python objects in RustDefining a Python class with the required attributesDefining class static methods to process input numbers Defining a class constructorWrapping up and testing our moduleSummaryQuestionsAnswersFurther reading

Chapter 7: Using Python Modules with Rust
Technical requirementsExploring NumPy Adding vectors in NumPy Adding vectors in pure Python Adding vectors using NumPy in Rust Building a model in NumPy Defining our modelBuilding a Python object that executes our modelUsing NumPy and other Python modules in RustRecreating our NumPy model in Rust Building get_weight_matrix and inverse_weight_matrix functions Building get_parameters, get_times, and get_input_vector functionsBuilding calculate_parameters and calculate_times functions Adding calculate functions to the Python bindings and adding a NumPy dependency to our setup.py fileBuilding our Python interface SummaryQuestionsAnswersFurther reading
Chapter 8: Structuring an End-to-End Python Package in Rust
Technical requirementsBreaking down a catastrophe modeling problem for our packageBuilding an end-to-end solution as a packageBuilding a footprint merging processBuilding the vulnerability merge processBuilding a Python interface in RustBuilding our interface in PythonBuilding package installation instructionsUtilizing and testing our packageBuilding a Python construct model using pandasBuilding a random event ID generator functionTiming our Python and Rust implementations with a series of different data sizesSummaryFurther reading
Section 3: Infusing Rust into a Web Application
Chapter 9: Structuring a Python Flask App for Rust
Technical requirementsBuilding a basic Flask applicationBuilding an entry point for our applicationBuilding our Fibonacci number calculator moduleBuilding a Docker image for our application Building our NGINX service Connecting and running our Nginx service Defining our data access layerDefining a PostgreSQL database in docker-compose Building a config loading system Building our data access layer Setting up the application database migration systemBuilding database modelsApplying the database access layer to the fib calculation viewBuilding a message bus Building a Celery broker for Flask Building a Fibonacci calculation task for Celery Updating our calculation viewDefining our Celery service in DockerSummaryQuestionsAnswersFurther reading
Chapter 10: Injecting Rust into a Python Flask App
Technical requirementsFusing Rust into Flask and CeleryDefining our dependency on the Rust Fibonacci number calculation packageBuilding our calculation model with RustCreating a calculation view using RustInserting Rust into our Celery taskDeploying Flask and Celery with RustDeploying with a private GitHub repositoryBuilding a Bash script that orchestrates the whole processReconfiguring the Rust Fib package installment in our Dockerfile Fusing Rust with data accessSetting up our database cloning packageSetting up the diesel environmentAutogenerating and configuring our database models and schema Defining our database connection in RustCreating a Rust function that gets all the Fibonacci records and returns themDeploying Rust nightly in FlaskSummaryQuestionsAnswersFurther reading
Chapter 11: Best Practices for Integrating Rust
Technical requirementsKeeping our Rust implementation simple by piping data to and from RustBuilding a Python script that formulates the numbers for calculationBuilding a Rust file that accepts the numbers, calculates the Fibonacci numbers, and returns the calculated numbers Building another Python script that accepts the calculated numbers and prints them outGiving the interface a native feel with objectsDefining traits Defining struct behavior with traits Passing traits through functions Storing structs with common traits Running our traits in the main file Keeping data-parallelism simple with RayonFurther reading
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Content preview from Speed Up Your Python with Rust

Chapter 8: Structuring an End-to-End Python Package in Rust

Now that we have covered enough Rust and pyo3 to theoretically build a range of real-world solutions, we must be careful. It would not be good if we decided to reinvent the wheel in Rust and ended up with a slower outcome after coding the solution. Hence, understanding how to solve a problem and testing our implementation is important. In this chapter, we will be building a Python package using Rust that solves a simplified real-world problem and loads data from files to build a catastrophe model. We will structure the package in a manner where we can slot in extra functionality if our model gets more complex. Once we build our model, we will test it to see whether our implementation ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Hands-On Data Structures and Algorithms with Rust

Publisher Resources

ISBN: 9781801811446

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Speed Up Your Python with Rust

by Maxwell Flitton

Chapter 8: Structuring an End-to-End Python Package in Rust

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.