MinimalLib Function Exposure: Scaffold Networks

Code/MinimalLib/CMakeLists.txt

@@ -6,7 +6,7 @@ if(RDK_BUILD_MINIMAL_LIB)
         "CIPLabeler_static;MolDraw2D_static;Depictor_static;RDInchiLib_static;"
         "SubstructMatch_static;FileParsers_static;"
         "SmilesParse_static;GraphMol_static;RDGeometryLib_static;"
-        "RDGeneral_static;RGroupDecomposition_static")
+        "RDGeneral_static;RGroupDecomposition_static;ScaffoldNetwork_static")
     if(RDK_BUILD_MINIMAL_LIB_RXN)
         add_definitions(-DRDK_BUILD_MINIMAL_LIB_RXN)
         set(MINIMAL_LIB_LIBRARIES "${MINIMAL_LIB_LIBRARIES};ChemReactions_static")
@@ -23,6 +23,10 @@ if(RDK_BUILD_MINIMAL_LIB)
         add_definitions(-DRDK_BUILD_MINIMAL_LIB_MMPA)
         set(MINIMAL_LIB_LIBRARIES "${MINIMAL_LIB_LIBRARIES};MMPA_static")
      endif()
+    if(RDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK)
+        add_definitions(-DRDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK)
+        set(MINIMAL_LIB_LIBRARIES "${MINIMAL_LIB_LIBRARIES};ChemReactions_static")
+     endif()
     if(RDK_BUILD_FREETYPE_SUPPORT)
         if( ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
             set(USE_FLAGS "-s USE_FREETYPE=1")

Code/MinimalLib/jswrapper.cpp

@@ -17,6 +17,10 @@
 #include <GraphMol/MolDraw2D/MolDraw2DUtils.h>
 #include <GraphMol/MolDraw2D/MolDraw2DJS.h>
 
+#ifdef RDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK
+#include <GraphMol/ScaffoldNetwork/ScaffoldNetwork.h>
+#endif
+
 using namespace RDKit;
 
 namespace {
@@ -340,6 +344,50 @@ emscripten::val get_avalon_fp_as_uint8array(const JSMol &self) {
 }
 #endif
 
+#ifdef RDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK
+std::string EdgeTypeToString(RDKit::ScaffoldNetwork::EdgeType edgeType) {
+  switch (edgeType) {
+    case RDKit::ScaffoldNetwork::EdgeType::Fragment:
+      return "Fragment";
+    case RDKit::ScaffoldNetwork::EdgeType::Generic:
+      return "Generic";
+    case RDKit::ScaffoldNetwork::EdgeType::GenericBond:
+      return "GenericBond";
+    case RDKit::ScaffoldNetwork::EdgeType::RemoveAttachment:
+      return "RemoveAttachment";
+    case RDKit::ScaffoldNetwork::EdgeType::Initialize:
+      return "Initialize";
+    default:
+      return "Unknown";
+  }
+}
+
+emscripten::val update_scaffold_network_wrapper(JSScaffoldNetwork& js_scaffold_network, const JSMolList &mol_list){
+  RDKit::ScaffoldNetwork::ScaffoldNetwork modified_network; 
+
+  modified_network = js_scaffold_network.update_scaffold_network(mol_list);
+
+  auto network_obj = emscripten::val::object();
+
+  network_obj.set("nodes", modified_network.nodes);
+  network_obj.set("counts", modified_network.counts);
+  network_obj.set("molCounts", modified_network.molCounts);
+
+  std::vector<emscripten::val> edges_array;
+  for (const auto &new_edge : modified_network.edges) {
+    auto edge_obj = emscripten::val::object();
+    edge_obj.set("beginIdx", new_edge.beginIdx);
+    edge_obj.set("endIdx", new_edge.endIdx);
+    edge_obj.set("type", EdgeTypeToString(new_edge.type));
+
+    edges_array.push_back(edge_obj);
+  }
+  network_obj.set("edges", edges_array);
+
+  return network_obj;
+}
+#endif
+
 #ifdef RDK_BUILD_MINIMAL_LIB_MMPA
 emscripten::val get_mmpa_frags_helper(const JSMol &self, unsigned int minCuts,
                                       unsigned int maxCuts,
@@ -352,11 +400,15 @@ emscripten::val get_mmpa_frags_helper(const JSMol &self, unsigned int minCuts,
 }
 #endif
 
+
+
 }  // namespace
 
 using namespace emscripten;
 EMSCRIPTEN_BINDINGS(RDKit_minimal) {
   register_vector<std::string>("StringList");
+  register_vector<emscripten::val>("JSObjectList");
+  register_vector<unsigned int>("UnsignedIntList");
   register_vector<JSMolList *>("JSMolListList");
 
   class_<JSMol>("Mol")
@@ -601,6 +653,13 @@ EMSCRIPTEN_BINDINGS(RDKit_minimal) {
                 &JSReaction::get_svg_with_highlights);
 #endif
 
+#ifdef RDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK
+class_<JSScaffoldNetwork>("ScaffoldNetwork")
+    .constructor<>()
+    .function("update_scaffold_network", select_overload<emscripten::val(JSScaffoldNetwork &self, const JSMolList &)>(update_scaffold_network_wrapper))
+    .function("set_scaffold_params", &JSScaffoldNetwork::set_scaffold_params);
+#endif
+
 #ifdef RDK_BUILD_MINIMAL_LIB_SUBSTRUCTLIBRARY
   class_<JSSubstructLibrary>("SubstructLibrary")
       .constructor<>()
@@ -686,4 +745,4 @@ EMSCRIPTEN_BINDINGS(RDKit_minimal) {
   function("get_mcs_as_smarts", &get_mcs_as_smarts);
   function("get_mcs_as_smarts", &get_mcs_as_smarts_no_details);
 #endif
-}
+}

Code/MinimalLib/minilib.cpp

@@ -40,6 +40,10 @@
 #include <DataStructs/BitOps.h>
 #include <DataStructs/ExplicitBitVect.h>
 
+#ifdef RDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK
+#include <GraphMol/ScaffoldNetwork/ScaffoldNetwork.h>
+#endif
+
 #include <INCHI-API/inchi.h>
 
 #include <rapidjson/document.h>
@@ -738,6 +742,72 @@ size_t JSMolList::insert(size_t idx, const JSMol &mol) {
   return res;
 }
 
+#ifdef RDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK
+RDKit::ScaffoldNetwork::ScaffoldNetwork JSScaffoldNetwork::update_scaffold_network(const JSMolList &scaffmols) {
+  std::vector<ROMOL_SPTR> mols;
+  for (const auto &reactant : scaffmols.mols()) {
+    mols.push_back(RDKit::ROMOL_SPTR(reactant));
+  }
+  RDKit::ScaffoldNetwork::updateScaffoldNetwork(mols, *d_network, *d_scaffparams);
+  return *d_network;
+}
+
+void JSScaffoldNetwork::set_scaffold_params(const std::string &params) {
+  if (params.empty()) {
+  return;
+  }
+  rj::Document d;
+  if (d.Parse(params.c_str()).HasParseError()) {
+    return;
+  }
+  if (d.HasMember("includeGenericScaffolds")) {
+    d_scaffparams->includeGenericScaffolds = d["includeGenericScaffolds"].GetBool();
+  }
+  if (d.HasMember("includeGenericBondScaffolds")) {
+    d_scaffparams->includeGenericBondScaffolds = d["includeGenericBondScaffolds"].GetBool();
+  }
+  if (d.HasMember("includeScaffoldsWithoutAttachments")) {
+    d_scaffparams->includeScaffoldsWithoutAttachments = d["includeScaffoldsWithoutAttachments"].GetBool();
+  }
+  if (d.HasMember("includeScaffoldsWithAttachments")) {
+    d_scaffparams->includeScaffoldsWithAttachments = d["includeScaffoldsWithAttachments"].GetBool();
+  }
+  if (d.HasMember("keepOnlyFirstFragment")) {
+    d_scaffparams->keepOnlyFirstFragment = d["keepOnlyFirstFragment"].GetBool();
+  }
+  if (d.HasMember("pruneBeforeFragmenting")) {
+    d_scaffparams->pruneBeforeFragmenting = d["pruneBeforeFragmenting"].GetBool();
+  }
+  if (d.HasMember("flattenIsotopes")) {
+    d_scaffparams->flattenIsotopes = d["flattenIsotopes"].GetBool();
+  }
+  if (d.HasMember("flattenChirality")) {
+    d_scaffparams->flattenChirality = d["flattenChirality"].GetBool();
+  }
+  if (d.HasMember("flattenKeepLargest")) {
+    d_scaffparams->flattenKeepLargest = d["flattenKeepLargest"].GetBool();
+  }
+  if (d.HasMember("collectMolCounts")) {
+    d_scaffparams->collectMolCounts = d["collectMolCounts"].GetBool();
+  }
+  if (d.HasMember("bondBreakersRxns") && d["bondBreakersRxns"].IsArray()) {
+      const rj::Value& bondBreakersRxnsStringArray = d["bondBreakersRxns"];
+      std::vector<std::shared_ptr<ChemicalReaction>> bondBreakersRxns;
+
+      for (rj::SizeType i = 0; i < bondBreakersRxnsStringArray.Size(); i++) {
+          if (bondBreakersRxnsStringArray[i].IsString()) {
+              const std::string rxnStr = bondBreakersRxnsStringArray[i].GetString();
+              ChemicalReaction *rxn = MinimalLib::rxn_from_input(rxnStr);
+              rxn->initReactantMatchers();
+              bondBreakersRxns.emplace_back(rxn);
+          }
+      }
+      d_scaffparams->bondBreakersRxns.clear();
+      d_scaffparams->bondBreakersRxns = bondBreakersRxns;        
+  }
+}
+#endif
+
 #ifdef RDK_BUILD_MINIMAL_LIB_SUBSTRUCTLIBRARY
 JSSubstructLibrary::JSSubstructLibrary(unsigned int num_bits)
     : d_fpHolder(nullptr) {
@@ -856,6 +926,16 @@ unsigned int JSSubstructLibrary::count_matches(const JSMol &q,
 }
 #endif
 
+// RDKit::ScaffoldNetwork::ScaffoldNetwork JSScaffoldNetwork::update_scaffold_network(const JSMolList &scaffmols) {
+//   std::vector<ROMOL_SPTR> mols;
+//   for (const auto &reactant : scaffmols.mols()) {
+//     mols.push_back(RDKit::ROMOL_SPTR(reactant));
+//   }
+//   RDKit::ScaffoldNetwork::updateScaffoldNetwork(mols, *d_network, *d_scaffparams);
+//   return *d_network;
+// }
+
+
 std::string get_inchikey_for_inchi(const std::string &input) {
   return InchiToInchiKey(input);
 }
@@ -1000,4 +1080,4 @@ JSLog *set_log_capture(const std::string &log_name) {
 
 void enable_logging() { RDKit::MinimalLib::LogHandle::enableLogging(); }
 
-void disable_logging() { RDKit::MinimalLib::LogHandle::disableLogging(); }
+void disable_logging() { RDKit::MinimalLib::LogHandle::disableLogging(); }

Code/MinimalLib/minilib.h

@@ -18,6 +18,10 @@
 #include <GraphMol/MMPA/MMPA.h>
 #endif
 
+#ifdef RDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK
+#include <GraphMol/ScaffoldNetwork/ScaffoldNetwork.h>
+#endif
+
 class JSMolList;
 
 class JSMol {
@@ -163,6 +167,8 @@ class JSMol {
   static constexpr int d_defaultHeight = 200;
 };
 
+
+
 class JSMolList {
  public:
   JSMolList(const std::vector<RDKit::ROMOL_SPTR> &mols)
@@ -225,6 +231,23 @@ class JSReaction {
 };
 #endif
 
+#ifdef RDK_BUILD_MINIMAL_LIB_SCAFFOLDNETWORK
+class JSScaffoldNetwork {
+ public:
+  JSScaffoldNetwork() : 
+    d_scaffparams(new RDKit::ScaffoldNetwork::ScaffoldNetworkParams), d_network(new RDKit::ScaffoldNetwork::ScaffoldNetwork) {}
+
+  RDKit::ScaffoldNetwork::ScaffoldNetwork update_scaffold_network(
+      const JSMolList &scaffmols);
+
+  void set_scaffold_params(const std::string &params);
+
+ private:
+  RDKit::ScaffoldNetwork::ScaffoldNetworkParams *d_scaffparams;
+  RDKit::ScaffoldNetwork::ScaffoldNetwork *d_network;
+};
+#endif
+
 #ifdef RDK_BUILD_MINIMAL_LIB_SUBSTRUCTLIBRARY
 class JSSubstructLibrary {
  public:
@@ -292,4 +315,4 @@ JSLog *set_log_capture(const std::string &log_name);
 std::string get_mcs_as_json(const JSMolList &mols, const std::string &details_json);
 std::string get_mcs_as_smarts(const JSMolList &mols, const std::string &details_json);
 JSMol *get_mcs_as_mol(const JSMolList &mols, const std::string &details_json);
-#endif
+#endif

Code/MinimalLib/tests/tests.js

@@ -2583,6 +2583,95 @@ function test_mcs() {
     }
 }
 
+function assert_edge_counts(net, edgeType, expectedLen) {
+    let count = 0;
+    for (let i = 0; i < net.edges.size(); i++) {
+        const edge = net.edges.get(i);
+        if (edge.type === edgeType) {
+            count++;
+        }
+    }
+    assert(count === expectedLen);
+}
+
+function test_scaffold_networks(){
+    let net_ins = new RDKitModule.ScaffoldNetwork();
+
+    // Basics
+    smis = ["c1ccccc1CC1NC(=O)CCC1", "c1cccnc1CC1NC(=O)CCC1"]
+    ms = molListFromSmiArray(smis);
+    net = net_ins.update_scaffold_network(ms);
+
+    assert(net.nodes.size() === 12);
+    assert(net.edges.size() === 13);
+    assert(net.nodes.size() === net.molCounts.size());
+    assert_edge_counts(net, "Fragment", 4);
+    assert_edge_counts(net, "Generic", 6);
+    assert_edge_counts(net, "RemoveAttachment", 3);
+
+    // Param updates test
+    net_ins = new RDKitModule.ScaffoldNetwork();
+    smis = ["c1ccccc1CC1NC(=O)CCC1", "c1cccnc1CC1NC(=O)CCC1"];
+    ms = molListFromSmiArray(smis);
+    net_ins.set_scaffold_params(JSON.stringify({"includeScaffoldsWithoutAttachments" : false}));
+    net = net_ins.update_scaffold_network(ms);
+
+    assert(net.nodes.size() === 7);
+    assert(net.edges.size() === 7);
+    assert_edge_counts(net, "Fragment", 4);
+    assert_edge_counts(net, "Generic", 3);
+
+    // Scaffold Network Update Tests
+    net_ins = new RDKitModule.ScaffoldNetwork();
+    ms = molListFromSmiArray(["c1ccccc1CC1NC(=O)CCC1"]);
+    net = net_ins.update_scaffold_network(ms);
+
+    assert(net.nodes.size() === 9);
+    assert(net.edges.size() === 8);
+    assert(net.nodes.size() === net.molCounts.size());
+
+    ms = molListFromSmiArray(["c1cccnc1CC1NC(=O)CCC1"]);
+    net = net_ins.update_scaffold_network(ms);
+
+    assert(net.nodes.size() === 12);
+    assert(net.edges.size() === 13);
+    assert(net.nodes.size() === net.molCounts.size());
+
+    assert_edge_counts(net, "Fragment", 4);
+    assert_edge_counts(net, "Generic", 6);
+    assert_edge_counts(net, "RemoveAttachment", 3);
+
+    // Bond Breaker Reactions Test
+    smis = ["c1c(CC2CC2)cc(NC2CC2)cc1OC1CC1"];
+    ms = molListFromSmiArray(smis);
+    let net_ins2 = new RDKitModule.ScaffoldNetwork();
+    net_ins2.set_scaffold_params(JSON.stringify(
+        {
+            "bondBreakersRxns" : ["[!#0;R:1]-!@[O:2]>>[*:1]-[#0].[#0]-[*:2]", "[!#0;R:1]-!@[N:2]>>[*:1]-[#0].[#0]-[*:2]"],
+            "includeScaffoldsWithoutAttachments" : false,
+            "includeGenericScaffolds":  false,
+        }
+    ));
+    net = net_ins2.update_scaffold_network(ms);
+    assert(net.nodes.size() === 5);
+    assert(net.edges.size() === 7);
+
+    // Test many more scaffold network params
+    smis = ["C1OC1Cc1ccccc1"]
+    ms = molListFromSmiArray(smis);
+    net_ins = new RDKitModule.ScaffoldNetwork();
+    net_ins.set_scaffold_params(JSON.stringify({"keepOnlyFirstFragment" : false}));
+    net = net_ins.update_scaffold_network(ms);
+    assert(net.nodes.size() === 19);
+    assert(net.edges.size() === 23);
+
+    net_ins = new RDKitModule.ScaffoldNetwork();
+    net_ins.set_scaffold_params(JSON.stringify({"includeGenericScaffolds" : false}));
+    net = net_ins.update_scaffold_network(ms);
+    assert(net.nodes.size() === 5);
+    assert(net.edges.size() === 4);
+}
+
 function test_get_num_atoms_bonds() {
     var mol = RDKitModule.get_mol('CCCC');
     var molH = RDKitModule.get_mol_copy(mol);
@@ -3013,6 +3102,9 @@ initRDKitModule().then(function(instance) {
     if (RDKitModule.get_mcs_as_mol)  {
         test_mcs();
     }
+    if (RDKitModule.ScaffoldNetwork){
+        test_scaffold_networks();
+    }
     test_sanitize_no_kekulize_no_setaromaticity();
     test_partial_sanitization();
     test_capture_logs();