diff --git a/src/rust/engine/Cargo.lock b/src/rust/engine/Cargo.lock
index d22e5d488971..8577417998dd 100644
--- a/src/rust/engine/Cargo.lock
+++ b/src/rust/engine/Cargo.lock
@@ -672,6 +672,7 @@ dependencies = [
  "petgraph 0.5.1",
  "process_execution",
  "protos",
+ "pyo3",
  "rand 0.8.2",
  "regex",
  "reqwest",
diff --git a/src/rust/engine/Cargo.toml b/src/rust/engine/Cargo.toml
index 83e8eecd05d3..4239063ccc67 100644
--- a/src/rust/engine/Cargo.toml
+++ b/src/rust/engine/Cargo.toml
@@ -138,6 +138,7 @@ num_enum = "0.4"
 parking_lot = "0.11"
 petgraph = "0.5"
 process_execution = { path = "process_execution" }
+pyo3 = "0.15"
 rand = "0.8"
 regex = "1"
 reqwest = { version = "0.11", default_features = false, features = ["stream", "rustls-tls"] }
diff --git a/src/rust/engine/src/externs/mod.rs b/src/rust/engine/src/externs/mod.rs
index 8016aa6de2b5..d335506d7dbc 100644
--- a/src/rust/engine/src/externs/mod.rs
+++ b/src/rust/engine/src/externs/mod.rs
@@ -23,25 +23,26 @@ use std::fmt;
 use crate::interning::Interns;
 use crate::python::{Failure, Key, TypeId, Value};
 
-use cpython::{
-  py_class, CompareOp, FromPyObject, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr,
-  PyObject, PyResult as CPyResult, PyTuple, PyType, Python, PythonObject, ToPyObject,
-};
+use cpython::ObjectProtocol;
 use lazy_static::lazy_static;
+use pyo3::basic::CompareOp;
+use pyo3::prelude::*;
+use pyo3::types::{PyBool, PyBytes, PyDict, PyTuple};
+use pyo3::ToPyObject;
 
 use logging::PythonLogLevel;
 
-pub fn equals(py: Python, h1: &PyObject, h2: &PyObject) -> bool {
+pub fn equals(h1: &PyAny, h2: &PyAny) -> bool {
   // NB: Although it does not precisely align with Python's definition of equality, we ban matches
   // between non-equal types to avoid legacy behavior like `assert True == 1`, which is very
   // surprising in interning, and would likely be surprising anywhere else in the engine where we
   // compare things.
-  if h1.get_type(py) != h2.get_type(py) {
+  if h1.get_type() != h2.get_type() {
     return false;
   }
-  h1.rich_compare(py, h2, CompareOp::Eq)
+  h1.rich_compare(h2, CompareOp::Eq)
     .unwrap()
-    .cast_as::<PyBool>(py)
+    .cast_as::<PyBool>()
     .unwrap()
     .is_true()
 }
@@ -55,14 +56,10 @@ pub fn store_tuple(py: Python, values: Vec<Value>) -> Value {
 }
 
 /// Store a slice containing 2-tuples of (key, value) as a Python dictionary.
-pub fn store_dict(py: Python, keys_and_values: Vec<(Value, Value)>) -> Result<Value, PyErr> {
+pub fn store_dict(py: Python, keys_and_values: Vec<(Value, Value)>) -> PyResult<Value> {
   let dict = PyDict::new(py);
   for (k, v) in keys_and_values {
-    dict.set_item(
-      py,
-      k.consume_into_py_object(py),
-      v.consume_into_py_object(py),
-    )?;
+    dict.set_item(k.consume_into_py_object(py), v.consume_into_py_object(py))?;
   }
   Ok(Value::from(dict.into_object()))
 }
@@ -72,31 +69,31 @@ pub fn store_bytes(py: Python, bytes: &[u8]) -> Value {
   Value::from(PyBytes::new(py, bytes).into_object())
 }
 
-/// Store an buffer of utf8 bytes to pass to Python. This will end up as a Python `str`.
+/// Store a buffer of utf8 bytes to pass to Python. This will end up as a Python `str`.
 pub fn store_utf8(py: Python, utf8: &str) -> Value {
-  Value::from(utf8.to_py_object(py).into_object())
+  Value::from(utf8.to_object(py).into_object())
 }
 
 pub fn store_u64(py: Python, val: u64) -> Value {
-  Value::from(val.to_py_object(py).into_object())
+  Value::from(val.to_object(py).into_object())
 }
 
 pub fn store_i64(py: Python, val: i64) -> Value {
-  Value::from(val.to_py_object(py).into_object())
+  Value::from(val.to_object(py).into_object())
 }
 
 pub fn store_bool(py: Python, val: bool) -> Value {
-  Value::from(val.to_py_object(py).into_object())
+  Value::from(val.to_object(py).into_object())
 }
 
 ///
 /// Gets an attribute of the given value as the given type.
 ///
-pub fn getattr<T>(value: &PyObject, field: &str) -> Result<T, String>
+pub fn getattr<T>(value: &cpython::PyObject, field: &str) -> Result<T, String>
 where
-  for<'a> T: FromPyObject<'a>,
+  for<'a> T: cpython::FromPyObject<'a>,
 {
-  let gil = Python::acquire_gil();
+  let gil = cpython::Python::acquire_gil();
   let py = gil.python();
   value
     .getattr(py, field)
@@ -115,8 +112,8 @@ where
 ///
 /// Collect the Values contained within an outer Python Iterable PyObject.
 ///
-pub fn collect_iterable(value: &PyObject) -> Result<Vec<PyObject>, String> {
-  let gil = Python::acquire_gil();
+pub fn collect_iterable(value: &cpython::PyObject) -> Result<Vec<cpython::PyObject>, String> {
+  let gil = cpython::Python::acquire_gil();
   let py = gil.python();
   match value.iter(py) {
     Ok(py_iter) => py_iter
@@ -140,10 +137,10 @@ pub fn collect_iterable(value: &PyObject) -> Result<Vec<PyObject>, String> {
   }
 }
 
-pub fn getattr_from_frozendict(value: &PyObject, field: &str) -> BTreeMap<String, String> {
+pub fn getattr_from_frozendict(value: &cpython::PyObject, field: &str) -> BTreeMap<String, String> {
   let frozendict = getattr(value, field).unwrap();
-  let pydict: PyDict = getattr(&frozendict, "_data").unwrap();
-  let gil = Python::acquire_gil();
+  let pydict: cpython::PyDict = getattr(&frozendict, "_data").unwrap();
+  let gil = cpython::Python::acquire_gil();
   let py = gil.python();
   pydict
     .items(py)
@@ -152,7 +149,11 @@ pub fn getattr_from_frozendict(value: &PyObject, field: &str) -> BTreeMap<String
     .collect()
 }
 
-pub fn getattr_as_optional_string(py: Python, value: &PyObject, field: &str) -> Option<String> {
+pub fn getattr_as_optional_string(
+  py: cpython::Python,
+  value: &cpython::PyObject,
+  field: &str,
+) -> Option<String> {
   let v = value.getattr(py, field).unwrap();
   if v.is_none(py) {
     return None;
@@ -162,8 +163,8 @@ pub fn getattr_as_optional_string(py: Python, value: &PyObject, field: &str) ->
   Some(v.extract(py).unwrap())
 }
 
-pub fn val_to_str(obj: &PyObject) -> String {
-  let gil = Python::acquire_gil();
+pub fn val_to_str(obj: &cpython::PyObject) -> String {
+  let gil = cpython::Python::acquire_gil();
   let py = gil.python();
 
   if *obj == py.None() {
@@ -174,7 +175,7 @@ pub fn val_to_str(obj: &PyObject) -> String {
   pystring.to_string(py).unwrap().into_owned()
 }
 
-pub fn val_to_log_level(obj: &PyObject) -> Result<log::Level, String> {
+pub fn val_to_log_level(obj: &cpython::PyObject) -> Result<log::Level, String> {
   let res: Result<PythonLogLevel, String> = getattr(obj, "_level").and_then(|n: u64| {
     n.try_into()
       .map_err(|e: num_enum::TryFromPrimitiveError<_>| {
@@ -186,39 +187,43 @@ pub fn val_to_log_level(obj: &PyObject) -> Result<log::Level, String> {
 
 /// Link to the Pants docs using the current version of Pants.
 pub fn doc_url(py: Python, slug: &str) -> String {
-  let docutil = py.import("pants.util.docutil").unwrap();
-  docutil
-    .call(py, "doc_url", (slug,), None)
-    .unwrap()
-    .extract(py)
-    .unwrap()
+  let docutil_module = py.import("pants.util.docutil").unwrap();
+  let doc_url_func = docutil_module.getattr("doc_url").unwrap();
+  doc_url_func.call1((slug,)).unwrap().extract().unwrap()
 }
 
-pub fn create_exception(py: Python, msg: &str) -> Value {
-  Value::from(PyErr::new::<cpython::exc::Exception, _>(py, msg).instance(py))
+pub fn create_exception(py: cpython::Python, msg: &str) -> Value {
+  Value::from(cpython::PyErr::new::<cpython::exc::Exception, _>(py, msg).instance(py))
 }
 
-pub fn call_method0(py: Python, value: &PyObject, method: &str) -> Result<PyObject, PyErr> {
-  value.call_method(py, method, PyTuple::new(py, &[]), None)
+pub fn call_method0(
+  py: cpython::Python,
+  value: &cpython::PyObject,
+  method: &str,
+) -> Result<cpython::PyObject, cpython::PyErr> {
+  value.call_method(py, method, cpython::PyTuple::new(py, &[]), None)
 }
 
-pub fn call_function<T: AsRef<PyObject>>(func: T, args: &[Value]) -> Result<PyObject, PyErr> {
-  let func: &PyObject = func.as_ref();
-  let arg_handles: Vec<PyObject> = args.iter().map(|v| v.clone().into()).collect();
-  let gil = Python::acquire_gil();
-  let args_tuple = PyTuple::new(gil.python(), &arg_handles);
+pub fn call_function<T: AsRef<cpython::PyObject>>(
+  func: T,
+  args: &[Value],
+) -> Result<cpython::PyObject, cpython::PyErr> {
+  let func: &cpython::PyObject = func.as_ref();
+  let arg_handles: Vec<cpython::PyObject> = args.iter().map(|v| v.clone().into()).collect();
+  let gil = cpython::Python::acquire_gil();
+  let args_tuple = cpython::PyTuple::new(gil.python(), &arg_handles);
   func.call(gil.python(), args_tuple, None)
 }
 
 pub fn generator_send(generator: &Value, arg: &Value) -> Result<GeneratorResponse, Failure> {
-  let gil = Python::acquire_gil();
+  let gil = cpython::Python::acquire_gil();
   let py = gil.python();
   let selectors = py.import("pants.engine.internals.selectors").unwrap();
   let response = selectors
     .call(
       py,
       "native_engine_generator_send",
-      (generator as &PyObject, arg as &PyObject),
+      (generator as &cpython::PyObject, arg as &cpython::PyObject),
       None,
     )
     .map_err(|py_err| Failure::from_py_err_with_gil(py, py_err))?;
@@ -253,15 +258,15 @@ pub fn generator_send(generator: &Value, arg: &Value) -> Result<GeneratorRespons
 /// those configured in types::Types.
 pub fn unsafe_call(py: Python, type_id: TypeId, args: &[Value]) -> Value {
   let py_type = type_id.as_py_type(py);
-  let arg_handles: Vec<PyObject> = args.iter().map(|v| v.clone().into()).collect();
+  let arg_handles: Vec<cpython::PyObject> = args.iter().map(|v| v.clone().into()).collect();
   let args_tuple = PyTuple::new(py, &arg_handles);
   py_type
-    .call(py, args_tuple, None)
+    .call(args_tuple, None)
     .map(Value::from)
     .unwrap_or_else(|e| {
       panic!(
         "Core type constructor `{}` failed: {:?}",
-        py_type.name(py),
+        py_type.name().unwrap(),
         e
       );
     })
diff --git a/src/rust/engine/src/interning.rs b/src/rust/engine/src/interning.rs
index c0a61a32c043..92bb8a9e29e7 100644
--- a/src/rust/engine/src/interning.rs
+++ b/src/rust/engine/src/interning.rs
@@ -5,8 +5,9 @@ use std::collections::HashMap;
 use std::hash;
 use std::sync::atomic;
 
-use cpython::{ObjectProtocol, PyErr, PyType, Python, ToPyObject};
 use parking_lot::{Mutex, RwLock};
+use pyo3::prelude::*;
+use pyo3::types::PyType;
 
 use crate::externs;
 use crate::python::{Fnv, Key, Value};
@@ -51,10 +52,10 @@ impl Interns {
     Interns::default()
   }
 
-  pub fn key_insert(&self, py: Python, v: Value) -> Result<Key, PyErr> {
+  pub fn key_insert(&self, py: Python, v: Value) -> PyResult<Key> {
     let (intern_key, type_id) = {
-      let obj = v.to_py_object(py).into();
-      (InternKey(v.hash(py)?, obj), (&v.get_type(py)).into())
+      let obj = v.to_object(py).into();
+      (InternKey(v.hash()?, obj), (&v.get_type()).into())
     };
 
     py.allow_threads(|| {
@@ -99,8 +100,7 @@ impl Eq for InternKey {}
 
 impl PartialEq for InternKey {
   fn eq(&self, other: &InternKey) -> bool {
-    let gil = Python::acquire_gil();
-    externs::equals(gil.python(), &self.1, &other.1)
+    Python::with_gil(|py| externs::equals(self.1.into_ref(py), other.1.into_ref(py)))
   }
 }
 
diff --git a/src/rust/engine/src/intrinsics.rs b/src/rust/engine/src/intrinsics.rs
index ec9753f20e5f..0dc99710bbe3 100644
--- a/src/rust/engine/src/intrinsics.rs
+++ b/src/rust/engine/src/intrinsics.rs
@@ -12,11 +12,12 @@ use crate::tasks::Intrinsic;
 use crate::types::Types;
 use crate::Failure;
 
-use cpython::{ObjectProtocol, Python};
+use cpython::ObjectProtocol;
 use fs::RelativePath;
 use futures::future::{self, BoxFuture, FutureExt, TryFutureExt};
 use hashing::{Digest, EMPTY_DIGEST};
 use indexmap::IndexMap;
+use pyo3::Python;
 use stdio::TryCloneAsFile;
 use store::{SnapshotOps, SubsetParams};
 use tempfile::TempDir;
@@ -197,25 +198,26 @@ fn multi_platform_process_request_to_process_result(
     })?;
 
     let platform_name: String = result.platform.into();
-    let gil = Python::acquire_gil();
-    let py = gil.python();
-    Ok(externs::unsafe_call(
-      py,
-      context.core.types.process_result,
-      &[
-        externs::store_bytes(py, &stdout_bytes),
-        Snapshot::store_file_digest(py, &context.core.types, &result.stdout_digest),
-        externs::store_bytes(py, &stderr_bytes),
-        Snapshot::store_file_digest(py, &context.core.types, &result.stderr_digest),
-        externs::store_i64(py, result.exit_code.into()),
-        Snapshot::store_directory_digest(py, &result.output_directory).map_err(|s| throw(&s))?,
-        externs::unsafe_call(
-          py,
-          context.core.types.platform,
-          &[externs::store_utf8(py, &platform_name)],
-        ),
-      ],
-    ))
+    let res = Python::with_gil(|py| {
+      externs::unsafe_call(
+        py,
+        context.core.types.process_result,
+        &[
+          externs::store_bytes(py, &stdout_bytes),
+          Snapshot::store_file_digest(py, &context.core.types, &result.stdout_digest),
+          externs::store_bytes(py, &stderr_bytes),
+          Snapshot::store_file_digest(py, &context.core.types, &result.stderr_digest),
+          externs::store_i64(py, result.exit_code.into()),
+          Snapshot::store_directory_digest(py, &result.output_directory).map_err(|s| throw(&s))?,
+          externs::unsafe_call(
+            py,
+            context.core.types.platform,
+            &[externs::store_utf8(py, &platform_name)],
+          ),
+        ],
+      )
+    });
+    Ok(res)
   }
   .boxed()
 }
@@ -232,8 +234,7 @@ fn directory_digest_to_digest_contents(
       .contents_for_directory(digest)
       .await
       .and_then(move |digest_contents| {
-        let gil = Python::acquire_gil();
-        Snapshot::store_digest_contents(gil.python(), &context, &digest_contents)
+        Python::with_gil(|py| Snapshot::store_digest_contents(py, &context, &digest_contents))
       })
       .map_err(|s| throw(&s))?;
     Ok(snapshot)
@@ -253,8 +254,7 @@ fn directory_digest_to_digest_entries(
       .entries_for_directory(digest)
       .await
       .and_then(move |digest_entries| {
-        let gil = Python::acquire_gil();
-        Snapshot::store_digest_entries(gil.python(), &context, &digest_entries)
+        Python::with_gil(|py| Snapshot::store_digest_entries(py, &context, &digest_entries))
       })
       .map_err(|s| throw(&s))?;
     Ok(snapshot)
@@ -279,8 +279,7 @@ fn remove_prefix_request_to_digest(
       .strip_prefix(input_digest, prefix)
       .await
       .map_err(|e| throw(&format!("{:?}", e)))?;
-    let gil = Python::acquire_gil();
-    Snapshot::store_directory_digest(gil.python(), &digest).map_err(|s| throw(&s))
+    Python::with_gil(|py| Snapshot::store_directory_digest(py, &digest).map_err(|s| throw(&s)))
   }
   .boxed()
 }
@@ -301,8 +300,7 @@ fn add_prefix_request_to_digest(
       .add_prefix(input_digest, prefix)
       .await
       .map_err(|e| throw(&format!("{:?}", e)))?;
-    let gil = Python::acquire_gil();
-    Snapshot::store_directory_digest(gil.python(), &digest).map_err(|s| throw(&s))
+    Python::with_gil(|py| Snapshot::store_directory_digest(py, &digest).map_err(|s| throw(&s)))
   }
   .boxed()
 }
@@ -312,8 +310,7 @@ fn digest_to_snapshot(context: Context, args: Vec<Value>) -> BoxFuture<'static,
   async move {
     let digest = lift_directory_digest(&args[0])?;
     let snapshot = store::Snapshot::from_digest(store, digest).await?;
-    let gil = Python::acquire_gil();
-    Snapshot::store_snapshot(gil.python(), snapshot)
+    Python::with_gil(|py| Snapshot::store_snapshot(py, snapshot))
   }
   .map_err(|e: String| throw(&e))
   .boxed()
@@ -336,8 +333,7 @@ fn merge_digests_request_to_digest(
       .merge(digests.map_err(|e| throw(&e))?)
       .await
       .map_err(|e| throw(&format!("{:?}", e)))?;
-    let gil = Python::acquire_gil();
-    Snapshot::store_directory_digest(gil.python(), &digest).map_err(|s| throw(&s))
+    Python::with_gil(|py| Snapshot::store_directory_digest(py, &digest).map_err(|s| throw(&s)))
   }
   .boxed()
 }
@@ -349,8 +345,7 @@ fn download_file_to_digest(
   async move {
     let key = Key::from_value(args.pop().unwrap()).map_err(Failure::from_py_err)?;
     let digest = context.get(DownloadedFile(key)).await?;
-    let gil = Python::acquire_gil();
-    Snapshot::store_directory_digest(gil.python(), &digest).map_err(|s| throw(&s))
+    Python::with_gil(|py| Snapshot::store_directory_digest(py, &digest).map_err(|s| throw(&s)))
   }
   .boxed()
 }
@@ -364,8 +359,7 @@ fn path_globs_to_digest(
     let path_globs = Snapshot::lift_path_globs(&val)
       .map_err(|e| throw(&format!("Failed to parse PathGlobs: {}", e)))?;
     let digest = context.get(Snapshot::from_path_globs(path_globs)).await?;
-    let gil = Python::acquire_gil();
-    Snapshot::store_directory_digest(gil.python(), &digest).map_err(|s| throw(&s))
+    Python::with_gil(|py| Snapshot::store_directory_digest(py, &digest).map_err(|s| throw(&s)))
   }
   .boxed()
 }
@@ -380,8 +374,7 @@ fn path_globs_to_paths(
     let path_globs = Snapshot::lift_path_globs(&val)
       .map_err(|e| throw(&format!("Failed to parse PathGlobs: {}", e)))?;
     let paths = context.get(Paths::from_path_globs(path_globs)).await?;
-    let gil = Python::acquire_gil();
-    Paths::store_paths(gil.python(), &core, &paths).map_err(|e: String| throw(&e))
+    Python::with_gil(|py| Paths::store_paths(py, &core, &paths).map_err(|e: String| throw(&e)))
   }
   .boxed()
 }
@@ -401,7 +394,7 @@ fn create_digest_to_digest(
           .map_err(|e| format!("The `path` must be relative: {:?}", e))?;
 
         let (is_file_content, is_file_entry) = {
-          let gil = Python::acquire_gil();
+          let gil = cpython::Python::acquire_gil();
           let py = gil.python();
           (
             file_item.hasattr(py, "content").unwrap(),
@@ -446,8 +439,7 @@ fn create_digest_to_digest(
       .merge(digests)
       .await
       .map_err(|e| throw(&format!("{:?}", e)))?;
-    let gil = Python::acquire_gil();
-    Snapshot::store_directory_digest(gil.python(), &digest).map_err(|s| throw(&s))
+    Python::with_gil(|py| Snapshot::store_directory_digest(py, &digest).map_err(|s| throw(&s)))
   }
   .boxed()
 }
@@ -468,8 +460,7 @@ fn digest_subset_to_digest(
       .subset(original_digest, subset_params)
       .await
       .map_err(|e| throw(&format!("{:?}", e)))?;
-    let gil = Python::acquire_gil();
-    Snapshot::store_directory_digest(gil.python(), &digest).map_err(|s| throw(&s))
+    Python::with_gil(|py| Snapshot::store_directory_digest(py, &digest).map_err(|s| throw(&s)))
   }
   .boxed()
 }
@@ -599,15 +590,13 @@ fn interactive_process(
       .await?;
 
     let code = exit_status.code().unwrap_or(-1);
-    let result = {
-      let gil = Python::acquire_gil();
-      let py = gil.python();
+    let result = Python::with_gil(|py| {
       externs::unsafe_call(
         py,
         interactive_process_result,
         &[externs::store_i64(py, i64::from(code))],
       )
-    };
+    });
     Ok(result)
   }.boxed()
 }
diff --git a/src/rust/engine/src/nodes.rs b/src/rust/engine/src/nodes.rs
index ba1fc5dd8d82..1449ddab9edd 100644
--- a/src/rust/engine/src/nodes.rs
+++ b/src/rust/engine/src/nodes.rs
@@ -15,6 +15,7 @@ use bytes::Bytes;
 use futures::future::{self, BoxFuture, FutureExt, TryFutureExt};
 use grpc_util::prost::MessageExt;
 use protos::gen::pants::cache::{CacheKey, CacheKeyType, ObservedUrl};
+use pyo3::prelude::Python;
 use url::Url;
 
 use crate::context::{Context, Core};
@@ -24,7 +25,7 @@ use crate::python::{display_sorted_in_parens, throw, Failure, Key, Params, TypeI
 use crate::selectors;
 use crate::tasks::{self, Rule};
 use crate::Types;
-use cpython::{PyObject, Python, PythonObject};
+use cpython::PythonObject;
 use fs::{
   self, DigestEntry, Dir, DirectoryListing, File, FileContent, FileEntry, GlobExpansionConjunction,
   GlobMatching, Link, PathGlobs, PathStat, PreparedPathGlobs, RelativePath, StrictGlobMatching,
@@ -264,12 +265,15 @@ impl From<Select> for NodeKey {
   }
 }
 
-pub fn lift_directory_digest(digest: &PyObject) -> Result<hashing::Digest, String> {
+pub fn lift_directory_digest(digest: &cpython::PyObject) -> Result<hashing::Digest, String> {
   externs::fs::from_py_digest(digest).map_err(|e| format!("{:?}", e))
 }
 
-pub fn lift_file_digest(types: &Types, digest: &PyObject) -> Result<hashing::Digest, String> {
-  let gil = Python::acquire_gil();
+pub fn lift_file_digest(
+  types: &Types,
+  digest: &cpython::PyObject,
+) -> Result<hashing::Digest, String> {
+  let gil = cpython::Python::acquire_gil();
   let py = gil.python();
   if TypeId::new(&digest.get_type(py)) != types.file_digest {
     return Err(format!("{} is not of type {}.", digest, types.file_digest));
@@ -292,7 +296,7 @@ pub struct MultiPlatformExecuteProcess {
 
 impl MultiPlatformExecuteProcess {
   fn lift_process(value: &Value, platform_constraint: Option<Platform>) -> Result<Process, String> {
-    let gil = Python::acquire_gil();
+    let gil = cpython::Python::acquire_gil();
     let py = gil.python();
     let env = externs::getattr_from_frozendict(value, "env");
     let working_directory =
@@ -326,7 +330,7 @@ impl MultiPlatformExecuteProcess {
     };
 
     let description: String = externs::getattr(value, "description").unwrap();
-    let py_level: PyObject = externs::getattr(value, "level").unwrap();
+    let py_level: cpython::PyObject = externs::getattr(value, "level").unwrap();
     let level = externs::val_to_log_level(&py_level)?;
 
     let append_only_caches = externs::getattr_from_frozendict(value, "append_only_caches")
@@ -344,7 +348,7 @@ impl MultiPlatformExecuteProcess {
       externs::getattr_as_optional_string(py, value, "execution_slot_variable");
 
     let cache_scope: ProcessCacheScope = {
-      let cache_scope_enum: PyObject = externs::getattr(value, "cache_scope").unwrap();
+      let cache_scope_enum: cpython::PyObject = externs::getattr(value, "cache_scope").unwrap();
       externs::getattr::<String>(&cache_scope_enum, "name")
         .unwrap()
         .try_into()?
@@ -593,11 +597,12 @@ impl From<Scandir> for NodeKey {
 }
 
 fn unmatched_globs_additional_context() -> Option<String> {
-  let gil = Python::acquire_gil();
-  let url = externs::doc_url(
-    gil.python(),
-    "troubleshooting#pants-cannot-find-a-file-in-your-project",
-  );
+  let url = Python::with_gil(|py| {
+    externs::doc_url(
+      py,
+      "troubleshooting#pants-cannot-find-a-file-in-your-project",
+    )
+  });
   Some(format!(
     "\n\nDo the file(s) exist? If so, check if the file(s) are in your `.gitignore` or the global \
     `pants_ignore` option, which may result in Pants not being able to see the file(s) even though \
@@ -721,19 +726,19 @@ impl Snapshot {
   }
 
   pub fn lift_path_globs(item: &Value) -> Result<PathGlobs, String> {
-    let gil = Python::acquire_gil();
+    let gil = cpython::Python::acquire_gil();
     let py = gil.python();
     let globs: Vec<String> = externs::getattr(item, "globs").unwrap();
     let description_of_origin =
       externs::getattr_as_optional_string(py, item, "description_of_origin");
 
-    let glob_match_error_behavior: PyObject =
+    let glob_match_error_behavior: cpython::PyObject =
       externs::getattr(item, "glob_match_error_behavior").unwrap();
     let failure_behavior: String = externs::getattr(&glob_match_error_behavior, "value").unwrap();
     let strict_glob_matching =
       StrictGlobMatching::create(failure_behavior.as_str(), description_of_origin)?;
 
-    let conjunction_obj: PyObject = externs::getattr(item, "conjunction").unwrap();
+    let conjunction_obj: cpython::PyObject = externs::getattr(item, "conjunction").unwrap();
     let conjunction_string: String = externs::getattr(&conjunction_obj, "value").unwrap();
     let conjunction = GlobExpansionConjunction::create(&conjunction_string)?;
     Ok(PathGlobs::new(globs, strict_glob_matching, conjunction))
@@ -752,7 +757,7 @@ impl Snapshot {
       .map_err(|e| format!("{:?}", e))
   }
 
-  pub fn lift_file_digest(item: &PyObject) -> Result<hashing::Digest, String> {
+  pub fn lift_file_digest(item: &cpython::PyObject) -> Result<hashing::Digest, String> {
     let fingerprint: String = externs::getattr(item, "fingerprint").unwrap();
     let serialized_bytes_length: usize = externs::getattr(item, "serialized_bytes_length")?;
     Ok(hashing::Digest::new(
@@ -1095,10 +1100,7 @@ impl Task {
     entry: Arc<rule_graph::Entry<Rule>>,
     generator: Value,
   ) -> NodeResult<Value> {
-    let mut input = {
-      let gil = Python::acquire_gil();
-      Value::from(gil.python().None())
-    };
+    let mut input = Python::with_gil(|py| Value::from(py.None()));
     loop {
       let context = context.clone();
       let params = params.clone();
@@ -1110,8 +1112,7 @@ impl Task {
         }
         externs::GeneratorResponse::GetMulti(gets) => {
           let values = Self::gen_get(&context, workunit, &params, &entry, gets).await?;
-          let gil = Python::acquire_gil();
-          input = externs::store_tuple(gil.python(), values);
+          input = Python::with_gil(|py| externs::store_tuple(py, values));
         }
         externs::GeneratorResponse::Break(val) => {
           break Ok(val);
@@ -1171,7 +1172,7 @@ impl WrappedNode for Task {
       .await?
       .into();
     let mut result_type = {
-      let gil = Python::acquire_gil();
+      let gil = cpython::Python::acquire_gil();
       let py = gil.python();
       TypeId::new(&result_val.get_type(py))
     };
@@ -1183,7 +1184,7 @@ impl WrappedNode for Task {
         Self::generate(&context, workunit, params, self.entry, result_val),
       )
       .await?;
-      let gil = Python::acquire_gil();
+      let gil = cpython::Python::acquire_gil();
       let py = gil.python();
       result_type = TypeId::new(&result_val.get_type(py));
     }
@@ -1196,7 +1197,7 @@ impl WrappedNode for Task {
     }
 
     let engine_aware_return_type = if self.task.engine_aware_return_type {
-      let gil = Python::acquire_gil();
+      let gil = cpython::Python::acquire_gil();
       let py = gil.python();
       EngineAwareReturnType::from_task_result(py, &result_val, &context)
     } else {
@@ -1370,9 +1371,7 @@ impl Node for NodeKey {
     let workunit_name = self.workunit_name();
     let user_facing_name = self.user_facing_name();
     let engine_aware_params: Vec<_> = match &self {
-      NodeKey::Task(ref task) => {
-        let gil = Python::acquire_gil();
-        let py = gil.python();
+      NodeKey::Task(ref task) => Python::with_gil(|py| {
         let engine_aware_param_ty = context.core.types.engine_aware_parameter.as_py_type(py);
         task
           .params
@@ -1389,17 +1388,15 @@ impl Node for NodeKey {
             }
           })
           .collect()
-      }
+      }),
       _ => vec![],
     };
-    let user_metadata = {
-      let gil = Python::acquire_gil();
-      let py = gil.python();
+    let user_metadata = Python::with_gil(|py| {
       engine_aware_params
         .iter()
         .flat_map(|val| EngineAwareParameter::metadata(py, &context, val))
         .collect()
-    };
+    });
 
     let metadata = WorkunitMetadata {
       desc: user_facing_name,
@@ -1496,14 +1493,12 @@ impl Node for NodeKey {
         // If the node failed, expand the Failure with a new frame.
         result = result.map_err(|failure| {
           let name = workunit_name;
-          let displayable_param_names: Vec<_> = {
-            let gil = Python::acquire_gil();
-            let py = gil.python();
+          let displayable_param_names: Vec<_> = Python::with_gil(|py| {
             engine_aware_params
               .iter()
               .filter_map(|val| EngineAwareParameter::debug_hint(py, val))
               .collect()
-          };
+          });
           let failure_name = if displayable_param_names.is_empty() {
             name
           } else if displayable_param_names.len() == 1 {
@@ -1559,9 +1554,7 @@ impl Node for NodeKey {
         ProcessCacheScope::PerSession => false,
       },
       (NodeKey::Task(ref t), NodeOutput::Value(ref v)) if t.task.engine_aware_return_type => {
-        let gil = Python::acquire_gil();
-        let py = gil.python();
-        EngineAwareReturnType::is_cacheable(py, v).unwrap_or(true)
+        Python::with_gil(|py| EngineAwareReturnType::is_cacheable(py, v).unwrap_or(true))
       }
       _ => true,
     }
@@ -1580,15 +1573,13 @@ impl Display for NodeKey {
       &NodeKey::Scandir(ref s) => write!(f, "Scandir({})", (s.0).0.display()),
       &NodeKey::Select(ref s) => write!(f, "{}", s.product),
       &NodeKey::Task(ref task) => {
-        let params = {
-          let gil = Python::acquire_gil();
-          let py = gil.python();
+        let params = Python::with_gil(|py| {
           task
             .params
             .keys()
             .filter_map(|k| EngineAwareParameter::debug_hint(py, &k.to_value()))
             .collect::<Vec<_>>()
-        };
+        });
         write!(
           f,
           "@rule({}({}))",
@@ -1614,11 +1605,8 @@ impl NodeError for Failure {
       path[0] += " <-";
       path[path_len - 1] += " <-"
     }
-    let gil = Python::acquire_gil();
-    let url = externs::doc_url(
-      gil.python(),
-      "targets#dependencies-and-dependency-inference",
-    );
+    let url =
+      Python::with_gil(|py| externs::doc_url(py, "targets#dependencies-and-dependency-inference"));
     throw(&format!(
       "The dependency graph contained a cycle:\
       \n\n  \
diff --git a/src/rust/engine/src/python.rs b/src/rust/engine/src/python.rs
index 334e6810bfe7..151b17c0de2a 100644
--- a/src/rust/engine/src/python.rs
+++ b/src/rust/engine/src/python.rs
@@ -1,20 +1,19 @@
 // Copyright 2017 Pants project contributors (see CONTRIBUTORS.md).
 // Licensed under the Apache License, Version 2.0 (see LICENSE).
 
-use fnv::FnvHasher;
-
 use std::convert::AsRef;
 use std::ops::Deref;
 use std::sync::Arc;
 use std::{fmt, hash};
 
-use crate::externs;
-
-use cpython::{
-  FromPyObject, PyClone, PyDict, PyErr, PyObject, PyResult, PyType, Python, ToPyObject,
-};
+use fnv::FnvHasher;
+use pyo3::prelude::*;
+use pyo3::types::PyType;
+use pyo3::{FromPyObject, ToPyObject};
 use smallvec::SmallVec;
 
+use crate::externs;
+
 pub type Fnv = hash::BuildHasherDefault<FnvHasher>;
 
 ///
@@ -115,13 +114,9 @@ impl fmt::Display for Params {
 
 pub type Id = u64;
 
-///
 /// A pointer to an underlying PyTypeObject instance.
-///
-/// NB: This is a void pointer because the `cpython::ffi::PyTypeObject` is not public.
-///
 #[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct TypeId(*mut std::ffi::c_void);
+pub struct TypeId(*mut pyo3::ffi::PyTypeObject);
 
 unsafe impl Send for TypeId {}
 unsafe impl Sync for TypeId {}
@@ -131,38 +126,35 @@ impl TypeId {
     py_type.into()
   }
 
-  pub fn as_py_type(&self, py: Python) -> PyType {
+  pub fn as_py_type<'py>(&self, py: Python<'py>) -> &'py PyType {
     // NB: Dereferencing a pointer to a PyTypeObject is safe as long as the module defining the
     // type is not unloaded. That is true today, but would not be if we implemented support for hot
     // reloading of plugins.
-    unsafe { PyType::from_type_ptr(py, self.0 as _) }
+    unsafe { PyType::from_type_ptr(py, self.0) }
   }
 
   pub fn is_union(&self) -> bool {
-    let gil = Python::acquire_gil();
-    let py = gil.python();
-    let unions = py.import("pants.engine.unions").unwrap();
-    unions
-      .call(py, "is_union", (self.as_py_type(py),), None)
-      .unwrap()
-      .extract(py)
-      .unwrap()
+    Python::with_gil(|py| {
+      let unions_module = py.import("pants.engine.unions").unwrap();
+      let is_union_func = unions_module.getattr("is_union").unwrap();
+      is_union_func
+        .call1((self.as_py_type(py),))
+        .unwrap()
+        .extract()
+        .unwrap()
+    })
   }
 }
 
 impl From<&PyType> for TypeId {
   fn from(py_type: &PyType) -> Self {
-    TypeId(py_type.as_type_ptr() as *mut std::ffi::c_void)
+    TypeId(py_type.as_type_ptr())
   }
 }
 
 impl fmt::Debug for TypeId {
   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    let name = {
-      let gil = Python::acquire_gil();
-      let py = gil.python();
-      self.as_py_type(py).name(py).into_owned()
-    };
+    let name = Python::with_gil(|py| self.as_py_type(py).name().unwrap());
     write!(f, "{}", name)
   }
 }
@@ -260,9 +252,8 @@ impl Key {
     &self.type_id
   }
 
-  pub fn from_value(val: Value) -> Result<Key, PyErr> {
-    let gil = Python::acquire_gil();
-    externs::INTERNS.key_insert(gil.python(), val)
+  pub fn from_value(val: Value) -> PyResult<Key> {
+    Python::with_gil(|py| externs::INTERNS.key_insert(py, val))
   }
 
   pub fn to_value(&self) -> Value {
@@ -270,22 +261,22 @@ impl Key {
   }
 }
 
-///
-/// We wrap PyObject (which cannot be cloned without acquiring the GIL) in an Arc in order to avoid
-/// accessing the Gil in many cases.
-///
+/// We wrap PyObject (aka Py<PyAny>) in an Arc in order to cheaply clone without needing to
+/// access the GIL. It's already cheap to clone `&PyAny` as it simply increases Python's ref
+/// count, but that type only works when we are holding the GIL. While we could clone the
+/// `PyObject` without the GIL, that would be an expensive deep clone.
 #[derive(Clone)]
 pub struct Value(Arc<PyObject>);
 
 impl Value {
-  pub fn new(handle: PyObject) -> Value {
-    Value(Arc::new(handle))
+  pub fn new(obj: PyObject) -> Value {
+    Value(Arc::new(obj))
   }
 
   // NB: Longer name because overloaded in a few places.
   pub fn consume_into_py_object(self, py: Python) -> PyObject {
     match Arc::try_unwrap(self.0) {
-      Ok(handle) => handle,
+      Ok(obj) => obj,
       Err(arc_handle) => arc_handle.clone_ref(py),
     }
   }
@@ -293,8 +284,7 @@ impl Value {
 
 impl PartialEq for Value {
   fn eq(&self, other: &Value) -> bool {
-    let gil = Python::acquire_gil();
-    externs::equals(gil.python(), &self.0, &other.0)
+    Python::with_gil(|py| externs::equals(self.0.into_ref(py), other.0.into_ref(py)))
   }
 }
 
@@ -326,15 +316,14 @@ impl fmt::Display for Value {
   }
 }
 
-impl FromPyObject<'_> for Value {
-  fn extract(py: Python, obj: &PyObject) -> PyResult<Self> {
-    Ok(obj.clone_ref(py).into())
+impl FromPyObject for Value {
+  fn extract(obj: &PyAny) -> PyResult<Self> {
+    Ok(obj.clone().into())
   }
 }
 
 impl ToPyObject for &Value {
-  type ObjectType = PyObject;
-  fn to_py_object(&self, py: Python) -> PyObject {
+  fn to_object(&self, py: Python) -> PyObject {
     self.0.clone_ref(py)
   }
 }
@@ -342,18 +331,15 @@ impl ToPyObject for &Value {
 impl From<Value> for PyObject {
   fn from(value: Value) -> Self {
     match Arc::try_unwrap(value.0) {
-      Ok(handle) => handle,
-      Err(arc_handle) => {
-        let gil = Python::acquire_gil();
-        arc_handle.clone_ref(gil.python())
-      }
+      Ok(obj) => obj,
+      Err(arc_handle) => Python::with_gil(|py| arc_handle.clone_ref(py)),
     }
   }
 }
 
 impl From<PyObject> for Value {
-  fn from(handle: PyObject) -> Self {
-    Value::new(handle)
+  fn from(obj: PyObject) -> Self {
+    Value::new(obj)
   }
 }
 
@@ -397,15 +383,15 @@ impl Failure {
 }
 
 impl Failure {
-  pub fn from_py_err(py_err: PyErr) -> Failure {
-    let gil = Python::acquire_gil();
+  pub fn from_py_err(py_err: cpython::PyErr) -> Failure {
+    let gil = cpython::Python::acquire_gil();
     let py = gil.python();
     Failure::from_py_err_with_gil(py, py_err)
   }
-  pub fn from_py_err_with_gil(py: Python, mut py_err: PyErr) -> Failure {
+  pub fn from_py_err_with_gil(py: cpython::Python, mut py_err: cpython::PyErr) -> Failure {
     let val = Value::from(py_err.instance(py));
     let python_traceback = if let Some(tb) = py_err.ptraceback.as_ref() {
-      let locals = PyDict::new(py);
+      let locals = cpython::PyDict::new(py);
       locals
         .set_item(py, "traceback", py.import("traceback").unwrap())
         .unwrap();