Speed Up Your Python with Rust: Optimize Python performance by creating Python pip modules in Rust with PyO3

Speed Up Your Python with Rust
Contributors
About the author
About the reviewers
Preface
	Who this book is for
	What this book covers
	To get the most out of this book
	Download the example code files
	Download the color images
	Conventions used
	Get in touch
	Share Your Thoughts
Section 1: Getting to Understand Rust
Chapter 1: An Introduction to Rust from a Python Perspective
	Technical requirements
	Understanding the differences between Python and Rust
		Why fuse Python with Rust?
		Passing strings in Rust
		Sizing up floats and integers in Rust
		Managing data in Rust's vectors and arrays
		Replacing dictionaries with hashmaps
		Error handling in Rust
	Understanding variable ownership
		Copy
		Move
		Immutable borrow
		Mutable borrow
	Keeping track of scopes and lifetimes
	Building structs instead of objects
	Metaprogramming with macros instead of decorators
	Summary
	Questions
	Answers
	Further reading
Chapter 2: Structuring Code in Rust
	Technical requirements
	Managing our code with crates and Cargo instead of pip
	Structuring code over multiple files and modules
	Building module interfaces
		Benefits of documentation when coding
	Interacting with the environment
	Summary
	Questions
	Answers
	Further reading
Chapter 3: Understanding Concurrency
	Technical requirements
	Introducing concurrency
		Threads
		Processes
	Basic asynchronous programming with threads
	Running multiple processes
	Customizing threads and processes safely
		Amdahl's law
		Deadlocks
		Race conditions
	Summary
	Questions
	Answers
	Further reading
Section 2: Fusing Rust with Python
Chapter 4: Building pip Modules in Python
	Technical requirements
	Configuring setup tools for a Python pip module
		Creating a GitHub repository
		Defining the basic parameters
		Defining a README file
		Defining a basic module
	Packaging Python code in a pip module
		Building our Fibonacci calculation code
		Creating a command-line interface
		Building unit tests
	Configuring continuous integration
		Manually deploying onto PyPI
		Managing dependencies
		Setting up type checking for Python
		Setting up and running tests and type-checking with GitHub Actions
		Create automatic versioning for our pip package
		Deploying onto PyPI using GitHub Actions
	Summary
	Questions
	Answers
	Further reading
Chapter 5: Creating a Rust Interface for Our pip Module
	Technical requirements
	Packaging Rust with pip
		Define gitignore and Cargo for our package
		Configuring the Python setup process for our package
		Installing our Rust library for our package
	Building a Rust interface with the pyO3 crate
		Building our Fibonacci Rust code
		Creating command-line tools for our package
		Creating adapters for our package
	Building tests for our Rust package
	Comparing speed with Python, Rust, and Numba
	Summary
	Questions
	Answers
	Further reading
Chapter 6: Working with Python Objects in Rust
	Technical requirements
	Passing complex Python objects into Rust
		Updating our setup.py file to support .yml loading
		Defining our .yml loading command
		Processing data from our Python dictionary
		Extracting data from our config file
		Returning our Rust dictionary to our Python system
	Inspecting and working with custom Python objects
		Creating an object for our Rust interface
		Acquiring the Python GIL in Rust
		Adding data to our newly created PyDict struct
		Setting the attributes of our custom object
	Constructing our own custom Python objects in Rust
		Defining a Python class with the required attributes
		Defining class static methods to process input numbers
		Defining a class constructor
		Wrapping up and testing our module
	Summary
	Questions
	Answers
	Further reading
Chapter 7: Using Python Modules with Rust
	Technical requirements
	Exploring NumPy
		Adding vectors in NumPy
		Adding vectors in pure Python
		Adding vectors using NumPy in Rust
	Building a model in NumPy
		Defining our model
		Building a Python object that executes our model
	Using NumPy and other Python modules in Rust
	Recreating our NumPy model in Rust
		Building get_weight_matrix and inverse_weight_matrix functions
		Building get_parameters, get_times, and get_input_vector functions
		Building calculate_parameters and calculate_times functions
		Adding calculate functions to the Python bindings and adding a NumPy dependency to our setup.py file
		Building our Python interface
	Summary
	Questions
	Answers
	Further reading
Chapter 8: Structuring an End-to-End Python Package in Rust
	Technical requirements
	Breaking down a catastrophe modeling problem for our package
	Building an end-to-end solution as a package
		Building a footprint merging process
		Building the vulnerability merge process
		Building a Python interface in Rust
		Building our interface in Python
		Building package installation instructions
	Utilizing and testing our package
		Building a Python construct model using pandas
		Building a random event ID generator function
		Timing our Python and Rust implementations with a series of different data sizes
	Summary
	Further reading
Section 3: Infusing Rust into a Web Application
Chapter 9: Structuring a Python Flask App for Rust
	Technical requirements
	Building a basic Flask application
		Building an entry point for our application
		Building our Fibonacci number calculator module
		Building a Docker image for our application
		Building our NGINX service
		Connecting and running our Nginx service
	Defining our data access layer
		Defining a PostgreSQL database in docker-compose
		Building a config loading system
		Building our data access layer
		Setting up the application database migration system
		Building database models
		Applying the database access layer to the fib calculation view
	Building a message bus
		Building a Celery broker for Flask
		Building a Fibonacci calculation task for Celery
		Updating our calculation view
		Defining our Celery service in Docker
	Summary
	Questions
	Answers
	Further reading
Chapter 10: Injecting Rust into a Python Flask App
	Technical requirements
	Fusing Rust into Flask and Celery
		Defining our dependency on the Rust Fibonacci number calculation package
		Building our calculation model with Rust
		Creating a calculation view using Rust
		Inserting Rust into our Celery task
	Deploying Flask and Celery with Rust
	Deploying with a private GitHub repository
		Building a Bash script that orchestrates the whole process
		Reconfiguring the Rust Fib package installment in our Dockerfile
	Fusing Rust with data access
		Setting up our database cloning package
		Setting up the diesel environment
		Autogenerating and configuring our database models and schema
		Defining our database connection in Rust
		Creating a Rust function that gets all the Fibonacci records and returns them
	Deploying Rust nightly in Flask
	Summary
	Questions
	Answers
	Further reading
Chapter 11: Best Practices for Integrating Rust
	Technical requirements
	Keeping our Rust implementation simple by piping data to and from Rust
		Building a Python script that formulates the numbers for calculation
		Building 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 out
	Giving the interface a native feel with objects
		Defining 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 Rayon
	Further reading
	Why subscribe?
Other Books You May Enjoy
	Packt is searching for authors like you
	Share Your Thoughts