Struct Installer 

pub struct Installer {
    pub config: InstallConfig,
    /* private fields */
}

Stateful installation context. The located uv/micromamba/Conda executables and selected Torch backend are cached across recipes in one run.

Fields

config: InstallConfig

Implementations

impl Installer

pub fn new(root: impl Into<PathBuf>) -> Self

pub fn from_environment(root: impl Into<PathBuf>) -> Result<Self, InstallError>

Construct an installer using the compatibility environment variables documented by the original Molchanica and bio_web installers.

pub fn for_process_executables( root: impl Into<PathBuf>, ) -> Result<Self, InstallError>

Construct an installer for the shared process_executables/python_envs layout.

Examples found in repository

examples/readme_install.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut installer = Installer::for_process_executables("process_executables")?;
    installer.install(Tool::OpenDde)?;

    // Independent recipes continue after an upstream failure.
    let report = installer.install_many([Tool::Boltz2, Tool::ProteinMpnn]);
    for failure in &report.failed {
        eprintln!("{}: {}", failure.tool.name(), failure.error);
    }

    // Status: `status_quick` inspects markers, executables, and required assets
    // without launching the tool; `status_full` also runs its help/version probe.
    let status = installer.status_quick(Tool::OpenDde);
    println!("{:?}: {}", status.result, status.detail);

    let report = installer.uninstall(Tool::OpenDde)?;
    println!("Removed {} paths", report.removed.len());
    Ok(())
}

pub fn from_config(config: InstallConfig) -> Self

pub fn with_reporter( self, reporter: impl Fn(InstallEvent) + Send + Sync + 'static, ) -> Self

pub fn environment_path(&self, tool: Tool) -> PathBuf

pub fn executable_path(&self, tool: Tool) -> PathBuf

Locate a tool’s installed console entry point in its managed environment.

pub fn tool_command(&self, tool: Tool) -> CommandSpec

Build a command for a tool’s console entry point in its managed environment.

The child receives VIRTUAL_ENV and a PATH whose first directory is the tool environment’s scripts directory. This is equivalent to activating the environment before running its console script, and lets dependencies such as PyTorch find helper executables installed beside the script.

pub fn tool_python_command(&self, tool: Tool) -> CommandSpec

Build a command for the managed Python interpreter of a tool.

pub fn tools_root(&self) -> &Path

pub fn install(&mut self, tool: Tool) -> Result<(), InstallError>

Install or refresh one tool. Recipes are designed to be safely rerunnable.

Examples found in repository

examples/readme_install.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut installer = Installer::for_process_executables("process_executables")?;
    installer.install(Tool::OpenDde)?;

    // Independent recipes continue after an upstream failure.
    let report = installer.install_many([Tool::Boltz2, Tool::ProteinMpnn]);
    for failure in &report.failed {
        eprintln!("{}: {}", failure.tool.name(), failure.error);
    }

    // Status: `status_quick` inspects markers, executables, and required assets
    // without launching the tool; `status_full` also runs its help/version probe.
    let status = installer.status_quick(Tool::OpenDde);
    println!("{:?}: {}", status.result, status.detail);

    let report = installer.uninstall(Tool::OpenDde)?;
    println!("Removed {} paths", report.removed.len());
    Ok(())
}

pub fn status_quick(&self, tool: Tool) -> ToolStatus

Inspect an installed tool without launching its application code.

Examples found in repository

examples/readme_install.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut installer = Installer::for_process_executables("process_executables")?;
    installer.install(Tool::OpenDde)?;

    // Independent recipes continue after an upstream failure.
    let report = installer.install_many([Tool::Boltz2, Tool::ProteinMpnn]);
    for failure in &report.failed {
        eprintln!("{}: {}", failure.tool.name(), failure.error);
    }

    // Status: `status_quick` inspects markers, executables, and required assets
    // without launching the tool; `status_full` also runs its help/version probe.
    let status = installer.status_quick(Tool::OpenDde);
    println!("{:?}: {}", status.result, status.detail);

    let report = installer.uninstall(Tool::OpenDde)?;
    println!("Removed {} paths", report.removed.len());
    Ok(())
}

pub fn status_full(&self, tool: Tool) -> ToolStatus

Launch an installed tool’s status probe and inspect its compute device.

pub fn status(&self, tool: Tool) -> ToolStatus

Backwards-compatible alias for Installer::status_full.

pub fn list_quick(&self) -> Vec<(Tool, ToolStatus)>

Quickly inspect every tool installed by this crate.

pub fn list_full(&self) -> Vec<(Tool, ToolStatus)>

Fully probe every tool installed by this crate.

pub fn list(&self) -> Vec<(Tool, ToolStatus)>

Backwards-compatible alias for Installer::list_full.

pub fn uninstall(&mut self, tool: Tool) -> Result<UninstallReport, InstallError>

Remove one tool’s environment, assets, and installation marker.

Rerunnable in the same sense the recipes are: a tool that is already absent uninstalls successfully with an empty report, which is what makes this safe to offer as a button beside a status that may be a few minutes stale.

Examples found in repository

examples/readme_install.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut installer = Installer::for_process_executables("process_executables")?;
    installer.install(Tool::OpenDde)?;

    // Independent recipes continue after an upstream failure.
    let report = installer.install_many([Tool::Boltz2, Tool::ProteinMpnn]);
    for failure in &report.failed {
        eprintln!("{}: {}", failure.tool.name(), failure.error);
    }

    // Status: `status_quick` inspects markers, executables, and required assets
    // without launching the tool; `status_full` also runs its help/version probe.
    let status = installer.status_quick(Tool::OpenDde);
    println!("{:?}: {}", status.result, status.detail);

    let report = installer.uninstall(Tool::OpenDde)?;
    println!("Removed {} paths", report.removed.len());
    Ok(())
}

pub fn install_many( &mut self, tools: impl IntoIterator<Item = Tool>, ) -> InstallReport

Install several tools without letting one broken upstream release suppress the rest.

Examples found in repository

examples/readme_install.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut installer = Installer::for_process_executables("process_executables")?;
    installer.install(Tool::OpenDde)?;

    // Independent recipes continue after an upstream failure.
    let report = installer.install_many([Tool::Boltz2, Tool::ProteinMpnn]);
    for failure in &report.failed {
        eprintln!("{}: {}", failure.tool.name(), failure.error);
    }

    // Status: `status_quick` inspects markers, executables, and required assets
    // without launching the tool; `status_full` also runs its help/version probe.
    let status = installer.status_quick(Tool::OpenDde);
    println!("{:?}: {}", status.result, status.detail);

    let report = installer.uninstall(Tool::OpenDde)?;
    println!("Removed {} paths", report.removed.len());
    Ok(())
}