rdkit_chem 2025.09.3.1-x86_64-linux

data/Code/RubyWrappers/Fingerprints.i

@@ -0,0 +1,56 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <DataStructs/ExplicitBitVect.h>
+#include <DataStructs/BitOps.h>
+#include <GraphMol/Fingerprints/FingerprintUtil.h>
+#include <GraphMol/Fingerprints/Fingerprints.h>
+#include <GraphMol/Fingerprints/MACCS.h>
+%}
+
+// Use base types (unsigned int) to avoid duplicate swig::traits definitions
+%template(UIntPair) std::pair<unsigned int,unsigned int>;
+%template(UIntPairVect) std::vector<std::pair<unsigned int,unsigned int> >;
+%template(BitInfoMap) std::map<unsigned int,std::vector<std::pair<unsigned int,unsigned int> > >;
+%newobject RDKit::RDKFingerprintMol;
+%newobject RDKit::LayeredFingerprintMol;
+%newobject RDKit::PatternFingerprintMol;
+%include <GraphMol/Fingerprints/Fingerprints.h>
+
+%newobject RDKit::MACCSFingerprints::getFingerprintAsBitVect;
+%rename(MACCSFingerprintMol) RDKit::MACCSFingerprints::getFingerprintAsBitVect;
+%include <GraphMol/Fingerprints/MACCS.h>
+
+%ignore RDKit::RDKitFPUtils::enumerateAllPaths;
+%include <GraphMol/Fingerprints/FingerprintUtil.h>

data/Code/RubyWrappers/ForceField.i

@@ -0,0 +1,161 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+%{
+#include <ForceField/ForceField.h>
+#include <GraphMol/ForceFieldHelpers/UFF/AtomTyper.h>
+#include <GraphMol/ForceFieldHelpers/UFF/Builder.h>
+#include <GraphMol/ForceFieldHelpers/MMFF/AtomTyper.h>
+#include <GraphMol/ForceFieldHelpers/MMFF/Builder.h>
+#include <ForceField/Contrib.h>
+#include <ForceField/UFF/Params.h>
+#include <ForceField/UFF/AngleBend.h>
+#include <ForceField/UFF/BondStretch.h>
+#include <ForceField/UFF/Contribs.h>
+#include <ForceField/DistanceConstraint.h>
+#include <ForceField/UFF/Nonbonded.h>
+#include <ForceField/UFF/TorsionAngle.h>
+#include <ForceField/UFF/Inversion.h>
+#include <boost/tuple/tuple.hpp>
+#include <GraphMol/ROMol.h>
+%}
+
+// We have trouble with the definition as it is -- make it a Point3D_Vect instead
+%ignore ForceFields::ForceField::positions();
+%ignore ForceFields::ForceField::positions() const;
+%rename(get) ForceFields::UFF::ParamCollection::operator();
+
+%include <ForceField/ForceField.h>
+%include <ForceField/Contrib.h>
+%include <ForceField/UFF/Params.h>
+%include <ForceField/UFF/AngleBend.h>
+%include <ForceField/UFF/BondStretch.h>
+%include <ForceField/DistanceConstraint.h>
+%include <ForceField/UFF/Nonbonded.h>
+%include <ForceField/UFF/TorsionAngle.h>
+%include <ForceField/UFF/Inversion.h>
+
+%template(FF_Contrib_Vect) std::vector<ForceFields::ContribPtr>;
+%extend ForceFields::ForceField {
+  std::vector<RDGeom::Point3D *> &positions3D () {
+    return ((std::vector<RDGeom::Point3D *> &) ($self)->positions());
+  }
+
+  static int UFFOptimizeMolecule(RDKit::ROMol &mol, int maxIters=200,
+    double vdwThresh=10.0, int confId=-1,
+    bool ignoreInterfragInteractions=true ) {
+
+    ForceFields::ForceField *ff=RDKit::UFF::constructForceField(mol,vdwThresh, confId, ignoreInterfragInteractions);
+    ff->initialize();
+    int res=ff->minimize(maxIters);
+    delete ff;
+    return res;
+  }
+
+  %newobject UFFGetMoleculeForceField;
+  static ForceFields::ForceField *UFFGetMoleculeForceField(RDKit::ROMol &mol,
+    double vdwThresh=10.0,
+    int confId=-1,
+    bool ignoreInterfragInteractions=true ) {
+
+    ForceFields::ForceField *ff=RDKit::UFF::constructForceField(mol,vdwThresh, confId, ignoreInterfragInteractions);
+    ff->initialize();
+    return ff;
+  }
+
+  static bool UFFHasAllMoleculeParams(const RDKit::ROMol &mol){
+    RDKit::UFF::AtomicParamVect types;
+    bool foundAll;
+    boost::tie(types,foundAll)=RDKit::UFF::getAtomTypes(mol);
+    return foundAll;
+  }
+
+  /* From GraphMol/ForceFieldHelpers/UFF/AtomTyper.h */
+  static void UFFAddAtomChargeFlags(const RDKit::Atom *atom, std::string &atomKey, bool tolerateChargeMismatch=true) {
+    RDKit::UFF::Tools::addAtomChargeFlags(atom, atomKey, tolerateChargeMismatch);
+  }
+
+  static std::string UFFGetAtomLabel(const RDKit::Atom *atom) {
+    return RDKit::UFF::Tools::getAtomLabel(atom);
+  }
+
+  /* From GraphMol/ForceFieldHelpers/UFF/AtomTyper.h */
+  static std::pair<std::vector<const ForceFields::UFF::AtomicParams *>,bool> UFFGetAtomTypes(const RDKit::ROMol &mol, const std::string &paramData="") {
+    return RDKit::UFF::getAtomTypes(mol, paramData);
+  }
+
+  static int MMFFOptimizeMolecule(RDKit::ROMol &mol,
+                                  std::string mmffVariant="MMFF94",
+                                  int maxIters=200,
+                                  double nonBondedThresh=100.0, int confId=-1,
+                                  bool ignoreInterfragInteractions=true ) {
+    int res=1;
+    RDKit::MMFF::MMFFMolProperties mmffMolProperties(mol, mmffVariant);
+
+    if (mmffMolProperties.isValid()) {
+      ForceFields::ForceField *ff = RDKit::MMFF::constructForceField(mol,
+        &mmffMolProperties, nonBondedThresh, confId, ignoreInterfragInteractions);
+      ff->initialize();
+      res = ff->minimize(maxIters);
+      delete ff;
+    } else {
+      BOOST_LOG(rdErrorLog) << "Could not construct MMFF force field"<<std::endl;
+    }
+
+    return res;
+  }
+
+  %newobject MMFFGetMoleculeForceField;
+  static ForceFields::ForceField *MMFFGetMoleculeForceField(RDKit::ROMol &mol,
+                                                            std::string mmffVariant="MMFF94",
+                                                            double nonBondedThresh=100.0,
+                                                            int confId=-1,
+                                                            bool ignoreInterfragInteractions=true ) {
+
+    ForceFields::ForceField *ff = 0;
+    RDKit::MMFF::MMFFMolProperties mmffMolProperties(mol, mmffVariant);
+    if (mmffMolProperties.isValid()) {
+      ff = RDKit::MMFF::constructForceField(mol,
+                                            &mmffMolProperties, nonBondedThresh,
+                                            confId, ignoreInterfragInteractions);
+      ff->initialize();
+    } else {
+      BOOST_LOG(rdErrorLog) << "Could not construct MMFF force field"<<std::endl;
+    }
+    return ff;
+  }
+  static bool MMFFHasAllMoleculeParams(RDKit::ROMol &mol){
+    RDKit::MMFF::MMFFMolProperties mmffMolProperties(mol);
+    return mmffMolProperties.isValid();
+  }
+
+ }

data/Code/RubyWrappers/GeneralizedSubstruct.i

@@ -0,0 +1,38 @@
+/*
+*
+*  This file is part of the RDKit.
+*  The contents are covered by the terms of the BSD license
+*  which is included in the file license.txt, found at the root
+*  of the RDKit source tree.
+*
+*/
+
+#if SWIG_VERSION >= 0x040101
+%include <std_unique_ptr.i>
+%unique_ptr(ExplicitBitVect)
+#endif
+
+%{
+#include <GraphMol/GeneralizedSubstruct/XQMol.h>
+%}
+
+#if SWIG_VERSION < 0x040101
+%ignore patternFingerprintTargetMol(const ROMol &mol, unsigned int fpSize = 2048U);
+%ignore patternFingerprintQuery(unsigned int fpSize = 2048U) const;
+#endif
+
+%ignore ExtendedQueryMol(std::unique_ptr<RWMol> mol);
+%ignore ExtendedQueryMol(std::unique_ptr<MolBundle> mol);
+%ignore ExtendedQueryMol(std::unique_ptr<TautomerQuery> mol);
+%ignore ExtendedQueryMol(
+      std::unique_ptr<std::vector<std::unique_ptr<TautomerQuery>>> tqs);
+%ignore xqmol;
+
+%include "GraphMol/GeneralizedSubstruct/XQMol.h";
+
+%extend RDKit::GeneralizedSubstruct::ExtendedQueryMol  {
+  std::vector< std::vector<std::pair<int, int> > > getSubstructMatches(RDKit::ROMol &target,RDKit::SubstructMatchParameters ps = RDKit::SubstructMatchParameters()){
+    std::vector<RDKit::MatchVectType> mvs = SubstructMatch(target, *($self),ps);
+    return mvs;
+  };
+}

data/Code/RubyWrappers/GenericRDKitException.h

@@ -0,0 +1,27 @@
+// $Id: GenericRDKitException.h
+//
+//   @@ All Rights Reserved @@
+//  This file is part of the RDKit.
+//  The contents are covered by the terms of the BSD license
+//  which is included in the file license.txt, found at the root
+//  of the RDKit source tree.
+//
+
+// A generic exception (to cause a corresponding one to be created in Java)
+
+#include <RDGeneral/export.h>
+#include <exception>
+
+namespace RDKit {
+
+class GenericRDKitException : public std::exception {
+ public:
+  GenericRDKitException(const std::string &i) : _value(i){};
+  GenericRDKitException(const char *msg) : _value(msg){};
+  const char *what() const noexcept override { return _value.c_str(); };
+  ~GenericRDKitException() noexcept {};
+
+ private:
+  std::string _value;
+};
+}  // namespace RDKit

data/Code/RubyWrappers/Inchi.i

@@ -0,0 +1,38 @@
+/* 
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <INCHI-API/inchi.h>
+%}
+%include <INCHI-API/inchi.h>
+

data/Code/RubyWrappers/MolBundle.i

@@ -0,0 +1,16 @@
+/*
+ *
+ *  Copyright (c) 2020, Greg Landrum and T5 Informatics GmbH
+ *  All rights reserved.
+ *
+ *  This file is part of the RDKit.
+ *  The contents are covered by the terms of the BSD license
+ *  which is included in the file license.txt, found at the root
+ *  of the RDKit source tree.
+ *
+ */
+%{
+#include <GraphMol/MolBundle.h>
+%}
+
+%include<GraphMol/MolBundle.h>

data/Code/RubyWrappers/MolDraw2D.i

@@ -0,0 +1,117 @@
+/*
+*
+*  Copyright (c) 2015, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+%include "boost_tuple.i"
+%include "std_vector.i"
+%include "std_map.i"
+%include "std_pair.i"
+%{
+#include <GraphMol/RDKitBase.h>
+#include <GraphMol/MolDraw2D/MolDraw2DHelpers.h>
+#include <GraphMol/MolDraw2D/MolDraw2D.h>
+#include <GraphMol/MolDraw2D/MolDraw2DSVG.h>
+#include <GraphMol/MolDraw2D/MolDraw2DUtils.h>
+#include <map>
+#include <vector>
+#include <utility>
+%}
+
+%template(Int_String_Map) std::map< int, std::string >;
+%template(ColourPalette) std::map< int, RDKit::DrawColour >;
+%template(Colour_Vect) std::vector< RDKit::DrawColour >;
+%template(MultipleColourPalette) std::map< int, std::vector< RDKit::DrawColour > >;
+%template(Int_Double_Map) std::map< int, double >;
+%template(Float_Pair) std::pair<float,float>;
+%template(Float_Pair_Vect) std::vector< std::pair<float,float> >;
+%template(ROMol_Ptr_Vect) std::vector<RDKit::ROMol*>;
+%template(Point2D_Vect) std::vector<RDGeom::Point2D *>;
+%template(ColourPalette_Vect) std::vector< std::map< int, RDKit::DrawColour > >;
+%template(Int_Double_Map_Vect) std::vector< std::map< int, double > >;
+
+%ignore RDKit::MolDraw2DSVG::MolDraw2DSVG(int,int,std::ostream &);
+%ignore RDKit::MolDraw2DUtils::contourAndDrawGaussians(
+    MolDraw2D &, const std::vector<Point2D> &,
+    const std::vector<double> &, const std::vector<double> &,
+    size_t, std::vector<double> &,
+    const ContourParams &);
+%ignore RDKit::MolDraw2DUtils::contourAndDrawGaussians(
+    MolDraw2D &, const std::vector<Point2D> &,
+    const std::vector<double> &, const std::vector<double> &,
+    size_t, ContourParams &);
+%ignore RDKit::MolDraw2DUtils::contourAndDrawGaussians;
+%ignore RDKit::MolDraw2DUtils::contourAndDrawGrid;
+
+
+%include <GraphMol/MolDraw2D/MolDraw2DHelpers.h>
+%include <GraphMol/MolDraw2D/MolDraw2D.h>
+%include <GraphMol/MolDraw2D/MolDraw2DSVG.h>
+%include <GraphMol/MolDraw2D/MolDraw2DUtils.h>
+
+%inline %{
+    void ContourAndDrawGaussians(
+    RDKit::MolDraw2D &drawer, const std::vector<RDGeom::Point2D *> &p_locs,
+    const std::vector<double> &heights, const std::vector<double> &widths,
+    size_t nContours, std::vector<double> &levels,
+    const RDKit::MolDraw2DUtils::ContourParams &ps = RDKit::MolDraw2DUtils::ContourParams()){
+        std::vector<Point2D> locs;
+        locs.reserve(p_locs.size());
+        for(const auto *p : p_locs){
+            locs.push_back(*p);
+        }
+        contourAndDrawGaussians(drawer,locs,heights,widths,nContours,levels,ps);
+    };
+    void ContourAndDrawGaussians(
+    RDKit::MolDraw2D &drawer, const std::vector<RDGeom::Point2D *> &p_locs,
+    const std::vector<double> &heights, const std::vector<double> &widths,
+    size_t nContours = 10,
+    const RDKit::MolDraw2DUtils::ContourParams &ps = RDKit::MolDraw2DUtils::ContourParams()){
+        std::vector<Point2D> locs;
+        locs.reserve(p_locs.size());
+        for(const auto *p : p_locs){
+            locs.push_back(*p);
+        }
+        contourAndDrawGaussians(drawer,locs,heights,widths,nContours,ps);
+    };
+    void ContourAndDrawGrid(
+    RDKit::MolDraw2D &drawer, const std::vector<double> &p_grid,
+    const std::vector<double> &xcoords, const std::vector<double> &ycoords,
+    size_t nContours, std::vector<double> &levels,
+    const RDKit::MolDraw2DUtils::ContourParams &ps = RDKit::MolDraw2DUtils::ContourParams()){
+        contourAndDrawGrid(drawer,p_grid.data(),xcoords,ycoords,nContours,levels,ps);
+    };
+    void ContourAndDrawGrid(
+    RDKit::MolDraw2D &drawer, const std::vector<double> &p_grid,
+    const std::vector<double> &xcoords, const std::vector<double> &ycoords,
+    size_t nContours=10,
+    const RDKit::MolDraw2DUtils::ContourParams &ps = RDKit::MolDraw2DUtils::ContourParams()){
+        contourAndDrawGrid(drawer,p_grid.data(),xcoords,ycoords,nContours,ps);
+    };
+%}

data/Code/RubyWrappers/MolEnumerator.i

@@ -0,0 +1,45 @@
+/*
+ *
+ *  Copyright (c) 2020-2021, Greg Landrum and T5 Informatics GmbH
+ *  All rights reserved.
+ *
+ *  This file is part of the RDKit.
+ *  The contents are covered by the terms of the BSD license
+ *  which is included in the file license.txt, found at the root
+ *  of the RDKit source tree.
+ *
+ */
+%{
+#include <GraphMol/MolEnumerator/MolEnumerator.h>
+%}
+
+
+%ignore RDKit::MolEnumerator::detail::idxPropName;
+%ignore RDKit::MolEnumerator::detail::preserveOrigIndices;
+%ignore RDKit::MolEnumerator::detail::removeOrigIndices;
+
+%ignore RDKit::MolEnumerator::MolEnumeratorOp;
+%ignore RDKit::MolEnumerator::PositionVariationOp;
+%ignore RDKit::MolEnumerator::LinkNodeOp;
+%ignore RDKit::MolEnumerator::RepeatUnitOp;
+
+%inline %{
+
+RDKit::MolEnumerator::MolEnumeratorParams getLinkNodeParams(){
+    RDKit::MolEnumerator::MolEnumeratorParams res;
+    res.dp_operation.reset(new RDKit::MolEnumerator::LinkNodeOp());
+    return res;
+}
+RDKit::MolEnumerator::MolEnumeratorParams getPositionVariationParams(){
+    RDKit::MolEnumerator::MolEnumeratorParams res;
+    res.dp_operation.reset(new RDKit::MolEnumerator::PositionVariationOp());
+    return res;
+}
+RDKit::MolEnumerator::MolEnumeratorParams getRepeatUnitParams(){
+    RDKit::MolEnumerator::MolEnumeratorParams res;
+    res.dp_operation.reset(new RDKit::MolEnumerator::RepeatUnitOp());
+    return res;
+}
+
+%}
+%include<GraphMol/MolEnumerator/MolEnumerator.h>

data/Code/RubyWrappers/MolHash.i

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2019 Greg Landrum
+ *  All rights reserved.
+ *
+ *  This file is part of the RDKit.
+ *  The contents are covered by the terms of the BSD license
+ *  which is included in the file license.txt, found at the root
+ *  of the RDKit source tree.
+ */
+
+%include "std_string.i"
+
+%{
+#include <GraphMol/MolHash/MolHash.h>
+%}
+
+%ignore RDKit::MolHash::generateMoleculeHashCode;
+%ignore RDKit::MolHash::CodeFlags;
+%ignore RDKit::MolHash::fillAtomBondCodes;
+%ignore RDKit::MolHash::HashSet;
+%ignore RDKit::MolHash::generateMoleculeHashSet;
+%ignore RDKit::MolHash::encode;
+
+%include<GraphMol/MolHash/nmmolhash.h>
+

data/Code/RubyWrappers/MolOps.i

@@ -0,0 +1,72 @@
+/*
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+%include "std_pair.i"
+
+%{
+#include <GraphMol/MolOps.h>
+%}
+
+%template(MolSanitizeException_Vect) std::vector<boost::shared_ptr<RDKit::MolSanitizeException>>;
+
+%newobject RDKit::MolOps::renumberAtoms;
+%newobject RDKit::MolOps::removeHs;
+%newobject RDKit::MolOps::addHs;
+%newobject RDKit::MolOps::removeAllHs;
+%newobject RDKit::MolOps::mergeQueryHs;
+%newobject RDKit::MolOps::adjustQueryProperties;
+
+%ignore RDKit::MolOps::detectChemistryProblems;
+// Ignore all native sanitizeMol overloads - we provide a custom wrapper below
+%ignore RDKit::MolOps::sanitizeMol;
+%include <GraphMol/MolOps.h>
+%template(BoolPair) std::pair<bool, bool>;
+
+%inline %{
+  int sanitizeMol(RDKit::RWMol &mol,int sanitizeOps){
+    unsigned int opThatFailed;
+    try{
+      RDKit::MolOps::sanitizeMol(mol,opThatFailed,
+                                 static_cast<unsigned int>(sanitizeOps));
+    } catch(...) {
+
+    }
+    return static_cast<int>(opThatFailed);
+  };
+  std::vector<boost::shared_ptr<RDKit::MolSanitizeException>> detectChemistryProblems(RDKit::ROMol &mol,int sanitizeOps=RDKit::MolOps::SANITIZE_ALL){
+    std::vector<boost::shared_ptr<RDKit::MolSanitizeException>> res;
+    auto probs = RDKit::MolOps::detectChemistryProblems(mol,sanitizeOps);
+    for(const auto &exc_ptr : probs) {
+      res.push_back(boost::shared_ptr<RDKit::MolSanitizeException>(exc_ptr->copy()));
+    }
+    return res;
+  };
+%}

data/Code/RubyWrappers/MolStandardize.i

@@ -0,0 +1,37 @@
+%{
+#include <GraphMol/MolStandardize/MolStandardize.h>
+#include <GraphMol/MolStandardize/Pipeline.h>
+
+namespace RDKit {
+namespace MolStandardize {
+    bool operator==(const PipelineLogEntry & rhs, const PipelineLogEntry & lhs) {
+        return (rhs.status == lhs.status) && (rhs.detail == lhs.detail);
+    }
+    bool operator!=(const PipelineLogEntry & rhs, const PipelineLogEntry & lhs) {
+        return !(rhs == lhs);
+    }
+}
+}
+%}
+
+%include <std_vector.i>
+namespace std {
+%template(PipelineLog) std::vector<RDKit::MolStandardize::PipelineLogEntry>;
+}
+
+%newobject RDKit::MolStandardize::cleanup;
+%newobject RDKit::MolStandardize::normalize;
+%newobject RDKit::MolStandardize::reionize;
+%newobject RDKit::MolStandardize::removeFragments;
+%newobject RDKit::MolStandardize::canonicalTautomer;
+%newobject RDKit::MolStandardize::tautomerParent;
+%newobject RDKit::MolStandardize::fragmentParent;
+%newobject RDKit::MolStandardize::stereoParent;
+%newobject RDKit::MolStandardize::isotopeParent;
+%newobject RDKit::MolStandardize::chargeParent;
+%newobject RDKit::MolStandardize::superParent;
+%newobject RDKit::MolStandardize::disconnectOrganometallics;
+
+%include <GraphMol/MolStandardize/MolStandardize.h>
+
+%include <GraphMol/MolStandardize/Pipeline.h>