Refactor periodic table

.gitignore

@@ -3,3 +3,6 @@
 .idea/
 tests/fixtures/*
 *.iml
+.vscode
+.env
+.DS_Store

Cargo.toml

@@ -2,7 +2,10 @@
 name = "rdkit"
 version = "0.4.11"
 edition = "2021"
-authors = ["Xavier Lange <[email protected]>", "Javier Pineda <[email protected]"]
+authors = [
+    "Xavier Lange <[email protected]>",
+    "Javier Pineda <[email protected]",
+]
 license = "MIT"
 description = "High level RDKit functionality for rust"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -14,6 +17,7 @@ members = ["rdkit-sys"]
 bitvec = "1"
 byteorder = "1.4.3"
 cxx = "1"
+dotenvy = "0.15.7"
 flate2 = "1"
 log = "0.4"
 rdkit-sys = { path = "rdkit-sys", version = "0.4.9" }

benches/molecule_benchmark.rs

@@ -2,7 +2,7 @@
 #![feature(test)]
 extern crate test;
 
-use rdkit::ROMol;
+use rdkit::graphmol::ro_mol::ROMol;
 
 #[bench]
 fn bench_molecules(bencher: &mut test::bench::Bencher) {

examples/tautomer_enumerator.rs

@@ -1,4 +1,4 @@
-use rdkit::{ROMol, TautomerEnumerator};
+use rdkit::{graphmol::ro_mol::ROMol, mol_standardize::TautomerEnumerator};
 
 fn main() {
     let mol = ROMol::from_smiles("c1ccccc1C(=O)NC").unwrap();

rdkit-sys/Cargo.toml

@@ -17,6 +17,7 @@ cxx = "1.0.109"
 env_logger = "0.10.0"
 cxx-build = "1.0.109"
 which = "4.4.2"
+dotenvy = "0.15.7"
 
 [features]
 default = []

rdkit-sys/build.rs

@@ -1,10 +1,10 @@
-const CPP_VERSION_FLAG: &str = "-std=c++17";
+const CPP_VERSION_FLAG: &str = "c++17";
 
 fn main() {
+    dotenvy::dotenv().ok();
     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();
@@ -106,7 +106,7 @@ fn main() {
         .files(wrapper_cc_paths)
         .includes(include_paths)
         .include(std::env::var("CARGO_MANIFEST_DIR").unwrap())
-        .flag(CPP_VERSION_FLAG)
+        .std(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)
@@ -118,25 +118,26 @@ fn main() {
     // println!("cargo:rustc-link-lib=static=c++");
 
     for lib in &[
-        // "Catalogs",
-        // "ChemReactions",
-        // "ChemTransforms",
+        "Catalogs",
+        "ChemReactions",
+        "ChemTransforms",
         "DataStructs",
-        // "Depictor",
+        "Depictor",
         "Descriptors",
         "FileParsers",
         "Fingerprints",
-        // "GenericGroups",
+        "FragCatalog",
+        "GenericGroups",
         "GraphMol",
         "MolStandardize",
-        // "MolTransforms",
-        // "PartialCharges",
+        "MolTransforms",
+        "PartialCharges",
         "RDGeneral",
-        // "RDGeometryLib",
-        // "RingDecomposerLib",
+        "RDGeometryLib",
+        "RingDecomposerLib",
         "ScaffoldNetwork",
         "SmilesParse",
-        // "Subgraphs",
+        "Subgraphs",
         "SubstructMatch",
     ] {
         println!("cargo:rustc-link-lib=dylib=RDKit{}", lib);

rdkit-sys/src/bridge/frag_catalog.rs

@@ -0,0 +1,10 @@
+#[cxx::bridge(namespace = "RDKit")]
+pub mod ffi {
+    unsafe extern "C++" {
+        include!("wrapper/include/frag_catalog.h");
+
+        pub type FragCatParams;
+
+        pub fn init_frat_cat_from_string(text: &CxxString) -> SharedPtr<FragCatParams>;
+    }
+}

rdkit-sys/src/bridge/mod.rs

@@ -24,3 +24,6 @@ pub use scaffold_network::ffi as scaffold_network_ffi;
 
 mod substruct_match;
 pub use substruct_match::ffi as substruct_match_ffi;
+
+mod frag_catalog;
+pub use frag_catalog::ffi as frag_catalog_ffi;

rdkit-sys/src/bridge/mol_ops.rs

@@ -83,5 +83,7 @@ pub mod ffi {
         pub fn romol_set_hybridization(mol: &mut SharedPtr<ROMol>);
 
         pub fn clean_up(rw_mol: &mut SharedPtr<RWMol>);
+
+        pub fn get_number_of_fragments(mol: &SharedPtr<ROMol>) -> u32;
     }
 }

rdkit-sys/src/bridge/periodic_table.rs

@@ -2,7 +2,8 @@
 pub mod ffi {
     unsafe extern "C++" {
         include!("wrapper/include/periodic_table.h");
+        type PeriodicTable;
         pub fn get_valence_list(atomic_number: u32) -> &'static CxxVector<i32>;
-        pub fn get_most_common_isotope_mass(atom: &CxxString) -> f64;
+        pub fn getMostCommonIsotopeMass(self: &PeriodicTable, atom: &CxxString) -> f64;
     }
 }

rdkit-sys/src/bridge/ro_mol.rs

@@ -67,6 +67,7 @@ pub mod ffi {
         pub fn get_total_valence(atom: Pin<&Atom>) -> u32;
         pub fn set_formal_charge(atom: Pin<&mut Atom>, what: i32);
         pub fn set_num_explicit_hs(atom: Pin<&mut Atom>, what: i32);
+        pub fn set_no_implicit(atom: Pin<&mut Atom>, what: bool);
         pub fn atom_update_property_cache(atom: Pin<&mut Atom>, strict: bool) -> Result<()>;
         pub fn atom_set_hybridization(atom: Pin<&mut Atom>, what: HybridizationType);
         pub fn atom_get_hybridization(atom: Pin<&Atom>) -> HybridizationType;

rdkit-sys/tests/frag_catalog.rs

@@ -0,0 +1,7 @@
+use cxx::let_cxx_string;
+
+#[test]
+fn test_frag_catalog() {
+    let_cxx_string!(s = "0 20 1e-008\n1\nNitroGroup	[N+](=O)[O-]\n");
+    let _frag_cat_params = rdkit_sys::frag_catalog_ffi::init_frat_cat_from_string(&s);
+}

rdkit-sys/tests/test_mol_ops.rs

@@ -25,3 +25,16 @@ fn test_mol_ops_cleanup() {
     let smiles = rdkit_sys::ro_mol_ffi::mol_to_smiles(&new_ro_mol);
     assert_eq!(smiles, "C");
 }
+
+#[test]
+fn test_number_of_fragments() {
+    cxx::let_cxx_string!(smiles = "CC");
+    let ro_mol = rdkit_sys::ro_mol_ffi::smiles_to_mol(&smiles).unwrap();
+    let num_frags = rdkit_sys::mol_ops_ffi::get_number_of_fragments(&ro_mol);
+    assert_eq!(num_frags, 1);
+
+    cxx::let_cxx_string!(smiles = "CC(=O)[O-].[NH3+]C");
+    let ro_mol = rdkit_sys::ro_mol_ffi::smiles_to_mol(&smiles).unwrap();
+    let num_frags = rdkit_sys::mol_ops_ffi::get_number_of_fragments(&ro_mol);
+    assert_eq!(num_frags, 2);
+}

rdkit-sys/wrapper/include/frag_catalog.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "rust/cxx.h"
+#include <GraphMol/FragCatalog/FragCatParams.h>
+
+namespace RDKit {
+std::shared_ptr<FragCatParams> init_frat_cat_from_string(const std::string &text);
+} // namespace RDKit

rdkit-sys/wrapper/include/mol_ops.h

@@ -3,6 +3,7 @@
 #include "rust/cxx.h"
 #include <GraphMol/GraphMol.h>
 #include <GraphMol/MolOps.h>
+#include <vector>
 
 namespace RDKit {
 //  pub fn new_remove_hs_parameters() -> SharedPtr<RemoveHsParameters>;
@@ -67,4 +68,9 @@ void romol_set_hybridization(std::shared_ptr<ROMol> &mol);
 
 // pub fn clean_up(rw_mol: &mut SharedPtr<RWMol>)
 void clean_up(std::shared_ptr<RWMol> &rw_mol);
+
+// get molecule fragments  RETURNS: a tuple of tuples with IDs for the atoms
+// in each fragment or a tuple of molecules.
+unsigned int get_number_of_fragments(const std::shared_ptr<ROMol> &romol);
+
 } // namespace RDKit

rdkit-sys/wrapper/include/periodic_table.h

@@ -1,8 +1,9 @@
 #pragma once
 
 #include "rust/cxx.h"
+#include <rdkit/GraphMol/PeriodicTable.h>
 
 namespace RDKit {
 const std::vector<int> &get_valence_list(unsigned int atomic_number);
-double get_most_common_isotope_mass(const std::string &symbol);
+// double get_most_common_isotope_mass(const std::string &symbol);
 } // namespace RDKit

rdkit-sys/wrapper/include/ro_mol.h

@@ -37,6 +37,7 @@ unsigned int get_total_num_hs(const Atom &atom);
 unsigned int get_total_valence(const Atom &atom);
 void set_formal_charge(Atom &atom, int what);
 void set_num_explicit_hs(Atom &atom, int what);
+void set_no_implicit(Atom &atom, bool what);
 void atom_update_property_cache(Atom &atom, bool strict);
 
 using HybridizationType = Atom::HybridizationType;

rdkit-sys/wrapper/src/frag_catalog.cc

@@ -0,0 +1,13 @@
+#include "rust/cxx.h"
+#include <GraphMol/FragCatalog/FragCatParams.h>
+// #include <GraphMol/GraphMol.h>
+#include <GraphMol/MolOps.h>
+#include <memory>
+
+namespace RDKit {
+std::shared_ptr<FragCatParams> init_frat_cat_from_string(const std::string &text) {
+	return std::shared_ptr<FragCatParams>(new FragCatParams(text));
+}
+
+// here we need to do something
+} // namespace RDKit

rdkit-sys/wrapper/src/mol_ops.cc

@@ -106,4 +106,9 @@ std::shared_ptr<ROMol> add_hs(const std::shared_ptr<ROMol> &mol, bool explicit_o
 void romol_set_hybridization(std::shared_ptr<ROMol> &mol) { MolOps::setHybridization(*mol); }
 
 void clean_up(std::shared_ptr<RWMol> &rw_mol) { MolOps::cleanUp(*rw_mol); }
-} // namespace RDKit
+
+unsigned int get_number_of_fragments(const std::shared_ptr<ROMol> &romol) {
+	std::vector<int> mapping;
+	return RDKit::MolOps::getMolFrags(*romol, mapping);
+}
+} // namespace RDKit

rdkit-sys/wrapper/src/periodic_table.cc

@@ -7,8 +7,8 @@ const std::vector<int> &get_valence_list(unsigned int atomic_number) {
 	return pt->getValenceList(atomic_number);
 }
 
-double get_most_common_isotope_mass(const std::string &symbol) {
-	PeriodicTable *pt = RDKit::PeriodicTable::getTable();
-	return pt->getMostCommonIsotopeMass(symbol);
-}
+// double get_most_common_isotope_mass(const std::string &symbol) {
+// 	PeriodicTable *pt = RDKit::PeriodicTable::getTable();
+// 	return pt->getMostCommonIsotopeMass(symbol);
+// }
 } // namespace RDKit

rdkit-sys/wrapper/src/ro_mol.cc

@@ -78,6 +78,7 @@ unsigned int get_total_num_hs(const Atom &atom) { return atom.getTotalNumHs(); }
 unsigned int get_total_valence(const Atom &atom) { return atom.getTotalValence(); }
 void set_formal_charge(Atom &atom, int what) { atom.setFormalCharge(what); }
 void set_num_explicit_hs(Atom &atom, int what) { atom.setNumExplicitHs(what); }
+void set_no_implicit(Atom &atom, bool what) { atom.setNoImplicit(what); }
 void atom_update_property_cache(Atom &atom, bool strict) { atom.updatePropertyCache(strict); }
 
 using HybridizationType = Atom::HybridizationType;

src/descriptors.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use cxx::SharedPtr;
 
-use crate::ROMol;
+use crate::graphmol::ro_mol::ROMol;
 
 pub struct Properties {
     ptr: SharedPtr<rdkit_sys::descriptors_ffi::Properties>,

src/file_parsers.rs

@@ -6,7 +6,7 @@ use std::{
 
 use flate2::bufread::GzDecoder;
 
-use crate::RWMol;
+use crate::graphmol::rw_mol::RWMol;
 
 pub struct MolBlockIter<R: BufRead> {
     buf_read: R,

src/graphmol/atom.rs

@@ -58,6 +58,10 @@ impl<'a> Atom<'a> {
         ro_mol_ffi::set_num_explicit_hs(self.ptr.as_mut(), what)
     }
 
+    pub fn set_no_implicit(&mut self, what: bool) {
+        ro_mol_ffi::set_no_implicit(self.ptr.as_mut(), what)
+    }
+
     pub fn update_property_cache(&mut self, strict: bool) -> Result<(), cxx::Exception> {
         ro_mol_ffi::atom_update_property_cache(self.ptr.as_mut(), strict)
     }

src/graphmol/frag_catalog.rs

@@ -0,0 +1,13 @@
+use cxx::let_cxx_string;
+use rdkit_sys::*;
+pub struct FragCatParams {
+    pub(crate) ptr: cxx::SharedPtr<frag_catalog_ffi::FragCatParams>,
+}
+
+impl FragCatParams {
+    pub fn new_from_string(text: &str) -> Self {
+        let_cxx_string!(cxx_text = text);
+        let ptr = rdkit_sys::frag_catalog_ffi::init_frat_cat_from_string(&cxx_text);
+        FragCatParams { ptr }
+    }
+}

src/graphmol/mod.rs

@@ -1,11 +1,5 @@
-mod atom;
-pub use atom::*;
-
-mod mol_ops;
-pub use mol_ops::*;
-
-mod ro_mol;
-pub use ro_mol::*;
-
-mod rw_mol;
-pub use rw_mol::*;
+pub mod atom;
+pub mod frag_catalog;
+pub mod mol_ops;
+pub mod ro_mol;
+pub mod rw_mol;

src/graphmol/mol_ops.rs

@@ -1,7 +1,7 @@
 use cxx::SharedPtr;
 use rdkit_sys::ro_mol_ffi as ro_mol;
 
-use crate::{ROMol, RWMol};
+use crate::graphmol::{ro_mol::ROMol, rw_mol::RWMol};
 
 #[derive(Debug, PartialEq)]
 pub enum MolSanitizeException {
@@ -209,3 +209,10 @@ pub fn set_hybridization(romol: &mut ROMol) {
 pub fn clean_up(rw_mol: &mut RWMol) {
     rdkit_sys::mol_ops_ffi::clean_up(&mut rw_mol.ptr);
 }
+
+/// Returns the number of fragments in the molecule.
+/// This could arguably be a method on ROMol. But to respect
+/// RDKit's design, it is a free function of the mol_ops module.
+pub fn get_number_of_fragments(ro_mol: &ROMol) -> u32 {
+    rdkit_sys::mol_ops_ffi::get_number_of_fragments(&ro_mol.ptr)
+}

src/graphmol/ro_mol.rs

@@ -3,7 +3,10 @@ use std::fmt::{Debug, Formatter};
 use cxx::let_cxx_string;
 use rdkit_sys::*;
 
-use crate::{Atom, Fingerprint, RWMol};
+use crate::{
+    fingerprint::Fingerprint,
+    graphmol::{atom::Atom, rw_mol::RWMol},
+};
 
 pub struct ROMol {
     pub(crate) ptr: cxx::SharedPtr<ro_mol_ffi::ROMol>,

src/graphmol/rw_mol.rs

@@ -3,7 +3,7 @@ use std::fmt::Formatter;
 use cxx::{let_cxx_string, SharedPtr};
 use rdkit_sys::*;
 
-use crate::ROMol;
+use crate::graphmol::ro_mol::ROMol;
 
 pub struct RWMol {
     pub(crate) ptr: SharedPtr<rdkit_sys::rw_mol_ffi::RWMol>,