maturin 1.7.7__tar.gz → 1.7.8__tar.gz

{maturin-1.7.7 → maturin-1.7.8}/.pre-commit-config.yaml

@@ -56,7 +56,7 @@ repos:
           )
       - id: mixed-line-ending
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.0
+    rev: v0.8.1
     hooks:
       - id: ruff-format
       - id: ruff

{maturin-1.7.7 → maturin-1.7.8}/Cargo.lock

@@ -1253,7 +1253,7 @@ dependencies = [
 
 [[package]]
 name = "maturin"
-version = "1.7.7"
+version = "1.7.8"
 dependencies = [
  "anyhow",
  "base64 0.21.7",

{maturin-1.7.7 → maturin-1.7.8}/Cargo.toml

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

{maturin-1.7.7 → maturin-1.7.8}/PKG-INFO

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

maturin-1.7.8/src/bridge.rs

@@ -0,0 +1,115 @@
+use std::fmt::{Display, Formatter};
+
+/// The name and version of the bindings crate
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Bindings {
+    /// The name of the bindings crate, `pyo3`, `rust-cpython` or `uniffi`
+    pub name: String,
+    /// bindings crate version
+    pub version: semver::Version,
+}
+
+impl Bindings {
+    /// Returns the minimum python minor version supported
+    pub fn minimal_python_minor_version(&self) -> usize {
+        use crate::python_interpreter::MINIMUM_PYTHON_MINOR;
+
+        match self.name.as_str() {
+            "pyo3" | "pyo3-ffi" => {
+                let major_version = self.version.major;
+                let minor_version = self.version.minor;
+                // N.B. must check large minor versions first
+                if (major_version, minor_version) >= (0, 16) {
+                    7
+                } else {
+                    MINIMUM_PYTHON_MINOR
+                }
+            }
+            _ => MINIMUM_PYTHON_MINOR,
+        }
+    }
+
+    /// Returns the minimum PyPy minor version supported
+    pub fn minimal_pypy_minor_version(&self) -> usize {
+        use crate::python_interpreter::MINIMUM_PYPY_MINOR;
+
+        match self.name.as_str() {
+            "pyo3" | "pyo3-ffi" => {
+                let major_version = self.version.major;
+                let minor_version = self.version.minor;
+                // N.B. must check large minor versions first
+                if (major_version, minor_version) >= (0, 23) {
+                    9
+                } else if (major_version, minor_version) >= (0, 14) {
+                    7
+                } else {
+                    MINIMUM_PYPY_MINOR
+                }
+            }
+            _ => MINIMUM_PYPY_MINOR,
+        }
+    }
+}
+
+/// The way the rust code is used in the wheel
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum BridgeModel {
+    /// A rust binary to be shipped a python package
+    Bin(Option<Bindings>),
+    /// A native module with pyo3 or rust-cpython bindings.
+    Bindings(Bindings),
+    /// `Bindings`, but specifically for pyo3 with feature flags that allow building a single wheel
+    /// for all cpython versions (pypy & graalpy still need multiple versions).
+    /// The numbers are the minimum major and minor version
+    BindingsAbi3(u8, u8),
+    /// A native module with c bindings, i.e. `#[no_mangle] extern "C" <some item>`
+    Cffi,
+    /// A native module generated from uniffi
+    UniFfi,
+}
+
+impl BridgeModel {
+    /// Returns the bindings
+    pub fn bindings(&self) -> Option<&Bindings> {
+        match self {
+            BridgeModel::Bin(Some(bindings)) => Some(bindings),
+            BridgeModel::Bindings(bindings) => Some(bindings),
+            _ => None,
+        }
+    }
+
+    /// Returns the name of the bindings crate
+    pub fn unwrap_bindings_name(&self) -> &str {
+        match self {
+            BridgeModel::Bindings(bindings) => &bindings.name,
+            _ => panic!("Expected Bindings"),
+        }
+    }
+
+    /// Test whether this is using a specific bindings crate
+    pub fn is_bindings(&self, name: &str) -> bool {
+        match self {
+            BridgeModel::Bin(Some(bindings)) => bindings.name == name,
+            BridgeModel::Bindings(bindings) => bindings.name == name,
+            _ => false,
+        }
+    }
+
+    /// Test whether this is bin bindings
+    pub fn is_bin(&self) -> bool {
+        matches!(self, BridgeModel::Bin(_))
+    }
+}
+
+impl Display for BridgeModel {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BridgeModel::Bin(Some(bindings)) => write!(f, "{} bin", bindings.name),
+            BridgeModel::Bin(None) => write!(f, "bin"),
+            BridgeModel::Bindings(bindings) => write!(f, "{}", bindings.name),
+            BridgeModel::BindingsAbi3(..) => write!(f, "pyo3"),
+            BridgeModel::Cffi => write!(f, "cffi"),
+            BridgeModel::UniFfi => write!(f, "uniffi"),
+        }
+    }
+}

{maturin-1.7.7 → maturin-1.7.8}/src/build_context.rs

@@ -10,8 +10,8 @@ use crate::project_layout::ProjectLayout;
 use crate::source_distribution::source_distribution;
 use crate::target::{Arch, Os};
 use crate::{
-    compile, pyproject_toml::Format, BuildArtifact, Metadata23, ModuleWriter, PyProjectToml,
-    PythonInterpreter, Target,
+    compile, pyproject_toml::Format, BridgeModel, BuildArtifact, Metadata23, ModuleWriter,
+    PyProjectToml, PythonInterpreter, Target,
 };
 use anyhow::{anyhow, bail, Context, Result};
 use cargo_metadata::CrateType;
@@ -26,126 +26,11 @@ use platform_info::*;
 use sha2::{Digest, Sha256};
 use std::collections::{BTreeMap, HashSet};
 use std::env;
-use std::fmt::{Display, Formatter};
 use std::io;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use tracing::instrument;
 
-/// The name and version of the bindings crate
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Bindings {
-    /// The name of the bindings crate, `pyo3`, `rust-cpython` or `uniffi`
-    pub name: String,
-    /// bindings crate version
-    pub version: semver::Version,
-}
-
-impl Bindings {
-    /// Returns the minimum python minor version supported
-    pub fn minimal_python_minor_version(&self) -> usize {
-        use crate::python_interpreter::MINIMUM_PYTHON_MINOR;
-
-        match self.name.as_str() {
-            "pyo3" | "pyo3-ffi" => {
-                let major_version = self.version.major;
-                let minor_version = self.version.minor;
-                // N.B. must check large minor versions first
-                if (major_version, minor_version) >= (0, 16) {
-                    7
-                } else {
-                    MINIMUM_PYTHON_MINOR
-                }
-            }
-            _ => MINIMUM_PYTHON_MINOR,
-        }
-    }
-
-    /// Returns the minimum PyPy minor version supported
-    pub fn minimal_pypy_minor_version(&self) -> usize {
-        use crate::python_interpreter::MINIMUM_PYPY_MINOR;
-
-        match self.name.as_str() {
-            "pyo3" | "pyo3-ffi" => {
-                let major_version = self.version.major;
-                let minor_version = self.version.minor;
-                // N.B. must check large minor versions first
-                if (major_version, minor_version) >= (0, 23) {
-                    9
-                } else if (major_version, minor_version) >= (0, 14) {
-                    7
-                } else {
-                    MINIMUM_PYPY_MINOR
-                }
-            }
-            _ => MINIMUM_PYPY_MINOR,
-        }
-    }
-}
-
-/// The way the rust code is used in the wheel
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum BridgeModel {
-    /// A rust binary to be shipped a python package
-    Bin(Option<Bindings>),
-    /// A native module with pyo3 or rust-cpython bindings.
-    Bindings(Bindings),
-    /// `Bindings`, but specifically for pyo3 with feature flags that allow building a single wheel
-    /// for all cpython versions (pypy & graalpy still need multiple versions).
-    /// The numbers are the minimum major and minor version
-    BindingsAbi3(u8, u8),
-    /// A native module with c bindings, i.e. `#[no_mangle] extern "C" <some item>`
-    Cffi,
-    /// A native module generated from uniffi
-    UniFfi,
-}
-
-impl BridgeModel {
-    /// Returns the bindings
-    pub fn bindings(&self) -> Option<&Bindings> {
-        match self {
-            BridgeModel::Bin(Some(bindings)) => Some(bindings),
-            BridgeModel::Bindings(bindings) => Some(bindings),
-            _ => None,
-        }
-    }
-
-    /// Returns the name of the bindings crate
-    pub fn unwrap_bindings_name(&self) -> &str {
-        match self {
-            BridgeModel::Bindings(bindings) => &bindings.name,
-            _ => panic!("Expected Bindings"),
-        }
-    }
-
-    /// Test whether this is using a specific bindings crate
-    pub fn is_bindings(&self, name: &str) -> bool {
-        match self {
-            BridgeModel::Bin(Some(bindings)) => bindings.name == name,
-            BridgeModel::Bindings(bindings) => bindings.name == name,
-            _ => false,
-        }
-    }
-
-    /// Test whether this is bin bindings
-    pub fn is_bin(&self) -> bool {
-        matches!(self, BridgeModel::Bin(_))
-    }
-}
-
-impl Display for BridgeModel {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            BridgeModel::Bin(Some(bindings)) => write!(f, "{} bin", bindings.name),
-            BridgeModel::Bin(None) => write!(f, "bin"),
-            BridgeModel::Bindings(bindings) => write!(f, "{}", bindings.name),
-            BridgeModel::BindingsAbi3(..) => write!(f, "pyo3"),
-            BridgeModel::Cffi => write!(f, "cffi"),
-            BridgeModel::UniFfi => write!(f, "uniffi"),
-        }
-    }
-}
-
 /// Insert wasm launcher scripts as entrypoints and the wasmtime dependency
 fn bin_wasi_helper(
     artifacts_and_files: &[(&BuildArtifact, String)],

{maturin-1.7.7 → maturin-1.7.8}/src/build_options.rs

@@ -1,11 +1,10 @@
 use crate::auditwheel::{AuditWheelMode, PlatformTag};
-use crate::build_context::BridgeModel;
 use crate::compile::{CompileTarget, LIB_CRATE_TYPES};
 use crate::cross_compile::{find_sysconfigdata, parse_sysconfigdata};
 use crate::project_layout::ProjectResolver;
 use crate::pyproject_toml::ToolMaturin;
 use crate::python_interpreter::{InterpreterConfig, InterpreterKind};
-use crate::{Bindings, BuildContext, PythonInterpreter, Target};
+use crate::{Bindings, BridgeModel, BuildContext, PythonInterpreter, Target};
 use anyhow::{bail, format_err, Context, Result};
 use cargo_metadata::{CrateType, TargetKind};
 use cargo_metadata::{Metadata, Node};

{maturin-1.7.7 → maturin-1.7.8}/src/compile.rs

@@ -1,8 +1,7 @@
-use crate::build_context::BridgeModel;
 use crate::target::RUST_1_64_0;
 #[cfg(feature = "zig")]
 use crate::PlatformTag;
-use crate::{BuildContext, PythonInterpreter, Target};
+use crate::{BridgeModel, BuildContext, PythonInterpreter, Target};
 use anyhow::{anyhow, bail, Context, Result};
 use cargo_metadata::CrateType;
 use fat_macho::FatWriter;
@@ -287,24 +286,40 @@ fn cargo_build_command(
             .extend(["-C".to_string(), "strip=symbols".to_string()]);
     }
 
-    let mut build_command = if target.is_msvc()
-        && (target.cross_compiling() || env::var("MATURIN_USE_XWIN").ok().as_deref() == Some("1"))
-    {
+    let mut build_command = if target.is_msvc() && target.cross_compiling() {
         #[cfg(feature = "xwin")]
         {
-            println!("🛠️ Using xwin for cross-compiling to {target_triple}");
-            let xwin_options = {
-                use clap::Parser;
-
-                // This will populate the default values for the options
-                // and then override them with cargo-xwin environment variables.
-                cargo_xwin::XWinOptions::parse_from(Vec::<&str>::new())
-            };
+            // Don't use xwin if the Windows MSVC compiler can compile to the target
+            let native_compile = cc::Build::new()
+                .opt_level(0)
+                .host(target.host_triple())
+                .target(target_triple)
+                .cargo_metadata(false)
+                .cargo_warnings(false)
+                .cargo_output(false)
+                .try_get_compiler()
+                .is_ok();
+            let force_xwin = env::var("MATURIN_USE_XWIN").ok().as_deref() == Some("1");
+            if !native_compile || force_xwin {
+                println!("🛠️ Using xwin for cross-compiling to {target_triple}");
+                let xwin_options = {
+                    use clap::Parser;
+
+                    // This will populate the default values for the options
+                    // and then override them with cargo-xwin environment variables.
+                    cargo_xwin::XWinOptions::parse_from(Vec::<&str>::new())
+                };
 
-            let mut build = cargo_xwin::Rustc::from(cargo_rustc);
-            build.target = vec![target_triple.to_string()];
-            build.xwin = xwin_options;
-            build.build_command()?
+                let mut build = cargo_xwin::Rustc::from(cargo_rustc);
+                build.target = vec![target_triple.to_string()];
+                build.xwin = xwin_options;
+                build.build_command()?
+            } else {
+                if target.user_specified {
+                    cargo_rustc.target = vec![target_triple.to_string()];
+                }
+                cargo_rustc.command()
+            }
         }
         #[cfg(not(feature = "xwin"))]
         {

{maturin-1.7.7 → maturin-1.7.8}/src/cross_compile.rs

@@ -27,21 +27,6 @@ pub fn is_cross_compiling(target: &Target) -> Result<bool> {
         // Not cross-compiling to compile for 32-bit Python from windows 64-bit
         return Ok(false);
     }
-    if (target_triple == "aarch64-pc-windows-msvc" && host == "x86_64-pc-windows-msvc")
-        || (target_triple == "x86_64-pc-windows-msvc" && host == "aarch64-pc-windows-msvc")
-    {
-        // Not cross-compiling if the Windows MSVC compiler can compile to the target
-        let native_compile = cc::Build::new()
-            .opt_level(0)
-            .host(host)
-            .target(target_triple)
-            .cargo_metadata(false)
-            .cargo_warnings(false)
-            .cargo_output(false)
-            .try_get_compiler()
-            .is_ok();
-        return Ok(!native_compile);
-    }
     if target_triple.ends_with("windows-gnu") && host.ends_with("windows-msvc") {
         // Not cross-compiling to compile for Windows GNU from Windows MSVC host
         return Ok(false);

{maturin-1.7.7 → maturin-1.7.8}/src/lib.rs

@@ -23,7 +23,8 @@
 
 #![deny(missing_docs)]
 
-pub use crate::build_context::{Bindings, BridgeModel, BuildContext, BuiltWheelMetadata};
+pub use crate::bridge::{Bindings, BridgeModel};
+pub use crate::build_context::{BuildContext, BuiltWheelMetadata};
 pub use crate::build_options::{BuildOptions, CargoOptions};
 pub use crate::cargo_toml::CargoToml;
 pub use crate::compile::{compile, BuildArtifact};
@@ -44,6 +45,7 @@ pub use crate::upload::{upload, upload_ui, PublishOpt, Registry, UploadError};
 pub use auditwheel::PlatformTag;
 
 mod auditwheel;
+mod bridge;
 mod build_context;
 mod build_options;
 mod cargo_toml;

{maturin-1.7.7 → maturin-1.7.8}/src/project_layout.rs

@@ -144,7 +144,16 @@ impl ProjectResolver {
             .unwrap_or_default()
             .to_vec();
         let py_root = match pyproject.and_then(|x| x.python_source()) {
-            Some(py_src) => project_root.join(py_src).normalize()?.into_path_buf(),
+            Some(py_src) => project_root
+                .join(py_src)
+                .normalize()
+                .with_context(|| {
+                    format!(
+                        "Failed to normalize python source path `{}`",
+                        py_src.display()
+                    )
+                })?
+                .into_path_buf(),
             None => match pyproject.and_then(|x| x.project_name()) {
                 Some(project_name) => {
                     // Detect src layout