maturin 1.9.5__tar.gz → 1.9.6__tar.gz

{maturin-1.9.5 → maturin-1.9.6}/.pre-commit-config.yaml

@@ -56,12 +56,12 @@ repos:
           )
       - id: mixed-line-ending
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.13.0
+    rev: v0.13.3
     hooks:
       - id: ruff-format
       - id: ruff
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.18.1
+    rev: v1.18.2
     hooks:
       - id: mypy
         entry: mypy maturin/

{maturin-1.9.5 → maturin-1.9.6}/Cargo.lock

@@ -1455,7 +1455,7 @@ dependencies = [
 
 [[package]]
 name = "maturin"
-version = "1.9.5"
+version = "1.9.6"
 dependencies = [
  "anyhow",
  "base64 0.21.7",

{maturin-1.9.5 → maturin-1.9.6}/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 authors = ["konstin <konstin@mailbox.org>", "messense <messense@icloud.com>"]
 name = "maturin"
-version = "1.9.5"
+version = "1.9.6"
 description = "Build and publish crates with pyo3, cffi and uniffi bindings as well as rust binaries as python packages"
 exclude = [
     "test-crates/**/*",

{maturin-1.9.5 → maturin-1.9.6}/Changelog.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [1.9.6]
+
+* Fix regressions to interpreter platform detection on Windows from 1.9.5
+* Further fixes to interpreter detection for Windows ARM64
+
 ## [1.9.5]
 
 * Add builtin sysconfig for FreeBSD 14.2 amd64
@@ -1104,7 +1109,8 @@ points-0.1.0-py2.py3-none-manylinux1_x86_64.whl | 2,8M | 752K | 85K
 
  * Initial Release
 
-[Unreleased]: https://github.com/pyo3/maturin/compare/v1.9.5...HEAD
+[Unreleased]: https://github.com/pyo3/maturin/compare/v1.9.6...HEAD
+[1.9.6]: https://github.com/pyo3/maturin/compare/v1.9.5...v1.9.6
 [1.9.5]: https://github.com/pyo3/maturin/compare/v1.9.4...v1.9.5
 [1.9.4]: https://github.com/pyo3/maturin/compare/v1.9.3...v1.9.4
 [1.9.3]: https://github.com/pyo3/maturin/compare/v1.9.2...v1.9.3

{maturin-1.9.5 → maturin-1.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maturin
-Version: 1.9.5
+Version: 1.9.6
 Classifier: Topic :: Software Development :: Build Tools
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython

{maturin-1.9.5 → maturin-1.9.6}/src/build_options.rs

@@ -374,8 +374,13 @@ impl BuildOptions {
                                 }
                             }
                         } else {
-                            interpreters =
-                                find_interpreter(bridge, interpreter, target, requires_python)?;
+                            interpreters = find_interpreter(
+                                bridge,
+                                interpreter,
+                                target,
+                                requires_python,
+                                generate_import_lib,
+                            )?;
                         }
 
                         let interpreters_str = interpreters
@@ -1288,6 +1293,7 @@ fn find_interpreter(
     interpreter: &[PathBuf],
     target: &Target,
     requires_python: Option<&VersionSpecifiers>,
+    generate_import_lib: bool,
 ) -> Result<Vec<PythonInterpreter>> {
     let mut found_interpreters = Vec::new();
     if !interpreter.is_empty() {
@@ -1301,6 +1307,16 @@ fn find_interpreter(
         if !missing.is_empty() {
             let sysconfig_interps =
                 find_interpreter_in_sysconfig(bridge, &missing, target, requires_python)?;
+
+            // Can only use sysconfig-derived interpreter on windows if generating the import lib
+            if !sysconfig_interps.is_empty() && target.is_windows() && !generate_import_lib {
+                let found = sysconfig_interps
+                    .iter()
+                    .map(|i| format!("{} {}.{}", i.interpreter_kind, i.major, i.minor))
+                    .collect::<Vec<_>>();
+                bail!("Interpreters {found:?} were found in maturin's bundled sysconfig, but compiling for Windows without an interpreter requires PyO3's `generate-import-lib` feature");
+            }
+
             found_interpreters.extend(sysconfig_interps);
         }
     } else {

{maturin-1.9.5 → maturin-1.9.6}/src/python_interpreter/mod.rs

@@ -26,55 +26,6 @@ pub const MINIMUM_PYPY_MINOR: usize = 8;
 pub const MAXIMUM_PYTHON_MINOR: usize = 13;
 pub const MAXIMUM_PYPY_MINOR: usize = 11;
 
-/// Identifies conditions where we do not want to build wheels
-fn windows_interpreter_no_build(
-    major: usize,
-    minor: usize,
-    target: &Target,
-    platform: String,
-    min_python_minor: usize,
-    requires_python: Option<&VersionSpecifiers>,
-) -> bool {
-    // Only python 3 with supported major versions
-    if major != 3 || minor < min_python_minor {
-        return true;
-    }
-
-    // From requires-python in pyproject.toml
-    if let Some(requires_python) = requires_python {
-        if !requires_python.contains(&Version::new([major as u64, minor as u64])) {
-            return true;
-        }
-    }
-
-    let python_arch = match platform.as_str() {
-        "win32" => Arch::X86,
-        "win-amd64" => Arch::X86_64,
-        "win-arm64" => Arch::Aarch64,
-        _ => {
-            eprintln!("⚠️  Warning: {major}.{minor} reports unknown platform '{platform}'. This may fail to build.");
-            // false => build it anyway
-            return false;
-        }
-    };
-
-    let target_arch = target.target_arch();
-
-    if python_arch != target.target_arch() {
-        eprintln!(
-            "👽 {major}.{minor} reports a platform '{platform}' (architecture '{python_arch}'), while the Rust target is '{target_arch}'. Skipping."
-        );
-        return true;
-    }
-    false
-}
-
-struct WindowsPythonInfo {
-    major: usize,
-    minor: usize,
-    platform: String, // e.g. win32, win-amd64, win-arm64
-}
-
 /// On windows regular Python installs are supported along with environments
 /// being managed by `conda`.
 ///
@@ -116,12 +67,32 @@ fn find_all_windows(
     target: &Target,
     bridge: &BridgeModel,
     requires_python: Option<&VersionSpecifiers>,
-) -> Result<Vec<String>> {
+) -> Result<Vec<PythonInterpreter>> {
     let min_python_minor = bridge.minimal_python_minor_version();
-    let code = "import sys; print(sys.executable or '')";
     let mut interpreter = vec![];
     let mut versions_found = HashSet::new();
 
+    macro_rules! maybe_add_interp {
+        ($executable:expr) => {
+            PythonInterpreter::check_executable($executable, target, bridge).map(|interp| {
+                if let Some(interp) = interp {
+                    let major = interp.major;
+                    let minor = interp.minor;
+                    if major == 3
+                        && minor >= min_python_minor
+                        && !versions_found.contains(&(major, minor))
+                        && requires_python.map_or(true, |requires_python| {
+                            requires_python.contains(&Version::new([major as u64, minor as u64]))
+                        })
+                    {
+                        interpreter.push(interp);
+                        versions_found.insert((major, minor));
+                    }
+                }
+            })
+        };
+    }
+
     // If Python is installed from Python.org it should include the "python launcher"
     // which is used to find the installed interpreters
     let execution = Command::new("cmd")
@@ -156,38 +127,7 @@ fn find_all_windows(
                     if !executable_path.exists() {
                         continue;
                     }
-                    if let Some(python_info) = windows_python_info(executable_path)? {
-                        if windows_interpreter_no_build(
-                            major,
-                            minor,
-                            target,
-                            python_info.platform,
-                            min_python_minor,
-                            requires_python,
-                        ) {
-                            continue;
-                        }
-
-                        let output = Command::new(executable).args(["-c", code]).output();
-                        let output = match output {
-                            Ok(output) => output,
-                            Err(err) => {
-                                eprintln!(
-                                    "⚠️  Warning: failed to determine the path to python for `{executable}`: {err}"
-                                );
-                                continue;
-                            }
-                        };
-                        let path = str::from_utf8(&output.stdout).unwrap().trim();
-                        if !output.status.success() || path.trim().is_empty() {
-                            eprintln!(
-                                "⚠️  Warning: couldn't determine the path to python for `{executable}`"
-                            );
-                            continue;
-                        }
-                        interpreter.push(path.to_string());
-                        versions_found.insert((major, minor));
-                    }
+                    maybe_add_interp!(executable_path)?;
                 }
             }
         }
@@ -218,20 +158,7 @@ fn find_all_windows(
             } else {
                 Path::new(&path).join("python")
             };
-            if let Some(python_info) = windows_python_info(&executable)? {
-                if windows_interpreter_no_build(
-                    python_info.major,
-                    python_info.minor,
-                    target,
-                    python_info.platform,
-                    min_python_minor,
-                    requires_python,
-                ) {
-                    continue;
-                }
-                interpreter.push(String::from(executable.to_str().unwrap()));
-                versions_found.insert((python_info.major, python_info.minor));
-            }
+            maybe_add_interp!(executable.as_path())?;
         }
     }
 
@@ -239,20 +166,7 @@ fn find_all_windows(
     for minor in min_python_minor..=bridge.maximum_python_minor_version() {
         if !versions_found.contains(&(3, minor)) {
             let executable = format!("python3.{minor}.exe");
-            if let Some(python_info) = windows_python_info(Path::new(&executable))? {
-                if windows_interpreter_no_build(
-                    python_info.major,
-                    python_info.minor,
-                    target,
-                    python_info.platform,
-                    min_python_minor,
-                    requires_python,
-                ) {
-                    continue;
-                }
-                interpreter.push(executable);
-                versions_found.insert((3, minor));
-            }
+            maybe_add_interp!(Path::new(&executable))?;
         }
     }
 
@@ -264,49 +178,6 @@ fn find_all_windows(
     Ok(interpreter)
 }
 
-fn windows_python_info(executable: &Path) -> Result<Option<WindowsPythonInfo>> {
-    let python_info = Command::new(executable)
-        .arg("-c")
-        .arg("import sys, sysconfig; print(sys.version_info.major, sys.version_info.minor, sysconfig.get_platform())")
-        .output();
-
-    let python_info = match python_info {
-        Ok(python_info) => python_info,
-        Err(err) => {
-            if err.kind() == io::ErrorKind::NotFound {
-                // python executable not found
-                return Ok(None);
-            } else {
-                bail!(
-                    "Error getting Python version info from {}",
-                    executable.display()
-                );
-            }
-        }
-    };
-
-    let version_info = str::from_utf8(&python_info.stdout).unwrap();
-
-    // Split into 3 segments: major, minor, platform by spaces
-    let segments: Vec<&str> = version_info.splitn(3, ' ').collect();
-    let [major, minor, platform] = segments.as_slice() else {
-        bail!(
-            "Unexpected output for Python version info from {}: '{}'",
-            executable.display(),
-            version_info
-        );
-    };
-    // can then parse each substring
-    let major = major.parse::<usize>().ok().unwrap_or(0);
-    let minor = minor.parse::<usize>().ok().unwrap_or(0);
-
-    Ok(Some(WindowsPythonInfo {
-        major,
-        minor,
-        platform: platform.to_string(),
-    }))
-}
-
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Deserialize, clap::ValueEnum)]
 #[serde(rename_all = "lowercase")]
 #[clap(rename_all = "lower")]
@@ -644,9 +515,15 @@ impl PythonInterpreter {
                             let mut metadata_py = tempfile::NamedTempFile::new()?;
                             write!(metadata_py, "{GET_INTERPRETER_METADATA}")?;
                             let mut cmd = Command::new("cmd");
+                            let suffix = match target.target_arch() {
+                                Arch::X86 => "-32",
+                                Arch::X86_64 => "-64",
+                                Arch::Aarch64 => "-arm64",
+                                _ => "",
+                            };
                             cmd.arg("/c")
                                 .arg("py")
-                                .arg(format!("-{}-{}", ver, target.pointer_width()))
+                                .arg(format!("-{ver}{suffix}"))
                                 .arg(metadata_py.path())
                                 .env("PYTHONNOUSERSITE", "1");
                             let output = cmd.output();
@@ -669,6 +546,18 @@ impl PythonInterpreter {
             .context(err_msg)
             .context(String::from_utf8_lossy(&output.stdout).trim().to_string())?;
 
+        Self::from_metadata_message(executable, target, bridge, message)
+    }
+
+    /// Configure a `PythonInterpreter` from the metadata message.
+    ///
+    /// Returns `None` if the interpreter is not suitable to use (e.g. too old or wrong architecture)
+    fn from_metadata_message(
+        executable: impl AsRef<Path>,
+        target: &Target,
+        bridge: &BridgeModel,
+        message: InterpreterMetadataMessage,
+    ) -> Result<Option<PythonInterpreter>> {
         if (message.major == 2 && message.minor != 7) || (message.major == 3 && message.minor < 5) {
             debug!(
                 "Skipping outdated python interpreter '{}'",
@@ -691,6 +580,41 @@ impl PythonInterpreter {
             executable.as_ref().display()
         ))?;
 
+        let executable = message
+            .executable
+            .map(PathBuf::from)
+            .unwrap_or_else(|| executable.as_ref().to_path_buf());
+
+        if target.is_windows() {
+            'windows_arch_check: {
+                // on windows we must check the architecture, because three different architectures
+                // can all run on the same hardware
+                let python_arch = match message.platform.as_str().trim() {
+                    "win32" => Arch::X86,
+                    "win-amd64" => Arch::X86_64,
+                    "win-arm64" => Arch::Aarch64,
+                    _ => {
+                        eprintln!(
+                            "⚠️  Warning: '{}' reports unknown platform. This may fail to build.",
+                            executable.display()
+                        );
+                        break 'windows_arch_check;
+                    }
+                };
+
+                if python_arch != target.target_arch() {
+                    eprintln!(
+                        "👽 '{}' reports a platform '{platform}' (architecture '{python_arch}'), while the Rust target is '{target_arch}'. Skipping.",
+                        executable.display(),
+                        platform = message.platform,
+                        python_arch = python_arch,
+                        target_arch = target.target_arch(),
+                    );
+                    return Ok(None);
+                }
+            }
+        }
+
         let platform = if message.platform.starts_with("macosx") {
             // We don't use platform from sysconfig on macOS
             None
@@ -698,10 +622,6 @@ impl PythonInterpreter {
             Some(message.platform.to_lowercase().replace(['-', '.'], "_"))
         };
 
-        let executable = message
-            .executable
-            .map(PathBuf::from)
-            .unwrap_or_else(|| executable.as_ref().to_path_buf());
         debug!(
             "Found {} interpreter at {}",
             interpreter,
@@ -807,37 +727,38 @@ impl PythonInterpreter {
         bridge: &BridgeModel,
         requires_python: Option<&VersionSpecifiers>,
     ) -> Result<Vec<PythonInterpreter>> {
-        let executables = if target.is_windows() {
+        if target.is_windows() {
             // TOFIX: add PyPy support to Windows
-            find_all_windows(target, bridge, requires_python)?
-        } else {
-            let mut executables: Vec<String> = (bridge.minimal_python_minor_version()
-                ..=bridge.maximum_python_minor_version())
-                .filter(|minor| {
-                    requires_python
-                        .map(|requires_python| {
-                            requires_python.contains(&Version::new([3, *minor as u64]))
-                        })
-                        .unwrap_or(true)
-                })
-                .map(|minor| format!("python3.{minor}"))
-                .collect();
-            // Also try to find PyPy for cffi and pyo3 bindings
-            if *bridge == BridgeModel::Cffi || bridge.is_pyo3() {
-                executables.extend(
-                    (bridge.minimal_pypy_minor_version()..=bridge.maximum_pypy_minor_version())
-                        .filter(|minor| {
-                            requires_python
-                                .map(|requires_python| {
-                                    requires_python.contains(&Version::new([3, *minor as u64]))
-                                })
-                                .unwrap_or(true)
-                        })
-                        .map(|minor| format!("pypy3.{minor}")),
-                );
-            }
-            executables
+            return find_all_windows(target, bridge, requires_python);
         };
+
+        let mut executables: Vec<String> = (bridge.minimal_python_minor_version()
+            ..=bridge.maximum_python_minor_version())
+            .filter(|minor| {
+                requires_python
+                    .map(|requires_python| {
+                        requires_python.contains(&Version::new([3, *minor as u64]))
+                    })
+                    .unwrap_or(true)
+            })
+            .map(|minor| format!("python3.{minor}"))
+            .collect();
+
+        // Also try to find PyPy for cffi and pyo3 bindings
+        if *bridge == BridgeModel::Cffi || bridge.is_pyo3() {
+            executables.extend(
+                (bridge.minimal_pypy_minor_version()..=bridge.maximum_pypy_minor_version())
+                    .filter(|minor| {
+                        requires_python
+                            .map(|requires_python| {
+                                requires_python.contains(&Version::new([3, *minor as u64]))
+                            })
+                            .unwrap_or(true)
+                    })
+                    .map(|minor| format!("pypy3.{minor}")),
+            );
+        }
+
         let mut available_versions = Vec::new();
         for executable in executables {
             if let Some(version) = PythonInterpreter::check_executable(executable, target, bridge)?
@@ -1195,135 +1116,140 @@ mod tests {
     }
 
     #[test]
-    fn test_windows_interpreter_no_build() {
-        use pep440_rs::VersionSpecifiers;
-        use std::str::FromStr;
-
+    fn test_interpreter_from_metadata_windows() {
         // Test cases for different scenarios
         let target_x64 = Target::from_resolved_target_triple("x86_64-pc-windows-msvc").unwrap();
         let target_x86 = Target::from_resolved_target_triple("i686-pc-windows-msvc").unwrap();
         let target_arm64 = Target::from_resolved_target_triple("aarch64-pc-windows-msvc").unwrap();
 
+        let bridge = BridgeModel::PyO3(PyO3 {
+            crate_name: PyO3Crate::PyO3,
+            version: semver::Version::new(0, 26, 0),
+            abi3: None,
+            metadata: None,
+        });
+
+        let message = |major, minor, platform: &str| InterpreterMetadataMessage {
+            major,
+            minor,
+            interpreter: "cpython".to_string(),
+            implementation_name: "CPython".to_string(),
+            abiflags: None,
+            ext_suffix: Some(".pyd".to_string()),
+            platform: platform.to_string(),
+            executable: None,
+            soabi: None,
+            gil_disabled: false,
+            system: "windows".to_string(),
+        };
+
         // Test Python 2.x should be rejected
-        assert!(windows_interpreter_no_build(
-            2,
-            7,
-            &target_x64,
-            "win-amd64".to_string(),
-            7,
-            None
-        ));
+        assert_eq!(
+            PythonInterpreter::from_metadata_message(
+                "python2.7",
+                &target_x64,
+                &bridge,
+                message(2, 7, "win-amd64"),
+            )
+            .unwrap_err()
+            .to_string(),
+            "Failed to get information from the python interpreter at python2.7"
+        );
 
         // Test Python 3.x but below minimum version
-        assert!(windows_interpreter_no_build(
-            3,
-            6,
-            &target_x64,
-            "win-amd64".to_string(),
-            7,
-            None
-        ));
+        assert_eq!(
+            PythonInterpreter::from_metadata_message(
+                "python3.6",
+                &target_x64,
+                &bridge,
+                message(3, 6, "win-amd64"),
+            )
+            .unwrap_err()
+            .to_string(),
+            "Failed to get information from the python interpreter at python3.6"
+        );
 
         // Test valid Python version with matching platform and architecture
-        assert!(!windows_interpreter_no_build(
-            3,
-            10,
-            &target_x64,
-            "win-amd64".to_string(),
-            7,
-            None
-        ));
-
-        // Test 32-bit Python on 64-bit target (should be rejected)
-        assert!(windows_interpreter_no_build(
-            3,
-            10,
-            &target_x64,
-            "win32".to_string(),
-            7,
-            None
-        ));
-
-        // Test 32-bit Python on 32-bit target (should be accepted)
-        assert!(!windows_interpreter_no_build(
-            3,
-            10,
-            &target_x86,
-            "win32".to_string(),
-            7,
-            None
-        ));
+        for (target, platform) in &[
+            (&target_x86, "win32"),
+            (&target_x64, "win-amd64"),
+            (&target_arm64, "win-arm64"),
+        ] {
+            assert_eq!(
+                PythonInterpreter::from_metadata_message(
+                    "python3.10",
+                    target,
+                    &bridge,
+                    message(3, 10, platform),
+                )
+                .unwrap()
+                .unwrap(),
+                PythonInterpreter {
+                    config: InterpreterConfig {
+                        major: 3,
+                        minor: 10,
+                        interpreter_kind: InterpreterKind::CPython,
+                        abiflags: "".to_string(),
+                        ext_suffix: ".pyd".to_string(),
+                        pointer_width: None,
+                        gil_disabled: false,
+                    },
+                    executable: PathBuf::from("python3.10"),
+                    platform: Some(platform.replace("-", "_")),
+                    runnable: true,
+                    implementation_name: "CPython".to_string(),
+                    soabi: None,
+                }
+            );
+        }
 
         // Test mismatched architectures
-        assert!(windows_interpreter_no_build(
-            3,
-            10,
-            &target_x64,
-            "win-arm64".to_string(),
-            7,
-            None
-        ));
-
-        assert!(windows_interpreter_no_build(
-            3,
-            10,
-            &target_arm64,
-            "win-amd64".to_string(),
-            7,
-            None
-        ));
-
-        // Test correct architecture matches
-        assert!(!windows_interpreter_no_build(
-            3,
-            10,
-            &target_arm64,
-            "win-arm64".to_string(),
-            7,
-            None
-        ));
-
-        // Test requires-python constraints
-        let requires_python = VersionSpecifiers::from_str(">=3.8,<3.12").unwrap();
-
-        // Should reject Python 3.7 due to requires-python
-        assert!(windows_interpreter_no_build(
-            3,
-            7,
-            &target_x64,
-            "win-amd64".to_string(),
-            7,
-            Some(&requires_python)
-        ));
-
-        // Should accept Python 3.10 within requires-python range
-        assert!(!windows_interpreter_no_build(
-            3,
-            10,
-            &target_x64,
-            "win-amd64".to_string(),
-            7,
-            Some(&requires_python)
-        ));
-
-        // Should reject Python 3.12 due to requires-python upper bound
-        assert!(windows_interpreter_no_build(
-            3,
-            12,
-            &target_x64,
-            "win-amd64".to_string(),
-            7,
-            Some(&requires_python)
-        ));
-
-        // Test edge case with unknown platform (should not match any specific architecture)
-        assert!(!windows_interpreter_no_build(
-            3,
-            10,
-            &target_x64,
-            "unknown-platform".to_string(),
-            7,
-            None
-        ));
+        for (target, platform) in &[
+            (&target_x86, "win-amd64"),
+            (&target_x86, "win-arm64"),
+            (&target_x64, "win32"),
+            (&target_x64, "win-arm64"),
+            (&target_arm64, "win32"),
+            (&target_arm64, "win-amd64"),
+        ] {
+            assert_eq!(
+                PythonInterpreter::from_metadata_message(
+                    "python3.10",
+                    target,
+                    &bridge,
+                    message(3, 10, platform),
+                )
+                .unwrap(),
+                None
+            );
+        }
+
+        // Test edge case with unknown platform (should not match any specific architecture, build anyway)
+        assert_eq!(
+            PythonInterpreter::from_metadata_message(
+                "python3.10",
+                &target_x64,
+                &bridge,
+                message(3, 10, "unknown-platform"),
+            )
+            .unwrap()
+            .unwrap(),
+            PythonInterpreter {
+                config: InterpreterConfig {
+                    major: 3,
+                    minor: 10,
+                    interpreter_kind: InterpreterKind::CPython,
+                    abiflags: "".to_string(),
+                    ext_suffix: ".pyd".to_string(),
+                    pointer_width: None,
+                    gil_disabled: false,
+                },
+                executable: PathBuf::from("python3.10"),
+                platform: Some("unknown_platform".to_string()),
+                runnable: true,
+                implementation_name: "CPython".to_string(),
+                soabi: None,
+            }
+        );
     }
 }