rdkit-sys 0.4.12

RDKit CFFI library builder and bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

const CPP_VERSION_FLAG: &str = "-std=c++17";

fn main() {
    if std::env::var("DOCS_RS").is_ok() {
        return;
    }

    env_logger::init();

    let use_conda = std::env::var("CARGO_FEATURE_DYNAMIC_LINKING_FROM_CONDA").is_ok();

    let mut lib_paths = vec![];
    let mut include_paths = vec![];

    match (std::env::consts::OS, std::env::consts::ARCH, use_conda) {
        (_, _, true) => {
            // prefer the prefix env var, if not, fall back to the base from the CLI
            match std::env::var("CONDA_PREFIX") {
                Ok(prefix) => {
                    include_paths.push(format!("{prefix}/include"));
                    include_paths.push(format!("{prefix}/include/rdkit"));
                    lib_paths.push(format!("{prefix}/lib"));
                }
                Err(_) => {
                    let conda = which::which("conda")
                        .map(|p| p.to_str().unwrap().to_string())
                        .unwrap_or_else(|_| panic!("conda not found"));
                    let mut conda = std::process::Command::new(conda);
                    conda.args(["info", "--base"]);

                    let output = conda.output().unwrap();
                    let stdout = String::from_utf8(output.stdout).unwrap();
                    let conda_root = stdout.trim().to_string();

                    lib_paths.push(format!("{}/lib", conda_root));
                    include_paths.push(format!("{}/include", conda_root));
                    include_paths.push(format!("{}/include/rdkit", conda_root));
                }
            }
        }
        ("macos", "x86_64", _) => {
            include_paths.push("/usr/local/include".to_string());
            include_paths.push("/usr/local/include/rdkit".to_string());
        }
        ("macos", "aarch64", _) => {
            include_paths.push("/opt/homebrew/include".to_string());
            include_paths.push("/opt/homebrew/include/rdkit".to_string());
            lib_paths.push("/opt/homebrew/lib".to_string())
        }
        ("linux", _, _) => {
            include_paths.push("/usr/local/include".to_string());
            include_paths.push("/usr/local/include/rdkit".to_string());
            include_paths.push("/usr/include".to_string());
            include_paths.push("/usr/include/rdkit".to_string());
        }
        (unsupported_os, unsupported_arch, use_conda) => panic!(
            "sorry, rdkit-sys doesn't support {}/{}/use_conda={} at this time",
            unsupported_os, unsupported_arch, use_conda
        ),
    };

    let dir = std::fs::read_dir("src/bridge").unwrap();
    let rust_files = dir
        .into_iter()
        .filter_map(|p| match p {
            Ok(p) => {
                if p.metadata().unwrap().is_file() {
                    Some(p.path())
                } else {
                    None
                }
            }
            Err(_) => None,
        })
        .filter(|p| !p.ends_with("mod.rs"))
        .collect::<Vec<_>>();

    let mut wrapper_cc_paths = vec![];

    let wrapper_root = std::path::PathBuf::from("wrapper");
    for file in &rust_files {
        let file_name = file.file_name().unwrap();
        let file_name = file_name.to_str().unwrap();
        let base_name = &file_name[0..file_name.len() - 3];

        let cc_path = wrapper_root.join("src").join(format!("{}.cc", base_name));
        let meta = std::fs::metadata(&cc_path).unwrap();
        if !meta.is_file() {
            panic!("{} must exist", cc_path.display())
        }
        println!("cargo:rerun-if-changed={}", cc_path.to_str().unwrap());
        wrapper_cc_paths.push(cc_path);

        let h_path = wrapper_root
            .join("include")
            .join(format!("{}.h", base_name));
        let meta = std::fs::metadata(&h_path)
            .unwrap_or_else(|_| panic!("could not get metadata for {h_path:?}"));
        if !meta.is_file() {
            panic!("{} must exist", h_path.display())
        }
        println!("cargo:rerun-if-changed={}", h_path.to_str().unwrap());
    }

    cxx_build::bridges(rust_files)
        .files(wrapper_cc_paths)
        .includes(include_paths)
        .include(std::env::var("CARGO_MANIFEST_DIR").unwrap())
        .flag(CPP_VERSION_FLAG)
        .warnings(false)
        // rdkit has warnings that blow up our build. we could enumerate all those warnings and tell
        // the compiler to allow them... .warnings_into_errors(true)
        .compile("rdkit");

    for path in lib_paths {
        println!("cargo:rustc-link-search=native={}", path);
    }
    // println!("cargo:rustc-link-lib=static=c++");

    for lib in &[
        // "Catalogs",
        // "ChemReactions",
        // "ChemTransforms",
        "DataStructs",
        // "Depictor",
        "Descriptors",
        "FileParsers",
        "Fingerprints",
        // "GenericGroups",
        "GraphMol",
        "MolStandardize",
        // "MolTransforms",
        // "PartialCharges",
        "RDGeneral",
        // "RDGeometryLib",
        // "RingDecomposerLib",
        "ScaffoldNetwork",
        "SmilesParse",
        // "Subgraphs",
        "SubstructMatch",
    ] {
        println!("cargo:rustc-link-lib=dylib=RDKit{}", lib);
    }

    println!("cargo:rustc-link-lib=dylib=boost_serialization");
}