# CONFIDENTIAL. (C) 2022 Cadence Design Systems, Inc. (Cadence)
# All rights reserved.
# ALL SOFTWARE BELOW IS PROPRIETARY AND CONFIDENTIAL TO CADENCE
# AND IS SUBJECT TO THE FULL PROTECTION OF COPYRIGHT AND TRADE SECRET LAW.
# Copying or modifying this software is strictly prohibited and illegal.
# Using this software without a valid license from Cadence is strictly
# prohibited and illegal.  De-obfuscating, de-minimizing, or any other
# attempt to reverse engineer or discover the workings of this software,
# is strictly prohibited. Even if software is exposed or visible, it is
# still proprietary and confidential and the above prohibitions apply.
# This software is NOT "Sample Code". For purposes of customization or
# interoperation with other software you must use Sample Code
# specifically labeled as such.
# Please contact Cadence at eyesopen.com/legal if you have any questions
# about this warning.


# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")


def swig_import_helper():
    from os.path import dirname
    import importlib.util
    import importlib.abc

    spec = importlib.machinery.PathFinder().find_spec("_oechem", [dirname(__file__)])

    if spec is None:
        # OpenEye Import Statements
        spec = importlib.machinery.PathFinder().find_spec("libs",[dirname(__file__)])
    libs = importlib.util.module_from_spec(spec)

    import sys
    sys.modules[spec.name] = libs
    spec.loader.exec_module(libs)

    assert not sys.platform.startswith('win')

    _oedocking = libs.OEGetModule('_oedocking4211')
    return _oedocking

_oedocking = swig_import_helper()
del swig_import_helper

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

ScoreID_Shapegauss = _oedocking.ScoreID_Shapegauss
ScoreID_PLP = _oedocking.ScoreID_PLP
ScoreID_Chemgauss3 = _oedocking.ScoreID_Chemgauss3
ScoreID_Chemscore = _oedocking.ScoreID_Chemscore
ScoreID_OldChemscore = _oedocking.ScoreID_OldChemscore
ScoreID_Screenscore = _oedocking.ScoreID_Screenscore
ScoreID_CGO = _oedocking.ScoreID_CGO
ScoreID_CGT = _oedocking.ScoreID_CGT
ScoreID_Chemgauss4 = _oedocking.ScoreID_Chemgauss4
ScoreID_Shapegauss3 = _oedocking.ScoreID_Shapegauss3
ScoreID_MAX = _oedocking.ScoreID_MAX
OEDockMethod_INVALID = _oedocking.OEDockMethod_INVALID
OEDockMethod_Shapegauss = _oedocking.OEDockMethod_Shapegauss
OEDockMethod_PLP = _oedocking.OEDockMethod_PLP
OEDockMethod_Chemscore = _oedocking.OEDockMethod_Chemscore
OEDockMethod_Chemgauss3 = _oedocking.OEDockMethod_Chemgauss3
OEDockMethod_Chemgauss4 = _oedocking.OEDockMethod_Chemgauss4
OEDockMethod_Hybrid1 = _oedocking.OEDockMethod_Hybrid1
OEDockMethod_Hybrid2 = _oedocking.OEDockMethod_Hybrid2

OEDockMethod_Default = OEDockMethod_Chemgauss4


OEDockMethod_Chemgauss = OEDockMethod_Chemgauss4


OEDockMethod_Hybrid = OEDockMethod_Hybrid2

OESearchResolution_INVALID = _oedocking.OESearchResolution_INVALID
OESearchResolution_High = _oedocking.OESearchResolution_High
OESearchResolution_Standard = _oedocking.OESearchResolution_Standard
OESearchResolution_Low = _oedocking.OESearchResolution_Low

OESearchResolution_Default = OESearchResolution_Standard

OEScoreType_INVALID = _oedocking.OEScoreType_INVALID
OEScoreType_Shapegauss = _oedocking.OEScoreType_Shapegauss
OEScoreType_PLP = _oedocking.OEScoreType_PLP
OEScoreType_Chemgauss3 = _oedocking.OEScoreType_Chemgauss3
OEScoreType_Chemgauss4 = _oedocking.OEScoreType_Chemgauss4
OEScoreType_Chemscore = _oedocking.OEScoreType_Chemscore

OEScoreType_Default = OEScoreType_Chemgauss4


OEScoreType_Chemgauss = OEScoreType_Chemgauss4

OEProteinConstraintType_Unknown = _oedocking.OEProteinConstraintType_Unknown
OEProteinConstraintType_Chelator = _oedocking.OEProteinConstraintType_Chelator
OEProteinConstraintType_Acceptor = _oedocking.OEProteinConstraintType_Acceptor
OEProteinConstraintType_Donor = _oedocking.OEProteinConstraintType_Donor
OEProteinConstraintType_Contact = _oedocking.OEProteinConstraintType_Contact
OEProteinConstraintType_Lipophilic = _oedocking.OEProteinConstraintType_Lipophilic
OENegativeImageType_INVALID = _oedocking.OENegativeImageType_INVALID
OENegativeImageType_LargeShape = _oedocking.OENegativeImageType_LargeShape
OENegativeImageType_StandardShape = _oedocking.OENegativeImageType_StandardShape
OENegativeImageType_SmallShape = _oedocking.OENegativeImageType_SmallShape

OENegativeImageType_Default = OENegativeImageType_StandardShape

OEDockingReturnCode_Success = _oedocking.OEDockingReturnCode_Success
OEDockingReturnCode_NotInitialized = _oedocking.OEDockingReturnCode_NotInitialized
OEDockingReturnCode_EmptyLigand = _oedocking.OEDockingReturnCode_EmptyLigand
OEDockingReturnCode_EmptyProtein = _oedocking.OEDockingReturnCode_EmptyProtein
OEDockingReturnCode_TypingError = _oedocking.OEDockingReturnCode_TypingError
OEDockingReturnCode_GridSetupError = _oedocking.OEDockingReturnCode_GridSetupError
OEDockingReturnCode_CoordError = _oedocking.OEDockingReturnCode_CoordError
OEDockingReturnCode_NoConstraintMatch = _oedocking.OEDockingReturnCode_NoConstraintMatch
OEDockingReturnCode_NoValidPoses = _oedocking.OEDockingReturnCode_NoValidPoses
OEDockingReturnCode_Aborted = _oedocking.OEDockingReturnCode_Aborted
OEDockingReturnCode_OutsideGrid = _oedocking.OEDockingReturnCode_OutsideGrid
OEDockingReturnCode_OptimizationError = _oedocking.OEDockingReturnCode_OptimizationError
OEDockingReturnCode_InvalidScore = _oedocking.OEDockingReturnCode_InvalidScore
OEDockingReturnCode_ScoreError = _oedocking.OEDockingReturnCode_ScoreError
OEDockingReturnCode_Failure = _oedocking.OEDockingReturnCode_Failure
OEDockingReturnCode_ConformerGenError = _oedocking.OEDockingReturnCode_ConformerGenError
OEDockingReturnCode_NoValidNonClashPoses = _oedocking.OEDockingReturnCode_NoValidNonClashPoses
OEAllowedClashType_NONE = _oedocking.OEAllowedClashType_NONE
OEAllowedClashType_HYDROGEN = _oedocking.OEAllowedClashType_HYDROGEN
OEAllowedClashType_ANY = _oedocking.OEAllowedClashType_ANY
OEPoseRelaxMode_NONE = _oedocking.OEPoseRelaxMode_NONE
OEPoseRelaxMode_CLASHED = _oedocking.OEPoseRelaxMode_CLASHED
OEPoseRelaxMode_ALL = _oedocking.OEPoseRelaxMode_ALL
OEPositMethod_UNKNOWN = _oedocking.OEPositMethod_UNKNOWN
OEPositMethod_SHAPEFIT = _oedocking.OEPositMethod_SHAPEFIT
OEPositMethod_HYBRID = _oedocking.OEPositMethod_HYBRID
OEPositMethod_FRED = _oedocking.OEPositMethod_FRED
OEPositMethod_MCS = _oedocking.OEPositMethod_MCS
OEPositMethod_SHAPEFIT_EXHAUSTIVE = _oedocking.OEPositMethod_SHAPEFIT_EXHAUSTIVE

OEPositMethod_ALL = OEPositMethod_SHAPEFIT|OEPositMethod_HYBRID|OEPositMethod_FRED|OEPositMethod_MCS

import openeye.oechem as oechem
import openeye.oeshape as oeshape

def OEReceptorGetBoundLigand(rec: "OEMolBase") -> "OEGraphMolWrapper":
    r"""OEReceptorGetBoundLigand(OEMolBase rec) -> OEGraphMol"""
    return _oedocking.OEReceptorGetBoundLigand(rec)
class OEDockOptions(oechem.OEOptions):
    r"""Proxy of C++ OEDocking::OEDockOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEDockOptions self) -> OEDockOptions
        __init__(OEDockOptions self, OEDockOptions arg2) -> OEDockOptions
        """
        _oedocking.OEDockOptions_swiginit(self, _oedocking.new_OEDockOptions(*args))
    __swig_destroy__ = _oedocking.delete_OEDockOptions

    def GetScoreMethod(self) -> "unsigned int":
        r"""GetScoreMethod(OEDockOptions self) -> unsigned int"""
        return _oedocking.OEDockOptions_GetScoreMethod(self)

    def SetScoreMethod(self, value: "unsigned int const") -> "bool":
        r"""SetScoreMethod(OEDockOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEDockOptions_SetScoreMethod(self, value)

    def GetResolution(self) -> "unsigned int":
        r"""GetResolution(OEDockOptions self) -> unsigned int"""
        return _oedocking.OEDockOptions_GetResolution(self)

    def SetResolution(self, value: "unsigned int const") -> "bool":
        r"""SetResolution(OEDockOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEDockOptions_SetResolution(self, value)

    def CreateCopy(self) -> "OEDocking::OEDockOptions *":
        r"""CreateCopy(OEDockOptions self) -> OEDockOptions"""
        return _oedocking.OEDockOptions_CreateCopy(self)

# Register OEDockOptions in _oedocking:
_oedocking.OEDockOptions_swigregister(OEDockOptions)

class OEDock(object):
    r"""Proxy of C++ OEDocking::OEDock class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEDock self, unsigned int scoring=, unsigned int resolution=) -> OEDock
        __init__(OEDock self, OEDockOptions arg2) -> OEDock
        __init__(OEDock self, OEDock arg2) -> OEDock
        """
        _oedocking.OEDock_swiginit(self, _oedocking.new_OEDock(*args))
    __swig_destroy__ = _oedocking.delete_OEDock

    def IsInitialized(self) -> "bool":
        r"""IsInitialized(OEDock self) -> bool"""
        return _oedocking.OEDock_IsInitialized(self)

    def Initialize(self, *args) -> "bool":
        r"""
        Initialize(OEDock self, OEMolBase receptor) -> bool
        Initialize(OEDock self, OEDesignUnit du) -> bool
        """
        return _oedocking.OEDock_Initialize(self, *args)

    def DockMultiConformerMolecule(self, *args) -> "unsigned int":
        r"""
        DockMultiConformerMolecule(OEDock self, OEMCMolBase dockedMol, OEMCMolBase inputMol, unsigned int numPoses=1) -> unsigned int
        DockMultiConformerMolecule(OEDock self, OEChem::OEMol & dockedMol, OEMCMolBase inputMol, unsigned int numPoses=1) -> unsigned int
        DockMultiConformerMolecule(OEDock self, OEMolBase dockedMol, OEMCMolBase inputMol) -> unsigned int
        """
        return _oedocking.OEDock_DockMultiConformerMolecule(self, *args)

    def GetHighScoresAreBetter(self) -> "bool":
        r"""GetHighScoresAreBetter(OEDock self) -> bool"""
        return _oedocking.OEDock_GetHighScoresAreBetter(self)

    def GetName(self) -> "std::string":
        r"""GetName(OEDock self) -> std::string"""
        return _oedocking.OEDock_GetName(self)

    def GetComponentNames(self) -> "OESystem::OEIterBase< std::string const > *":
        r"""GetComponentNames(OEDock self) -> OESystem::OEIterBase< std::string const > *"""
        return _oedocking.OEDock_GetComponentNames(self)

    def ScoreLigand(self, pose: "OEMolBase") -> "float":
        r"""ScoreLigand(OEDock self, OEMolBase pose) -> float"""
        return _oedocking.OEDock_ScoreLigand(self, pose)

    def ScoreAtom(self, atom: "OEAtomBase", pose: "OEMolBase") -> "float":
        r"""ScoreAtom(OEDock self, OEAtomBase atom, OEMolBase pose) -> float"""
        return _oedocking.OEDock_ScoreAtom(self, atom, pose)

    def ScoreLigandComponent(self, pose: "OEMolBase", compName: "std::string") -> "float":
        r"""ScoreLigandComponent(OEDock self, OEMolBase pose, std::string compName) -> float"""
        return _oedocking.OEDock_ScoreLigandComponent(self, pose, compName)

    def ScoreAtomComponent(self, atom: "OEAtomBase", pose: "OEMolBase", compName: "std::string") -> "float":
        r"""ScoreAtomComponent(OEDock self, OEAtomBase atom, OEMolBase pose, std::string compName) -> float"""
        return _oedocking.OEDock_ScoreAtomComponent(self, atom, pose, compName)

    def AnnotatePose(self, *args) -> "bool":
        r"""
        AnnotatePose(OEDock self, OEMolBase pose) -> bool
        AnnotatePose(OEDock self, OEMCMolBase pose) -> bool
        """
        return _oedocking.OEDock_AnnotatePose(self, *args)

    def CacheScoringSetup(self, *args) -> "bool":
        r"""
        CacheScoringSetup(OEDock self, OEMolBase receptor, bool clearOldData=True) -> bool
        CacheScoringSetup(OEDock self, OEDesignUnit du, bool clearOldData=True) -> bool
        """
        return _oedocking.OEDock_CacheScoringSetup(self, *args)

# Register OEDock in _oedocking:
_oedocking.OEDock_swigregister(OEDock)

class OEHybrid(OEDock):
    r"""Proxy of C++ OEDocking::OEHybrid class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(OEHybrid self, unsigned int scoring=, unsigned int resolution=) -> OEHybrid"""
        _oedocking.OEHybrid_swiginit(self, _oedocking.new_OEHybrid(*args))
    __swig_destroy__ = _oedocking.delete_OEHybrid

# Register OEHybrid in _oedocking:
_oedocking.OEHybrid_swigregister(OEHybrid)


def OEDockMethodGetName(method: "unsigned int") -> "std::string":
    r"""OEDockMethodGetName(unsigned int method) -> std::string"""
    return _oedocking.OEDockMethodGetName(method)

def OEDockMethodConfigure(itf: "OEInterface", parameter: "std::string") -> "bool":
    r"""OEDockMethodConfigure(OEInterface itf, std::string parameter) -> bool"""
    return _oedocking.OEDockMethodConfigure(itf, parameter)

def OEDockMethodGetValue(*args) -> "unsigned int":
    r"""
    OEDockMethodGetValue(std::string name) -> unsigned int
    OEDockMethodGetValue(OEInterface itf, std::string parameter) -> unsigned int
    """
    return _oedocking.OEDockMethodGetValue(*args)

def OESearchResolutionGetName(resolution: "unsigned int") -> "std::string":
    r"""OESearchResolutionGetName(unsigned int resolution) -> std::string"""
    return _oedocking.OESearchResolutionGetName(resolution)

def OESearchResolutionConfigure(itf: "OEInterface", parameter: "std::string") -> "bool":
    r"""OESearchResolutionConfigure(OEInterface itf, std::string parameter) -> bool"""
    return _oedocking.OESearchResolutionConfigure(itf, parameter)

def OESearchResolutionGetValue(*args) -> "unsigned int":
    r"""
    OESearchResolutionGetValue(std::string name) -> unsigned int
    OESearchResolutionGetValue(OEInterface itf, std::string parameter) -> unsigned int
    """
    return _oedocking.OESearchResolutionGetValue(*args)

def OEScoreTypeGetName(scoring: "unsigned int") -> "std::string":
    r"""OEScoreTypeGetName(unsigned int scoring) -> std::string"""
    return _oedocking.OEScoreTypeGetName(scoring)

def OEScoreTypeConfigure(itf: "OEInterface", parameter: "std::string") -> "bool":
    r"""OEScoreTypeConfigure(OEInterface itf, std::string parameter) -> bool"""
    return _oedocking.OEScoreTypeConfigure(itf, parameter)

def OEScoreTypeGetValue(*args) -> "unsigned int":
    r"""
    OEScoreTypeGetValue(std::string name) -> unsigned int
    OEScoreTypeGetValue(OEInterface itf, std::string parameter) -> unsigned int
    """
    return _oedocking.OEScoreTypeGetValue(*args)

def OEProteinConstraintTypeGetName(arg1: "unsigned int") -> "std::string":
    r"""OEProteinConstraintTypeGetName(unsigned int arg1) -> std::string"""
    return _oedocking.OEProteinConstraintTypeGetName(arg1)

def OENegativeImageTypeGetName(arg1: "unsigned int") -> "std::string":
    r"""OENegativeImageTypeGetName(unsigned int arg1) -> std::string"""
    return _oedocking.OENegativeImageTypeGetName(arg1)

def OENegativeImageTypeConfigure(itf: "OEInterface", parameter: "std::string") -> "bool":
    r"""OENegativeImageTypeConfigure(OEInterface itf, std::string parameter) -> bool"""
    return _oedocking.OENegativeImageTypeConfigure(itf, parameter)

def OENegativeImageTypeGetValue(*args) -> "unsigned int":
    r"""
    OENegativeImageTypeGetValue(std::string name) -> unsigned int
    OENegativeImageTypeGetValue(OEInterface itf, std::string parameter) -> unsigned int
    """
    return _oedocking.OENegativeImageTypeGetValue(*args)

def OEDockingReturnCodeGetName(rcode: "unsigned int") -> "std::string":
    r"""OEDockingReturnCodeGetName(unsigned int rcode) -> std::string"""
    return _oedocking.OEDockingReturnCodeGetName(rcode)

def GetSWIG_NewPointerObj(*args) -> "PyObject *":
    r"""
    GetSWIG_NewPointerObj(OEAtomBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEBondBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEMolBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEConfBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OETransBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OENbrs arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEAltLocation arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEAltGroup arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OESequenceAlignment arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OERole arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEResidue arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(std::string const & arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(std::string & arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OERotamer arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OETorsion arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEColor arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEColorStop arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEGroupBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEAtomBondSet arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OESubSearch arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEInteractionHintTypeBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEInteractionHint arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OESphere arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEReceptorProteinConstraint arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEReceptorConstraintFeature arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEHierResidue arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEHierFragment arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEHierChain arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEPlaceHydrogensMoverNote arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEAnnotation arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEFuzzy arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEFComponent arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEInteraction arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OESphereBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEFeature arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEProteinConstraint arg, bool owned) -> PyObject *
    """
    return _oedocking.GetSWIG_NewPointerObj(*args)
class OESphereIter2(object):
    r"""Proxy of C++ OESystem::OEIter< OEDocking::OESphereBase > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OESphereIter2 self) -> OESphereIter2
        __init__(OESphereIter2 self, OESphereIter2 rhs) -> OESphereIter2
        __init__(OESphereIter2 self, OESystem::OEIterBase< OEDocking::OESphereBase > * rhs) -> OESphereIter2
        __init__(OESphereIter2 self, OESystem::OEIterBase< OESystem::OEIter< OEDocking::OESphereBase >::NonConstA > * rhs) -> OESphereIter2
        """
        _oedocking.OESphereIter2_swiginit(self, _oedocking.new_OESphereIter2(*args))
    __swig_destroy__ = _oedocking.delete_OESphereIter2

    def Copy(self) -> "OESystem::OEIterBase< OEDocking::OESphereBase > *":
        r"""Copy(OESphereIter2 self) -> OESystem::OEIterBase< OEDocking::OESphereBase > *"""
        return _oedocking.OESphereIter2_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OESphereIter2 self, OESystem::OEIterBase< OEDocking::OESphereBase > * ib)
        Push(OESphereIter2 self, OESphereIter2 iter)
        """
        return _oedocking.OESphereIter2_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEDocking::OESphereBase,OEDocking::OESphereBase > const &") -> "void":
        r"""Sort(OESphereIter2 self, OESystem::OEBinaryPredicate< OEDocking::OESphereBase,OEDocking::OESphereBase > const & sort_criterion)"""
        return _oedocking.OESphereIter2_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEDocking::OESphereBase > &":
        r"""ToFirst(OESphereIter2 self) -> OESphereIter2"""
        return _oedocking.OESphereIter2_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEDocking::OESphereBase > &":
        r"""ToLast(OESphereIter2 self) -> OESphereIter2"""
        return _oedocking.OESphereIter2_ToLast(self)

    def __ref__(self) -> "OEDocking::OESphereBase &":
        r"""__ref__(OESphereIter2 self) -> OESphereBase"""
        return _oedocking.OESphereIter2___ref__(self)

    def IsValid(self):
      return _oedocking.OESphereIter2___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OESphereIter2 self) -> PyObject *"""
        return _oedocking.OESphereIter2_next(self)

    def Target(self) -> "OEDocking::OESphereBase &":
        r"""Target(OESphereIter2 self) -> OESphereBase"""
        return _oedocking.OESphereIter2_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEDocking::OESphereBase > &":
        r"""
        Next(OESphereIter2 self) -> OESphereIter2
        Next(OESphereIter2 self, int i) -> OESphereIter2
        """
        return _oedocking.OESphereIter2_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEDocking::OESphereBase > &":
        r"""
        Prev(OESphereIter2 self) -> OESphereIter2
        Prev(OESphereIter2 self, int i) -> OESphereIter2
        """
        return _oedocking.OESphereIter2_Prev(self, *args)

# Register OESphereIter2 in _oedocking:
_oedocking.OESphereIter2_swigregister(OESphereIter2)

class OEFeatureIter2(object):
    r"""Proxy of C++ OESystem::OEIter< OEDocking::OEFeature > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEFeatureIter2 self) -> OEFeatureIter2
        __init__(OEFeatureIter2 self, OEFeatureIter2 rhs) -> OEFeatureIter2
        __init__(OEFeatureIter2 self, OESystem::OEIterBase< OEDocking::OEFeature > * rhs) -> OEFeatureIter2
        __init__(OEFeatureIter2 self, OESystem::OEIterBase< OESystem::OEIter< OEDocking::OEFeature >::NonConstA > * rhs) -> OEFeatureIter2
        """
        _oedocking.OEFeatureIter2_swiginit(self, _oedocking.new_OEFeatureIter2(*args))
    __swig_destroy__ = _oedocking.delete_OEFeatureIter2

    def Copy(self) -> "OESystem::OEIterBase< OEDocking::OEFeature > *":
        r"""Copy(OEFeatureIter2 self) -> OESystem::OEIterBase< OEDocking::OEFeature > *"""
        return _oedocking.OEFeatureIter2_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEFeatureIter2 self, OESystem::OEIterBase< OEDocking::OEFeature > * ib)
        Push(OEFeatureIter2 self, OEFeatureIter2 iter)
        """
        return _oedocking.OEFeatureIter2_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEDocking::OEFeature,OEDocking::OEFeature > const &") -> "void":
        r"""Sort(OEFeatureIter2 self, OESystem::OEBinaryPredicate< OEDocking::OEFeature,OEDocking::OEFeature > const & sort_criterion)"""
        return _oedocking.OEFeatureIter2_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEDocking::OEFeature > &":
        r"""ToFirst(OEFeatureIter2 self) -> OEFeatureIter2"""
        return _oedocking.OEFeatureIter2_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEDocking::OEFeature > &":
        r"""ToLast(OEFeatureIter2 self) -> OEFeatureIter2"""
        return _oedocking.OEFeatureIter2_ToLast(self)

    def __ref__(self) -> "OEDocking::OEFeature &":
        r"""__ref__(OEFeatureIter2 self) -> OEFeature"""
        return _oedocking.OEFeatureIter2___ref__(self)

    def IsValid(self):
      return _oedocking.OEFeatureIter2___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEFeatureIter2 self) -> PyObject *"""
        return _oedocking.OEFeatureIter2_next(self)

    def Target(self) -> "OEDocking::OEFeature &":
        r"""Target(OEFeatureIter2 self) -> OEFeature"""
        return _oedocking.OEFeatureIter2_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEDocking::OEFeature > &":
        r"""
        Next(OEFeatureIter2 self) -> OEFeatureIter2
        Next(OEFeatureIter2 self, int i) -> OEFeatureIter2
        """
        return _oedocking.OEFeatureIter2_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEDocking::OEFeature > &":
        r"""
        Prev(OEFeatureIter2 self) -> OEFeatureIter2
        Prev(OEFeatureIter2 self, int i) -> OEFeatureIter2
        """
        return _oedocking.OEFeatureIter2_Prev(self, *args)

# Register OEFeatureIter2 in _oedocking:
_oedocking.OEFeatureIter2_swigregister(OEFeatureIter2)

class OEConstProteinConstraintIter3(object):
    r"""Proxy of C++ OESystem::OEIter< OEDocking::OEProteinConstraint const > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEConstProteinConstraintIter3 self) -> OEConstProteinConstraintIter3
        __init__(OEConstProteinConstraintIter3 self, OEConstProteinConstraintIter3 rhs) -> OEConstProteinConstraintIter3
        __init__(OEConstProteinConstraintIter3 self, OESystem::OEIterBase< OEDocking::OEProteinConstraint const > * rhs) -> OEConstProteinConstraintIter3
        __init__(OEConstProteinConstraintIter3 self, OESystem::OEIterBase< OESystem::OEIter< OEDocking::OEProteinConstraint const >::NonConstA > * rhs) -> OEConstProteinConstraintIter3
        """
        _oedocking.OEConstProteinConstraintIter3_swiginit(self, _oedocking.new_OEConstProteinConstraintIter3(*args))
    __swig_destroy__ = _oedocking.delete_OEConstProteinConstraintIter3

    def Copy(self) -> "OESystem::OEIterBase< OEDocking::OEProteinConstraint const > *":
        r"""Copy(OEConstProteinConstraintIter3 self) -> OESystem::OEIterBase< OEDocking::OEProteinConstraint const > *"""
        return _oedocking.OEConstProteinConstraintIter3_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEConstProteinConstraintIter3 self, OESystem::OEIterBase< OEDocking::OEProteinConstraint const > * ib)
        Push(OEConstProteinConstraintIter3 self, OEConstProteinConstraintIter3 iter)
        """
        return _oedocking.OEConstProteinConstraintIter3_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEDocking::OEProteinConstraint const,OEDocking::OEProteinConstraint const > const &") -> "void":
        r"""Sort(OEConstProteinConstraintIter3 self, OESystem::OEBinaryPredicate< OEDocking::OEProteinConstraint const,OEDocking::OEProteinConstraint const > const & sort_criterion)"""
        return _oedocking.OEConstProteinConstraintIter3_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEDocking::OEProteinConstraint const > &":
        r"""ToFirst(OEConstProteinConstraintIter3 self) -> OEConstProteinConstraintIter3"""
        return _oedocking.OEConstProteinConstraintIter3_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEDocking::OEProteinConstraint const > &":
        r"""ToLast(OEConstProteinConstraintIter3 self) -> OEConstProteinConstraintIter3"""
        return _oedocking.OEConstProteinConstraintIter3_ToLast(self)

    def __ref__(self) -> "OEDocking::OEProteinConstraint const &":
        r"""__ref__(OEConstProteinConstraintIter3 self) -> OEProteinConstraint"""
        return _oedocking.OEConstProteinConstraintIter3___ref__(self)

    def IsValid(self):
      return _oedocking.OEConstProteinConstraintIter3___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEConstProteinConstraintIter3 self) -> PyObject *"""
        return _oedocking.OEConstProteinConstraintIter3_next(self)

    def Target(self) -> "OEDocking::OEProteinConstraint const &":
        r"""Target(OEConstProteinConstraintIter3 self) -> OEProteinConstraint"""
        return _oedocking.OEConstProteinConstraintIter3_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEDocking::OEProteinConstraint const > &":
        r"""
        Next(OEConstProteinConstraintIter3 self) -> OEConstProteinConstraintIter3
        Next(OEConstProteinConstraintIter3 self, int i) -> OEConstProteinConstraintIter3
        """
        return _oedocking.OEConstProteinConstraintIter3_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEDocking::OEProteinConstraint const > &":
        r"""
        Prev(OEConstProteinConstraintIter3 self) -> OEConstProteinConstraintIter3
        Prev(OEConstProteinConstraintIter3 self, int i) -> OEConstProteinConstraintIter3
        """
        return _oedocking.OEConstProteinConstraintIter3_Prev(self, *args)

# Register OEConstProteinConstraintIter3 in _oedocking:
_oedocking.OEConstProteinConstraintIter3_swigregister(OEConstProteinConstraintIter3)

class OEBoxBase(oechem.OEBox):
    r"""Proxy of C++ OEDocking::OEBoxBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEBoxBase self) -> OEBoxBase
        __init__(OEBoxBase self, OEBoxBase arg2) -> OEBoxBase
        """
        _oedocking.OEBoxBase_swiginit(self, _oedocking.new_OEBoxBase(*args))
    __swig_destroy__ = _oedocking.delete_OEBoxBase

# Register OEBoxBase in _oedocking:
_oedocking.OEBoxBase_swigregister(OEBoxBase)

class OESphereBase(oechem.OESphere):
    r"""Proxy of C++ OEDocking::OESphereBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OESphereBase self) -> OESphereBase
        __init__(OESphereBase self, OESphereBase arg2) -> OESphereBase
        """
        _oedocking.OESphereBase_swiginit(self, _oedocking.new_OESphereBase(*args))
    __swig_destroy__ = _oedocking.delete_OESphereBase

# Register OESphereBase in _oedocking:
_oedocking.OESphereBase_swigregister(OESphereBase)

class OEBox(OEBoxBase):
    r"""Proxy of C++ OEDocking::OEBox class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEBox self) -> OEBox
        __init__(OEBox self, OEMolBase mol, float addbox=0.0) -> OEBox
        __init__(OEBox self, OEMCMolBase mol, float addbox=0.0) -> OEBox
        __init__(OEBox self, float const x1, float const y1, float const z1, float const x2, float const y2, float const z2) -> OEBox
        __init__(OEBox self, OEBox arg2) -> OEBox
        __init__(OEBox self, OEBoxBase box) -> OEBox
        """
        _oedocking.OEBox_swiginit(self, _oedocking.new_OEBox(*args))
    __swig_destroy__ = _oedocking.delete_OEBox

# Register OEBox in _oedocking:
_oedocking.OEBox_swigregister(OEBox)


def OEBoxExtend(*args) -> "bool":
    r"""
    OEBoxExtend(OEBoxBase box, float x_ext, float y_ext, float z_ext) -> bool
    OEBoxExtend(OEBoxBase box, float ext) -> bool
    """
    return _oedocking.OEBoxExtend(*args)

def OEBoxTranslate(box: "OEBoxBase", x_trans: "float", y_trans: "float", z_trans: "float") -> "bool":
    r"""OEBoxTranslate(OEBoxBase box, float x_trans, float y_trans, float z_trans) -> bool"""
    return _oedocking.OEBoxTranslate(box, x_trans, y_trans, z_trans)

def OEBoxVolume(box: "OEBoxBase") -> "float":
    r"""OEBoxVolume(OEBoxBase box) -> float"""
    return _oedocking.OEBoxVolume(box)

def OEBoxArea(box: "OEBoxBase") -> "float":
    r"""OEBoxArea(OEBoxBase box) -> float"""
    return _oedocking.OEBoxArea(box)

def OEInBox(box: "OEBoxBase", x: "float", y: "float", z: "float") -> "bool":
    r"""OEInBox(OEBoxBase box, float x, float y, float z) -> bool"""
    return _oedocking.OEInBox(box, x, y, z)

def OEBoxXMid(box: "OEBoxBase") -> "float":
    r"""OEBoxXMid(OEBoxBase box) -> float"""
    return _oedocking.OEBoxXMid(box)

def OEBoxYMid(box: "OEBoxBase") -> "float":
    r"""OEBoxYMid(OEBoxBase box) -> float"""
    return _oedocking.OEBoxYMid(box)

def OEBoxZMid(box: "OEBoxBase") -> "float":
    r"""OEBoxZMid(OEBoxBase box) -> float"""
    return _oedocking.OEBoxZMid(box)

def OEBoxXDim(box: "OEBoxBase") -> "float":
    r"""OEBoxXDim(OEBoxBase box) -> float"""
    return _oedocking.OEBoxXDim(box)

def OEBoxYDim(box: "OEBoxBase") -> "float":
    r"""OEBoxYDim(OEBoxBase box) -> float"""
    return _oedocking.OEBoxYDim(box)

def OEBoxZDim(box: "OEBoxBase") -> "float":
    r"""OEBoxZDim(OEBoxBase box) -> float"""
    return _oedocking.OEBoxZDim(box)

def OESetupBoxCenterAndExtents(arg1: "OEBoxBase", center: "float *", extents: "float *") -> "bool":
    r"""OESetupBoxCenterAndExtents(OEBoxBase arg1, float * center, float * extents) -> bool"""
    return _oedocking.OESetupBoxCenterAndExtents(arg1, center, extents)

def OESphereVolume(sph: "OESphereBase") -> "float":
    r"""OESphereVolume(OESphereBase sph) -> float"""
    return _oedocking.OESphereVolume(sph)

def OESphereArea(sph: "OESphereBase") -> "float":
    r"""OESphereArea(OESphereBase sph) -> float"""
    return _oedocking.OESphereArea(sph)

def OEInSphere(sph: "OESphereBase", x: "float", y: "float", z: "float") -> "bool":
    r"""OEInSphere(OESphereBase sph, float x, float y, float z) -> bool"""
    return _oedocking.OEInSphere(sph, x, y, z)
class OEFeature(oechem.OEReceptorConstraintFeature):
    r"""Proxy of C++ OEDocking::OEFeature class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEFeature self) -> OEFeature
        __init__(OEFeature self, OEFeature arg2) -> OEFeature
        """
        _oedocking.OEFeature_swiginit(self, _oedocking.new_OEFeature(*args))
    __swig_destroy__ = _oedocking.delete_OEFeature

    def GetSpheres(self, *args) -> "OESystem::OEIterBase< OEDocking::OESphereBase > *":
        r"""
        GetSpheres(OEFeature self) -> OESystem::OEIterBase< OEDocking::OESphereBase const >
        GetSpheres(OEFeature self) -> OESystem::OEIterBase< OEDocking::OESphereBase > *
        """
        return _oedocking.OEFeature_GetSpheres(self, *args)

    def AddSphere(self, *args) -> "OEDocking::OESphereBase *":
        r"""
        AddSphere(OEFeature self, OESphereBase arg2) -> OESphereBase
        AddSphere(OEFeature self) -> OESphereBase
        """
        return _oedocking.OEFeature_AddSphere(self, *args)

# Register OEFeature in _oedocking:
_oedocking.OEFeature_swigregister(OEFeature)

class OECustomConstraints(oechem.OEReceptorCustomConstraints):
    r"""Proxy of C++ OEDocking::OECustomConstraints class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OECustomConstraints self) -> OECustomConstraints
        __init__(OECustomConstraints self, OECustomConstraints arg2) -> OECustomConstraints
        __init__(OECustomConstraints self, OEReceptorCustomConstraints constr) -> OECustomConstraints
        """
        _oedocking.OECustomConstraints_swiginit(self, _oedocking.new_OECustomConstraints(*args))
    __swig_destroy__ = _oedocking.delete_OECustomConstraints

    def GetFeatures(self, *args) -> "OESystem::OEIterBase< OEDocking::OEFeature > *":
        r"""
        GetFeatures(OECustomConstraints self, bool const enabledOnly=True) -> OESystem::OEIterBase< OEDocking::OEFeature const >
        GetFeatures(OECustomConstraints self, bool const enabledOnly=True) -> OESystem::OEIterBase< OEDocking::OEFeature >
        """
        return _oedocking.OECustomConstraints_GetFeatures(self, *args)

    def AddFeature(self) -> "OEDocking::OEFeature *":
        r"""AddFeature(OECustomConstraints self) -> OEFeature"""
        return _oedocking.OECustomConstraints_AddFeature(self)

# Register OECustomConstraints in _oedocking:
_oedocking.OECustomConstraints_swigregister(OECustomConstraints)

class OEProteinConstraint(oechem.OEReceptorProteinConstraint):
    r"""Proxy of C++ OEDocking::OEProteinConstraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEProteinConstraint self) -> OEProteinConstraint
        __init__(OEProteinConstraint self, OEProteinConstraint arg2) -> OEProteinConstraint
        __init__(OEProteinConstraint self, OEReceptorProteinConstraint constr) -> OEProteinConstraint
        """
        _oedocking.OEProteinConstraint_swiginit(self, _oedocking.new_OEProteinConstraint(*args))
    __swig_destroy__ = _oedocking.delete_OEProteinConstraint

    def GetAtom(self) -> "OEChem::OEAtomBase *":
        r"""GetAtom(OEProteinConstraint self) -> OEAtomBase"""
        return _oedocking.OEProteinConstraint_GetAtom(self)

    def SetAtom(self, atom: "OEAtomBase") -> "void":
        r"""SetAtom(OEProteinConstraint self, OEAtomBase atom)"""
        return _oedocking.OEProteinConstraint_SetAtom(self, atom)

# Register OEProteinConstraint in _oedocking:
_oedocking.OEProteinConstraint_swigregister(OEProteinConstraint)


def OEIsReceptor(rec: "OEMolBase") -> "bool":
    r"""OEIsReceptor(OEMolBase rec) -> bool"""
    return _oedocking.OEIsReceptor(rec)

def OEReceptorHasNegativeImageGrid(rec: "OEMolBase") -> "bool":
    r"""OEReceptorHasNegativeImageGrid(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorHasNegativeImageGrid(rec)

def OEReceptorHasInnerContourLevel(rec: "OEMolBase") -> "bool":
    r"""OEReceptorHasInnerContourLevel(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorHasInnerContourLevel(rec)

def OEReceptorHasOuterContourLevel(rec: "OEMolBase") -> "bool":
    r"""OEReceptorHasOuterContourLevel(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorHasOuterContourLevel(rec)

def OEReceptorHasCustomConstraints(rec: "OEMolBase", enabledOnly: "bool"=True) -> "bool":
    r"""OEReceptorHasCustomConstraints(OEMolBase rec, bool enabledOnly=True) -> bool"""
    return _oedocking.OEReceptorHasCustomConstraints(rec, enabledOnly)

def OEReceptorHasProteinConstraints(rec: "OEMolBase", enabledOnly: "bool"=True) -> "bool":
    r"""OEReceptorHasProteinConstraints(OEMolBase rec, bool enabledOnly=True) -> bool"""
    return _oedocking.OEReceptorHasProteinConstraints(rec, enabledOnly)

def OEReceptorHasBoundLigand(rec: "OEMolBase") -> "bool":
    r"""OEReceptorHasBoundLigand(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorHasBoundLigand(rec)

def OEReceptorHasExtraMols(rec: "OEMolBase") -> "bool":
    r"""OEReceptorHasExtraMols(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorHasExtraMols(rec)

def OEReceptorHasCachedScore(rec: "OEMolBase") -> "bool":
    r"""OEReceptorHasCachedScore(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorHasCachedScore(rec)

def OEReceptorGetNegativeImageGrid(rec: "OEMolBase") -> "OESystem::OEGrid< float >":
    r"""OEReceptorGetNegativeImageGrid(OEMolBase rec) -> OEFloatGrid"""
    return _oedocking.OEReceptorGetNegativeImageGrid(rec)

def OEReceptorGetInnerContourLevel(rec: "OEMolBase") -> "float":
    r"""OEReceptorGetInnerContourLevel(OEMolBase rec) -> float"""
    return _oedocking.OEReceptorGetInnerContourLevel(rec)

def OEReceptorGetOuterContourLevel(rec: "OEMolBase") -> "float":
    r"""OEReceptorGetOuterContourLevel(OEMolBase rec) -> float"""
    return _oedocking.OEReceptorGetOuterContourLevel(rec)

def OEReceptorGetCustomConstraints(rec: "OEMolBase") -> "OEDocking::OECustomConstraints":
    r"""OEReceptorGetCustomConstraints(OEMolBase rec) -> OECustomConstraints"""
    return _oedocking.OEReceptorGetCustomConstraints(rec)

def OEReceptorGetProteinConstraints(rec: "OEMolBase", enabledOnly: "bool"=True) -> "OESystem::OEIterBase< OEDocking::OEProteinConstraint const > *":
    r"""OEReceptorGetProteinConstraints(OEMolBase rec, bool enabledOnly=True) -> OESystem::OEIterBase< OEDocking::OEProteinConstraint const >"""
    return _oedocking.OEReceptorGetProteinConstraints(rec, enabledOnly)

def OEReceptorGetExtraMols(rec: "OEMolBase") -> "OESystem::OEIterBase< OEChem::OEMolBase const > *":
    r"""OEReceptorGetExtraMols(OEMolBase rec) -> OESystem::OEIterBase< OEChem::OEMolBase const > *"""
    return _oedocking.OEReceptorGetExtraMols(rec)

def OEReceptorSetInnerContourLevel(rec: "OEMolBase", level: "float") -> "bool":
    r"""OEReceptorSetInnerContourLevel(OEMolBase rec, float level) -> bool"""
    return _oedocking.OEReceptorSetInnerContourLevel(rec, level)

def OEReceptorSetOuterContourLevel(rec: "OEMolBase", level: "float") -> "bool":
    r"""OEReceptorSetOuterContourLevel(OEMolBase rec, float level) -> bool"""
    return _oedocking.OEReceptorSetOuterContourLevel(rec, level)

def OEReceptorSetCustomConstraints(rec: "OEMolBase", arg2: "OECustomConstraints") -> "bool":
    r"""OEReceptorSetCustomConstraints(OEMolBase rec, OECustomConstraints arg2) -> bool"""
    return _oedocking.OEReceptorSetCustomConstraints(rec, arg2)

def OEReceptorSetProteinConstraint(rec: "OEMolBase", arg2: "OEProteinConstraint") -> "bool":
    r"""OEReceptorSetProteinConstraint(OEMolBase rec, OEProteinConstraint arg2) -> bool"""
    return _oedocking.OEReceptorSetProteinConstraint(rec, arg2)

def OEReceptorSetBoundLigand(rec: "OEMolBase", boundLig: "OEMolBase") -> "bool":
    r"""OEReceptorSetBoundLigand(OEMolBase rec, OEMolBase boundLig) -> bool"""
    return _oedocking.OEReceptorSetBoundLigand(rec, boundLig)

def OEReceptorAddExtraMol(rec: "OEMolBase", arg2: "OEMolBase") -> "bool":
    r"""OEReceptorAddExtraMol(OEMolBase rec, OEMolBase arg2) -> bool"""
    return _oedocking.OEReceptorAddExtraMol(rec, arg2)

def OEReceptorAddCachedScore(*args) -> "bool":
    r"""
    OEReceptorAddCachedScore(OEMolBase rec, OEScore score) -> bool
    OEReceptorAddCachedScore(OEMolBase rec, OEDock dock) -> bool
    """
    return _oedocking.OEReceptorAddCachedScore(*args)

def OEReceptorSetCachedScore(*args) -> "bool":
    r"""
    OEReceptorSetCachedScore(OEMolBase rec, OEScore score) -> bool
    OEReceptorSetCachedScore(OEMolBase rec, OEDock dock) -> bool
    """
    return _oedocking.OEReceptorSetCachedScore(*args)

def OEReceptorClear(rec: "OEMolBase") -> "bool":
    r"""OEReceptorClear(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorClear(rec)

def OEReceptorClearCustomConstraints(rec: "OEMolBase") -> "bool":
    r"""OEReceptorClearCustomConstraints(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorClearCustomConstraints(rec)

def OEReceptorClearProteinConstraint(rec: "OEMolBase", arg2: "OEProteinConstraint") -> "bool":
    r"""OEReceptorClearProteinConstraint(OEMolBase rec, OEProteinConstraint arg2) -> bool"""
    return _oedocking.OEReceptorClearProteinConstraint(rec, arg2)

def OEReceptorClearProteinConstraints(rec: "OEMolBase") -> "bool":
    r"""OEReceptorClearProteinConstraints(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorClearProteinConstraints(rec)

def OEReceptorClearBoundLigand(rec: "OEMolBase") -> "bool":
    r"""OEReceptorClearBoundLigand(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorClearBoundLigand(rec)

def OEReceptorClearExtraMols(rec: "OEMolBase") -> "bool":
    r"""OEReceptorClearExtraMols(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorClearExtraMols(rec)

def OEReceptorClearCachedScore(rec: "OEMolBase") -> "bool":
    r"""OEReceptorClearCachedScore(OEMolBase rec) -> bool"""
    return _oedocking.OEReceptorClearCachedScore(rec)

def OEWriteReceptorFile(receptor: "OEMolBase", filename: "std::string") -> "bool":
    r"""OEWriteReceptorFile(OEMolBase receptor, std::string filename) -> bool"""
    return _oedocking.OEWriteReceptorFile(receptor, filename)

def OEReadReceptorFile(*args) -> "bool":
    r"""
    OEReadReceptorFile(OEMolBase receptor, std::string filename) -> bool
    OEReadReceptorFile(OEMolBase receptor, oemolistream imstr) -> bool
    """
    return _oedocking.OEReadReceptorFile(*args)

def OEReadReceptorFromString(*args) -> "bool":
    r"""
    OEReadReceptorFromString(OEMolBase receptor, std::string const & format, std::string const & input) -> bool
    OEReadReceptorFromString(OEMolBase receptor, unsigned int format, unsigned int flavor, bool gzip, std::string const & input) -> bool
    """
    return _oedocking.OEReadReceptorFromString(*args)

def OEWriteReceptorToString(*args) -> "std::string":
    r"""
    OEWriteReceptorToString(std::string const & format, OEMolBase receptor) -> std::string
    OEWriteReceptorToString(unsigned int format, unsigned int flavor, bool gzip, OEMolBase receptor) -> std::string
    """
    return _oedocking.OEWriteReceptorToString(*args)
class OEAlignReceptorFunction(object):
    r"""Proxy of C++ OEDocking::OEAlignReceptorFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oedocking.delete_OEAlignReceptorFunction

    def SetupTarget(self, target: "OEMolBase") -> "bool":
        r"""SetupTarget(OEAlignReceptorFunction self, OEMolBase target) -> bool"""
        return _oedocking.OEAlignReceptorFunction_SetupTarget(self, target)

    def __call__(self, arg2: "OEMolBase") -> "OESystem::OEIterBase< OEChem::OETrans const > *":
        r"""__call__(OEAlignReceptorFunction self, OEMolBase arg2) -> OESystem::OEIterBase< OEChem::OETrans const > *"""
        return _oedocking.OEAlignReceptorFunction___call__(self, arg2)

    def CreateCopy(self) -> "OEDocking::OEAlignReceptorFunction *":
        r"""CreateCopy(OEAlignReceptorFunction self) -> OEAlignReceptorFunction"""
        return _oedocking.OEAlignReceptorFunction_CreateCopy(self)

# Register OEAlignReceptorFunction in _oedocking:
_oedocking.OEAlignReceptorFunction_swigregister(OEAlignReceptorFunction)


def OEAlignReceptors(*args) -> "OESystem::OEIterBase< OEChem::OEMolBase const > *":
    r"""
    OEAlignReceptors(OEMolBase target_receptor, OEMolBase receptor_to_align) -> OESystem::OEIterBase< OEChem::OEMolBase const >
    OEAlignReceptors(OEMolBase target_receptor, OEMolBase receptor_to_align, OEAlignReceptorFunction arg3) -> OESystem::OEIterBase< OEChem::OEMolBase const > *
    """
    return _oedocking.OEAlignReceptors(*args)
class OEMakeReceptorOptions(oechem.OEOptions):
    r"""Proxy of C++ OEDocking::OEMakeReceptorOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEMakeReceptorOptions self) -> OEMakeReceptorOptions
        __init__(OEMakeReceptorOptions self, OEMakeReceptorOptions arg2) -> OEMakeReceptorOptions
        """
        _oedocking.OEMakeReceptorOptions_swiginit(self, _oedocking.new_OEMakeReceptorOptions(*args))
    __swig_destroy__ = _oedocking.delete_OEMakeReceptorOptions

    def GetTargetMask(self) -> "unsigned int":
        r"""GetTargetMask(OEMakeReceptorOptions self) -> unsigned int"""
        return _oedocking.OEMakeReceptorOptions_GetTargetMask(self)

    def SetTargetMask(self, value: "unsigned int const") -> "bool":
        r"""SetTargetMask(OEMakeReceptorOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEMakeReceptorOptions_SetTargetMask(self, value)

    def GetNegativeImageType(self) -> "unsigned int":
        r"""GetNegativeImageType(OEMakeReceptorOptions self) -> unsigned int"""
        return _oedocking.OEMakeReceptorOptions_GetNegativeImageType(self)

    def SetNegativeImageType(self, value: "unsigned int const") -> "bool":
        r"""SetNegativeImageType(OEMakeReceptorOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEMakeReceptorOptions_SetNegativeImageType(self, value)

    def GetAutoConstraints(self) -> "bool":
        r"""GetAutoConstraints(OEMakeReceptorOptions self) -> bool"""
        return _oedocking.OEMakeReceptorOptions_GetAutoConstraints(self)

    def SetAutoConstraints(self, value: "bool const") -> "bool":
        r"""SetAutoConstraints(OEMakeReceptorOptions self, bool const value) -> bool"""
        return _oedocking.OEMakeReceptorOptions_SetAutoConstraints(self, value)

    def GetBoxMol(self) -> "OEChem::OEMolBase const &":
        r"""GetBoxMol(OEMakeReceptorOptions self) -> OEMolBase"""
        return _oedocking.OEMakeReceptorOptions_GetBoxMol(self)

    def SetBoxMol(self, value: "OEMolBase") -> "bool":
        r"""SetBoxMol(OEMakeReceptorOptions self, OEMolBase value) -> bool"""
        return _oedocking.OEMakeReceptorOptions_SetBoxMol(self, value)

    def GetBoxExtension(self) -> "double":
        r"""GetBoxExtension(OEMakeReceptorOptions self) -> double"""
        return _oedocking.OEMakeReceptorOptions_GetBoxExtension(self)

    def SetBoxExtension(self, value: "double const") -> "bool":
        r"""SetBoxExtension(OEMakeReceptorOptions self, double const value) -> bool"""
        return _oedocking.OEMakeReceptorOptions_SetBoxExtension(self, value)

    def GetTargetPred(self) -> "std::string":
        r"""GetTargetPred(OEMakeReceptorOptions self) -> std::string"""
        return _oedocking.OEMakeReceptorOptions_GetTargetPred(self)

    def SetTargetPred(self, value: "std::string const") -> "bool":
        r"""SetTargetPred(OEMakeReceptorOptions self, std::string const value) -> bool"""
        return _oedocking.OEMakeReceptorOptions_SetTargetPred(self, value)

    def CreateCopy(self) -> "OEDocking::OEMakeReceptorOptions *":
        r"""CreateCopy(OEMakeReceptorOptions self) -> OEMakeReceptorOptions"""
        return _oedocking.OEMakeReceptorOptions_CreateCopy(self)

# Register OEMakeReceptorOptions in _oedocking:
_oedocking.OEMakeReceptorOptions_swigregister(OEMakeReceptorOptions)


def OEMakeReceptor(*args) -> "bool":
    r"""
    OEMakeReceptor(OEMolBase receptor, OEDesignUnit designUnit, bool strip_water=True, unsigned int const negImgType=) -> bool
    OEMakeReceptor(OEMolBase receptor, OEMolBase pro, OEBox box, bool strip_water=True, unsigned int const negImgType=) -> bool
    OEMakeReceptor(OEMolBase receptor, OEMolBase pro, OEMolBase lig, bool strip_water=True, unsigned int const negImgType=) -> bool
    OEMakeReceptor(OEMolBase receptor, OEMolBase pro, OEAtomBase hint, bool strip_water=True, unsigned int const negImgType=) -> bool
    OEMakeReceptor(OEMolBase receptor, OEMolBase pro, float hint_x, float hint_y, float hint_z, bool strip_water=True, unsigned int const negImgType=) -> bool
    OEMakeReceptor(OEDesignUnit designUnit, OEMakeReceptorOptions opts=OEDocking::OEMakeReceptorOptions(), OETracerBase tracer=OENoTracer) -> bool
    """
    return _oedocking.OEMakeReceptor(*args)

def OECreateDUFromReceptorMol(du: "OEDesignUnit", recMol: "OEMolBase") -> "bool":
    r"""OECreateDUFromReceptorMol(OEDesignUnit du, OEMolBase recMol) -> bool"""
    return _oedocking.OECreateDUFromReceptorMol(du, recMol)

def OECreateActiveSiteBox(box: "OEBox", du: "OEDesignUnit") -> "bool":
    r"""OECreateActiveSiteBox(OEBox box, OEDesignUnit du) -> bool"""
    return _oedocking.OECreateActiveSiteBox(box, du)

def GetFileFormat(format: "char const *") -> "unsigned int":
    r"""GetFileFormat(char const * format) -> unsigned int"""
    return _oedocking.GetFileFormat(format)

def OEReceptorFromBytes(*args) -> "PyObject *":
    r"""
    OEReceptorFromBytes(OEMolBase & mol, char const * format, PyObject * bytes) -> PyObject
    OEReceptorFromBytes(OEMolBase & mol, unsigned int format, unsigned int flavor, bool gzip, PyObject * bytes) -> PyObject *
    """
    return _oedocking.OEReceptorFromBytes(*args)

def OEReceptorToBytes(*args) -> "PyObject *":
    r"""
    OEReceptorToBytes(char const * format, OEMolBase & mol) -> PyObject
    OEReceptorToBytes(unsigned int format, unsigned int flavor, bool gzip, OEMolBase & mol) -> PyObject *
    """
    return _oedocking.OEReceptorToBytes(*args)

def OESetupBox(*args) -> "bool":
    r"""
    OESetupBox(OEBoxBase arg1, float * xyz, unsigned int N, bool addbox=0.0) -> bool
    OESetupBox(OEBox arg1, OEMolBase arg2, float addbox=0.0) -> bool
    OESetupBox(OEBox arg1, OEMCMolBase arg2, float addbox=0.0) -> bool
    """
    return _oedocking.OESetupBox(*args)

def OEMakeBoxMolecule(mol: "OEMolBase", box: "OEBox") -> "bool":
    r"""OEMakeBoxMolecule(OEMolBase mol, OEBox box) -> bool"""
    return _oedocking.OEMakeBoxMolecule(mol, box)
class OEScore(object):
    r"""Proxy of C++ OEDocking::OEScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEScore self, unsigned int const scoring=) -> OEScore
        __init__(OEScore self, OEScore arg2) -> OEScore
        """
        _oedocking.OEScore_swiginit(self, _oedocking.new_OEScore(*args))
    __swig_destroy__ = _oedocking.delete_OEScore

    def IsInitialized(self) -> "bool":
        r"""IsInitialized(OEScore self) -> bool"""
        return _oedocking.OEScore_IsInitialized(self)

    def Initialize(self, *args) -> "bool":
        r"""
        Initialize(OEScore self, OEMolBase pro, OEBox box) -> bool
        Initialize(OEScore self, OEMolBase receptor) -> bool
        Initialize(OEScore self, OEDesignUnit du) -> bool
        """
        return _oedocking.OEScore_Initialize(self, *args)

    def GetName(self) -> "std::string":
        r"""GetName(OEScore self) -> std::string"""
        return _oedocking.OEScore_GetName(self)

    def GetComponentNames(self) -> "OESystem::OEIterBase< std::string const > *":
        r"""GetComponentNames(OEScore self) -> OESystem::OEIterBase< std::string const > *"""
        return _oedocking.OEScore_GetComponentNames(self)

    def GetHighScoresAreBetter(self) -> "bool":
        r"""GetHighScoresAreBetter(OEScore self) -> bool"""
        return _oedocking.OEScore_GetHighScoresAreBetter(self)

    def ScoreLigand(self, lig: "OEMolBase") -> "float":
        r"""ScoreLigand(OEScore self, OEMolBase lig) -> float"""
        return _oedocking.OEScore_ScoreLigand(self, lig)

    def ScoreAtom(self, atom: "OEAtomBase", lig: "OEMolBase") -> "float":
        r"""ScoreAtom(OEScore self, OEAtomBase atom, OEMolBase lig) -> float"""
        return _oedocking.OEScore_ScoreAtom(self, atom, lig)

    def ScoreLigandComponent(self, lig: "OEMolBase", compName: "std::string") -> "float":
        r"""ScoreLigandComponent(OEScore self, OEMolBase lig, std::string compName) -> float"""
        return _oedocking.OEScore_ScoreLigandComponent(self, lig, compName)

    def ScoreAtomComponent(self, atom: "OEAtomBase", lig: "OEMolBase", compName: "std::string") -> "float":
        r"""ScoreAtomComponent(OEScore self, OEAtomBase atom, OEMolBase lig, std::string compName) -> float"""
        return _oedocking.OEScore_ScoreAtomComponent(self, atom, lig, compName)

    def SystematicSolidBodyOptimize(self, *args) -> "bool":
        r"""
        SystematicSolidBodyOptimize(OEScore self, OEMCMolBase mol, unsigned int searchRes=) -> bool
        SystematicSolidBodyOptimize(OEScore self, OEMolBase mol, unsigned int searchRes=) -> bool
        """
        return _oedocking.OEScore_SystematicSolidBodyOptimize(self, *args)

    def AnnotatePose(self, *args) -> "bool":
        r"""
        AnnotatePose(OEScore self, OEMolBase lig) -> bool
        AnnotatePose(OEScore self, OEMCMolBase lig) -> bool
        """
        return _oedocking.OEScore_AnnotatePose(self, *args)

    def CacheScoringSetup(self, *args) -> "bool":
        r"""
        CacheScoringSetup(OEScore self, OEMolBase receptor, bool clearOldData=True) -> bool
        CacheScoringSetup(OEScore self, OEDesignUnit du, bool clearOldData=True) -> bool
        """
        return _oedocking.OEScore_CacheScoringSetup(self, *args)

# Register OEScore in _oedocking:
_oedocking.OEScore_swigregister(OEScore)


def OESetEnergyScore(*args) -> "bool":
    r"""
    OESetEnergyScore(OEMCMolBase ligand, OEDock scoreFxn, bool sortPoses=False) -> bool
    OESetEnergyScore(OEMolBase ligand, OEDock scoreFxn) -> bool
    OESetEnergyScore(OEMCMolBase ligand, OEScore scoreFxn, bool sortPoses=False) -> bool
    OESetEnergyScore(OEMolBase ligand, OEScore scoreFxn) -> bool
    """
    return _oedocking.OESetEnergyScore(*args)

def OESetScore(*args) -> "bool":
    r"""
    OESetScore(OEMCMolBase ligand, OEDock scoreFxn, std::string tag, bool sortPoses=False) -> bool
    OESetScore(OEMolBase arg1, OEDock scoreFxn, std::string tag) -> bool
    OESetScore(OEMCMolBase ligand, OEScore scoreFxn, std::string tag, bool sortPoses=False) -> bool
    OESetScore(OEMolBase arg1, OEScore scoreFxn, std::string tag) -> bool
    """
    return _oedocking.OESetScore(*args)

def OESetEnergyScoreComponent(*args) -> "bool":
    r"""
    OESetEnergyScoreComponent(OEMCMolBase ligand, OEDock scoreFxn, std::string component, bool sortPoses=False) -> bool
    OESetEnergyScoreComponent(OEMolBase ligand, OEDock scoreFxn, std::string component) -> bool
    OESetEnergyScoreComponent(OEMCMolBase ligand, OEScore scoreFxn, std::string component, bool sortPoses=False) -> bool
    OESetEnergyScoreComponent(OEMolBase ligand, OEScore scoreFxn, std::string component) -> bool
    """
    return _oedocking.OESetEnergyScoreComponent(*args)

def OESetSDScoreComponent(*args) -> "bool":
    r"""
    OESetSDScoreComponent(OEMCMolBase ligand, OEDock scoreFxn, std::string component, std::string tag, bool sortPoses=False) -> bool
    OESetSDScoreComponent(OEMolBase ligand, OEDock scoreFxn, std::string component, std::string tag) -> bool
    OESetSDScoreComponent(OEMCMolBase ligand, OEScore scoreFxn, std::string component, std::string tag, bool sortPoses=False) -> bool
    OESetSDScoreComponent(OEMolBase ligand, OEScore scoreFxn, std::string component, std::string tag) -> bool
    """
    return _oedocking.OESetSDScoreComponent(*args)

def OESetScoreComponent(*args) -> "bool":
    r"""
    OESetScoreComponent(OEMCMolBase ligand, OEDock scoreFxn, std::string component, std::string tag, bool sortPoses=False) -> bool
    OESetScoreComponent(OEMolBase ligand, OEDock scoreFxn, std::string component, std::string tag) -> bool
    OESetScoreComponent(OEMCMolBase ligand, OEScore scoreFxn, std::string component, std::string tag, bool sortPoses=False) -> bool
    OESetScoreComponent(OEMolBase ligand, OEScore scoreFxn, std::string component, std::string tag) -> bool
    """
    return _oedocking.OESetScoreComponent(*args)
OE_OEDOCKING_VERSION = _oedocking.OE_OEDOCKING_VERSION


def OEDockingGetRelease() -> "char const *":
    r"""OEDockingGetRelease() -> char const *"""
    return _oedocking.OEDockingGetRelease()

def OEDockingGetVersion() -> "unsigned int":
    r"""OEDockingGetVersion() -> unsigned int"""
    return _oedocking.OEDockingGetVersion()

def OEDockingGetArch() -> "char const *":
    r"""OEDockingGetArch() -> char const *"""
    return _oedocking.OEDockingGetArch()

def OEDockingGetPlatform() -> "char const *":
    r"""OEDockingGetPlatform() -> char const *"""
    return _oedocking.OEDockingGetPlatform()

def OEDockingIsLicensed(feature: "char const *"=None, expdate: "unsigned int *"=None) -> "bool":
    r"""OEDockingIsLicensed(char const * feature=None, unsigned int * expdate=None) -> bool"""
    return _oedocking.OEDockingIsLicensed(feature, expdate)

def OEDockingGetLicensee(*args) -> "std::string":
    r"""
    OEDockingGetLicensee(std::string & licensee) -> bool
    OEDockingGetLicensee() -> std::string
    """
    return _oedocking.OEDockingGetLicensee(*args)

def OEDockingGetSite(*args) -> "std::string":
    r"""
    OEDockingGetSite(std::string & site) -> bool
    OEDockingGetSite() -> std::string
    """
    return _oedocking.OEDockingGetSite(*args)
class OEShapeFitResultsIter(object):
    r"""Proxy of C++ OESystem::OEIter< OEDocking::OEShapeFitResults > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEShapeFitResultsIter self) -> OEShapeFitResultsIter
        __init__(OEShapeFitResultsIter self, OEShapeFitResultsIter rhs) -> OEShapeFitResultsIter
        __init__(OEShapeFitResultsIter self, OESystem::OEIterBase< OEDocking::OEShapeFitResults > * rhs) -> OEShapeFitResultsIter
        __init__(OEShapeFitResultsIter self, OESystem::OEIterBase< OESystem::OEIter< OEDocking::OEShapeFitResults >::NonConstA > * rhs) -> OEShapeFitResultsIter
        """
        _oedocking.OEShapeFitResultsIter_swiginit(self, _oedocking.new_OEShapeFitResultsIter(*args))
    __swig_destroy__ = _oedocking.delete_OEShapeFitResultsIter

    def Copy(self) -> "OESystem::OEIterBase< OEDocking::OEShapeFitResults > *":
        r"""Copy(OEShapeFitResultsIter self) -> OESystem::OEIterBase< OEDocking::OEShapeFitResults > *"""
        return _oedocking.OEShapeFitResultsIter_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEShapeFitResultsIter self, OESystem::OEIterBase< OEDocking::OEShapeFitResults > * ib)
        Push(OEShapeFitResultsIter self, OEShapeFitResultsIter iter)
        """
        return _oedocking.OEShapeFitResultsIter_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEDocking::OEShapeFitResults,OEDocking::OEShapeFitResults > const &") -> "void":
        r"""Sort(OEShapeFitResultsIter self, OESystem::OEBinaryPredicate< OEDocking::OEShapeFitResults,OEDocking::OEShapeFitResults > const & sort_criterion)"""
        return _oedocking.OEShapeFitResultsIter_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEDocking::OEShapeFitResults > &":
        r"""ToFirst(OEShapeFitResultsIter self) -> OEShapeFitResultsIter"""
        return _oedocking.OEShapeFitResultsIter_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEDocking::OEShapeFitResults > &":
        r"""ToLast(OEShapeFitResultsIter self) -> OEShapeFitResultsIter"""
        return _oedocking.OEShapeFitResultsIter_ToLast(self)

    def __ref__(self) -> "OEDocking::OEShapeFitResults &":
        r"""__ref__(OEShapeFitResultsIter self) -> OEShapeFitResults"""
        return _oedocking.OEShapeFitResultsIter___ref__(self)

    def IsValid(self):
      return _oedocking.OEShapeFitResultsIter___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEShapeFitResultsIter self) -> PyObject *"""
        return _oedocking.OEShapeFitResultsIter_next(self)

    def Target(self) -> "OEDocking::OEShapeFitResults &":
        r"""Target(OEShapeFitResultsIter self) -> OEShapeFitResults"""
        return _oedocking.OEShapeFitResultsIter_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEDocking::OEShapeFitResults > &":
        r"""
        Next(OEShapeFitResultsIter self) -> OEShapeFitResultsIter
        Next(OEShapeFitResultsIter self, int i) -> OEShapeFitResultsIter
        """
        return _oedocking.OEShapeFitResultsIter_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEDocking::OEShapeFitResults > &":
        r"""
        Prev(OEShapeFitResultsIter self) -> OEShapeFitResultsIter
        Prev(OEShapeFitResultsIter self, int i) -> OEShapeFitResultsIter
        """
        return _oedocking.OEShapeFitResultsIter_Prev(self, *args)

# Register OEShapeFitResultsIter in _oedocking:
_oedocking.OEShapeFitResultsIter_swigregister(OEShapeFitResultsIter)

class OEShapeFitOptions(oeshape.OEFlexiOverlayOptions):
    r"""Proxy of C++ OEDocking::OEShapeFitOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEShapeFitOptions self) -> OEShapeFitOptions
        __init__(OEShapeFitOptions self, OEShapeFitOptions arg2) -> OEShapeFitOptions
        """
        _oedocking.OEShapeFitOptions_swiginit(self, _oedocking.new_OEShapeFitOptions(*args))
    __swig_destroy__ = _oedocking.delete_OEShapeFitOptions

    def CreateCopy(self) -> "OEDocking::OEShapeFitOptions *":
        r"""CreateCopy(OEShapeFitOptions self) -> OEShapeFitOptions"""
        return _oedocking.OEShapeFitOptions_CreateCopy(self)

# Register OEShapeFitOptions in _oedocking:
_oedocking.OEShapeFitOptions_swigregister(OEShapeFitOptions)

class OEShapeFitResults(object):
    r"""Proxy of C++ OEDocking::OEShapeFitResults class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEShapeFitResults self) -> OEShapeFitResults
        __init__(OEShapeFitResults self, OEShapeFitResults rhs) -> OEShapeFitResults
        """
        _oedocking.OEShapeFitResults_swiginit(self, _oedocking.new_OEShapeFitResults(*args))

    def GetPose(self) -> "OEChem::OEMolBase const &":
        r"""GetPose(OEShapeFitResults self) -> OEMolBase"""
        return _oedocking.OEShapeFitResults_GetPose(self)

    def GetScore(self) -> "double":
        r"""GetScore(OEShapeFitResults self) -> double"""
        return _oedocking.OEShapeFitResults_GetScore(self)
    __swig_destroy__ = _oedocking.delete_OEShapeFitResults

# Register OEShapeFitResults in _oedocking:
_oedocking.OEShapeFitResults_swigregister(OEShapeFitResults)

class OEShapeFit(object):
    r"""Proxy of C++ OEDocking::OEShapeFit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEShapeFit self, OEShapeFitOptions options=OEDocking::OEShapeFitOptions()) -> OEShapeFit
        __init__(OEShapeFit self, OEShapeFit arg2) -> OEShapeFit
        """
        _oedocking.OEShapeFit_swiginit(self, _oedocking.new_OEShapeFit(*args))
    __swig_destroy__ = _oedocking.delete_OEShapeFit

    def SetupRef(self, du: "OEDesignUnit") -> "bool":
        r"""SetupRef(OEShapeFit self, OEDesignUnit du) -> bool"""
        return _oedocking.OEShapeFit_SetupRef(self, du)

    def Fit(self, fitmol: "OEMCMolBase", numPoses: "unsigned int const"=1) -> "OESystem::OEIterBase< OEDocking::OEShapeFitResults > *":
        r"""Fit(OEShapeFit self, OEMCMolBase fitmol, unsigned int const numPoses=1) -> OESystem::OEIterBase< OEDocking::OEShapeFitResults >"""
        return _oedocking.OEShapeFit_Fit(self, fitmol, numPoses)

# Register OEShapeFit in _oedocking:
_oedocking.OEShapeFit_swigregister(OEShapeFit)

class OEConstMolBaseIter(object):
    r"""Proxy of C++ OESystem::OEIter< OEChem::OEMolBase const > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEConstMolBaseIter self) -> OEConstMolBaseIter
        __init__(OEConstMolBaseIter self, OEConstMolBaseIter rhs) -> OEConstMolBaseIter
        __init__(OEConstMolBaseIter self, OESystem::OEIterBase< OEChem::OEMolBase const > * rhs) -> OEConstMolBaseIter
        __init__(OEConstMolBaseIter self, OESystem::OEIterBase< OESystem::OEIter< OEChem::OEMolBase const >::NonConstA > * rhs) -> OEConstMolBaseIter
        """
        _oedocking.OEConstMolBaseIter_swiginit(self, _oedocking.new_OEConstMolBaseIter(*args))
    __swig_destroy__ = _oedocking.delete_OEConstMolBaseIter

    def Copy(self) -> "OESystem::OEIterBase< OEChem::OEMolBase const > *":
        r"""Copy(OEConstMolBaseIter self) -> OESystem::OEIterBase< OEChem::OEMolBase const > *"""
        return _oedocking.OEConstMolBaseIter_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEConstMolBaseIter self, OESystem::OEIterBase< OEChem::OEMolBase const > * ib)
        Push(OEConstMolBaseIter self, OEConstMolBaseIter iter)
        """
        return _oedocking.OEConstMolBaseIter_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEChem::OEMolBase const,OEChem::OEMolBase const > const &") -> "void":
        r"""Sort(OEConstMolBaseIter self, OESystem::OEBinaryPredicate< OEChem::OEMolBase const,OEChem::OEMolBase const > const & sort_criterion)"""
        return _oedocking.OEConstMolBaseIter_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEChem::OEMolBase const > &":
        r"""ToFirst(OEConstMolBaseIter self) -> OEConstMolBaseIter"""
        return _oedocking.OEConstMolBaseIter_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEChem::OEMolBase const > &":
        r"""ToLast(OEConstMolBaseIter self) -> OEConstMolBaseIter"""
        return _oedocking.OEConstMolBaseIter_ToLast(self)

    def __ref__(self) -> "OEChem::OEMolBase const &":
        r"""__ref__(OEConstMolBaseIter self) -> OEMolBase"""
        return _oedocking.OEConstMolBaseIter___ref__(self)

    def IsValid(self):
      return _oedocking.OEConstMolBaseIter___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEConstMolBaseIter self) -> PyObject *"""
        return _oedocking.OEConstMolBaseIter_next(self)

    def Target(self) -> "OEChem::OEMolBase const &":
        r"""Target(OEConstMolBaseIter self) -> OEMolBase"""
        return _oedocking.OEConstMolBaseIter_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEChem::OEMolBase const > &":
        r"""
        Next(OEConstMolBaseIter self) -> OEConstMolBaseIter
        Next(OEConstMolBaseIter self, int i) -> OEConstMolBaseIter
        """
        return _oedocking.OEConstMolBaseIter_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEChem::OEMolBase const > &":
        r"""
        Prev(OEConstMolBaseIter self) -> OEConstMolBaseIter
        Prev(OEConstMolBaseIter self, int i) -> OEConstMolBaseIter
        """
        return _oedocking.OEConstMolBaseIter_Prev(self, *args)

# Register OEConstMolBaseIter in _oedocking:
_oedocking.OEConstMolBaseIter_swigregister(OEConstMolBaseIter)

class OESinglePoseResultIter(object):
    r"""Proxy of C++ OESystem::OEIter< OEDocking::OESinglePoseResult > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OESinglePoseResultIter self) -> OESinglePoseResultIter
        __init__(OESinglePoseResultIter self, OESinglePoseResultIter rhs) -> OESinglePoseResultIter
        __init__(OESinglePoseResultIter self, OESystem::OEIterBase< OEDocking::OESinglePoseResult > * rhs) -> OESinglePoseResultIter
        __init__(OESinglePoseResultIter self, OESystem::OEIterBase< OESystem::OEIter< OEDocking::OESinglePoseResult >::NonConstA > * rhs) -> OESinglePoseResultIter
        """
        _oedocking.OESinglePoseResultIter_swiginit(self, _oedocking.new_OESinglePoseResultIter(*args))
    __swig_destroy__ = _oedocking.delete_OESinglePoseResultIter

    def Copy(self) -> "OESystem::OEIterBase< OEDocking::OESinglePoseResult > *":
        r"""Copy(OESinglePoseResultIter self) -> OESystem::OEIterBase< OEDocking::OESinglePoseResult > *"""
        return _oedocking.OESinglePoseResultIter_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OESinglePoseResultIter self, OESystem::OEIterBase< OEDocking::OESinglePoseResult > * ib)
        Push(OESinglePoseResultIter self, OESinglePoseResultIter iter)
        """
        return _oedocking.OESinglePoseResultIter_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEDocking::OESinglePoseResult,OEDocking::OESinglePoseResult > const &") -> "void":
        r"""Sort(OESinglePoseResultIter self, OESystem::OEBinaryPredicate< OEDocking::OESinglePoseResult,OEDocking::OESinglePoseResult > const & sort_criterion)"""
        return _oedocking.OESinglePoseResultIter_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEDocking::OESinglePoseResult > &":
        r"""ToFirst(OESinglePoseResultIter self) -> OESinglePoseResultIter"""
        return _oedocking.OESinglePoseResultIter_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEDocking::OESinglePoseResult > &":
        r"""ToLast(OESinglePoseResultIter self) -> OESinglePoseResultIter"""
        return _oedocking.OESinglePoseResultIter_ToLast(self)

    def __ref__(self) -> "OEDocking::OESinglePoseResult &":
        r"""__ref__(OESinglePoseResultIter self) -> OESinglePoseResult"""
        return _oedocking.OESinglePoseResultIter___ref__(self)

    def IsValid(self):
      return _oedocking.OESinglePoseResultIter___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OESinglePoseResultIter self) -> PyObject *"""
        return _oedocking.OESinglePoseResultIter_next(self)

    def Target(self) -> "OEDocking::OESinglePoseResult &":
        r"""Target(OESinglePoseResultIter self) -> OESinglePoseResult"""
        return _oedocking.OESinglePoseResultIter_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEDocking::OESinglePoseResult > &":
        r"""
        Next(OESinglePoseResultIter self) -> OESinglePoseResultIter
        Next(OESinglePoseResultIter self, int i) -> OESinglePoseResultIter
        """
        return _oedocking.OESinglePoseResultIter_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEDocking::OESinglePoseResult > &":
        r"""
        Prev(OESinglePoseResultIter self) -> OESinglePoseResultIter
        Prev(OESinglePoseResultIter self, int i) -> OESinglePoseResultIter
        """
        return _oedocking.OESinglePoseResultIter_Prev(self, *args)

# Register OESinglePoseResultIter in _oedocking:
_oedocking.OESinglePoseResultIter_swigregister(OESinglePoseResultIter)

class OEReceptorIter(object):
    r"""Proxy of C++ OESystem::OEIter< OEChem::OEMolBase > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEReceptorIter self) -> OEReceptorIter
        __init__(OEReceptorIter self, OEMolBaseIter rhs) -> OEReceptorIter
        __init__(OEReceptorIter self, OESystem::OEIterBase< OEChem::OEMolBase > * rhs) -> OEReceptorIter
        __init__(OEReceptorIter self, OESystem::OEIterBase< OESystem::OEIter< OEChem::OEMolBase >::NonConstA > * rhs) -> OEReceptorIter
        """
        _oedocking.OEReceptorIter_swiginit(self, _oedocking.new_OEReceptorIter(*args))
    __swig_destroy__ = _oedocking.delete_OEReceptorIter

    def Copy(self) -> "OESystem::OEIterBase< OEChem::OEMolBase > *":
        r"""Copy(OEReceptorIter self) -> OESystem::OEIterBase< OEChem::OEMolBase > *"""
        return _oedocking.OEReceptorIter_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEReceptorIter self, OESystem::OEIterBase< OEChem::OEMolBase > * ib)
        Push(OEReceptorIter self, OEMolBaseIter iter)
        """
        return _oedocking.OEReceptorIter_Push(self, *args)

    def Sort(self, sort_criterion: "OEBinaryMolBasePred") -> "void":
        r"""Sort(OEReceptorIter self, OEBinaryMolBasePred sort_criterion)"""
        return _oedocking.OEReceptorIter_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEChem::OEMolBase > &":
        r"""ToFirst(OEReceptorIter self) -> OEMolBaseIter"""
        return _oedocking.OEReceptorIter_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEChem::OEMolBase > &":
        r"""ToLast(OEReceptorIter self) -> OEMolBaseIter"""
        return _oedocking.OEReceptorIter_ToLast(self)

    def __ref__(self) -> "OEChem::OEMolBase &":
        r"""__ref__(OEReceptorIter self) -> OEMolBase"""
        return _oedocking.OEReceptorIter___ref__(self)

    def IsValid(self):
      return _oedocking.OEReceptorIter___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEReceptorIter self) -> PyObject *"""
        return _oedocking.OEReceptorIter_next(self)

    def Target(self) -> "OEChem::OEMolBase &":
        r"""Target(OEReceptorIter self) -> OEMolBase"""
        return _oedocking.OEReceptorIter_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEChem::OEMolBase > &":
        r"""
        Next(OEReceptorIter self) -> OEMolBaseIter
        Next(OEReceptorIter self, int i) -> OEMolBaseIter
        """
        return _oedocking.OEReceptorIter_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEChem::OEMolBase > &":
        r"""
        Prev(OEReceptorIter self) -> OEMolBaseIter
        Prev(OEReceptorIter self, int i) -> OEMolBaseIter
        """
        return _oedocking.OEReceptorIter_Prev(self, *args)

# Register OEReceptorIter in _oedocking:
_oedocking.OEReceptorIter_swigregister(OEReceptorIter)

class OEDesignUnitIter(object):
    r"""Proxy of C++ OESystem::OEIter< OEBio::OEDesignUnit > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEDesignUnitIter self) -> OEDesignUnitIter
        __init__(OEDesignUnitIter self, OEDesignUnitIter rhs) -> OEDesignUnitIter
        __init__(OEDesignUnitIter self, OESystem::OEIterBase< OEBio::OEDesignUnit > * rhs) -> OEDesignUnitIter
        __init__(OEDesignUnitIter self, OESystem::OEIterBase< OESystem::OEIter< OEBio::OEDesignUnit >::NonConstA > * rhs) -> OEDesignUnitIter
        """
        _oedocking.OEDesignUnitIter_swiginit(self, _oedocking.new_OEDesignUnitIter(*args))
    __swig_destroy__ = _oedocking.delete_OEDesignUnitIter

    def Copy(self) -> "OESystem::OEIterBase< OEBio::OEDesignUnit > *":
        r"""Copy(OEDesignUnitIter self) -> OESystem::OEIterBase< OEBio::OEDesignUnit > *"""
        return _oedocking.OEDesignUnitIter_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEDesignUnitIter self, OESystem::OEIterBase< OEBio::OEDesignUnit > * ib)
        Push(OEDesignUnitIter self, OEDesignUnitIter iter)
        """
        return _oedocking.OEDesignUnitIter_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEBio::OEDesignUnit,OEBio::OEDesignUnit > const &") -> "void":
        r"""Sort(OEDesignUnitIter self, OESystem::OEBinaryPredicate< OEBio::OEDesignUnit,OEBio::OEDesignUnit > const & sort_criterion)"""
        return _oedocking.OEDesignUnitIter_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEBio::OEDesignUnit > &":
        r"""ToFirst(OEDesignUnitIter self) -> OEDesignUnitIter"""
        return _oedocking.OEDesignUnitIter_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEBio::OEDesignUnit > &":
        r"""ToLast(OEDesignUnitIter self) -> OEDesignUnitIter"""
        return _oedocking.OEDesignUnitIter_ToLast(self)

    def __ref__(self) -> "OEBio::OEDesignUnit &":
        r"""__ref__(OEDesignUnitIter self) -> OEDesignUnit"""
        return _oedocking.OEDesignUnitIter___ref__(self)

    def IsValid(self):
      return _oedocking.OEDesignUnitIter___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEDesignUnitIter self) -> PyObject *"""
        return _oedocking.OEDesignUnitIter_next(self)

    def Target(self) -> "OEBio::OEDesignUnit &":
        r"""Target(OEDesignUnitIter self) -> OEDesignUnit"""
        return _oedocking.OEDesignUnitIter_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEBio::OEDesignUnit > &":
        r"""
        Next(OEDesignUnitIter self) -> OEDesignUnitIter
        Next(OEDesignUnitIter self, int i) -> OEDesignUnitIter
        """
        return _oedocking.OEDesignUnitIter_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEBio::OEDesignUnit > &":
        r"""
        Prev(OEDesignUnitIter self) -> OEDesignUnitIter
        Prev(OEDesignUnitIter self, int i) -> OEDesignUnitIter
        """
        return _oedocking.OEDesignUnitIter_Prev(self, *args)

# Register OEDesignUnitIter in _oedocking:
_oedocking.OEDesignUnitIter_swigregister(OEDesignUnitIter)

class OESinglePoseResult(object):
    r"""Proxy of C++ OEDocking::OESinglePoseResult class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _oedocking.delete_OESinglePoseResult

    def __init__(self, *args):
        r"""
        __init__(OESinglePoseResult self) -> OESinglePoseResult
        __init__(OESinglePoseResult self, OESinglePoseResult arg2) -> OESinglePoseResult
        """
        _oedocking.OESinglePoseResult_swiginit(self, _oedocking.new_OESinglePoseResult(*args))

    def GetPose(self) -> "OEChem::OEMolBase const &":
        r"""GetPose(OESinglePoseResult self) -> OEMolBase"""
        return _oedocking.OESinglePoseResult_GetPose(self)

    def GetReceptor(self) -> "OEChem::OEMolBase const &":
        r"""GetReceptor(OESinglePoseResult self) -> OEMolBase"""
        return _oedocking.OESinglePoseResult_GetReceptor(self)

    def GetDesignUnit(self) -> "OEBio::OEDesignUnit const &":
        r"""GetDesignUnit(OESinglePoseResult self) -> OEDesignUnit"""
        return _oedocking.OESinglePoseResult_GetDesignUnit(self)

    def GetTargetMask(self) -> "unsigned int":
        r"""GetTargetMask(OESinglePoseResult self) -> unsigned int"""
        return _oedocking.OESinglePoseResult_GetTargetMask(self)

    def GetTargetPred(self) -> "OEBio::OEAtomMatchResidue":
        r"""GetTargetPred(OESinglePoseResult self) -> OEAtomMatchResidue"""
        return _oedocking.OESinglePoseResult_GetTargetPred(self)

    def GetProbability(self) -> "double":
        r"""GetProbability(OESinglePoseResult self) -> double"""
        return _oedocking.OESinglePoseResult_GetProbability(self)

    def GetPositMethod(self) -> "unsigned int":
        r"""GetPositMethod(OESinglePoseResult self) -> unsigned int"""
        return _oedocking.OESinglePoseResult_GetPositMethod(self)

    def GetHasClash(self) -> "bool":
        r"""GetHasClash(OESinglePoseResult self) -> bool"""
        return _oedocking.OESinglePoseResult_GetHasClash(self)

    def GetReceptorIndex(self) -> "unsigned int":
        r"""GetReceptorIndex(OESinglePoseResult self) -> unsigned int"""
        return _oedocking.OESinglePoseResult_GetReceptorIndex(self)

    def GetNumContacts(self) -> "unsigned int":
        r"""GetNumContacts(OESinglePoseResult self) -> unsigned int"""
        return _oedocking.OESinglePoseResult_GetNumContacts(self)

    def GetNumClashes(self) -> "unsigned int":
        r"""GetNumClashes(OESinglePoseResult self) -> unsigned int"""
        return _oedocking.OESinglePoseResult_GetNumClashes(self)

    def GetRelaxed(self) -> "bool":
        r"""GetRelaxed(OESinglePoseResult self) -> bool"""
        return _oedocking.OESinglePoseResult_GetRelaxed(self)

# Register OESinglePoseResult in _oedocking:
_oedocking.OESinglePoseResult_swigregister(OESinglePoseResult)

class OEPositResults(object):
    r"""Proxy of C++ OEDocking::OEPositResults class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _oedocking.delete_OEPositResults

    def __init__(self, *args):
        r"""
        __init__(OEPositResults self) -> OEPositResults
        __init__(OEPositResults self, OEPositResults arg2) -> OEPositResults
        """
        _oedocking.OEPositResults_swiginit(self, _oedocking.new_OEPositResults(*args))

    def GetReturnCode(self) -> "unsigned int":
        r"""GetReturnCode(OEPositResults self) -> unsigned int"""
        return _oedocking.OEPositResults_GetReturnCode(self)

    def GetNumPoses(self) -> "unsigned int":
        r"""GetNumPoses(OEPositResults self) -> unsigned int"""
        return _oedocking.OEPositResults_GetNumPoses(self)

    def GetSinglePoseResults(self) -> "OESystem::OEIterBase< OEDocking::OESinglePoseResult > *":
        r"""GetSinglePoseResults(OEPositResults self) -> OESystem::OEIterBase< OEDocking::OESinglePoseResult > *"""
        return _oedocking.OEPositResults_GetSinglePoseResults(self)

# Register OEPositResults in _oedocking:
_oedocking.OEPositResults_swigregister(OEPositResults)

class OEPositOptions(oechem.OEOptions):
    r"""Proxy of C++ OEDocking::OEPositOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEPositOptions self, bool const fullConformationalSearch=True, unsigned int const ipositMethods=) -> OEPositOptions
        __init__(OEPositOptions self, OEPositOptions arg2) -> OEPositOptions
        """
        _oedocking.OEPositOptions_swiginit(self, _oedocking.new_OEPositOptions(*args))
    __swig_destroy__ = _oedocking.delete_OEPositOptions

    def GetFullConformationSearch(self) -> "bool":
        r"""GetFullConformationSearch(OEPositOptions self) -> bool"""
        return _oedocking.OEPositOptions_GetFullConformationSearch(self)

    def SetFullConformationSearch(self, value: "bool const") -> "bool":
        r"""SetFullConformationSearch(OEPositOptions self, bool const value) -> bool"""
        return _oedocking.OEPositOptions_SetFullConformationSearch(self, value)

    def GetIgnoreNitrogenStereo(self) -> "bool":
        r"""GetIgnoreNitrogenStereo(OEPositOptions self) -> bool"""
        return _oedocking.OEPositOptions_GetIgnoreNitrogenStereo(self)

    def SetIgnoreNitrogenStereo(self, value: "bool const") -> "bool":
        r"""SetIgnoreNitrogenStereo(OEPositOptions self, bool const value) -> bool"""
        return _oedocking.OEPositOptions_SetIgnoreNitrogenStereo(self, value)

    def GetExcludeSelf(self) -> "bool":
        r"""GetExcludeSelf(OEPositOptions self) -> bool"""
        return _oedocking.OEPositOptions_GetExcludeSelf(self)

    def SetExcludeSelf(self, value: "bool const") -> "bool":
        r"""SetExcludeSelf(OEPositOptions self, bool const value) -> bool"""
        return _oedocking.OEPositOptions_SetExcludeSelf(self, value)

    def GetMinProbability(self) -> "double":
        r"""GetMinProbability(OEPositOptions self) -> double"""
        return _oedocking.OEPositOptions_GetMinProbability(self)

    def SetMinProbability(self, value: "double const") -> "bool":
        r"""SetMinProbability(OEPositOptions self, double const value) -> bool"""
        return _oedocking.OEPositOptions_SetMinProbability(self, value)

    def GetPoserCacheCount(self) -> "unsigned int":
        r"""GetPoserCacheCount(OEPositOptions self) -> unsigned int"""
        return _oedocking.OEPositOptions_GetPoserCacheCount(self)

    def SetPoserCacheCount(self, value: "unsigned int const") -> "bool":
        r"""SetPoserCacheCount(OEPositOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEPositOptions_SetPoserCacheCount(self, value)

    def GetPositMethods(self) -> "unsigned int":
        r"""GetPositMethods(OEPositOptions self) -> unsigned int"""
        return _oedocking.OEPositOptions_GetPositMethods(self)

    def SetPositMethods(self, value: "unsigned int const") -> "bool":
        r"""SetPositMethods(OEPositOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEPositOptions_SetPositMethods(self, value)

    def GetAllowedClashType(self) -> "unsigned int":
        r"""GetAllowedClashType(OEPositOptions self) -> unsigned int"""
        return _oedocking.OEPositOptions_GetAllowedClashType(self)

    def SetAllowedClashType(self, value: "unsigned int const") -> "bool":
        r"""SetAllowedClashType(OEPositOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEPositOptions_SetAllowedClashType(self, value)

    def GetPoseRelaxMode(self) -> "unsigned int":
        r"""GetPoseRelaxMode(OEPositOptions self) -> unsigned int"""
        return _oedocking.OEPositOptions_GetPoseRelaxMode(self)

    def SetPoseRelaxMode(self, value: "unsigned int const") -> "bool":
        r"""SetPoseRelaxMode(OEPositOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEPositOptions_SetPoseRelaxMode(self, value)

    def GetBestReceptorPoseOnly(self) -> "bool":
        r"""GetBestReceptorPoseOnly(OEPositOptions self) -> bool"""
        return _oedocking.OEPositOptions_GetBestReceptorPoseOnly(self)

    def SetBestReceptorPoseOnly(self, value: "bool const") -> "bool":
        r"""SetBestReceptorPoseOnly(OEPositOptions self, bool const value) -> bool"""
        return _oedocking.OEPositOptions_SetBestReceptorPoseOnly(self, value)

    def SetFlexiOverlayOptions(self, opts: "OEShapeFitOptions") -> "void":
        r"""SetFlexiOverlayOptions(OEPositOptions self, OEShapeFitOptions opts)"""
        return _oedocking.OEPositOptions_SetFlexiOverlayOptions(self, opts)

    def GetFlexiOverlayOptions(self, *args) -> "OEDocking::OEShapeFitOptions const &":
        r"""
        GetFlexiOverlayOptions(OEPositOptions self) -> OEShapeFitOptions
        GetFlexiOverlayOptions(OEPositOptions self) -> OEShapeFitOptions
        """
        return _oedocking.OEPositOptions_GetFlexiOverlayOptions(self, *args)

    def CreateCopy(self) -> "OEDocking::OEPositOptions *":
        r"""CreateCopy(OEPositOptions self) -> OEPositOptions"""
        return _oedocking.OEPositOptions_CreateCopy(self)

# Register OEPositOptions in _oedocking:
_oedocking.OEPositOptions_swigregister(OEPositOptions)

class OEPosit(object):
    r"""Proxy of C++ OEDocking::OEPosit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEPosit self, OEPositOptions options=OEDocking::OEPositOptions()) -> OEPosit
        __init__(OEPosit self, OEPosit arg2) -> OEPosit
        """
        _oedocking.OEPosit_swiginit(self, _oedocking.new_OEPosit(*args))
    __swig_destroy__ = _oedocking.delete_OEPosit

    def IsInitialized(self) -> "bool":
        r"""IsInitialized(OEPosit self) -> bool"""
        return _oedocking.OEPosit_IsInitialized(self)

    def ClearReceptors(self) -> "void":
        r"""ClearReceptors(OEPosit self)"""
        return _oedocking.OEPosit_ClearReceptors(self)

    def Dock(self, *args) -> "unsigned int":
        r"""
        Dock(OEPosit self, OESinglePoseResult res, OEMCMolBase mol) -> unsigned int
        Dock(OEPosit self, OEPositResults res, OEMCMolBase mol, unsigned int const numPoses=1) -> unsigned int
        """
        return _oedocking.OEPosit_Dock(self, *args)

    def GetName(self) -> "std::string":
        r"""GetName(OEPosit self) -> std::string"""
        return _oedocking.OEPosit_GetName(self)

    def GetHighScoresAreBetter(self) -> "bool":
        r"""GetHighScoresAreBetter(OEPosit self) -> bool"""
        return _oedocking.OEPosit_GetHighScoresAreBetter(self)

    def GetInvalidScore(self) -> "float":
        r"""GetInvalidScore(OEPosit self) -> float"""
        return _oedocking.OEPosit_GetInvalidScore(self)

    def ScoreLigand(self, pose: "OEMolBase") -> "float":
        r"""ScoreLigand(OEPosit self, OEMolBase pose) -> float"""
        return _oedocking.OEPosit_ScoreLigand(self, pose)

    def RankDesignUnits(self, mol: "OEMCMolBase") -> "OESystem::OEIterBase< OEBio::OEDesignUnit > *":
        r"""RankDesignUnits(OEPosit self, OEMCMolBase mol) -> OESystem::OEIterBase< OEBio::OEDesignUnit > *"""
        return _oedocking.OEPosit_RankDesignUnits(self, mol)

    def Initialize(self, receptor: "OEMolBase") -> "bool":
        r"""Initialize(OEPosit self, OEMolBase receptor) -> bool"""
        return _oedocking.OEPosit_Initialize(self, receptor)

    def AddReceptor(self, *args) -> "bool":
        r"""
        AddReceptor(OEPosit self, OEDesignUnit du) -> bool
        AddReceptor(OEPosit self, OEMolBase receptor) -> bool
        """
        return _oedocking.OEPosit_AddReceptor(self, *args)

    def RankReceptors(self, mol: "OEMCMolBase") -> "OESystem::OEIterBase< OEChem::OEMolBase > *":
        r"""RankReceptors(OEPosit self, OEMCMolBase mol) -> OESystem::OEIterBase< OEChem::OEMolBase > *"""
        return _oedocking.OEPosit_RankReceptors(self, mol)

    def DockMultiConformerMolecule(self, *args) -> "unsigned int":
        r"""
        DockMultiConformerMolecule(OEPosit self, OEMCMolBase dockedMol, OEMCMolBase inputMol, unsigned int numPoses=1) -> unsigned int
        DockMultiConformerMolecule(OEPosit self, OEMolBase dockedMol, OEMCMolBase inputMol) -> unsigned int
        """
        return _oedocking.OEPosit_DockMultiConformerMolecule(self, *args)

# Register OEPosit in _oedocking:
_oedocking.OEPosit_swigregister(OEPosit)


def OEHasClash(ligand: "OEMolBase", receptor: "OEMolBase", allowedType: "unsigned int const") -> "bool":
    r"""OEHasClash(OEMolBase ligand, OEMolBase receptor, unsigned int const allowedType) -> bool"""
    return _oedocking.OEHasClash(ligand, receptor, allowedType)

def OEPositMethodGetName(method: "unsigned int const") -> "std::string":
    r"""OEPositMethodGetName(unsigned int const method) -> std::string"""
    return _oedocking.OEPositMethodGetName(method)

def OEGetPositMethod(arg1: "OEMolBase") -> "unsigned int":
    r"""OEGetPositMethod(OEMolBase arg1) -> unsigned int"""
    return _oedocking.OEGetPositMethod(arg1)

def OESetSDScore(*args) -> "bool":
    r"""
    OESetSDScore(OEMCMolBase ligand, OEDock scoreFxn, std::string tag, bool sortPoses=False) -> bool
    OESetSDScore(OEMolBase ligand, OEDock scoreFxn, std::string tag) -> bool
    OESetSDScore(OEMCMolBase ligand, OEScore scoreFxn, std::string tag, bool sortPoses=False) -> bool
    OESetSDScore(OEMolBase ligand, OEScore scoreFxn, std::string tag) -> bool
    OESetSDScore(OEMolBase ligand, OEPosit scoreFxn, std::string tag) -> bool
    OESetSDScore(OEMolBase ligand, OEPosit scoreFxn) -> bool
    OESetSDScore(OEMCMolBase ligand, OEPosit scoreFxn, std::string tag, bool sortPoses=False) -> bool
    """
    return _oedocking.OESetSDScore(*args)

def OEGetEstimatedPositProbability(*args) -> "double":
    r"""
    OEGetEstimatedPositProbability(OEMCMolBase ligand, OEDesignUnit du) -> double
    OEGetEstimatedPositProbability(OEMCMolBase ligand, OEMolBase receptor) -> double
    """
    return _oedocking.OEGetEstimatedPositProbability(*args)

def OEAddDockingInteractions(container: "OEInteractionHintContainer") -> "bool":
    r"""OEAddDockingInteractions(OEInteractionHintContainer container) -> bool"""
    return _oedocking.OEAddDockingInteractions(container)
class OEPoseOptimizerOptions(oechem.OEOptions):
    r"""Proxy of C++ OEDocking::OEPoseOptimizerOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEPoseOptimizerOptions self) -> OEPoseOptimizerOptions
        __init__(OEPoseOptimizerOptions self, OEPoseOptimizerOptions arg2) -> OEPoseOptimizerOptions
        """
        _oedocking.OEPoseOptimizerOptions_swiginit(self, _oedocking.new_OEPoseOptimizerOptions(*args))
    __swig_destroy__ = _oedocking.delete_OEPoseOptimizerOptions

    def GetForceField(self) -> "OEFF::OEComplexFF const *":
        r"""GetForceField(OEPoseOptimizerOptions self) -> OEFF::OEComplexFF const *"""
        return _oedocking.OEPoseOptimizerOptions_GetForceField(self)

    def GetForceFieldType(self) -> "unsigned int":
        r"""GetForceFieldType(OEPoseOptimizerOptions self) -> unsigned int"""
        return _oedocking.OEPoseOptimizerOptions_GetForceFieldType(self)

    def SetForceField(self, *args) -> "bool":
        r"""
        SetForceField(OEPoseOptimizerOptions self, unsigned int const value) -> bool
        SetForceField(OEPoseOptimizerOptions self, std::string const & value) -> bool
        SetForceField(OEPoseOptimizerOptions self, oeistream value) -> bool
        SetForceField(OEPoseOptimizerOptions self, OEFF::OEComplexFF const & value) -> bool
        """
        return _oedocking.OEPoseOptimizerOptions_SetForceField(self, *args)

    def GetFlexRange(self) -> "double":
        r"""GetFlexRange(OEPoseOptimizerOptions self) -> double"""
        return _oedocking.OEPoseOptimizerOptions_GetFlexRange(self)

    def SetFlexRange(self, value: "double const") -> "bool":
        r"""SetFlexRange(OEPoseOptimizerOptions self, double const value) -> bool"""
        return _oedocking.OEPoseOptimizerOptions_SetFlexRange(self, value)

    def CreateCopy(self) -> "OEDocking::OEPoseOptimizerOptions *":
        r"""CreateCopy(OEPoseOptimizerOptions self) -> OEPoseOptimizerOptions"""
        return _oedocking.OEPoseOptimizerOptions_CreateCopy(self)

# Register OEPoseOptimizerOptions in _oedocking:
_oedocking.OEPoseOptimizerOptions_swigregister(OEPoseOptimizerOptions)

class OEPoseOptimizer(object):
    r"""Proxy of C++ OEDocking::OEPoseOptimizer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEPoseOptimizer self, OEPoseOptimizerOptions opts=OEDocking::OEPoseOptimizerOptions()) -> OEPoseOptimizer
        __init__(OEPoseOptimizer self, OEPoseOptimizer arg2) -> OEPoseOptimizer
        """
        _oedocking.OEPoseOptimizer_swiginit(self, _oedocking.new_OEPoseOptimizer(*args))
    __swig_destroy__ = _oedocking.delete_OEPoseOptimizer

    def Optimize(self, *args) -> "bool":
        r"""
        Optimize(OEPoseOptimizer self, OEDesignUnit du) -> bool
        Optimize(OEPoseOptimizer self, OEMCMolBase ligand, OEMolBase protein) -> bool
        """
        return _oedocking.OEPoseOptimizer_Optimize(self, *args)

# Register OEPoseOptimizer in _oedocking:
_oedocking.OEPoseOptimizer_swigregister(OEPoseOptimizer)

class OEShapeQueryIter(object):
    r"""Proxy of C++ OESystem::OEIter< OEShape::OEShapeQuery > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEShapeQueryIter self) -> OEShapeQueryIter
        __init__(OEShapeQueryIter self, OEShapeQueryIter rhs) -> OEShapeQueryIter
        __init__(OEShapeQueryIter self, OESystem::OEIterBase< OEShape::OEShapeQuery > * rhs) -> OEShapeQueryIter
        __init__(OEShapeQueryIter self, OESystem::OEIterBase< OESystem::OEIter< OEShape::OEShapeQuery >::NonConstA > * rhs) -> OEShapeQueryIter
        """
        _oedocking.OEShapeQueryIter_swiginit(self, _oedocking.new_OEShapeQueryIter(*args))
    __swig_destroy__ = _oedocking.delete_OEShapeQueryIter

    def Copy(self) -> "OESystem::OEIterBase< OEShape::OEShapeQuery > *":
        r"""Copy(OEShapeQueryIter self) -> OESystem::OEIterBase< OEShape::OEShapeQuery > *"""
        return _oedocking.OEShapeQueryIter_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEShapeQueryIter self, OESystem::OEIterBase< OEShape::OEShapeQuery > * ib)
        Push(OEShapeQueryIter self, OEShapeQueryIter iter)
        """
        return _oedocking.OEShapeQueryIter_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEShape::OEShapeQuery,OEShape::OEShapeQuery > const &") -> "void":
        r"""Sort(OEShapeQueryIter self, OESystem::OEBinaryPredicate< OEShape::OEShapeQuery,OEShape::OEShapeQuery > const & sort_criterion)"""
        return _oedocking.OEShapeQueryIter_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEShape::OEShapeQuery > &":
        r"""ToFirst(OEShapeQueryIter self) -> OEShapeQueryIter"""
        return _oedocking.OEShapeQueryIter_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEShape::OEShapeQuery > &":
        r"""ToLast(OEShapeQueryIter self) -> OEShapeQueryIter"""
        return _oedocking.OEShapeQueryIter_ToLast(self)

    def __ref__(self) -> "OEShape::OEShapeQuery &":
        r"""__ref__(OEShapeQueryIter self) -> OEShapeQuery"""
        return _oedocking.OEShapeQueryIter___ref__(self)

    def IsValid(self):
      return _oedocking.OEShapeQueryIter___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEShapeQueryIter self) -> PyObject *"""
        return _oedocking.OEShapeQueryIter_next(self)

    def Target(self) -> "OEShape::OEShapeQuery &":
        r"""Target(OEShapeQueryIter self) -> OEShapeQuery"""
        return _oedocking.OEShapeQueryIter_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEShape::OEShapeQuery > &":
        r"""
        Next(OEShapeQueryIter self) -> OEShapeQueryIter
        Next(OEShapeQueryIter self, int i) -> OEShapeQueryIter
        """
        return _oedocking.OEShapeQueryIter_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEShape::OEShapeQuery > &":
        r"""
        Prev(OEShapeQueryIter self) -> OEShapeQueryIter
        Prev(OEShapeQueryIter self, int i) -> OEShapeQueryIter
        """
        return _oedocking.OEShapeQueryIter_Prev(self, *args)

# Register OEShapeQueryIter in _oedocking:
_oedocking.OEShapeQueryIter_swigregister(OEShapeQueryIter)

class OEROCSQueryModelOptions(oechem.OEOptions):
    r"""Proxy of C++ OEModels::OEROCSQueryModelOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEROCSQueryModelOptions self) -> OEROCSQueryModelOptions
        __init__(OEROCSQueryModelOptions self, OEROCSQueryModelOptions arg2) -> OEROCSQueryModelOptions
        """
        _oedocking.OEROCSQueryModelOptions_swiginit(self, _oedocking.new_OEROCSQueryModelOptions(*args))
    __swig_destroy__ = _oedocking.delete_OEROCSQueryModelOptions

    def GetMergeColorAtoms(self) -> "bool":
        r"""GetMergeColorAtoms(OEROCSQueryModelOptions self) -> bool"""
        return _oedocking.OEROCSQueryModelOptions_GetMergeColorAtoms(self)

    def SetMergeColorAtoms(self, value: "bool const") -> "bool":
        r"""SetMergeColorAtoms(OEROCSQueryModelOptions self, bool const value) -> bool"""
        return _oedocking.OEROCSQueryModelOptions_SetMergeColorAtoms(self, value)

    def GetMaxMoleculesPerModel(self) -> "unsigned int":
        r"""GetMaxMoleculesPerModel(OEROCSQueryModelOptions self) -> unsigned int"""
        return _oedocking.OEROCSQueryModelOptions_GetMaxMoleculesPerModel(self)

    def SetMaxMoleculesPerModel(self, value: "unsigned int const") -> "bool":
        r"""SetMaxMoleculesPerModel(OEROCSQueryModelOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEROCSQueryModelOptions_SetMaxMoleculesPerModel(self, value)

    def GetNumModels(self) -> "unsigned int":
        r"""GetNumModels(OEROCSQueryModelOptions self) -> unsigned int"""
        return _oedocking.OEROCSQueryModelOptions_GetNumModels(self)

    def SetNumModels(self, value: "unsigned int const") -> "bool":
        r"""SetNumModels(OEROCSQueryModelOptions self, unsigned int const value) -> bool"""
        return _oedocking.OEROCSQueryModelOptions_SetNumModels(self, value)

    def GetColorForceField(self) -> "OEShape::OEColorForceField const *":
        r"""GetColorForceField(OEROCSQueryModelOptions self) -> OEColorForceField"""
        return _oedocking.OEROCSQueryModelOptions_GetColorForceField(self)

    def GetColorForceFieldType(self) -> "unsigned int":
        r"""GetColorForceFieldType(OEROCSQueryModelOptions self) -> unsigned int"""
        return _oedocking.OEROCSQueryModelOptions_GetColorForceFieldType(self)

    def SetColorForceField(self, *args) -> "bool":
        r"""
        SetColorForceField(OEROCSQueryModelOptions self, unsigned int const value) -> bool
        SetColorForceField(OEROCSQueryModelOptions self, std::string const & value) -> bool
        SetColorForceField(OEROCSQueryModelOptions self, oeistream value) -> bool
        SetColorForceField(OEROCSQueryModelOptions self, OEColorForceField value) -> bool
        """
        return _oedocking.OEROCSQueryModelOptions_SetColorForceField(self, *args)

    def CreateCopy(self) -> "OEModels::OEROCSQueryModelOptions *":
        r"""CreateCopy(OEROCSQueryModelOptions self) -> OEROCSQueryModelOptions"""
        return _oedocking.OEROCSQueryModelOptions_CreateCopy(self)

# Register OEROCSQueryModelOptions in _oedocking:
_oedocking.OEROCSQueryModelOptions_swigregister(OEROCSQueryModelOptions)

class OEROCSQueryModelBuilder(object):
    r"""Proxy of C++ OEModels::OEROCSQueryModelBuilder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEROCSQueryModelBuilder self, OEROCSQueryModelOptions options=OEModels::OEROCSQueryModelOptions()) -> OEROCSQueryModelBuilder
        __init__(OEROCSQueryModelBuilder self, OEROCSQueryModelBuilder arg2) -> OEROCSQueryModelBuilder
        """
        _oedocking.OEROCSQueryModelBuilder_swiginit(self, _oedocking.new_OEROCSQueryModelBuilder(*args))
    __swig_destroy__ = _oedocking.delete_OEROCSQueryModelBuilder

    def GetROCSQueryModelOptions(self) -> "OEModels::OEROCSQueryModelOptions const &":
        r"""GetROCSQueryModelOptions(OEROCSQueryModelBuilder self) -> OEROCSQueryModelOptions"""
        return _oedocking.OEROCSQueryModelBuilder_GetROCSQueryModelOptions(self)

    def SetLigands(self, *args) -> "bool":
        r"""
        SetLigands(OEROCSQueryModelBuilder self, oemolistream ifs) -> bool
        SetLigands(OEROCSQueryModelBuilder self, oeistream ifs) -> bool
        """
        return _oedocking.OEROCSQueryModelBuilder_SetLigands(self, *args)

    def AddLigand(self, *args) -> "bool":
        r"""
        AddLigand(OEROCSQueryModelBuilder self, OEDesignUnit du) -> bool
        AddLigand(OEROCSQueryModelBuilder self, OEMolBase mol) -> bool
        """
        return _oedocking.OEROCSQueryModelBuilder_AddLigand(self, *args)

    def ClearLigands(self) -> "bool":
        r"""ClearLigands(OEROCSQueryModelBuilder self) -> bool"""
        return _oedocking.OEROCSQueryModelBuilder_ClearLigands(self)

    def Build(self, *args) -> "OESystem::OEIterBase< OEShape::OEShapeQuery > *":
        r"""Build(OEROCSQueryModelBuilder self, OETracerBase tracer=&OESystem::NullTracer) -> OESystem::OEIterBase< OEShape::OEShapeQuery >"""
        return _oedocking.OEROCSQueryModelBuilder_Build(self, *args)

# Register OEROCSQueryModelBuilder in _oedocking:
_oedocking.OEROCSQueryModelBuilder_swigregister(OEROCSQueryModelBuilder)


def OEJSONBytesToReceptor(c: "OEMolBase", json: "PyObject *") -> "PyObject *":
    r"""OEJSONBytesToReceptor(OEMolBase c, PyObject * json) -> PyObject *"""
    return _oedocking.OEJSONBytesToReceptor(c, json)

def OEReceptorToJSONBytes(*args) -> "PyObject *":
    r"""OEReceptorToJSONBytes(OEMolBase c, unsigned int flavor=) -> PyObject"""
    return _oedocking.OEReceptorToJSONBytes(*args)

def OEReadReceptorFromBytes(*args) -> "PyObject *":
    r"""
    OEReadReceptorFromBytes(OEMolBase c, char const * format, PyObject * rcbytes) -> PyObject
    OEReadReceptorFromBytes(OEMolBase c, unsigned int format, unsigned int flavor, bool gzip, PyObject * rcbytes) -> PyObject *
    """
    return _oedocking.OEReadReceptorFromBytes(*args)

def OEWriteReceptorToBytes(*args) -> "PyObject *":
    r"""
    OEWriteReceptorToBytes(char const * format, OEMolBase c) -> PyObject
    OEWriteReceptorToBytes(unsigned int format, unsigned int flavor, bool gzip, OEMolBase c) -> PyObject *
    """
    return _oedocking.OEWriteReceptorToBytes(*args)


