functiontrace 0.5.0__tar.gz → 0.5.2__tar.gz

{functiontrace-0.5.0 → functiontrace-0.5.2}/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "_functiontrace_rs"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 color-eyre = { version = "0.6", default-features = false }
@@ -10,17 +10,17 @@ functiontrace-server = { version = "0.8.4", default-features = false, features =
 jiff = { version = "0.2", default-features = false, features = ["std", "serde"] }
 libc = "0.2"
 owo-colors = "4.2"
-pyo3 = { version = "0.25", features = ["eyre"] }
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
+pyo3 = { version = "0.29", features = ["eyre"] }
+reqwest = { version = "0.13", default-features = false, features = ["blocking", "json", "rustls"] }
 rmp-serde = "1.3"
 serde = "1"
-toml = "0.9"
+toml = "1.1"
 tracing = { version = "0.1", features = ["log"] }
 tracing-subscriber = { version = "0.3", default-features = false, features = ["ansi", "env-filter", "fmt", "std"] }
 
 [build-dependencies]
-toml = { version = "0.9", default-features = false, features = ["parse", "serde"] }
-pyo3-build-config = { version = "0.25", features = ["resolve-config"] }
+toml = { version = "1.1", default-features = false, features = ["parse", "serde"] }
+pyo3-build-config = { version = "0.29" }
 
 [lib]
 # See https://github.com/PyO3/pyo3 for details

{functiontrace-0.5.0/functiontrace.egg-info → functiontrace-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.5.0
+Version: 0.5.2
 Summary: A profiling tool that traces your application's execution
 Author: Alistair Dobke
 Author-email: Matt Bryant <functiontrace@programsareproofs.com>
@@ -15,7 +15,7 @@ Classifier: Environment :: Console
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.md
 Dynamic: license-file
@@ -28,7 +28,7 @@ Dependencies
 ------------
 
 The FunctionTrace server must be installed for this package to work.
-See installation instructions at https://functiontrace.com#installation.
+See installation instructions at https://functiontrace.com/installation/.
 
 Usage
 -----

{functiontrace-0.5.0 → functiontrace-0.5.2}/README.rst

@@ -6,7 +6,7 @@ Dependencies
 ------------
 
 The FunctionTrace server must be installed for this package to work.
-See installation instructions at https://functiontrace.com#installation.
+See installation instructions at https://functiontrace.com/installation/.
 
 Usage
 -----

{functiontrace-0.5.0 → functiontrace-0.5.2}/build.rs

@@ -5,14 +5,24 @@ fn main() -> std::io::Result<()> {
     let pyproject = std::fs::read_to_string("pyproject.toml")?
         .parse::<toml::Table>()
         .expect("pyproject.toml is valid toml");
-    let version = pyproject
+    let project = pyproject
         .get("project")
         .and_then(|p| p.as_table())
-        .and_then(|p| p.get("version"))
+        .expect("project field is present in pyproject.toml");
+
+    let version = project
+        .get("version")
         .and_then(|v| v.as_str())
         .expect("version field is present in pyproject.toml");
     println!("cargo::rustc-env=PACKAGE_VERSION={}", version);
 
+    let min_python = project
+        .get("requires-python")
+        .and_then(|v| v.as_str())
+        .and_then(|v| v.strip_prefix(">=3."))
+        .expect("requires-python field is present in pyproject.toml");
+    println!("cargo::rustc-env=MIN_PYTHON_VERSION={}", min_python);
+
     // Figure out which Python version we're building for
     pyo3_build_config::use_pyo3_cfgs();
 

{functiontrace-0.5.0 → functiontrace-0.5.2/functiontrace.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.5.0
+Version: 0.5.2
 Summary: A profiling tool that traces your application's execution
 Author: Alistair Dobke
 Author-email: Matt Bryant <functiontrace@programsareproofs.com>
@@ -15,7 +15,7 @@ Classifier: Environment :: Console
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.md
 Dynamic: license-file
@@ -28,7 +28,7 @@ Dependencies
 ------------
 
 The FunctionTrace server must be installed for this package to work.
-See installation instructions at https://functiontrace.com#installation.
+See installation instructions at https://functiontrace.com/installation/.
 
 Usage
 -----

{functiontrace-0.5.0 → functiontrace-0.5.2}/functiontrace.py

@@ -19,7 +19,12 @@ exec $(which {python}) -m functiontrace "$@"
 
 
 def setup_dependencies():
-    # Generate a temp directory to store our wrappers in.  We'll temporarily
+    if f"{tempfile.gettempdir()}/py-functiontrace" in os.environ["PATH"]:
+        # We've already set up dependencies. This only needs to happen once, since otherwise we'll
+        # just make a bunch of useless temp directories.
+        return
+
+    # Generate a temp directory to store our wrappers in. We'll temporarily
     # add this directory to our path.
     tempdir = tempfile.mkdtemp(prefix="py-functiontrace")
     os.environ["PATH"] = tempdir + os.pathsep + os.environ["PATH"]
@@ -27,7 +32,8 @@ def setup_dependencies():
     # Generate wrappers for the various Python versions we support to ensure
     # they're included in our PATH.
     wrap_pythons = ["python", "python3"] + [
-        "python3.{}".format(minor) for minor in range(6, 13)
+        "python3.{}".format(minor)
+        for minor in range(rust._min_python_version, rust._max_python_version + 1)
     ]
     for python in wrap_pythons:
         with open(os.path.join(tempdir, python), "w") as f:
@@ -88,10 +94,19 @@ def main():
     # below, which needs to operate in the context of our new module.
     # NOTE: We use SourceFileLoader, rather than allowing importlib to infer
     # the proper loader, in order to support files without a .py extension.
-    spec = util.spec_from_loader(
-        "__main__", machinery.SourceFileLoader("__main__", target_file)
+    mod = util.module_from_spec(
+        util.spec_from_loader(
+            "__main__", machinery.SourceFileLoader("__main__", target_file)
+        )
     )
-    mod = util.module_from_spec(spec)
+
+    # Clear __spec__ to match Python's standard `python foo.py` loading
+    mod.__spec__ = None
+    # Record the file we're using so `multiprocessing` can load it (in a non-forked context).
+    # Without this, `multiprocessing` in `forkserver` contexts is asked to load functions that
+    # it can't find.
+    mod.__file__ = target_file
+
     sys.modules.update({"__main__": mod})
 
     # Ensure we're setup to be able to run.

{functiontrace-0.5.0 → functiontrace-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "functiontrace"
-version = "0.5.0"
+version = "0.5.2"
 description = "A profiling tool that traces your application's execution"
 authors = [
     { name = "Matt Bryant", email = "functiontrace@programsareproofs.com"},
@@ -9,13 +9,13 @@ authors = [
 license = "LicenseRef-Prosperity-Public-License-3.0.0"
 license-files = ["LICENSE.md"]
 readme = "README.rst"
-# NOTE: Actively tested on Python 3.9 - 3.13 and may plausibly break on greater
-# versions due to C extension hacks.  However, setting a maximum version causes
-# new Python versions to simply install very old versions of Functiontrace that
-# didn't have the `requires-python` annotation on them and are also unlikely to
-# work.  Best to only set the minimum and let bug reports notify us of issues
-# with new Python releases.
-requires-python = ">=3.9"
+# NOTE: Actively tested on Python 3.10 - 3.14 and may plausibly break on
+# greater versions due to C extension hacks. However, setting a maximum version
+# causes new Python versions to simply install very old versions of
+# Functiontrace that didn't have the `requires-python` annotation on them and
+# are also unlikely to work. Best to only set the minimum and let bug reports
+# notify us of issues with new Python releases.
+requires-python = ">=3.10"
 keywords = [
     "profiler",
     "debugger"

{functiontrace-0.5.0 → functiontrace-0.5.2}/rust/lib.rs

@@ -7,7 +7,7 @@ mod _functiontrace_rs {
     use serde::{Deserialize, Serialize};
     use std::borrow::Cow;
     use std::cell::Cell;
-    use std::ffi::{CStr, OsString, c_void};
+    use std::ffi::{CStr, OsString};
     use std::io::Write;
     use std::os::unix::net::UnixStream;
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -148,7 +148,7 @@ mod _functiontrace_rs {
         let state = THREAD_STATE.get();
 
         if state.is_null() {
-            // We shouldn't be asked to reset at thread that hasn't yet been registered.
+            // We shouldn't be asked to reset a thread that hasn't yet been registered.
             return None;
         }
 
@@ -195,10 +195,20 @@ mod _functiontrace_rs {
     /// Initialization code run on this module's import (mostly useful for adding constants)
     #[pymodule_init]
     fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
-        // Arbitrary code to run at the module initialization
         m.add("__version__", env!("PACKAGE_VERSION"))
             .wrap_err("Failed to expose PACKAGE_VERSION")?;
 
+        // Expose the minimum and maximum Python 3 versions we support
+        m.add(
+            "_min_python_version",
+            env!("MIN_PYTHON_VERSION")
+                .parse::<u32>()
+                .wrap_err("Failed to convert MIN_PYTHON_VERSION to int")?,
+        )
+        .wrap_err("Failed to expose _min_python_version")?;
+        m.add("_max_python_version", 14)
+            .wrap_err("Failed to expose _max_python_version")?;
+
         color_eyre::install().wrap_err("Failed to install color_eyre")?;
 
         // If someone else has already installed a tracing subscriber, we'll fail to initialize
@@ -244,6 +254,57 @@ mod _functiontrace_rs {
             return Err(eyre!("FunctionTrace is already initialized!"));
         }
 
+        // Store the processes' args, since threads will need it as part of the registration message.
+        ARGV.set({
+            // Parse args out of `sys.argv`, since it excludes the Python executable and shows the
+            // script's path first.  This is much more complicated than using `std::env::args`, but
+            // is more practical.
+            Python::attach(|py| -> Result<String> {
+                let argv = py
+                    .import("sys")
+                    .and_then(|sys| sys.getattr("argv"))
+                    .wrap_err("Failed to access sys.argv")?;
+
+                let args = argv
+                    .cast::<pyo3::types::PyList>()
+                    .map_err(|e| eyre!("Failed to read sys.argv as list: {}", e))?;
+
+                let mut full_args = args.iter().fold(String::new(), |s, arg| {
+                    // Fetch the next arg as a string if possible.
+                    let arg = arg
+                        .cast::<pyo3::types::PyString>()
+                        .map_err(|e| eyre!("Failed to read sys.argv[x] as string: {}", e))
+                        .and_then(|arg| {
+                            arg.to_str()
+                                .wrap_err("Failed to read Rust string out of PyString")
+                        })
+                        .unwrap_or("<UNKNOWN>");
+
+                    s + " " + arg
+                });
+
+                // We'll display this in the UI, so ensure it's under (the rather
+                // arbitrary) 100 chars.
+                if full_args.chars().count() > 95 {
+                    full_args.truncate(95);
+                    full_args.push_str(" ...");
+                }
+
+                // We'll be cloning this
+                full_args.shrink_to_fit();
+                Ok(full_args)
+            })
+            .unwrap_or_else(|_err| {
+                tracing::warn!("Failed to read ARGV");
+
+                "<UNKNOWN>".into()
+            })
+        })
+        .expect("ARGV is only set in `trace_initialization`");
+
+        /////////////////////////////////////////////////////////////////////////
+        // Server initialization
+        /////////////////////////////////////////////////////////////////////////
         // Check if we're in a subprocess of a command being run under functiontrace.  If we are,
         // we should connect to the same socket.  Otherwise, we should setup the full profiling
         // configuration ourselves.
@@ -253,155 +314,105 @@ mod _functiontrace_rs {
             SOCKADDR
                 .set(existing_sockaddr)
                 .expect("sockaddr is only set in `trace_initialization`");
-            return Ok(());
-        }
+        } else {
+            // Launch the functiontrace-server as a daemon, then record the address of the socket we'll
+            // need to communicate with it on.
+            let sockaddr = {
+                let server = match std::process::Command::new("functiontrace-server")
+                    .arg("--directory")
+                    .arg(output_directory)
+                    .spawn()
+                {
+                    Ok(server) => server,
+                    Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                        eprintln!("Unable to find `functiontrace-server` in the current $PATH.");
+                        eprintln!(
+                            "See https://functiontrace.com/installation/ for installation instructions."
+                        );
 
-        // Launch the functiontrace-server as a daemon, then record the address of the socket we'll
-        // need to communicate with it on.
-        let sockaddr = {
-            let server = match std::process::Command::new("functiontrace-server")
-                .arg("--directory")
-                .arg(output_directory)
-                .spawn()
-            {
-                Ok(server) => server,
-                Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
-                    eprintln!("Unable to find `functiontrace-server` in the current $PATH.");
-                    eprintln!(
-                        "See https://functiontrace.com#installation for installation instructions."
-                    );
+                        // Exit here rather than returning an error, since that'll emit a confusing
+                        // Python stacktrace.
+                        std::process::exit(1);
+                    }
+                    e => e.wrap_err("Failed to launch functiontrace-server")?,
+                };
 
-                    // Exit here rather than returning an error, since that'll emit a confusing
-                    // Python stacktrace.
-                    std::process::exit(1);
-                }
-                e => e.wrap_err("Failed to launch functiontrace-server")?,
+                format!("/tmp/functiontrace-server.sock.{}", server.id()).into()
             };
 
-            format!("/tmp/functiontrace-server.sock.{}", server.id()).into()
-        };
+            Python::attach(|_| {
+                // Register an env var so subprocesses know how to connect to our
+                // profile.
+                unsafe {
+                    // SAFETY: `set_var` can only be done while no one else is reading or writing to the
+                    // environment. We're holding the GIL, so this _should_ be true, but there's no real
+                    // way to enforce this.
+                    //
+                    // This doesn't seem to blow up in C even when we don't have the GIL, so
+                    // it's hopefully good enough in practice since there's not really an alternative.
+                    std::env::set_var(BREADCRUMB, &sockaddr);
+                }
+            });
 
-        Python::with_gil(|_| {
-            // Register an env var so subprocesses know how to connect to our
-            // profile.
-            unsafe {
-                // SAFETY: `set_var` can only be done while no one else is reading or writing to the
-                // environment.  We're holding the GIL, so this _should_ be true, but there's no real
-                // way to enforce this.
-                //
-                // This doesn't seem to blow up in C even when we don't have the GIL, so
-                // it's hopefully good enough in practice since there's not really an alternative.
-                std::env::set_var(BREADCRUMB, &sockaddr);
-            }
-        });
+            // Store the server's address so our threads know how to talk to it.
+            SOCKADDR
+                .set(sockaddr)
+                .expect("sockaddr is only set in `trace_initialization`");
 
-        // Store the server's address so our threads know how to talk to it.
-        SOCKADDR
-            .set(sockaddr)
-            .expect("sockaddr is only set in `trace_initialization`");
-
-        // Send an initialization message to the server with some information about us.  This will
-        // only be sent once, and all future threads/subprocesses will be associated underneath us.
-        let init = {
-            let argv = {
-                // Parse  args out of `sys.argv`, since it excludes the Python executable and shows
-                // the script's path first.  This is much more complicated than using
-                // `std::env::args`, but is more practical.
-                let args_prefix = Python::with_gil(|py| -> Result<String> {
-                    let argv = py
-                        .import("sys")
-                        .and_then(|sys| sys.getattr("argv"))
-                        .wrap_err("Failed to access sys.argv")?;
-
-                    let args = argv
-                        .downcast::<pyo3::types::PyList>()
-                        .map_err(|e| eyre!("Failed to read sys.argv as list: {}", e))?;
-
-                    let mut full_args = args.iter().fold(String::new(), |s, arg| {
-                        // Fetch the next arg as a string if possible.
-                        let arg = arg
-                            .downcast::<pyo3::types::PyString>()
-                            .map_err(|e| eyre!("Failed to read sys.argv[x] as string: {}", e))
-                            .and_then(|arg| {
-                                arg.to_str()
-                                    .wrap_err("Failed to read Rust string out of PyString")
-                            })
-                            .unwrap_or("<UNKNOWN>");
-
-                        s + " " + arg
-                    });
-
-                    // We'll display this in the UI, so ensure it's under (the rather
-                    // arbitrary) 100 chars.
-                    if full_args.chars().count() > 95 {
-                        full_args.truncate(95);
-                        full_args.push_str(" ...");
-                    }
+            // Send an initialization message to the server with some information about us.  This will
+            // only be sent once, and all future threads/subprocesses will be associated underneath us.
+            let init = {
+                let python_version = Python::attach(|py| {
+                    let version = py.version_info();
+
+                    format!(
+                        "Python {}.{}.{}",
+                        version.major, version.minor, version.patch
+                    )
+                });
 
-                    // We'll be cloning this
-                    full_args.shrink_to_fit();
-                    Ok(full_args)
+                let platform = Python::attach(|py| -> Result<String> {
+                    let platform = py
+                        .import("sys")
+                        .and_then(|sys| sys.getattr("platform"))
+                        .wrap_err("Failed to access sys.platform")?;
+
+                    Ok(platform
+                        .cast::<pyo3::types::PyString>()
+                        .map_err(|e| eyre!("Failed to read sys.platform as string: {}", e))?
+                        .to_str()
+                        .wrap_err("Failed to read Rust string out of PyString")?
+                        .into())
                 })
                 .unwrap_or_else(|_err| {
-                    tracing::warn!("Failed to read ARGV");
+                    tracing::warn!("Failed to read sys.platform");
 
                     "<UNKNOWN>".into()
                 });
 
-                // Store the args, since threads will need it as part of the registration message.
-                ARGV.set(args_prefix.clone())
-                    .expect("ARGV is only set in `trace_initialization`");
-
-                args_prefix
+                function_trace::TraceInitialization {
+                    program_name: ARGV
+                        .get()
+                        .expect("ARGV is set earlier in trace_initialization")
+                        .clone(),
+                    program_version: format!("py-functiontrace {}", env!("PACKAGE_VERSION")),
+                    lang_version: python_version,
+                    platform,
+                    time: trace_time(),
+                }
             };
 
-            let python_version = Python::with_gil(|py| {
-                let version = py.version_info();
+            let mut socket = message_initialize();
 
-                format!(
-                    "Python {}.{}.{}",
-                    version.major, version.minor, version.patch
-                )
-            });
-
-            let platform = Python::with_gil(|py| -> Result<String> {
-                let platform = py
-                    .import("sys")
-                    .and_then(|sys| sys.getattr("platform"))
-                    .wrap_err("Failed to access sys.platform")?;
-
-                Ok(platform
-                    .downcast::<pyo3::types::PyString>()
-                    .map_err(|e| eyre!("Failed to read sys.platform as string: {}", e))?
-                    .to_str()
-                    .wrap_err("Failed to read Rust string out of PyString")?
-                    .into())
-            })
-            .unwrap_or_else(|_err| {
-                tracing::warn!("Failed to read sys.platform");
-
-                "<UNKNOWN>".into()
-            });
+            init.serialize(&mut rmp_serde::encode::Serializer::new(&mut socket))
+                .wrap_err("Failed to emit TraceInitialization message")?;
 
-            function_trace::TraceInitialization {
-                program_name: argv,
-                program_version: format!("py-functiontrace {}", env!("PACKAGE_VERSION")),
-                lang_version: python_version,
-                platform,
-                time: trace_time(),
-            }
-        };
-
-        let mut socket = message_initialize();
-
-        init.serialize(&mut rmp_serde::encode::Serializer::new(&mut socket))
-            .wrap_err("Failed to emit TraceInitialization message")?;
-
-        // Close the initialization socket to trigger `functiontrace-server` to
-        // read our message, since otherwise it'll wait forever for more data.
-        socket
-            .shutdown(std::net::Shutdown::Both)
-            .wrap_err("Failed to close initialization socket")?;
+            // Close the initialization socket to trigger `functiontrace-server` to
+            // read our message, since otherwise it'll wait forever for more data.
+            socket
+                .shutdown(std::net::Shutdown::Both)
+                .wrap_err("Failed to close initialization socket")?;
+        }
 
         ////////////////////////////////////////////////////////////////////////////
         // Teardown Configuration
@@ -422,7 +433,7 @@ mod _functiontrace_rs {
         //
         // NOTE: We specifically do this rather than `Py_AtExit`  since we want to run before all
         // the Python teardown occurs.
-        Python::with_gil(|py| -> Result<()> {
+        Python::attach(|py| -> Result<()> {
             py.import("atexit")
                 .and_then(|atexit| atexit.getattr("register"))
                 .wrap_err("Failed to access atexit.register")?
@@ -449,12 +460,13 @@ mod _functiontrace_rs {
 
         // Register our tracing functions with Python - both the normal one and the multithreaded
         // setup trampoline.
+        // TODO: PyEval_SetProfileAllThreads in >=3.12 should simplify this.
         unsafe {
             // SAFETY: both parameters are of the proper type.
             pyo3::ffi::PyEval_SetProfile(Some(functiontrace), std::ptr::null_mut())
         };
 
-        Python::with_gil(|py| -> Result<()> {
+        Python::attach(|py| -> Result<()> {
             py.import("threading")
                 .and_then(|threading| threading.getattr("setprofile"))
                 .wrap_err("Failed to access threading.setprofile")?
@@ -550,23 +562,6 @@ mod _functiontrace_rs {
         Ok(())
     }
 
-    #[unsafe(no_mangle)]
-    extern "C" fn c_thread_teardown(state: *mut c_void) {
-        if state.is_null() {
-            // We never fully initialized this thread, so skip teardown.
-            return;
-        }
-
-        let writer = unsafe {
-            // SAFETY: writer is a valid pointer to an initialized `ThreadState`.
-            &mut (state as *mut ThreadState)
-                .as_mut()
-                .expect("state is non-null")
-        };
-
-        thread_teardown(writer).expect("Failed to tear down FunctionTrace thread")
-    }
-
     /// Tear down the given thread by flushing any outstanding messages.
     ///
     /// This is called when the thread has shut down, including in multithread/process situations.
@@ -625,7 +620,11 @@ mod _functiontrace_rs {
     /// thread state, before replacing itself with the normal Fprofile_FunctionTrace handler.
     #[pyfunction]
     #[pyo3(name = "_thread_trace_trampoline")]
-    fn thread_trace_trampoline(_frame: PyObject, _event: PyObject, _arg: PyObject) -> Result<()> {
+    fn thread_trace_trampoline(
+        _frame: Py<PyAny>,
+        _event: Py<PyAny>,
+        _arg: Py<PyAny>,
+    ) -> Result<()> {
         // Register the current thread for tracing
         thread_register().wrap_err("Failed to register new FunctionTrace thread")?;
 
@@ -776,7 +775,7 @@ mod _functiontrace_rs {
                         pyo3::ffi::PyFrame_GetCode(frame) as *mut pyo3::ffi::PyObject
                     };
 
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                         let code = unsafe {
                             // SAFETY: code is guaranteed to be a valid PyCodeObject since it
                             // came from `PyFrame_GetCode`.
@@ -788,7 +787,7 @@ mod _functiontrace_rs {
                         let unicode_converter = |pyobj: PyResult<Bound<'_, PyAny>>| {
                             pyobj
                                 .map(|obj| {
-                                    if let Ok(filename) = obj.downcast::<pyo3::types::PyString>() {
+                                    if let Ok(filename) = obj.cast::<pyo3::types::PyString>() {
                                         Cow::from(filename.to_string_lossy().into_owned())
                                     } else {
                                         Cow::Borrowed("<UNKNOWN>")
@@ -845,13 +844,13 @@ mod _functiontrace_rs {
                 if !func.m_module.is_null() {
                     // NOTE: _Typically_ `m_module` is a PyModule, but there are no requirements on
                     // what type it needs to be!  In practice, we only see PyModules and PyStrings.
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                         let m_module = unsafe {
                             // SAFETY: m_module is a non-NULL pointer to a valid Python object.
                             Bound::from_borrowed_ptr(py, func.m_module)
                         };
 
-                        if let Ok(module) = m_module.downcast::<pyo3::types::PyModule>() {
+                        if let Ok(module) = m_module.cast::<pyo3::types::PyModule>() {
                             // This is a PyModule, so get its name if possible.
                             let name = module.name();
                             let module_name = if let Ok(name) = &name {
@@ -868,7 +867,7 @@ mod _functiontrace_rs {
                             .serialize(&mut rmp_serde::encode::Serializer::new(&mut writer))
                         } else {
                             let module_name =
-                                if let Ok(module) = m_module.downcast::<pyo3::types::PyString>() {
+                                if let Ok(module) = m_module.cast::<pyo3::types::PyString>() {
                                     module.to_cow().unwrap_or(Cow::Borrowed("<invalid string>"))
                                 } else {
                                     if let Ok(typ) = m_module.get_type().qualname().map(|x| x.to_string()) {
@@ -1114,7 +1113,7 @@ mod _functiontrace_rs {
                     if let Some(result) = parser(&input) {
                         return Ok(result);
                     }
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                         // We need to check with the Python interpreter during loops, otherwise we
                         // might not receive ctrl-c events.
                         py.check_signals()
@@ -1496,7 +1495,7 @@ mod hooks {
     /// function, then attaching enough information about the original function to call it.
     pub fn install() -> Result<()> {
         for hook in HOOKS.iter() {
-            Python::with_gil(|py| -> Result<()> {
+            Python::attach(|py| -> Result<()> {
                 let (module_name, method_name) = hook
                     .target
                     .rsplit_once(".")
@@ -1638,14 +1637,14 @@ mod hooks {
             .get()
             .expect("Wrapper functions can't be called until hooked");
 
-        let proxied = Python::with_gil(|py| -> Result<()> {
+        let proxied = Python::attach(|py| -> Result<()> {
             if let Some(mut writer) = crate::_functiontrace_rs::thread_state() {
                 let args = unsafe {
                     // SAFETY: `args` represents a valid argument tuple
                     Bound::from_borrowed_ptr(py, args)
                 };
                 let args = args
-                    .downcast()
+                    .cast()
                     .map_err(Into::<PyErr>::into)
                     .wrap_err("Python args must be a tuple")?;
 
@@ -1722,7 +1721,7 @@ mod hooks {
                 // `import` takes rather complicated arguments, but in practice we only care about
                 // the first argument (name)
                 let module = if let Ok(arg) = args.get_item(0) {
-                    arg.downcast()
+                    arg.cast()
                         .map_err(Into::into)
                         .and_then(|module| module.to_str())
                         .map(|module| Cow::Owned(module.to_string()))