Created
March 15, 2015 12:49
-
-
Save siriusjack/ae359025557d304de0e9 to your computer and use it in GitHub Desktop.
swig: openbabel-python.i
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
%module openbabel | |
%{ | |
// used to set import/export for Cygwin DLLs | |
#ifdef WIN32 | |
#define USING_OBDLL | |
#endif | |
#include <openbabel/obutil.h> | |
#include <openbabel/rand.h> | |
#include <openbabel/math/vector3.h> | |
#include <openbabel/math/matrix3x3.h> | |
#include <openbabel/math/transform3d.h> | |
#include <openbabel/math/spacegroup.h> | |
#include <openbabel/generic.h> | |
#include <openbabel/griddata.h> | |
#include <openbabel/base.h> | |
#include <openbabel/mol.h> | |
#include <openbabel/atom.h> | |
#include <openbabel/bond.h> | |
#include <openbabel/reaction.h> | |
#include <openbabel/residue.h> | |
#include <openbabel/internalcoord.h> | |
#include <openbabel/ring.h> | |
#include <openbabel/obconversion.h> | |
#include <openbabel/oberror.h> | |
#include <openbabel/plugin.h> | |
#include <openbabel/fingerprint.h> | |
#include <openbabel/descriptor.h> | |
#include <openbabel/format.h> | |
#include <openbabel/forcefield.h> | |
#include <openbabel/builder.h> | |
#include <openbabel/op.h> | |
#include <openbabel/bitvec.h> | |
#include <openbabel/data.h> | |
#include <openbabel/parsmart.h> | |
#include <openbabel/alias.h> | |
#include <openbabel/atomclass.h> | |
#include <openbabel/kinetics.h> | |
#include <openbabel/rotor.h> | |
#include <openbabel/rotamer.h> | |
#include <openbabel/spectrophore.h> | |
#include <openbabel/chargemodel.h> | |
#include <openbabel/phmodel.h> | |
#include <openbabel/graphsym.h> | |
#include <openbabel/isomorphism.h> | |
#include <openbabel/query.h> | |
#include <openbabel/canon.h> | |
#include <openbabel/stereo/tetrahedral.h> | |
#include <openbabel/stereo/cistrans.h> | |
#include <openbabel/stereo/squareplanar.h> | |
#include <openbabel/stereo/bindings.h> | |
%} | |
#ifdef HAVE_EIGEN | |
%{ | |
#include <openbabel/conformersearch.h> | |
#include <openbabel/math/align.h> | |
%} | |
#else | |
%ignore OpenBabel::OBForceField::FastRotorSearch; | |
%ignore OpenBabel::OBForceField::DiverseConfGen; | |
#endif | |
%include "std_list.i" | |
%include "std_map.i" | |
%include "std_vector.i" | |
%include "std_string.i" | |
%include "std_pair.i" | |
namespace std { | |
%define VVTEMPLATE_WRAP(name, T) | |
%feature("ignore") vector< vector<T> >::append; | |
%feature("ignore") vector< vector<T> >::assign; | |
%feature("ignore") vector< vector<T> >::back; | |
%feature("ignore") vector< vector<T> >::begin; | |
%feature("ignore") vector< vector<T> >::capacity; | |
%feature("ignore") vector< vector<T> >::clear; | |
%feature("ignore") vector< vector<T> >::empty; | |
%feature("ignore") vector< vector<T> >::end; | |
%feature("ignore") vector< vector<T> >::erase; | |
%feature("ignore") vector< vector<T> >::front; | |
%feature("ignore") vector< vector<T> >::get_allocator; | |
%feature("ignore") vector< vector<T> >::insert; | |
%feature("ignore") vector< vector<T> >::pop; | |
%feature("ignore") vector< vector<T> >::pop_back; | |
%feature("ignore") vector< vector<T> >::push_back; | |
%feature("ignore") vector< vector<T> >::rbegin; | |
%feature("ignore") vector< vector<T> >::rend; | |
%feature("ignore") vector< vector<T> >::reserve; | |
%feature("ignore") vector< vector<T> >::resize; | |
%feature("ignore") vector< vector<T> >::size; | |
%feature("ignore") vector< vector<T> >::swap; | |
%template(vectorv ## name) vector< vector<T> >; | |
%enddef | |
%define VECTORTEMPLATE_WRAP(vectorname, T) | |
%feature("ignore") vector<T>::append; | |
%feature("ignore") vector<T>::assign; | |
%feature("ignore") vector<T>::back; | |
%feature("ignore") vector<T>::begin; | |
%feature("ignore") vector<T>::capacity; | |
%feature("ignore") vector<T>::clear; | |
%feature("ignore") vector<T>::empty; | |
%feature("ignore") vector<T>::end; | |
%feature("ignore") vector<T>::erase; | |
%feature("ignore") vector<T>::front; | |
%feature("ignore") vector<T>::get_allocator; | |
%feature("ignore") vector<T>::insert; | |
%feature("ignore") vector<T>::pop; | |
%feature("ignore") vector<T>::pop_back; | |
%feature("ignore") vector<T>::push_back; | |
%feature("ignore") vector<T>::rbegin; | |
%feature("ignore") vector<T>::rend; | |
%feature("ignore") vector<T>::reserve; | |
%feature("ignore") vector<T>::resize; | |
%feature("ignore") vector<T>::size; | |
%feature("ignore") vector<T>::swap; | |
%template(vector ## vectorname) vector<T>; | |
%enddef | |
%define VECTORPAIRTEMPLATE_WRAP(vectorname, T1, T2) | |
%feature("ignore") vector< pair<T1, T2> >::append; | |
%feature("ignore") vector< pair<T1, T2> >::assign; | |
%feature("ignore") vector< pair<T1, T2> >::back; | |
%feature("ignore") vector< pair<T1, T2> >::begin; | |
%feature("ignore") vector< pair<T1, T2> >::capacity; | |
%feature("ignore") vector< pair<T1, T2> >::clear; | |
%feature("ignore") vector< pair<T1, T2> >::empty; | |
%feature("ignore") vector< pair<T1, T2> >::end; | |
%feature("ignore") vector< pair<T1, T2> >::erase; | |
%feature("ignore") vector< pair<T1, T2> >::front; | |
%feature("ignore") vector< pair<T1, T2> >::get_allocator; | |
%feature("ignore") vector< pair<T1, T2> >::insert; | |
%feature("ignore") vector< pair<T1, T2> >::pop; | |
%feature("ignore") vector< pair<T1, T2> >::pop_back; | |
%feature("ignore") vector< pair<T1, T2> >::push_back; | |
%feature("ignore") vector< pair<T1, T2> >::rbegin; | |
%feature("ignore") vector< pair<T1, T2> >::rend; | |
%feature("ignore") vector< pair<T1, T2> >::reserve; | |
%feature("ignore") vector< pair<T1, T2> >::resize; | |
%feature("ignore") vector< pair<T1, T2> >::size; | |
%feature("ignore") vector< pair<T1, T2> >::swap; | |
%template(vpair ## vectorname) vector< pair<T1, T2> >; | |
%enddef | |
VECTORTEMPLATE_WRAP(Int, int) | |
VECTORTEMPLATE_WRAP(UnsignedInt, unsigned int) | |
VVTEMPLATE_WRAP(Int, int) | |
VECTORTEMPLATE_WRAP(Double, double) | |
VECTORTEMPLATE_WRAP(ULong, unsigned long) | |
VECTORTEMPLATE_WRAP(String, std::string) | |
VECTORTEMPLATE_WRAP(Vector3, OpenBabel::vector3) | |
VVTEMPLATE_WRAP(Vector3, OpenBabel::vector3) | |
VECTORTEMPLATE_WRAP(OBMol, OpenBabel::OBMol) | |
VECTORTEMPLATE_WRAP(OBBond, OpenBabel::OBBond) | |
VECTORTEMPLATE_WRAP(OBResidue, OpenBabel::OBResidue) | |
VECTORTEMPLATE_WRAP(OBRing, OpenBabel::OBRing) | |
VECTORTEMPLATE_WRAP(pOBRing, OpenBabel::OBRing*) | |
VECTORTEMPLATE_WRAP(pOBGenericData, OpenBabel::OBGenericData*) | |
VECTORTEMPLATE_WRAP(pOBInternalCoord, OpenBabel::OBInternalCoord*) | |
%template(pairUIntUInt) pair<unsigned int, unsigned int>; | |
VECTORPAIRTEMPLATE_WRAP(UIntUInt, unsigned int, unsigned int); | |
%template(vvpairUIntUInt) vector< vector< pair<unsigned int, unsigned int> > >; | |
} | |
%define CAST_GENERICDATA_TO(subclass) | |
%inline %{ | |
OpenBabel::OB ## subclass *to ## subclass(OpenBabel::OBGenericData *data) { | |
return (OpenBabel::OB ## subclass *) data; | |
} | |
%} | |
%enddef | |
%inline %{ /* can't use macro -- AliasData not OBAliasData */ | |
OpenBabel::AliasData *toAliasData(OpenBabel::OBGenericData *data) { | |
return (OpenBabel::AliasData*) data; | |
} | |
%} | |
CAST_GENERICDATA_TO(AngleData) | |
CAST_GENERICDATA_TO(AtomClassData) | |
CAST_GENERICDATA_TO(ChiralData) | |
CAST_GENERICDATA_TO(CommentData) | |
CAST_GENERICDATA_TO(ConformerData) | |
CAST_GENERICDATA_TO(ExternalBondData) | |
CAST_GENERICDATA_TO(GridData) | |
CAST_GENERICDATA_TO(MatrixData) | |
CAST_GENERICDATA_TO(NasaThermoData) | |
CAST_GENERICDATA_TO(PairData) | |
// CAST_GENERICDATA_TO(PairTemplate) | |
CAST_GENERICDATA_TO(RateData) | |
CAST_GENERICDATA_TO(RotamerList) | |
CAST_GENERICDATA_TO(RotationData) | |
CAST_GENERICDATA_TO(SerialNums) | |
CAST_GENERICDATA_TO(SetData) | |
CAST_GENERICDATA_TO(SymmetryData) | |
CAST_GENERICDATA_TO(TorsionData) | |
CAST_GENERICDATA_TO(UnitCell) | |
CAST_GENERICDATA_TO(VectorData) | |
CAST_GENERICDATA_TO(VibrationData) | |
CAST_GENERICDATA_TO(VirtualBond) | |
CAST_GENERICDATA_TO(TetrahedralStereo) | |
CAST_GENERICDATA_TO(CisTransStereo) | |
CAST_GENERICDATA_TO(SquarePlanarStereo) | |
// This method is renamed to a valid Python method name, as otherwise | |
// it cannot be used from Python | |
%rename(inc) *::operator++; | |
%ignore *::operator=; | |
%ignore *::operator[]; | |
%import <openbabel/babelconfig.h> | |
%include <openbabel/data.h> | |
%include <openbabel/rand.h> | |
%include <openbabel/obutil.h> | |
%include <openbabel/math/vector3.h> | |
%warnfilter(503) OpenBabel::matrix3x3; // Not wrapping any of the overloaded operators | |
%include <openbabel/math/matrix3x3.h> | |
%include <openbabel/math/transform3d.h> | |
%include <openbabel/math/spacegroup.h> | |
//# CloneData should be used instead of the following method | |
%ignore OpenBabel::OBBase::SetData; | |
%include <openbabel/base.h> | |
%include <openbabel/generic.h> | |
%include <openbabel/griddata.h> | |
%include <openbabel/chains.h> | |
%include <openbabel/typer.h> | |
// To avoid warning in plugin.h about "Nothing known about std::binary_function" | |
namespace std { | |
template <T1, T2, T3> | |
class binary_function {}; | |
} | |
%template(dummy) std::binary_function <const char *, const char *, bool>; | |
%include <openbabel/plugin.h> | |
// To avoid warning in oberror.h about "Nothing known about std::stringbuf" | |
namespace std { class stringbuf {}; } | |
%warnfilter(503) OpenBabel::OBError; // Not wrapping any of the overloaded operators | |
%include <openbabel/oberror.h> | |
%include <openbabel/format.h> | |
%include <openbabel/obconversion.h> | |
%include <openbabel/residue.h> | |
%include <openbabel/internalcoord.h> | |
%include <openbabel/atom.h> | |
%include <openbabel/bond.h> | |
%include <openbabel/reaction.h> | |
// Remove C++ iterators | |
%pythoncode %{ | |
def exceptionIter(*args): | |
raise Exception("""\nThis method can only be used from C++. To iterate from Python | |
use the Iter classes (OBMolAtomIter, etc.) as described at | |
http://openbabel.org/wiki/Python""") | |
%} | |
%define IGNORE_ITER(parent, iteree) | |
%ignore OpenBabel::parent::Begin ## iteree ## s; | |
%ignore OpenBabel::parent::End ## iteree ## s; | |
%ignore OpenBabel::parent::Begin ## iteree; | |
%ignore OpenBabel::parent::Next ## iteree; | |
%enddef | |
IGNORE_ITER(OBMol, Bond) | |
IGNORE_ITER(OBMol, Atom) | |
IGNORE_ITER(OBMol, Residue) | |
%include <openbabel/mol.h> | |
%pythoncode %{ | |
OBMol.BeginAtoms = OBMol.EndAtoms = OBMol.BeginAtom = OBMol.EndAtom = exceptionIter | |
OBMol.BeginBonds = OBMol.EndBonds = OBMol.BeginBond = OBMol.EndBond = exceptionIter | |
OBMol.BeginResidues = OBMol.EndResidues = OBMol.BeginResidue = OBMol.EndResidue = exceptionIter | |
%} | |
%include <openbabel/ring.h> | |
%include <openbabel/parsmart.h> | |
%include <openbabel/alias.h> | |
%include <openbabel/atomclass.h> | |
%ignore OpenBabel::FptIndex; | |
%include <openbabel/fingerprint.h> | |
%ignore OpenBabel::OBDescriptor::LessThan; | |
%include <openbabel/descriptor.h> | |
//# Ignore shadowed methods | |
%ignore OpenBabel::OBForceField::VectorSubtract(const double *const, const double *const, double *); | |
%ignore OpenBabel::OBForceField::VectorMultiply(const double *const, const double, double *); | |
%include <openbabel/forcefield.h> | |
%include <openbabel/builder.h> | |
%include <openbabel/op.h> | |
%include <openbabel/chargemodel.h> | |
%apply std::string& INPUT { std::string &start } // Required for OBChemTsfm.Init | |
%apply std::string& INPUT { std::string &end } // Required for OBChemTsfm.Init | |
%include <openbabel/phmodel.h> | |
%include <openbabel/graphsym.h> | |
%include <openbabel/isomorphism.h> | |
%include <openbabel/query.h> | |
%include <openbabel/canon.h> | |
%include <openbabel/stereo/stereo.h> | |
%warnfilter(503) OpenBabel::OBBitVec; // Not wrapping any of the overloaded operators | |
%include <openbabel/bitvec.h> | |
//# Ignore shadowed method | |
%ignore OpenBabel::OBRotor::GetRotAtoms() const; | |
%include <openbabel/rotor.h> | |
%ignore OpenBabel::Swab; | |
%include <openbabel/rotamer.h> | |
%include <openbabel/spectrophore.h> | |
#ifdef HAVE_EIGEN | |
%include <openbabel/conformersearch.h> | |
%include <openbabel/math/align.h> | |
#endif | |
//# The following %ignores avoid warning messages due to shadowed classes. | |
//# This does not imply a loss of functionality as (in this case) | |
//# the shadowed class is identical (from the point of view of SWIG) to | |
//# the shadowing class. | |
//# This is because C++ references (&) are transformed by SWIG back into | |
//# pointers, so that OBAtomIter(OBMol &) would be treated the same as | |
//# OBAtomIter(OBMol *). | |
%ignore OBAtomAtomIter(OBAtom &); | |
%ignore OBAtomBondIter(OBAtom &); | |
%ignore OBMolAngleIter(OBMol &); | |
%ignore OBMolAtomIter(OBMol &); | |
%ignore OBMolAtomBFSIter(OBMol &); | |
%ignore OBMolAtomDFSIter(OBMol &); | |
%ignore OBMolAtomBFSIter(OBMol &, int); | |
%ignore OBMolAtomDFSIter(OBMol &, int); | |
%ignore OBMolBondIter(OBMol &); | |
%ignore OBMolBondBFSIter(OBMol &); | |
%ignore OBMolBondBFSIter(OBMol &, int); | |
%ignore OBMolPairIter(OBMol &); | |
%ignore OBMolRingIter(OBMol &); | |
%ignore OBMolTorsionIter(OBMol &); | |
%ignore OBResidueIter(OBMol &); | |
%ignore OBResidueAtomIter(OBResidue &); | |
//# These classes are renamed so that they can be replaced by Python | |
//# classes of the same name which provide Pythonic iterators | |
//# (see %pythoncode section below) | |
%rename(_OBAtomAtomIter) OpenBabel::OBAtomAtomIter; | |
%rename(_OBAtomBondIter) OpenBabel::OBAtomBondIter; | |
%rename(_OBMolAngleIter) OpenBabel::OBMolAngleIter; | |
%rename(_OBMolAtomIter) OpenBabel::OBMolAtomIter; | |
%rename(_OBMolAtomBFSIter) OpenBabel::OBMolAtomBFSIter; | |
%rename(_OBMolAtomDFSIter) OpenBabel::OBMolAtomDFSIter; | |
%rename(_OBMolBondIter) OpenBabel::OBMolBondIter; | |
%rename(_OBMolPairIter) OpenBabel::OBMolPairIter; | |
%rename(_OBMolRingIter) OpenBabel::OBMolRingIter; | |
%rename(_OBMolTorsionIter) OpenBabel::OBMolTorsionIter; | |
%rename(_OBResidueIter) OpenBabel::OBResidueIter; | |
%rename(_OBResidueAtomIter) OpenBabel::OBResidueAtomIter; | |
%rename(_OBFingerprintIter) OpenBabel::PluginIter<OBFingerprint>; | |
%include <openbabel/obiter.h> | |
//# The following class, OBiter, is subclassed to provide Python iterators | |
//# equivalent to the C++ iterators in obiter.h and the plugin iterators | |
%pythoncode %{ | |
class OBIter(object): | |
OBiterator = None # This is defined by the subclasses | |
def __init__(self, *params): | |
self.iter = self.OBiterator(*params) | |
self.finished = False | |
if not self.iter.__bool__(): | |
self.finished = True | |
def __iter__(self): | |
return self | |
def next(self): | |
if not self.finished: | |
b = self.iter.__ref__() | |
self.iter.inc() | |
if not self.iter.__bool__(): | |
# There is nothing left to iterate over | |
self.finished = True | |
return b | |
else: | |
raise StopIteration | |
__next__ = next | |
class OBIterWithDepth(OBIter): | |
def next(self): | |
if not self.finished: | |
b = self.iter.__ref__() | |
depth = self.iter.CurrentDepth() | |
self.iter.inc() | |
if not self.iter.__bool__(): | |
# There is nothing left to iterate over | |
self.finished = True | |
return b, depth | |
else: | |
raise StopIteration | |
class OBAtomAtomIter(OBIter): | |
"""Iterator over the atoms attached to an atom.""" | |
OBiterator = _OBAtomAtomIter | |
class OBAtomBondIter(OBIter): | |
"""Iterator over the bonds attached to an atom.""" | |
OBiterator = _OBAtomBondIter | |
class OBMolAngleIter(OBIter): | |
"""Iterator over the angles in a molecule.""" | |
OBiterator = _OBMolAngleIter | |
class OBMolAtomIter(OBIter): | |
"""Iterator over the atoms in a molecule.""" | |
OBiterator = _OBMolAtomIter | |
class OBMolAtomBFSIter(OBIterWithDepth): | |
"""Iterator over the atoms in a molecule in a breadth-first manner.""" | |
OBiterator = _OBMolAtomBFSIter | |
class OBMolAtomDFSIter(OBIter): | |
"""Iterator over the atoms in a molecule in a depth-first manner.""" | |
OBiterator = _OBMolAtomDFSIter | |
class OBMolBondIter(OBIter): | |
"""Iterator over the bonds in a molecule.""" | |
OBiterator = _OBMolBondIter | |
class OBMolPairIter(OBIter): | |
"""Iterator over pairs of atoms in a molecule.""" | |
OBiterator = _OBMolPairIter | |
class OBMolRingIter(OBIter): | |
"""Iterator over the rings in a molecule.""" | |
OBiterator = _OBMolRingIter | |
class OBMolTorsionIter(OBIter): | |
"""Iterator over the torsion angles in a molecule.""" | |
OBiterator = _OBMolTorsionIter | |
class OBResidueIter(OBIter): | |
"""Iterator over the residues in a molecule.""" | |
OBiterator = _OBResidueIter | |
class OBResidueAtomIter(OBIter): | |
"""Iterator over the atoms in a residue.""" | |
OBiterator = _OBResidueAtomIter | |
%} | |
%include "carrays.i" | |
%array_class(double, doubleArray) | |
%pythoncode %{ | |
def double_array(mylist): | |
"""Create a C array of doubles from a list.""" | |
c = doubleArray(len(mylist)) | |
for i,v in enumerate(mylist): | |
c[i] = v | |
return c | |
%} | |
//# Copy some of the global variables in cvar into the openbabel namespace | |
%pythoncode %{ | |
obErrorLog = cvar.obErrorLog | |
ttab = cvar.ttab | |
etab = cvar.etab | |
isotab = cvar.isotab | |
atomtyper = cvar.atomtyper | |
aromtyper = cvar.aromtyper | |
%} | |
//# Functions to set the log file to std::cout and std::cerr | |
%ignore OBForceField::SetLogFile(std::ostream *pos); | |
%extend OpenBabel::OBForceField { | |
void SetLogToStdOut() | |
{ | |
self->SetLogFile(&std::cout); | |
} | |
void SetLogToStdErr() | |
{ | |
self->SetLogFile(&std::cerr); | |
} | |
}; | |
%extend OpenBabel::OBMol { | |
void SetTorsion(int i, int j, int k, int l, double ang) | |
{ | |
self->SetTorsion(self->GetAtom(i), self->GetAtom(j), | |
self->GetAtom(k), self->GetAtom(l), ang); | |
} | |
}; | |
%pythoncode %{ | |
def exception(*args): | |
raise Exception("Use OBMol.CloneData instead. OBMol.SetData is only for use from C++.") | |
OBMol.SetData = exception | |
%} | |
%include "stereo.i" |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
swigでエラーを吐く部分(#から始まるコメント行)を//でコメントアウト
pip install openbabel
が死ぬのでsetup.pyを直接叩いてみた