pub fn build_bin_wheel(&self) -> Result<PathBuf> {
        let artifacts = compile(&self, None, &self.bridge)
            .context("Failed to build a native library through cargo")?;

        let artifact = artifacts
            .get("bin")
            .cloned()
            .ok_or_else(|| anyhow!("Cargo didn't build a binary"))?;

        #[cfg(feature = "auditwheel")]
        auditwheel_rs(&artifact, &self.target, &self.manylinux)
            .context(format!("Failed to ensure {} compliance", self.manylinux))?;

        let (tag, tags) = self
            .target
            .get_universal_tags(&self.manylinux, self.universal2);

        if !self.scripts.is_empty() {
            bail!("Defining entrypoints and working with a binary doesn't mix well");
        }

        let mut builder =
            WheelWriter::new(&tag, &self.out, &self.metadata21, &self.scripts, &tags)?;

        match self.project_layout {
            ProjectLayout::Mixed(ref python_module) => {
                write_python_part(&mut builder, python_module, &self.module_name)
                    .context("Failed to add the python module to the package")?;
            }
            ProjectLayout::PureRust => {}
        }

        // I wouldn't know of any case where this would be the wrong (and neither do
        // I know a better alternative)
        let bin_name = artifact
            .file_name()
            .expect("Couldn't get the filename from the binary produced by cargo");
        write_bin(&mut builder, &artifact, &self.metadata21, bin_name)?;

        let wheel_path = builder.finish()?;

        println!("📦 Built wheel to {}", wheel_path.display());

        Ok(wheel_path)
    }
/// Builds a wheel that contains a binary
///
/// Runs [auditwheel_rs()] if not deactivated
Builds a wheel that contains a binary
Runs [auditwheel_rs()] if not deactivated
Builds a wheel that contains a binary Runs [ auditwheel_rs () ] if not deactivated
pub fn build_bin_wheel(&self) -> Result<PathBuf> {
        let artifacts = compile(&self, None, &self.bridge)
            .context("Failed to build a native library through cargo")?;
        let artifact = artifacts
            .get("bin")
            .cloned()
            .ok_or_else(|| anyhow!("Cargo didn't build a binary"))?;
        #[cfg(feature = "auditwheel")]
        auditwheel_rs(&artifact, &self.target, &self.manylinux)
            .context(format!("Failed to ensure {} compliance", self.manylinux))?;
        let (tag, tags) = self
            .target
            .get_universal_tags(&self.manylinux, self.universal2);
        if !self.scripts.is_empty() {
            bail!("Defining entrypoints and working with a binary doesn't mix well");
        }
        let mut builder =
            WheelWriter::new(&tag, &self.out, &self.metadata21, &self.scripts, &tags)?;
        match self.project_layout {
            ProjectLayout::Mixed(ref python_module) => {
                write_python_part(&mut builder, python_module, &self.module_name)
                    .context("Failed to add the python module to the package")?;
            }
            ProjectLayout::PureRust => {}
        }
        // I wouldn't know of any case where this would be the wrong (and neither do
        // I know a better alternative)
        let bin_name = artifact
            .file_name()
            .expect("Couldn't get the filename from the binary produced by cargo");
        write_bin(&mut builder, &artifact, &self.metadata21, bin_name)?;
        let wheel_path = builder.finish()?;
        println!("📦 Built wheel to {}", wheel_path.display());
        Ok(wheel_path)
    }
pub fn build_bin_wheel ( & self ) -> Result < PathBuf > { let artifacts = compile ( & self , None , & self . bridge ) . context ( " " ) ? ; let artifact = artifacts . get ( " " ) . cloned ( ) . ok_or_else ( | | anyhow ! ( " " ) ) ? ; # [ cfg ( feature " " ) ] auditwheel_rs ( & artifact , & self . target , & self . manylinux ) . context ( format ! ( " " self manylinux ) ) ? ; let ( tag , tags ) = self . target . get_universal_tags ( & self . manylinux , self . universal2 ) ; if ! self . scripts . is_empty ( ) { bail ! ( " " ) ; } let mut builder = WheelWriter :: new ( & tag , & self . out , & self . metadata21 , & self . scripts , & tags ) ? ; match self . project_layout { ProjectLayout :: Mixed ( ref python_module ) => { write_python_part ( & mut builder , python_module , & self . module_name ) . context ( " " ) ? ; } ProjectLayout :: PureRust => { } } // I wouldn't know of any case where this would be the wrong (and neither do // I know a better alternative) let bin_name = artifact . file_name ( ) . expect ( " " ) ; write_bin ( & mut builder , & artifact , & self . metadata21 , bin_name ) ? ; let wheel_path = builder . finish ( ) ? ; println ! ( " w el_path.di play()) ; Ok ( wheel_path ) }
Builds a wheel that contains a binary
Runs [auditwheel_rs()] if not deactivated
Builds a wheel that contains a binary Runs [ auditwheel_rs () ] if not deactivated
&self
&self