container/__init__.py

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

# This wrapper is part of IMP,
# Copyright 2007-2015 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import




from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_container', [dirname(__file__)])
        except ImportError:
            import _IMP_container
            return _IMP_container
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_container', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_container = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_container
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class IMP_CONTAINER_SwigPyIterator(object):
    """Proxy of C++ swig::IMP_CONTAINER_SwigPyIterator class"""
    thisown = _swig_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__ = _IMP_container.delete_IMP_CONTAINER_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(IMP_CONTAINER_SwigPyIterator self) -> PyObject *"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(IMP_CONTAINER_SwigPyIterator self, size_t n=1) -> IMP_CONTAINER_SwigPyIterator
        incr(IMP_CONTAINER_SwigPyIterator self) -> IMP_CONTAINER_SwigPyIterator
        """
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(IMP_CONTAINER_SwigPyIterator self, size_t n=1) -> IMP_CONTAINER_SwigPyIterator
        decr(IMP_CONTAINER_SwigPyIterator self) -> IMP_CONTAINER_SwigPyIterator
        """
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> bool"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(IMP_CONTAINER_SwigPyIterator self) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_copy(self)


    def next(self):
        """next(IMP_CONTAINER_SwigPyIterator self) -> PyObject *"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_next(self)


    def __next__(self):
        """__next__(IMP_CONTAINER_SwigPyIterator self) -> PyObject *"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___next__(self)


    def previous(self):
        """previous(IMP_CONTAINER_SwigPyIterator self) -> PyObject *"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> bool"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> bool"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator
        __sub__(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
IMP_CONTAINER_SwigPyIterator_swigregister = _IMP_container.IMP_CONTAINER_SwigPyIterator_swigregister
IMP_CONTAINER_SwigPyIterator_swigregister(IMP_CONTAINER_SwigPyIterator)

_value_types=[]
_object_types=[]
_raii_types=[]
_plural_types=[]


_IMP_container.IMP_DEBUG_swigconstant(_IMP_container)
IMP_DEBUG = _IMP_container.IMP_DEBUG

_IMP_container.IMP_RELEASE_swigconstant(_IMP_container)
IMP_RELEASE = _IMP_container.IMP_RELEASE

_IMP_container.IMP_SILENT_swigconstant(_IMP_container)
IMP_SILENT = _IMP_container.IMP_SILENT

_IMP_container.IMP_PROGRESS_swigconstant(_IMP_container)
IMP_PROGRESS = _IMP_container.IMP_PROGRESS

_IMP_container.IMP_TERSE_swigconstant(_IMP_container)
IMP_TERSE = _IMP_container.IMP_TERSE

_IMP_container.IMP_VERBOSE_swigconstant(_IMP_container)
IMP_VERBOSE = _IMP_container.IMP_VERBOSE

_IMP_container.IMP_MEMORY_swigconstant(_IMP_container)
IMP_MEMORY = _IMP_container.IMP_MEMORY

_IMP_container.IMP_NONE_swigconstant(_IMP_container)
IMP_NONE = _IMP_container.IMP_NONE

_IMP_container.IMP_USAGE_swigconstant(_IMP_container)
IMP_USAGE = _IMP_container.IMP_USAGE

_IMP_container.IMP_INTERNAL_swigconstant(_IMP_container)
IMP_INTERNAL = _IMP_container.IMP_INTERNAL

_IMP_container.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_container)
IMP_KERNEL_HAS_LOG4CXX = _IMP_container.IMP_KERNEL_HAS_LOG4CXX

_IMP_container.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_container)
IMP_COMPILER_HAS_AUTO = _IMP_container.IMP_COMPILER_HAS_AUTO

_IMP_container.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_container)
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_container.IMP_COMPILER_HAS_DEBUG_VECTOR

_IMP_container.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_container)
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_container.IMP_KERNEL_HAS_BOOST_RANDOM

_IMP_container.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_container)
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_container.IMP_KERNEL_HAS_GPERFTOOLS

_IMP_container.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_container)
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_container.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

_IMP_container.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_container)
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_container.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

_IMP_container.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_container)
IMPKERNEL_SHOW_WARNINGS = _IMP_container.IMPKERNEL_SHOW_WARNINGS
import sys
class _DirectorObjects(object):
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
        # Do in two steps so the references are kept until the end of the
        # function (deleting references may trigger a fresh call to this method)
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

class _ostream(object):
    """Proxy of C++ std::ostream class"""
    thisown = _swig_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")
    __repr__ = _swig_repr

    def write(self, osa_buf):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_container._ostream_write(self, osa_buf)

_ostream_swigregister = _IMP_container._ostream_swigregister
_ostream_swigregister(_ostream)


_IMP_container.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_container)
IMP_COMPILER_HAS_OVERRIDE = _IMP_container.IMP_COMPILER_HAS_OVERRIDE

_IMP_container.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_container)
IMP_COMPILER_HAS_FINAL = _IMP_container.IMP_COMPILER_HAS_FINAL

_IMP_container.IMP_HAS_NOEXCEPT_swigconstant(_IMP_container)
IMP_HAS_NOEXCEPT = _IMP_container.IMP_HAS_NOEXCEPT
import IMP

_IMP_container.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_container)
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CGAL_HAS_BOOST_FILESYSTEM

_IMP_container.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_container)
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

_IMP_container.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_container)
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_container.IMP_CGAL_HAS_BOOST_RANDOM

_IMP_container.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_container)
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_container.IMP_CGAL_HAS_BOOST_SYSTEM

_IMP_container.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_container)
IMPCGAL_SHOW_WARNINGS = _IMP_container.IMPCGAL_SHOW_WARNINGS
import IMP.cgal

_IMP_container.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_container)
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_container.IMP_ALGEBRA_HAS_IMP_CGAL

_IMP_container.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_container)
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

_IMP_container.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_container)
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

_IMP_container.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_container)
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_container.IMP_ALGEBRA_HAS_BOOST_RANDOM

_IMP_container.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_container)
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_container.IMP_ALGEBRA_HAS_BOOST_SYSTEM

_IMP_container.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_container)
IMP_ALGEBRA_HAS_CGAL = _IMP_container.IMP_ALGEBRA_HAS_CGAL

_IMP_container.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_container)
IMP_ALGEBRA_HAS_ANN = _IMP_container.IMP_ALGEBRA_HAS_ANN

_IMP_container.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_container)
IMPALGEBRA_SHOW_WARNINGS = _IMP_container.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra

_IMP_container.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_container)
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_container.IMP_DISPLAY_HAS_IMP_CGAL

_IMP_container.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_container)
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

_IMP_container.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_container)
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

_IMP_container.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_container)
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_container.IMP_DISPLAY_HAS_BOOST_RANDOM

_IMP_container.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_container)
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_container.IMP_DISPLAY_HAS_BOOST_SYSTEM

_IMP_container.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_container)
IMP_DISPLAY_HAS_CGAL = _IMP_container.IMP_DISPLAY_HAS_CGAL

_IMP_container.IMPDISPLAY_SHOW_WARNINGS_swigconstant(_IMP_container)
IMPDISPLAY_SHOW_WARNINGS = _IMP_container.IMPDISPLAY_SHOW_WARNINGS
import IMP.display

_IMP_container.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL_swigconstant(_IMP_container)
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_container.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

_IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_container)
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

_IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_container)
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

_IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM_swigconstant(_IMP_container)
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

_IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM_swigconstant(_IMP_container)
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

_IMP_container.IMP_SCORE_FUNCTOR_HAS_CGAL_swigconstant(_IMP_container)
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_container.IMP_SCORE_FUNCTOR_HAS_CGAL

_IMP_container.IMP_SCORE_FUNCTOR_HAS_HDF5_swigconstant(_IMP_container)
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_container.IMP_SCORE_FUNCTOR_HAS_HDF5

_IMP_container.IMPSCOREFUNCTOR_SHOW_WARNINGS_swigconstant(_IMP_container)
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_container.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor

_IMP_container.IMP_CORE_HAS_IMP_CGAL_swigconstant(_IMP_container)
IMP_CORE_HAS_IMP_CGAL = _IMP_container.IMP_CORE_HAS_IMP_CGAL

_IMP_container.IMP_CORE_HAS_IMP_KERNEL_swigconstant(_IMP_container)
IMP_CORE_HAS_IMP_KERNEL = _IMP_container.IMP_CORE_HAS_IMP_KERNEL

_IMP_container.IMP_CORE_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_container)
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CORE_HAS_BOOST_FILESYSTEM

_IMP_container.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_container)
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

_IMP_container.IMP_CORE_HAS_BOOST_RANDOM_swigconstant(_IMP_container)
IMP_CORE_HAS_BOOST_RANDOM = _IMP_container.IMP_CORE_HAS_BOOST_RANDOM

_IMP_container.IMP_CORE_HAS_BOOST_SYSTEM_swigconstant(_IMP_container)
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_container.IMP_CORE_HAS_BOOST_SYSTEM

_IMP_container.IMP_CORE_HAS_CGAL_swigconstant(_IMP_container)
IMP_CORE_HAS_CGAL = _IMP_container.IMP_CORE_HAS_CGAL

_IMP_container.IMP_CORE_HAS_HDF5_swigconstant(_IMP_container)
IMP_CORE_HAS_HDF5 = _IMP_container.IMP_CORE_HAS_HDF5

_IMP_container.IMPCORE_SHOW_WARNINGS_swigconstant(_IMP_container)
IMPCORE_SHOW_WARNINGS = _IMP_container.IMPCORE_SHOW_WARNINGS
import IMP.core

_IMP_container.IMP_CONTAINER_HAS_IMP_ALGEBRA_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_container.IMP_CONTAINER_HAS_IMP_ALGEBRA

_IMP_container.IMP_CONTAINER_HAS_IMP_CGAL_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_container.IMP_CONTAINER_HAS_IMP_CGAL

_IMP_container.IMP_CONTAINER_HAS_IMP_DISPLAY_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_container.IMP_CONTAINER_HAS_IMP_DISPLAY

_IMP_container.IMP_CONTAINER_HAS_IMP_KERNEL_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_container.IMP_CONTAINER_HAS_IMP_KERNEL

_IMP_container.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_container.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

_IMP_container.IMP_CONTAINER_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

_IMP_container.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

_IMP_container.IMP_CONTAINER_HAS_BOOST_RANDOM_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_container.IMP_CONTAINER_HAS_BOOST_RANDOM

_IMP_container.IMP_CONTAINER_HAS_BOOST_SYSTEM_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_container.IMP_CONTAINER_HAS_BOOST_SYSTEM

_IMP_container.IMP_CONTAINER_HAS_CGAL_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_CGAL = _IMP_container.IMP_CONTAINER_HAS_CGAL

_IMP_container.IMP_CONTAINER_HAS_HDF5_swigconstant(_IMP_container)
IMP_CONTAINER_HAS_HDF5 = _IMP_container.IMP_CONTAINER_HAS_HDF5

_IMP_container.IMPCONTAINER_SHOW_WARNINGS_swigconstant(_IMP_container)
IMPCONTAINER_SHOW_WARNINGS = _IMP_container.IMPCONTAINER_SHOW_WARNINGS
_object_types.append("AllBipartitePairContainer")


def _object_cast_to_AllBipartitePairContainer(o):
    """_object_cast_to_AllBipartitePairContainer(Object o) -> AllBipartitePairContainer"""
    return _IMP_container._object_cast_to_AllBipartitePairContainer(o)
_object_types.append("AllPairContainer")


def _object_cast_to_AllPairContainer(o):
    """_object_cast_to_AllPairContainer(Object o) -> AllPairContainer"""
    return _IMP_container._object_cast_to_AllPairContainer(o)
_object_types.append("CloseBipartitePairContainer")


def _object_cast_to_CloseBipartitePairContainer(o):
    """_object_cast_to_CloseBipartitePairContainer(Object o) -> CloseBipartitePairContainer"""
    return _IMP_container._object_cast_to_CloseBipartitePairContainer(o)
_object_types.append("ClosePairContainer")


def _object_cast_to_ClosePairContainer(o):
    """_object_cast_to_ClosePairContainer(Object o) -> ClosePairContainer"""
    return _IMP_container._object_cast_to_ClosePairContainer(o)
_object_types.append("ConnectingPairContainer")


def _object_cast_to_ConnectingPairContainer(o):
    """_object_cast_to_ConnectingPairContainer(Object o) -> ConnectingPairContainer"""
    return _IMP_container._object_cast_to_ConnectingPairContainer(o)
_object_types.append("ConsecutivePairContainer")


def _object_cast_to_ConsecutivePairContainer(o):
    """_object_cast_to_ConsecutivePairContainer(Object o) -> ConsecutivePairContainer"""
    return _IMP_container._object_cast_to_ConsecutivePairContainer(o)
_object_types.append("ExclusiveConsecutivePairContainer")


def _object_cast_to_ExclusiveConsecutivePairContainer(o):
    """_object_cast_to_ExclusiveConsecutivePairContainer(Object o) -> ExclusiveConsecutivePairContainer"""
    return _IMP_container._object_cast_to_ExclusiveConsecutivePairContainer(o)
_object_types.append("ExclusiveConsecutivePairFilter")


def _object_cast_to_ExclusiveConsecutivePairFilter(o):
    """_object_cast_to_ExclusiveConsecutivePairFilter(Object o) -> ExclusiveConsecutivePairFilter"""
    return _IMP_container._object_cast_to_ExclusiveConsecutivePairFilter(o)
_object_types.append("ConsecutivePairFilter")


def _object_cast_to_ConsecutivePairFilter(o):
    """_object_cast_to_ConsecutivePairFilter(Object o) -> ConsecutivePairFilter"""
    return _IMP_container._object_cast_to_ConsecutivePairFilter(o)
_object_types.append("ListPairContainer")


def _object_cast_to_ListPairContainer(o):
    """_object_cast_to_ListPairContainer(Object o) -> ListPairContainer"""
    return _IMP_container._object_cast_to_ListPairContainer(o)
_object_types.append("ListQuadContainer")


def _object_cast_to_ListQuadContainer(o):
    """_object_cast_to_ListQuadContainer(Object o) -> ListQuadContainer"""
    return _IMP_container._object_cast_to_ListQuadContainer(o)
_object_types.append("ListSingletonContainer")


def _object_cast_to_ListSingletonContainer(o):
    """_object_cast_to_ListSingletonContainer(Object o) -> ListSingletonContainer"""
    return _IMP_container._object_cast_to_ListSingletonContainer(o)
_object_types.append("ListTripletContainer")


def _object_cast_to_ListTripletContainer(o):
    """_object_cast_to_ListTripletContainer(Object o) -> ListTripletContainer"""
    return _IMP_container._object_cast_to_ListTripletContainer(o)
_object_types.append("DynamicListPairContainer")


def _object_cast_to_DynamicListPairContainer(o):
    """_object_cast_to_DynamicListPairContainer(Object o) -> DynamicListPairContainer"""
    return _IMP_container._object_cast_to_DynamicListPairContainer(o)
_object_types.append("DynamicListQuadContainer")


def _object_cast_to_DynamicListQuadContainer(o):
    """_object_cast_to_DynamicListQuadContainer(Object o) -> DynamicListQuadContainer"""
    return _IMP_container._object_cast_to_DynamicListQuadContainer(o)
_object_types.append("DynamicListSingletonContainer")


def _object_cast_to_DynamicListSingletonContainer(o):
    """_object_cast_to_DynamicListSingletonContainer(Object o) -> DynamicListSingletonContainer"""
    return _IMP_container._object_cast_to_DynamicListSingletonContainer(o)
_object_types.append("DynamicListTripletContainer")


def _object_cast_to_DynamicListTripletContainer(o):
    """_object_cast_to_DynamicListTripletContainer(Object o) -> DynamicListTripletContainer"""
    return _IMP_container._object_cast_to_DynamicListTripletContainer(o)
_object_types.append("MinimumPairRestraint")


def _object_cast_to_MinimumPairRestraint(o):
    """_object_cast_to_MinimumPairRestraint(Object o) -> MinimumPairRestraint"""
    return _IMP_container._object_cast_to_MinimumPairRestraint(o)
_object_types.append("MinimumPairScore")


def _object_cast_to_MinimumPairScore(o):
    """_object_cast_to_MinimumPairScore(Object o) -> MinimumPairScore"""
    return _IMP_container._object_cast_to_MinimumPairScore(o)
_object_types.append("MinimumQuadRestraint")


def _object_cast_to_MinimumQuadRestraint(o):
    """_object_cast_to_MinimumQuadRestraint(Object o) -> MinimumQuadRestraint"""
    return _IMP_container._object_cast_to_MinimumQuadRestraint(o)
_object_types.append("MinimumQuadScore")


def _object_cast_to_MinimumQuadScore(o):
    """_object_cast_to_MinimumQuadScore(Object o) -> MinimumQuadScore"""
    return _IMP_container._object_cast_to_MinimumQuadScore(o)
_object_types.append("MinimumSingletonRestraint")


def _object_cast_to_MinimumSingletonRestraint(o):
    """_object_cast_to_MinimumSingletonRestraint(Object o) -> MinimumSingletonRestraint"""
    return _IMP_container._object_cast_to_MinimumSingletonRestraint(o)
_object_types.append("MinimumSingletonScore")


def _object_cast_to_MinimumSingletonScore(o):
    """_object_cast_to_MinimumSingletonScore(Object o) -> MinimumSingletonScore"""
    return _IMP_container._object_cast_to_MinimumSingletonScore(o)
_object_types.append("MinimumTripletRestraint")


def _object_cast_to_MinimumTripletRestraint(o):
    """_object_cast_to_MinimumTripletRestraint(Object o) -> MinimumTripletRestraint"""
    return _IMP_container._object_cast_to_MinimumTripletRestraint(o)
_object_types.append("MinimumTripletScore")


def _object_cast_to_MinimumTripletScore(o):
    """_object_cast_to_MinimumTripletScore(Object o) -> MinimumTripletScore"""
    return _IMP_container._object_cast_to_MinimumTripletScore(o)
_object_types.append("PairContainerSet")


def _object_cast_to_PairContainerSet(o):
    """_object_cast_to_PairContainerSet(Object o) -> PairContainerSet"""
    return _IMP_container._object_cast_to_PairContainerSet(o)
_object_types.append("PairsConstraint")


def _object_cast_to_PairsConstraint(o):
    """_object_cast_to_PairsConstraint(Object o) -> PairsConstraint"""
    return _IMP_container._object_cast_to_PairsConstraint(o)
_object_types.append("PairsOptimizerState")


def _object_cast_to_PairsOptimizerState(o):
    """_object_cast_to_PairsOptimizerState(Object o) -> PairsOptimizerState"""
    return _IMP_container._object_cast_to_PairsOptimizerState(o)
_object_types.append("PairsRestraint")


def _object_cast_to_PairsRestraint(o):
    """_object_cast_to_PairsRestraint(Object o) -> PairsRestraint"""
    return _IMP_container._object_cast_to_PairsRestraint(o)
_object_types.append("QuadContainerSet")


def _object_cast_to_QuadContainerSet(o):
    """_object_cast_to_QuadContainerSet(Object o) -> QuadContainerSet"""
    return _IMP_container._object_cast_to_QuadContainerSet(o)
_object_types.append("QuadsConstraint")


def _object_cast_to_QuadsConstraint(o):
    """_object_cast_to_QuadsConstraint(Object o) -> QuadsConstraint"""
    return _IMP_container._object_cast_to_QuadsConstraint(o)
_object_types.append("QuadsOptimizerState")


def _object_cast_to_QuadsOptimizerState(o):
    """_object_cast_to_QuadsOptimizerState(Object o) -> QuadsOptimizerState"""
    return _IMP_container._object_cast_to_QuadsOptimizerState(o)
_object_types.append("QuadsRestraint")


def _object_cast_to_QuadsRestraint(o):
    """_object_cast_to_QuadsRestraint(Object o) -> QuadsRestraint"""
    return _IMP_container._object_cast_to_QuadsRestraint(o)
_object_types.append("SingletonContainerSet")


def _object_cast_to_SingletonContainerSet(o):
    """_object_cast_to_SingletonContainerSet(Object o) -> SingletonContainerSet"""
    return _IMP_container._object_cast_to_SingletonContainerSet(o)
_object_types.append("SingletonsConstraint")


def _object_cast_to_SingletonsConstraint(o):
    """_object_cast_to_SingletonsConstraint(Object o) -> SingletonsConstraint"""
    return _IMP_container._object_cast_to_SingletonsConstraint(o)
_object_types.append("SingletonsOptimizerState")


def _object_cast_to_SingletonsOptimizerState(o):
    """_object_cast_to_SingletonsOptimizerState(Object o) -> SingletonsOptimizerState"""
    return _IMP_container._object_cast_to_SingletonsOptimizerState(o)
_object_types.append("SingletonsRestraint")


def _object_cast_to_SingletonsRestraint(o):
    """_object_cast_to_SingletonsRestraint(Object o) -> SingletonsRestraint"""
    return _IMP_container._object_cast_to_SingletonsRestraint(o)
_object_types.append("TripletContainerSet")


def _object_cast_to_TripletContainerSet(o):
    """_object_cast_to_TripletContainerSet(Object o) -> TripletContainerSet"""
    return _IMP_container._object_cast_to_TripletContainerSet(o)
_object_types.append("TripletsConstraint")


def _object_cast_to_TripletsConstraint(o):
    """_object_cast_to_TripletsConstraint(Object o) -> TripletsConstraint"""
    return _IMP_container._object_cast_to_TripletsConstraint(o)
_object_types.append("TripletsOptimizerState")


def _object_cast_to_TripletsOptimizerState(o):
    """_object_cast_to_TripletsOptimizerState(Object o) -> TripletsOptimizerState"""
    return _IMP_container._object_cast_to_TripletsOptimizerState(o)
_object_types.append("TripletsRestraint")


def _object_cast_to_TripletsRestraint(o):
    """_object_cast_to_TripletsRestraint(Object o) -> TripletsRestraint"""
    return _IMP_container._object_cast_to_TripletsRestraint(o)
_object_types.append("InContainerSingletonFilter")


def _object_cast_to_InContainerSingletonFilter(o):
    """_object_cast_to_InContainerSingletonFilter(Object o) -> InContainerSingletonFilter"""
    return _IMP_container._object_cast_to_InContainerSingletonFilter(o)
_object_types.append("InContainerPairFilter")


def _object_cast_to_InContainerPairFilter(o):
    """_object_cast_to_InContainerPairFilter(Object o) -> InContainerPairFilter"""
    return _IMP_container._object_cast_to_InContainerPairFilter(o)
_object_types.append("InContainerTripletFilter")


def _object_cast_to_InContainerTripletFilter(o):
    """_object_cast_to_InContainerTripletFilter(Object o) -> InContainerTripletFilter"""
    return _IMP_container._object_cast_to_InContainerTripletFilter(o)
_object_types.append("InContainerQuadFilter")


def _object_cast_to_InContainerQuadFilter(o):
    """_object_cast_to_InContainerQuadFilter(Object o) -> InContainerQuadFilter"""
    return _IMP_container._object_cast_to_InContainerQuadFilter(o)
_object_types.append("SingletonContainerStatistics")


def _object_cast_to_SingletonContainerStatistics(o):
    """_object_cast_to_SingletonContainerStatistics(Object o) -> SingletonContainerStatistics"""
    return _IMP_container._object_cast_to_SingletonContainerStatistics(o)
_object_types.append("PairContainerStatistics")


def _object_cast_to_PairContainerStatistics(o):
    """_object_cast_to_PairContainerStatistics(Object o) -> PairContainerStatistics"""
    return _IMP_container._object_cast_to_PairContainerStatistics(o)
_object_types.append("TripletContainerStatistics")


def _object_cast_to_TripletContainerStatistics(o):
    """_object_cast_to_TripletContainerStatistics(Object o) -> TripletContainerStatistics"""
    return _IMP_container._object_cast_to_TripletContainerStatistics(o)
_object_types.append("QuadContainerStatistics")


def _object_cast_to_QuadContainerStatistics(o):
    """_object_cast_to_QuadContainerStatistics(Object o) -> QuadContainerStatistics"""
    return _IMP_container._object_cast_to_QuadContainerStatistics(o)
_object_types.append("EventSingletonsOptimizerState")


def _object_cast_to_EventSingletonsOptimizerState(o):
    """_object_cast_to_EventSingletonsOptimizerState(Object o) -> EventSingletonsOptimizerState"""
    return _IMP_container._object_cast_to_EventSingletonsOptimizerState(o)
_object_types.append("EventPairsOptimizerState")


def _object_cast_to_EventPairsOptimizerState(o):
    """_object_cast_to_EventPairsOptimizerState(Object o) -> EventPairsOptimizerState"""
    return _IMP_container._object_cast_to_EventPairsOptimizerState(o)
_object_types.append("EventTripletsOptimizerState")


def _object_cast_to_EventTripletsOptimizerState(o):
    """_object_cast_to_EventTripletsOptimizerState(Object o) -> EventTripletsOptimizerState"""
    return _IMP_container._object_cast_to_EventTripletsOptimizerState(o)
_object_types.append("EventQuadsOptimizerState")


def _object_cast_to_EventQuadsOptimizerState(o):
    """_object_cast_to_EventQuadsOptimizerState(Object o) -> EventQuadsOptimizerState"""
    return _IMP_container._object_cast_to_EventQuadsOptimizerState(o)
_object_types.append("PredicateSingletonsRestraint")


def _object_cast_to_PredicateSingletonsRestraint(o):
    """_object_cast_to_PredicateSingletonsRestraint(Object o) -> PredicateSingletonsRestraint"""
    return _IMP_container._object_cast_to_PredicateSingletonsRestraint(o)
_object_types.append("PredicatePairsRestraint")


def _object_cast_to_PredicatePairsRestraint(o):
    """_object_cast_to_PredicatePairsRestraint(Object o) -> PredicatePairsRestraint"""
    return _IMP_container._object_cast_to_PredicatePairsRestraint(o)
_object_types.append("PredicateTripletsRestraint")


def _object_cast_to_PredicateTripletsRestraint(o):
    """_object_cast_to_PredicateTripletsRestraint(Object o) -> PredicateTripletsRestraint"""
    return _IMP_container._object_cast_to_PredicateTripletsRestraint(o)
_object_types.append("PredicateQuadsRestraint")


def _object_cast_to_PredicateQuadsRestraint(o):
    """_object_cast_to_PredicateQuadsRestraint(Object o) -> PredicateQuadsRestraint"""
    return _IMP_container._object_cast_to_PredicateQuadsRestraint(o)
_object_types.append("DistributeSingletonsScoreState")


def _object_cast_to_DistributeSingletonsScoreState(o):
    """_object_cast_to_DistributeSingletonsScoreState(Object o) -> DistributeSingletonsScoreState"""
    return _IMP_container._object_cast_to_DistributeSingletonsScoreState(o)
_object_types.append("DistributePairsScoreState")


def _object_cast_to_DistributePairsScoreState(o):
    """_object_cast_to_DistributePairsScoreState(Object o) -> DistributePairsScoreState"""
    return _IMP_container._object_cast_to_DistributePairsScoreState(o)
_object_types.append("DistributeTripletsScoreState")


def _object_cast_to_DistributeTripletsScoreState(o):
    """_object_cast_to_DistributeTripletsScoreState(Object o) -> DistributeTripletsScoreState"""
    return _IMP_container._object_cast_to_DistributeTripletsScoreState(o)
_object_types.append("DistributeQuadsScoreState")


def _object_cast_to_DistributeQuadsScoreState(o):
    """_object_cast_to_DistributeQuadsScoreState(Object o) -> DistributeQuadsScoreState"""
    return _IMP_container._object_cast_to_DistributeQuadsScoreState(o)
class AllBipartitePairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::AllBipartitePairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::AllBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, std::string name) -> AllBipartitePairContainer
        __init__(IMP::container::AllBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b) -> AllBipartitePairContainer
        """
        this = _IMP_container.new_AllBipartitePairContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(AllBipartitePairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.AllBipartitePairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(AllBipartitePairContainer self, PairModifier sm)"""
        return _IMP_container.AllBipartitePairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(AllBipartitePairContainer self) -> VersionInfo"""
        return _IMP_container.AllBipartitePairContainer_get_version_info(self)


    def __str__(self):
        """__str__(AllBipartitePairContainer self) -> std::string"""
        return _IMP_container.AllBipartitePairContainer___str__(self)


    def __repr__(self):
        """__repr__(AllBipartitePairContainer self) -> std::string"""
        return _IMP_container.AllBipartitePairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_AllBipartitePairContainer(o)
    get_from = staticmethod(get_from)

AllBipartitePairContainer_swigregister = _IMP_container.AllBipartitePairContainer_swigregister
AllBipartitePairContainer_swigregister(AllBipartitePairContainer)

class AllPairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::AllPairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::AllPairContainer self, _SingletonContainerAdaptor c, std::string name) -> AllPairContainer
        __init__(IMP::container::AllPairContainer self, _SingletonContainerAdaptor c) -> AllPairContainer
        """
        this = _IMP_container.new_AllPairContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(AllPairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.AllPairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(AllPairContainer self, PairModifier sm)"""
        return _IMP_container.AllPairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(AllPairContainer self) -> VersionInfo"""
        return _IMP_container.AllPairContainer_get_version_info(self)


    def __str__(self):
        """__str__(AllPairContainer self) -> std::string"""
        return _IMP_container.AllPairContainer___str__(self)


    def __repr__(self):
        """__repr__(AllPairContainer self) -> std::string"""
        return _IMP_container.AllPairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_AllPairContainer(o)
    get_from = staticmethod(get_from)

AllPairContainer_swigregister = _IMP_container.AllPairContainer_swigregister
AllPairContainer_swigregister(AllPairContainer)

class CloseBipartitePairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::CloseBipartitePairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, double slack=1, std::string name) -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, double slack=1) -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance) -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, ClosePairsFinder cpf, double slack=1, std::string name) -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, ClosePairsFinder cpf, double slack=1) -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, ClosePairsFinder cpf) -> CloseBipartitePairContainer
        """
        this = _IMP_container.new_CloseBipartitePairContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def remove_pair_filter(self, d):
        """remove_pair_filter(CloseBipartitePairContainer self, PairPredicate d)"""
        return _IMP_container.CloseBipartitePairContainer_remove_pair_filter(self, d)


    def remove_pair_filters(self, d):
        """remove_pair_filters(CloseBipartitePairContainer self, IMP::PairPredicates const & d)"""
        return _IMP_container.CloseBipartitePairContainer_remove_pair_filters(self, d)


    def set_pair_filters(self, ps):
        """set_pair_filters(CloseBipartitePairContainer self, IMP::PairPredicates const & ps)"""
        return _IMP_container.CloseBipartitePairContainer_set_pair_filters(self, ps)


    def set_pair_filters_order(self, objs):
        """set_pair_filters_order(CloseBipartitePairContainer self, IMP::PairPredicates const & objs)"""
        return _IMP_container.CloseBipartitePairContainer_set_pair_filters_order(self, objs)


    def add_pair_filter(self, obj):
        """add_pair_filter(CloseBipartitePairContainer self, PairPredicate obj) -> unsigned int"""
        return _IMP_container.CloseBipartitePairContainer_add_pair_filter(self, obj)


    def add_pair_filters(self, objs):
        """add_pair_filters(CloseBipartitePairContainer self, IMP::PairPredicates const & objs)"""
        return _IMP_container.CloseBipartitePairContainer_add_pair_filters(self, objs)


    def clear_pair_filters(self):
        """clear_pair_filters(CloseBipartitePairContainer self)"""
        return _IMP_container.CloseBipartitePairContainer_clear_pair_filters(self)


    def get_number_of_pair_filters(self):
        """get_number_of_pair_filters(CloseBipartitePairContainer self) -> unsigned int"""
        return _IMP_container.CloseBipartitePairContainer_get_number_of_pair_filters(self)


    def get_has_pair_filters(self):
        """get_has_pair_filters(CloseBipartitePairContainer self) -> bool"""
        return _IMP_container.CloseBipartitePairContainer_get_has_pair_filters(self)


    def get_pair_filter(self, i):
        """get_pair_filter(CloseBipartitePairContainer self, unsigned int i) -> PairPredicate"""
        return _IMP_container.CloseBipartitePairContainer_get_pair_filter(self, i)


    def get_pair_filters(self):
        """get_pair_filters(CloseBipartitePairContainer self) -> IMP::PairPredicates"""
        return _IMP_container.CloseBipartitePairContainer_get_pair_filters(self)


    def reserve_pair_filters(self, sz):
        """reserve_pair_filters(CloseBipartitePairContainer self, unsigned int sz)"""
        return _IMP_container.CloseBipartitePairContainer_reserve_pair_filters(self, sz)


    def do_get_inputs(self):
        """do_get_inputs(CloseBipartitePairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.CloseBipartitePairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(CloseBipartitePairContainer self, PairModifier sm)"""
        return _IMP_container.CloseBipartitePairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(CloseBipartitePairContainer self) -> VersionInfo"""
        return _IMP_container.CloseBipartitePairContainer_get_version_info(self)


    def __str__(self):
        """__str__(CloseBipartitePairContainer self) -> std::string"""
        return _IMP_container.CloseBipartitePairContainer___str__(self)


    def __repr__(self):
        """__repr__(CloseBipartitePairContainer self) -> std::string"""
        return _IMP_container.CloseBipartitePairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_CloseBipartitePairContainer(o)
    get_from = staticmethod(get_from)

CloseBipartitePairContainer_swigregister = _IMP_container.CloseBipartitePairContainer_swigregister
CloseBipartitePairContainer_swigregister(CloseBipartitePairContainer)

class ClosePairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::ClosePairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, double slack=1, std::string name) -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, double slack=1) -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff) -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, ClosePairsFinder cpf, double slack=1, std::string name) -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, ClosePairsFinder cpf, double slack=1) -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, ClosePairsFinder cpf) -> ClosePairContainer
        """
        this = _IMP_container.new_ClosePairContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def remove_pair_filter(self, d):
        """remove_pair_filter(ClosePairContainer self, PairPredicate d)"""
        return _IMP_container.ClosePairContainer_remove_pair_filter(self, d)


    def remove_pair_filters(self, d):
        """remove_pair_filters(ClosePairContainer self, IMP::PairPredicates const & d)"""
        return _IMP_container.ClosePairContainer_remove_pair_filters(self, d)


    def set_pair_filters(self, ps):
        """set_pair_filters(ClosePairContainer self, IMP::PairPredicates const & ps)"""
        return _IMP_container.ClosePairContainer_set_pair_filters(self, ps)


    def set_pair_filters_order(self, objs):
        """set_pair_filters_order(ClosePairContainer self, IMP::PairPredicates const & objs)"""
        return _IMP_container.ClosePairContainer_set_pair_filters_order(self, objs)


    def add_pair_filter(self, obj):
        """add_pair_filter(ClosePairContainer self, PairPredicate obj) -> unsigned int"""
        return _IMP_container.ClosePairContainer_add_pair_filter(self, obj)


    def add_pair_filters(self, objs):
        """add_pair_filters(ClosePairContainer self, IMP::PairPredicates const & objs)"""
        return _IMP_container.ClosePairContainer_add_pair_filters(self, objs)


    def clear_pair_filters(self):
        """clear_pair_filters(ClosePairContainer self)"""
        return _IMP_container.ClosePairContainer_clear_pair_filters(self)


    def get_number_of_pair_filters(self):
        """get_number_of_pair_filters(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_pair_filters(self)


    def get_has_pair_filters(self):
        """get_has_pair_filters(ClosePairContainer self) -> bool"""
        return _IMP_container.ClosePairContainer_get_has_pair_filters(self)


    def get_pair_filter(self, i):
        """get_pair_filter(ClosePairContainer self, unsigned int i) -> PairPredicate"""
        return _IMP_container.ClosePairContainer_get_pair_filter(self, i)


    def get_pair_filters(self):
        """get_pair_filters(ClosePairContainer self) -> IMP::PairPredicates"""
        return _IMP_container.ClosePairContainer_get_pair_filters(self)


    def reserve_pair_filters(self, sz):
        """reserve_pair_filters(ClosePairContainer self, unsigned int sz)"""
        return _IMP_container.ClosePairContainer_reserve_pair_filters(self, sz)


    def set_slack(self, s):
        """set_slack(ClosePairContainer self, double s)"""
        return _IMP_container.ClosePairContainer_set_slack(self, s)


    def get_slack(self):
        """get_slack(ClosePairContainer self) -> double"""
        return _IMP_container.ClosePairContainer_get_slack(self)


    def do_get_inputs(self):
        """do_get_inputs(ClosePairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ClosePairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(ClosePairContainer self, PairModifier sm)"""
        return _IMP_container.ClosePairContainer_do_apply(self, sm)


    def get_number_of_update_calls(self):
        """get_number_of_update_calls(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_update_calls(self)


    def get_number_of_full_rebuilds(self):
        """get_number_of_full_rebuilds(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_full_rebuilds(self)


    def get_number_of_partial_rebuilds(self):
        """get_number_of_partial_rebuilds(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_partial_rebuilds(self)


    def get_version_info(self):
        """get_version_info(ClosePairContainer self) -> VersionInfo"""
        return _IMP_container.ClosePairContainer_get_version_info(self)


    def __str__(self):
        """__str__(ClosePairContainer self) -> std::string"""
        return _IMP_container.ClosePairContainer___str__(self)


    def __repr__(self):
        """__repr__(ClosePairContainer self) -> std::string"""
        return _IMP_container.ClosePairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ClosePairContainer(o)
    get_from = staticmethod(get_from)

ClosePairContainer_swigregister = _IMP_container.ClosePairContainer_swigregister
ClosePairContainer_swigregister(ClosePairContainer)


def get_slack_estimate(ps, upper_bound, step, restraints, derivatives, opt, cpc):
    """get_slack_estimate(IMP::ParticlesTemp const & ps, double upper_bound, double step, IMP::RestraintsTemp const & restraints, bool derivatives, Optimizer opt, ClosePairContainer cpc) -> double"""
    return _IMP_container.get_slack_estimate(ps, upper_bound, step, restraints, derivatives, opt, cpc)
class ConnectingPairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::ConnectingPairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, sc, error):
        """__init__(IMP::container::ConnectingPairContainer self, SingletonContainer sc, double error) -> ConnectingPairContainer"""
        this = _IMP_container.new_ConnectingPairContainer(sc, error)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(ConnectingPairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ConnectingPairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(ConnectingPairContainer self, PairModifier sm)"""
        return _IMP_container.ConnectingPairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(ConnectingPairContainer self) -> VersionInfo"""
        return _IMP_container.ConnectingPairContainer_get_version_info(self)


    def __str__(self):
        """__str__(ConnectingPairContainer self) -> std::string"""
        return _IMP_container.ConnectingPairContainer___str__(self)


    def __repr__(self):
        """__repr__(ConnectingPairContainer self) -> std::string"""
        return _IMP_container.ConnectingPairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ConnectingPairContainer(o)
    get_from = staticmethod(get_from)

ConnectingPairContainer_swigregister = _IMP_container.ConnectingPairContainer_swigregister
ConnectingPairContainer_swigregister(ConnectingPairContainer)

class ConsecutivePairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::ConsecutivePairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::ConsecutivePairContainer self, Model m, IMP::ParticleIndexes const & ps, std::string name) -> ConsecutivePairContainer
        __init__(IMP::container::ConsecutivePairContainer self, Model m, IMP::ParticleIndexes const & ps) -> ConsecutivePairContainer
        __init__(IMP::container::ConsecutivePairContainer self, IMP::ParticlesTemp const & ps, std::string name) -> ConsecutivePairContainer
        __init__(IMP::container::ConsecutivePairContainer self, IMP::ParticlesTemp const & ps) -> ConsecutivePairContainer
        """
        this = _IMP_container.new_ConsecutivePairContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(ConsecutivePairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ConsecutivePairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(ConsecutivePairContainer self, PairModifier sm)"""
        return _IMP_container.ConsecutivePairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(ConsecutivePairContainer self) -> VersionInfo"""
        return _IMP_container.ConsecutivePairContainer_get_version_info(self)


    def __str__(self):
        """__str__(ConsecutivePairContainer self) -> std::string"""
        return _IMP_container.ConsecutivePairContainer___str__(self)


    def __repr__(self):
        """__repr__(ConsecutivePairContainer self) -> std::string"""
        return _IMP_container.ConsecutivePairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ConsecutivePairContainer(o)
    get_from = staticmethod(get_from)

ConsecutivePairContainer_swigregister = _IMP_container.ConsecutivePairContainer_swigregister
ConsecutivePairContainer_swigregister(ConsecutivePairContainer)

class ConsecutivePairFilter(IMP.PairPredicate):
    """Proxy of C++ IMP::container::ConsecutivePairFilter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, cpc):
        """__init__(IMP::container::ConsecutivePairFilter self, ConsecutivePairContainer cpc) -> ConsecutivePairFilter"""
        this = _IMP_container.new_ConsecutivePairFilter(cpc)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(ConsecutivePairFilter self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ConsecutivePairFilter_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(ConsecutivePairFilter self, IMP::ParticlePair const & a) -> int
        get_value(ConsecutivePairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.ConsecutivePairFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(ConsecutivePairFilter self, Model arg2, IMP::ParticleIndexPair const & pip) -> int
        get_value_index(ConsecutivePairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_container.ConsecutivePairFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(ConsecutivePairFilter self) -> VersionInfo"""
        return _IMP_container.ConsecutivePairFilter_get_version_info(self)


    def __str__(self):
        """__str__(ConsecutivePairFilter self) -> std::string"""
        return _IMP_container.ConsecutivePairFilter___str__(self)


    def __repr__(self):
        """__repr__(ConsecutivePairFilter self) -> std::string"""
        return _IMP_container.ConsecutivePairFilter___repr__(self)

    def get_from(o):
       return _object_cast_to_ConsecutivePairFilter(o)
    get_from = staticmethod(get_from)

ConsecutivePairFilter_swigregister = _IMP_container.ConsecutivePairFilter_swigregister
ConsecutivePairFilter_swigregister(ConsecutivePairFilter)

class ExclusiveConsecutivePairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::ExclusiveConsecutivePairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::ExclusiveConsecutivePairContainer self, Model m, IMP::ParticleIndexes const & ps, std::string name) -> ExclusiveConsecutivePairContainer
        __init__(IMP::container::ExclusiveConsecutivePairContainer self, Model m, IMP::ParticleIndexes const & ps) -> ExclusiveConsecutivePairContainer
        __init__(IMP::container::ExclusiveConsecutivePairContainer self, IMP::ParticlesTemp const & ps, std::string name) -> ExclusiveConsecutivePairContainer
        __init__(IMP::container::ExclusiveConsecutivePairContainer self, IMP::ParticlesTemp const & ps) -> ExclusiveConsecutivePairContainer
        """
        this = _IMP_container.new_ExclusiveConsecutivePairContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(ExclusiveConsecutivePairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ExclusiveConsecutivePairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(ExclusiveConsecutivePairContainer self, PairModifier sm)"""
        return _IMP_container.ExclusiveConsecutivePairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(ExclusiveConsecutivePairContainer self) -> VersionInfo"""
        return _IMP_container.ExclusiveConsecutivePairContainer_get_version_info(self)


    def __str__(self):
        """__str__(ExclusiveConsecutivePairContainer self) -> std::string"""
        return _IMP_container.ExclusiveConsecutivePairContainer___str__(self)


    def __repr__(self):
        """__repr__(ExclusiveConsecutivePairContainer self) -> std::string"""
        return _IMP_container.ExclusiveConsecutivePairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ExclusiveConsecutivePairContainer(o)
    get_from = staticmethod(get_from)

ExclusiveConsecutivePairContainer_swigregister = _IMP_container.ExclusiveConsecutivePairContainer_swigregister
ExclusiveConsecutivePairContainer_swigregister(ExclusiveConsecutivePairContainer)

class ExclusiveConsecutivePairFilter(IMP.PairPredicate):
    """Proxy of C++ IMP::container::ExclusiveConsecutivePairFilter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self):
        """__init__(IMP::container::ExclusiveConsecutivePairFilter self) -> ExclusiveConsecutivePairFilter"""
        this = _IMP_container.new_ExclusiveConsecutivePairFilter()
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(ExclusiveConsecutivePairFilter self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ExclusiveConsecutivePairFilter_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(ExclusiveConsecutivePairFilter self, IMP::ParticlePair const & a) -> int
        get_value(ExclusiveConsecutivePairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.ExclusiveConsecutivePairFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(ExclusiveConsecutivePairFilter self, Model m, IMP::ParticleIndexPair const & pip) -> int
        get_value_index(ExclusiveConsecutivePairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_container.ExclusiveConsecutivePairFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(ExclusiveConsecutivePairFilter self) -> VersionInfo"""
        return _IMP_container.ExclusiveConsecutivePairFilter_get_version_info(self)


    def __str__(self):
        """__str__(ExclusiveConsecutivePairFilter self) -> std::string"""
        return _IMP_container.ExclusiveConsecutivePairFilter___str__(self)


    def __repr__(self):
        """__repr__(ExclusiveConsecutivePairFilter self) -> std::string"""
        return _IMP_container.ExclusiveConsecutivePairFilter___repr__(self)

    def get_from(o):
       return _object_cast_to_ExclusiveConsecutivePairFilter(o)
    get_from = staticmethod(get_from)

ExclusiveConsecutivePairFilter_swigregister = _IMP_container.ExclusiveConsecutivePairFilter_swigregister
ExclusiveConsecutivePairFilter_swigregister(ExclusiveConsecutivePairFilter)

class ListPairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::ListPairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def set_particle_pairs(self, *args):
        """
        set_particle_pairs(ListPairContainer self, IMP::ParticlePairsTemp const & ps)
        set_particle_pairs(ListPairContainer self, IMP::ParticleIndexPairs const & contents)
        """
        return _IMP_container.ListPairContainer_set_particle_pairs(self, *args)


    def __init__(self, *args):
        """
        __init__(IMP::container::ListPairContainer self, Model m, IMP::ParticleIndexPairs const & contents, std::string name) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, Model m, IMP::ParticleIndexPairs const & contents) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, IMP::ParticlePairsTemp const & ps, std::string name) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, IMP::ParticlePairsTemp const & ps) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, Model m, std::string name) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, Model m) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, Model m, char const * name) -> ListPairContainer
        """
        this = _IMP_container.new_ListPairContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_particle_pair(self, vt):
        """add_particle_pair(ListPairContainer self, IMP::ParticlePair const & vt)"""
        return _IMP_container.ListPairContainer_add_particle_pair(self, vt)


    def add_particle_pairs(self, c):
        """add_particle_pairs(ListPairContainer self, IMP::ParticlePairsTemp const & c)"""
        return _IMP_container.ListPairContainer_add_particle_pairs(self, c)


    def clear_particle_pairs(self):
        """clear_particle_pairs(ListPairContainer self)"""
        return _IMP_container.ListPairContainer_clear_particle_pairs(self)


    def add(self, *args):
        """
        add(ListPairContainer self, IMP::ParticleIndexPair const & vt)
        add(ListPairContainer self, IMP::ParticleIndexPairs const & c)
        """
        return _IMP_container.ListPairContainer_add(self, *args)


    def set(self, cp):
        """set(ListPairContainer self, IMP::ParticleIndexPairs cp)"""
        return _IMP_container.ListPairContainer_set(self, cp)


    def clear(self):
        """clear(ListPairContainer self)"""
        return _IMP_container.ListPairContainer_clear(self)


    def do_get_inputs(self):
        """do_get_inputs(ListPairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ListPairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(ListPairContainer self, PairModifier sm)"""
        return _IMP_container.ListPairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(ListPairContainer self) -> VersionInfo"""
        return _IMP_container.ListPairContainer_get_version_info(self)


    def __str__(self):
        """__str__(ListPairContainer self) -> std::string"""
        return _IMP_container.ListPairContainer___str__(self)


    def __repr__(self):
        """__repr__(ListPairContainer self) -> std::string"""
        return _IMP_container.ListPairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ListPairContainer(o)
    get_from = staticmethod(get_from)

ListPairContainer_swigregister = _IMP_container.ListPairContainer_swigregister
ListPairContainer_swigregister(ListPairContainer)

class ListQuadContainer(IMP.QuadContainer):
    """Proxy of C++ IMP::container::ListQuadContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def set_particle_quads(self, *args):
        """
        set_particle_quads(ListQuadContainer self, IMP::ParticleQuadsTemp const & ps)
        set_particle_quads(ListQuadContainer self, IMP::ParticleIndexQuads const & contents)
        """
        return _IMP_container.ListQuadContainer_set_particle_quads(self, *args)


    def __init__(self, *args):
        """
        __init__(IMP::container::ListQuadContainer self, Model m, IMP::ParticleIndexQuads const & contents, std::string name) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, Model m, IMP::ParticleIndexQuads const & contents) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, IMP::ParticleQuadsTemp const & ps, std::string name) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, IMP::ParticleQuadsTemp const & ps) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, Model m, std::string name) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, Model m) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, Model m, char const * name) -> ListQuadContainer
        """
        this = _IMP_container.new_ListQuadContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_particle_quad(self, vt):
        """add_particle_quad(ListQuadContainer self, IMP::ParticleQuad const & vt)"""
        return _IMP_container.ListQuadContainer_add_particle_quad(self, vt)


    def add_particle_quads(self, c):
        """add_particle_quads(ListQuadContainer self, IMP::ParticleQuadsTemp const & c)"""
        return _IMP_container.ListQuadContainer_add_particle_quads(self, c)


    def clear_particle_quads(self):
        """clear_particle_quads(ListQuadContainer self)"""
        return _IMP_container.ListQuadContainer_clear_particle_quads(self)


    def add(self, *args):
        """
        add(ListQuadContainer self, IMP::ParticleIndexQuad const & vt)
        add(ListQuadContainer self, IMP::ParticleIndexQuads const & c)
        """
        return _IMP_container.ListQuadContainer_add(self, *args)


    def set(self, cp):
        """set(ListQuadContainer self, IMP::ParticleIndexQuads cp)"""
        return _IMP_container.ListQuadContainer_set(self, cp)


    def clear(self):
        """clear(ListQuadContainer self)"""
        return _IMP_container.ListQuadContainer_clear(self)


    def do_get_inputs(self):
        """do_get_inputs(ListQuadContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ListQuadContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(ListQuadContainer self, QuadModifier sm)"""
        return _IMP_container.ListQuadContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(ListQuadContainer self) -> VersionInfo"""
        return _IMP_container.ListQuadContainer_get_version_info(self)


    def __str__(self):
        """__str__(ListQuadContainer self) -> std::string"""
        return _IMP_container.ListQuadContainer___str__(self)


    def __repr__(self):
        """__repr__(ListQuadContainer self) -> std::string"""
        return _IMP_container.ListQuadContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ListQuadContainer(o)
    get_from = staticmethod(get_from)

ListQuadContainer_swigregister = _IMP_container.ListQuadContainer_swigregister
ListQuadContainer_swigregister(ListQuadContainer)

class ListSingletonContainer(IMP.SingletonContainer):
    """Proxy of C++ IMP::container::ListSingletonContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def set_particles(self, *args):
        """
        set_particles(ListSingletonContainer self, IMP::ParticlesTemp const & ps)
        set_particles(ListSingletonContainer self, IMP::ParticleIndexes const & contents)
        """
        return _IMP_container.ListSingletonContainer_set_particles(self, *args)


    def __init__(self, *args):
        """
        __init__(IMP::container::ListSingletonContainer self, Model m, IMP::ParticleIndexes const & contents, std::string name) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, Model m, IMP::ParticleIndexes const & contents) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, IMP::ParticlesTemp const & ps, std::string name) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, IMP::ParticlesTemp const & ps) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, Model m, std::string name) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, Model m) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, Model m, char const * name) -> ListSingletonContainer
        """
        this = _IMP_container.new_ListSingletonContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_particle(self, vt):
        """add_particle(ListSingletonContainer self, Particle vt)"""
        return _IMP_container.ListSingletonContainer_add_particle(self, vt)


    def add_particles(self, c):
        """add_particles(ListSingletonContainer self, IMP::ParticlesTemp const & c)"""
        return _IMP_container.ListSingletonContainer_add_particles(self, c)


    def clear_particles(self):
        """clear_particles(ListSingletonContainer self)"""
        return _IMP_container.ListSingletonContainer_clear_particles(self)


    def add(self, *args):
        """
        add(ListSingletonContainer self, ParticleIndex vt)
        add(ListSingletonContainer self, IMP::ParticleIndexes const & c)
        """
        return _IMP_container.ListSingletonContainer_add(self, *args)


    def set(self, cp):
        """set(ListSingletonContainer self, IMP::ParticleIndexes cp)"""
        return _IMP_container.ListSingletonContainer_set(self, cp)


    def clear(self):
        """clear(ListSingletonContainer self)"""
        return _IMP_container.ListSingletonContainer_clear(self)


    def do_get_inputs(self):
        """do_get_inputs(ListSingletonContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ListSingletonContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(ListSingletonContainer self, SingletonModifier sm)"""
        return _IMP_container.ListSingletonContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(ListSingletonContainer self) -> VersionInfo"""
        return _IMP_container.ListSingletonContainer_get_version_info(self)


    def __str__(self):
        """__str__(ListSingletonContainer self) -> std::string"""
        return _IMP_container.ListSingletonContainer___str__(self)


    def __repr__(self):
        """__repr__(ListSingletonContainer self) -> std::string"""
        return _IMP_container.ListSingletonContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ListSingletonContainer(o)
    get_from = staticmethod(get_from)

ListSingletonContainer_swigregister = _IMP_container.ListSingletonContainer_swigregister
ListSingletonContainer_swigregister(ListSingletonContainer)

class ListTripletContainer(IMP.TripletContainer):
    """Proxy of C++ IMP::container::ListTripletContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def set_particle_triplets(self, *args):
        """
        set_particle_triplets(ListTripletContainer self, IMP::ParticleTripletsTemp const & ps)
        set_particle_triplets(ListTripletContainer self, IMP::ParticleIndexTriplets const & contents)
        """
        return _IMP_container.ListTripletContainer_set_particle_triplets(self, *args)


    def __init__(self, *args):
        """
        __init__(IMP::container::ListTripletContainer self, Model m, IMP::ParticleIndexTriplets const & contents, std::string name) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, Model m, IMP::ParticleIndexTriplets const & contents) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, IMP::ParticleTripletsTemp const & ps, std::string name) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, IMP::ParticleTripletsTemp const & ps) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, Model m, std::string name) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, Model m) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, Model m, char const * name) -> ListTripletContainer
        """
        this = _IMP_container.new_ListTripletContainer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_particle_triplet(self, vt):
        """add_particle_triplet(ListTripletContainer self, IMP::ParticleTriplet const & vt)"""
        return _IMP_container.ListTripletContainer_add_particle_triplet(self, vt)


    def add_particle_triplets(self, c):
        """add_particle_triplets(ListTripletContainer self, IMP::ParticleTripletsTemp const & c)"""
        return _IMP_container.ListTripletContainer_add_particle_triplets(self, c)


    def clear_particle_triplets(self):
        """clear_particle_triplets(ListTripletContainer self)"""
        return _IMP_container.ListTripletContainer_clear_particle_triplets(self)


    def add(self, *args):
        """
        add(ListTripletContainer self, IMP::ParticleIndexTriplet const & vt)
        add(ListTripletContainer self, IMP::ParticleIndexTriplets const & c)
        """
        return _IMP_container.ListTripletContainer_add(self, *args)


    def set(self, cp):
        """set(ListTripletContainer self, IMP::ParticleIndexTriplets cp)"""
        return _IMP_container.ListTripletContainer_set(self, cp)


    def clear(self):
        """clear(ListTripletContainer self)"""
        return _IMP_container.ListTripletContainer_clear(self)


    def do_get_inputs(self):
        """do_get_inputs(ListTripletContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.ListTripletContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(ListTripletContainer self, TripletModifier sm)"""
        return _IMP_container.ListTripletContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(ListTripletContainer self) -> VersionInfo"""
        return _IMP_container.ListTripletContainer_get_version_info(self)


    def __str__(self):
        """__str__(ListTripletContainer self) -> std::string"""
        return _IMP_container.ListTripletContainer___str__(self)


    def __repr__(self):
        """__repr__(ListTripletContainer self) -> std::string"""
        return _IMP_container.ListTripletContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ListTripletContainer(o)
    get_from = staticmethod(get_from)

ListTripletContainer_swigregister = _IMP_container.ListTripletContainer_swigregister
ListTripletContainer_swigregister(ListTripletContainer)

class DynamicListPairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::container::DynamicListPairContainer class"""
    thisown = _swig_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")

    def add(self, *args):
        """
        add(DynamicListPairContainer self, IMP::ParticleIndexPair const & vt)
        add(DynamicListPairContainer self, IMP::ParticleIndexPairs const & c)
        """
        return _IMP_container.DynamicListPairContainer_add(self, *args)


    def set(self, cp):
        """set(DynamicListPairContainer self, IMP::ParticleIndexPairs cp)"""
        return _IMP_container.DynamicListPairContainer_set(self, cp)


    def clear(self):
        """clear(DynamicListPairContainer self)"""
        return _IMP_container.DynamicListPairContainer_clear(self)


    def add_particle_pair(self, vt):
        """add_particle_pair(DynamicListPairContainer self, IMP::ParticlePair const & vt)"""
        return _IMP_container.DynamicListPairContainer_add_particle_pair(self, vt)


    def add_particle_pairs(self, c):
        """add_particle_pairs(DynamicListPairContainer self, IMP::ParticlePairsTemp const & c)"""
        return _IMP_container.DynamicListPairContainer_add_particle_pairs(self, c)


    def set_particle_pairs(self, c):
        """set_particle_pairs(DynamicListPairContainer self, IMP::ParticlePairsTemp c)"""
        return _IMP_container.DynamicListPairContainer_set_particle_pairs(self, c)


    def clear_particle_pairs(self):
        """clear_particle_pairs(DynamicListPairContainer self)"""
        return _IMP_container.DynamicListPairContainer_clear_particle_pairs(self)


    def do_get_inputs(self):
        """do_get_inputs(DynamicListPairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DynamicListPairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(DynamicListPairContainer self, PairModifier sm)"""
        return _IMP_container.DynamicListPairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(DynamicListPairContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListPairContainer_get_version_info(self)


    def __str__(self):
        """__str__(DynamicListPairContainer self) -> std::string"""
        return _IMP_container.DynamicListPairContainer___str__(self)


    def __repr__(self):
        """__repr__(DynamicListPairContainer self) -> std::string"""
        return _IMP_container.DynamicListPairContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_DynamicListPairContainer(o)
    get_from = staticmethod(get_from)

DynamicListPairContainer_swigregister = _IMP_container.DynamicListPairContainer_swigregister
DynamicListPairContainer_swigregister(DynamicListPairContainer)

class DynamicListQuadContainer(IMP.QuadContainer):
    """Proxy of C++ IMP::container::DynamicListQuadContainer class"""
    thisown = _swig_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")

    def add(self, *args):
        """
        add(DynamicListQuadContainer self, IMP::ParticleIndexQuad const & vt)
        add(DynamicListQuadContainer self, IMP::ParticleIndexQuads const & c)
        """
        return _IMP_container.DynamicListQuadContainer_add(self, *args)


    def set(self, cp):
        """set(DynamicListQuadContainer self, IMP::ParticleIndexQuads cp)"""
        return _IMP_container.DynamicListQuadContainer_set(self, cp)


    def clear(self):
        """clear(DynamicListQuadContainer self)"""
        return _IMP_container.DynamicListQuadContainer_clear(self)


    def add_particle_quad(self, vt):
        """add_particle_quad(DynamicListQuadContainer self, IMP::ParticleQuad const & vt)"""
        return _IMP_container.DynamicListQuadContainer_add_particle_quad(self, vt)


    def add_particle_quads(self, c):
        """add_particle_quads(DynamicListQuadContainer self, IMP::ParticleQuadsTemp const & c)"""
        return _IMP_container.DynamicListQuadContainer_add_particle_quads(self, c)


    def set_particle_quads(self, c):
        """set_particle_quads(DynamicListQuadContainer self, IMP::ParticleQuadsTemp c)"""
        return _IMP_container.DynamicListQuadContainer_set_particle_quads(self, c)


    def clear_particle_quads(self):
        """clear_particle_quads(DynamicListQuadContainer self)"""
        return _IMP_container.DynamicListQuadContainer_clear_particle_quads(self)


    def do_get_inputs(self):
        """do_get_inputs(DynamicListQuadContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DynamicListQuadContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(DynamicListQuadContainer self, QuadModifier sm)"""
        return _IMP_container.DynamicListQuadContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(DynamicListQuadContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListQuadContainer_get_version_info(self)


    def __str__(self):
        """__str__(DynamicListQuadContainer self) -> std::string"""
        return _IMP_container.DynamicListQuadContainer___str__(self)


    def __repr__(self):
        """__repr__(DynamicListQuadContainer self) -> std::string"""
        return _IMP_container.DynamicListQuadContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_DynamicListQuadContainer(o)
    get_from = staticmethod(get_from)

DynamicListQuadContainer_swigregister = _IMP_container.DynamicListQuadContainer_swigregister
DynamicListQuadContainer_swigregister(DynamicListQuadContainer)

class DynamicListSingletonContainer(IMP.SingletonContainer):
    """Proxy of C++ IMP::container::DynamicListSingletonContainer class"""
    thisown = _swig_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")

    def add(self, *args):
        """
        add(DynamicListSingletonContainer self, ParticleIndex vt)
        add(DynamicListSingletonContainer self, IMP::ParticleIndexes const & c)
        """
        return _IMP_container.DynamicListSingletonContainer_add(self, *args)


    def set(self, cp):
        """set(DynamicListSingletonContainer self, IMP::ParticleIndexes cp)"""
        return _IMP_container.DynamicListSingletonContainer_set(self, cp)


    def clear(self):
        """clear(DynamicListSingletonContainer self)"""
        return _IMP_container.DynamicListSingletonContainer_clear(self)


    def add_particle(self, vt):
        """add_particle(DynamicListSingletonContainer self, Particle vt)"""
        return _IMP_container.DynamicListSingletonContainer_add_particle(self, vt)


    def add_particles(self, c):
        """add_particles(DynamicListSingletonContainer self, IMP::ParticlesTemp const & c)"""
        return _IMP_container.DynamicListSingletonContainer_add_particles(self, c)


    def set_particles(self, c):
        """set_particles(DynamicListSingletonContainer self, IMP::ParticlesTemp c)"""
        return _IMP_container.DynamicListSingletonContainer_set_particles(self, c)


    def clear_particles(self):
        """clear_particles(DynamicListSingletonContainer self)"""
        return _IMP_container.DynamicListSingletonContainer_clear_particles(self)


    def do_get_inputs(self):
        """do_get_inputs(DynamicListSingletonContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DynamicListSingletonContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(DynamicListSingletonContainer self, SingletonModifier sm)"""
        return _IMP_container.DynamicListSingletonContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(DynamicListSingletonContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListSingletonContainer_get_version_info(self)


    def __str__(self):
        """__str__(DynamicListSingletonContainer self) -> std::string"""
        return _IMP_container.DynamicListSingletonContainer___str__(self)


    def __repr__(self):
        """__repr__(DynamicListSingletonContainer self) -> std::string"""
        return _IMP_container.DynamicListSingletonContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_DynamicListSingletonContainer(o)
    get_from = staticmethod(get_from)

DynamicListSingletonContainer_swigregister = _IMP_container.DynamicListSingletonContainer_swigregister
DynamicListSingletonContainer_swigregister(DynamicListSingletonContainer)

class DynamicListTripletContainer(IMP.TripletContainer):
    """Proxy of C++ IMP::container::DynamicListTripletContainer class"""
    thisown = _swig_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")

    def add(self, *args):
        """
        add(DynamicListTripletContainer self, IMP::ParticleIndexTriplet const & vt)
        add(DynamicListTripletContainer self, IMP::ParticleIndexTriplets const & c)
        """
        return _IMP_container.DynamicListTripletContainer_add(self, *args)


    def set(self, cp):
        """set(DynamicListTripletContainer self, IMP::ParticleIndexTriplets cp)"""
        return _IMP_container.DynamicListTripletContainer_set(self, cp)


    def clear(self):
        """clear(DynamicListTripletContainer self)"""
        return _IMP_container.DynamicListTripletContainer_clear(self)


    def add_particle_triplet(self, vt):
        """add_particle_triplet(DynamicListTripletContainer self, IMP::ParticleTriplet const & vt)"""
        return _IMP_container.DynamicListTripletContainer_add_particle_triplet(self, vt)


    def add_particle_triplets(self, c):
        """add_particle_triplets(DynamicListTripletContainer self, IMP::ParticleTripletsTemp const & c)"""
        return _IMP_container.DynamicListTripletContainer_add_particle_triplets(self, c)


    def set_particle_triplets(self, c):
        """set_particle_triplets(DynamicListTripletContainer self, IMP::ParticleTripletsTemp c)"""
        return _IMP_container.DynamicListTripletContainer_set_particle_triplets(self, c)


    def clear_particle_triplets(self):
        """clear_particle_triplets(DynamicListTripletContainer self)"""
        return _IMP_container.DynamicListTripletContainer_clear_particle_triplets(self)


    def do_get_inputs(self):
        """do_get_inputs(DynamicListTripletContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DynamicListTripletContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(DynamicListTripletContainer self, TripletModifier sm)"""
        return _IMP_container.DynamicListTripletContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(DynamicListTripletContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListTripletContainer_get_version_info(self)


    def __str__(self):
        """__str__(DynamicListTripletContainer self) -> std::string"""
        return _IMP_container.DynamicListTripletContainer___str__(self)


    def __repr__(self):
        """__repr__(DynamicListTripletContainer self) -> std::string"""
        return _IMP_container.DynamicListTripletContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_DynamicListTripletContainer(o)
    get_from = staticmethod(get_from)

DynamicListTripletContainer_swigregister = _IMP_container.DynamicListTripletContainer_swigregister
DynamicListTripletContainer_swigregister(DynamicListTripletContainer)

class MinimumPairRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::MinimumPairRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::MinimumPairRestraint self, PairScore f, _PairContainerAdaptor c, unsigned int n=1, std::string name) -> MinimumPairRestraint
        __init__(IMP::container::MinimumPairRestraint self, PairScore f, _PairContainerAdaptor c, unsigned int n=1) -> MinimumPairRestraint
        __init__(IMP::container::MinimumPairRestraint self, PairScore f, _PairContainerAdaptor c) -> MinimumPairRestraint
        """
        this = _IMP_container.new_MinimumPairRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(MinimumPairRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.MinimumPairRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(MinimumPairRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumPairRestraint_get_version_info(self)


    def set_n(self, n):
        """set_n(MinimumPairRestraint self, unsigned int n)"""
        return _IMP_container.MinimumPairRestraint_set_n(self, n)


    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MinimumPairRestraint self) -> IMP::Restraints"""
        return _IMP_container.MinimumPairRestraint_do_create_current_decomposition(self)


    def __str__(self):
        """__str__(MinimumPairRestraint self) -> std::string"""
        return _IMP_container.MinimumPairRestraint___str__(self)


    def __repr__(self):
        """__repr__(MinimumPairRestraint self) -> std::string"""
        return _IMP_container.MinimumPairRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumPairRestraint(o)
    get_from = staticmethod(get_from)

MinimumPairRestraint_swigregister = _IMP_container.MinimumPairRestraint_swigregister
MinimumPairRestraint_swigregister(MinimumPairRestraint)

class MinimumPairScore(IMP.PairScore):
    """Proxy of C++ IMP::container::MinimumPairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::MinimumPairScore self, IMP::PairScoresTemp const & scores, unsigned int n=1, std::string name) -> MinimumPairScore
        __init__(IMP::container::MinimumPairScore self, IMP::PairScoresTemp const & scores, unsigned int n=1) -> MinimumPairScore
        __init__(IMP::container::MinimumPairScore self, IMP::PairScoresTemp const & scores) -> MinimumPairScore
        """
        this = _IMP_container.new_MinimumPairScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(MinimumPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_container.MinimumPairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(MinimumPairScore self) -> VersionInfo"""
        return _IMP_container.MinimumPairScore_get_version_info(self)


    def do_create_current_decomposition(self, m, vt):
        """do_create_current_decomposition(MinimumPairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
        return _IMP_container.MinimumPairScore_do_create_current_decomposition(self, m, vt)


    def __str__(self):
        """__str__(MinimumPairScore self) -> std::string"""
        return _IMP_container.MinimumPairScore___str__(self)


    def __repr__(self):
        """__repr__(MinimumPairScore self) -> std::string"""
        return _IMP_container.MinimumPairScore___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumPairScore(o)
    get_from = staticmethod(get_from)

MinimumPairScore_swigregister = _IMP_container.MinimumPairScore_swigregister
MinimumPairScore_swigregister(MinimumPairScore)

class MinimumQuadRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::MinimumQuadRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::MinimumQuadRestraint self, QuadScore f, _QuadContainerAdaptor c, unsigned int n=1, std::string name) -> MinimumQuadRestraint
        __init__(IMP::container::MinimumQuadRestraint self, QuadScore f, _QuadContainerAdaptor c, unsigned int n=1) -> MinimumQuadRestraint
        __init__(IMP::container::MinimumQuadRestraint self, QuadScore f, _QuadContainerAdaptor c) -> MinimumQuadRestraint
        """
        this = _IMP_container.new_MinimumQuadRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(MinimumQuadRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.MinimumQuadRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(MinimumQuadRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumQuadRestraint_get_version_info(self)


    def set_n(self, n):
        """set_n(MinimumQuadRestraint self, unsigned int n)"""
        return _IMP_container.MinimumQuadRestraint_set_n(self, n)


    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MinimumQuadRestraint self) -> IMP::Restraints"""
        return _IMP_container.MinimumQuadRestraint_do_create_current_decomposition(self)


    def __str__(self):
        """__str__(MinimumQuadRestraint self) -> std::string"""
        return _IMP_container.MinimumQuadRestraint___str__(self)


    def __repr__(self):
        """__repr__(MinimumQuadRestraint self) -> std::string"""
        return _IMP_container.MinimumQuadRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumQuadRestraint(o)
    get_from = staticmethod(get_from)

MinimumQuadRestraint_swigregister = _IMP_container.MinimumQuadRestraint_swigregister
MinimumQuadRestraint_swigregister(MinimumQuadRestraint)

class MinimumQuadScore(IMP.QuadScore):
    """Proxy of C++ IMP::container::MinimumQuadScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::MinimumQuadScore self, IMP::QuadScoresTemp const & scores, unsigned int n=1, std::string name) -> MinimumQuadScore
        __init__(IMP::container::MinimumQuadScore self, IMP::QuadScoresTemp const & scores, unsigned int n=1) -> MinimumQuadScore
        __init__(IMP::container::MinimumQuadScore self, IMP::QuadScoresTemp const & scores) -> MinimumQuadScore
        """
        this = _IMP_container.new_MinimumQuadScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(MinimumQuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_container.MinimumQuadScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(MinimumQuadScore self) -> VersionInfo"""
        return _IMP_container.MinimumQuadScore_get_version_info(self)


    def do_create_current_decomposition(self, m, vt):
        """do_create_current_decomposition(MinimumQuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
        return _IMP_container.MinimumQuadScore_do_create_current_decomposition(self, m, vt)


    def __str__(self):
        """__str__(MinimumQuadScore self) -> std::string"""
        return _IMP_container.MinimumQuadScore___str__(self)


    def __repr__(self):
        """__repr__(MinimumQuadScore self) -> std::string"""
        return _IMP_container.MinimumQuadScore___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumQuadScore(o)
    get_from = staticmethod(get_from)

MinimumQuadScore_swigregister = _IMP_container.MinimumQuadScore_swigregister
MinimumQuadScore_swigregister(MinimumQuadScore)

class MinimumSingletonRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::MinimumSingletonRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::MinimumSingletonRestraint self, SingletonScore f, _SingletonContainerAdaptor c, unsigned int n=1, std::string name) -> MinimumSingletonRestraint
        __init__(IMP::container::MinimumSingletonRestraint self, SingletonScore f, _SingletonContainerAdaptor c, unsigned int n=1) -> MinimumSingletonRestraint
        __init__(IMP::container::MinimumSingletonRestraint self, SingletonScore f, _SingletonContainerAdaptor c) -> MinimumSingletonRestraint
        """
        this = _IMP_container.new_MinimumSingletonRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(MinimumSingletonRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.MinimumSingletonRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(MinimumSingletonRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumSingletonRestraint_get_version_info(self)


    def set_n(self, n):
        """set_n(MinimumSingletonRestraint self, unsigned int n)"""
        return _IMP_container.MinimumSingletonRestraint_set_n(self, n)


    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MinimumSingletonRestraint self) -> IMP::Restraints"""
        return _IMP_container.MinimumSingletonRestraint_do_create_current_decomposition(self)


    def __str__(self):
        """__str__(MinimumSingletonRestraint self) -> std::string"""
        return _IMP_container.MinimumSingletonRestraint___str__(self)


    def __repr__(self):
        """__repr__(MinimumSingletonRestraint self) -> std::string"""
        return _IMP_container.MinimumSingletonRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumSingletonRestraint(o)
    get_from = staticmethod(get_from)

MinimumSingletonRestraint_swigregister = _IMP_container.MinimumSingletonRestraint_swigregister
MinimumSingletonRestraint_swigregister(MinimumSingletonRestraint)

class MinimumSingletonScore(IMP.SingletonScore):
    """Proxy of C++ IMP::container::MinimumSingletonScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::MinimumSingletonScore self, IMP::SingletonScoresTemp const & scores, unsigned int n=1, std::string name) -> MinimumSingletonScore
        __init__(IMP::container::MinimumSingletonScore self, IMP::SingletonScoresTemp const & scores, unsigned int n=1) -> MinimumSingletonScore
        __init__(IMP::container::MinimumSingletonScore self, IMP::SingletonScoresTemp const & scores) -> MinimumSingletonScore
        """
        this = _IMP_container.new_MinimumSingletonScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(MinimumSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_container.MinimumSingletonScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(MinimumSingletonScore self) -> VersionInfo"""
        return _IMP_container.MinimumSingletonScore_get_version_info(self)


    def do_create_current_decomposition(self, m, vt):
        """do_create_current_decomposition(MinimumSingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
        return _IMP_container.MinimumSingletonScore_do_create_current_decomposition(self, m, vt)


    def __str__(self):
        """__str__(MinimumSingletonScore self) -> std::string"""
        return _IMP_container.MinimumSingletonScore___str__(self)


    def __repr__(self):
        """__repr__(MinimumSingletonScore self) -> std::string"""
        return _IMP_container.MinimumSingletonScore___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumSingletonScore(o)
    get_from = staticmethod(get_from)

MinimumSingletonScore_swigregister = _IMP_container.MinimumSingletonScore_swigregister
MinimumSingletonScore_swigregister(MinimumSingletonScore)

class MinimumTripletRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::MinimumTripletRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::MinimumTripletRestraint self, TripletScore f, _TripletContainerAdaptor c, unsigned int n=1, std::string name) -> MinimumTripletRestraint
        __init__(IMP::container::MinimumTripletRestraint self, TripletScore f, _TripletContainerAdaptor c, unsigned int n=1) -> MinimumTripletRestraint
        __init__(IMP::container::MinimumTripletRestraint self, TripletScore f, _TripletContainerAdaptor c) -> MinimumTripletRestraint
        """
        this = _IMP_container.new_MinimumTripletRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(MinimumTripletRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.MinimumTripletRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(MinimumTripletRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumTripletRestraint_get_version_info(self)


    def set_n(self, n):
        """set_n(MinimumTripletRestraint self, unsigned int n)"""
        return _IMP_container.MinimumTripletRestraint_set_n(self, n)


    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MinimumTripletRestraint self) -> IMP::Restraints"""
        return _IMP_container.MinimumTripletRestraint_do_create_current_decomposition(self)


    def __str__(self):
        """__str__(MinimumTripletRestraint self) -> std::string"""
        return _IMP_container.MinimumTripletRestraint___str__(self)


    def __repr__(self):
        """__repr__(MinimumTripletRestraint self) -> std::string"""
        return _IMP_container.MinimumTripletRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumTripletRestraint(o)
    get_from = staticmethod(get_from)

MinimumTripletRestraint_swigregister = _IMP_container.MinimumTripletRestraint_swigregister
MinimumTripletRestraint_swigregister(MinimumTripletRestraint)

class MinimumTripletScore(IMP.TripletScore):
    """Proxy of C++ IMP::container::MinimumTripletScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::MinimumTripletScore self, IMP::TripletScoresTemp const & scores, unsigned int n=1, std::string name) -> MinimumTripletScore
        __init__(IMP::container::MinimumTripletScore self, IMP::TripletScoresTemp const & scores, unsigned int n=1) -> MinimumTripletScore
        __init__(IMP::container::MinimumTripletScore self, IMP::TripletScoresTemp const & scores) -> MinimumTripletScore
        """
        this = _IMP_container.new_MinimumTripletScore(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(MinimumTripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_container.MinimumTripletScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(MinimumTripletScore self) -> VersionInfo"""
        return _IMP_container.MinimumTripletScore_get_version_info(self)


    def do_create_current_decomposition(self, m, vt):
        """do_create_current_decomposition(MinimumTripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
        return _IMP_container.MinimumTripletScore_do_create_current_decomposition(self, m, vt)


    def __str__(self):
        """__str__(MinimumTripletScore self) -> std::string"""
        return _IMP_container.MinimumTripletScore___str__(self)


    def __repr__(self):
        """__repr__(MinimumTripletScore self) -> std::string"""
        return _IMP_container.MinimumTripletScore___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumTripletScore(o)
    get_from = staticmethod(get_from)

MinimumTripletScore_swigregister = _IMP_container.MinimumTripletScore_swigregister
MinimumTripletScore_swigregister(MinimumTripletScore)

class PairContainerSet(IMP.PairContainer):
    """Proxy of C++ IMP::container::PairContainerSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::PairContainerSet self, Model m, std::string name) -> PairContainerSet
        __init__(IMP::container::PairContainerSet self, Model m) -> PairContainerSet
        __init__(IMP::container::PairContainerSet self, IMP::PairContainersTemp const & pc, std::string name) -> PairContainerSet
        __init__(IMP::container::PairContainerSet self, IMP::PairContainersTemp const & pc) -> PairContainerSet
        """
        this = _IMP_container.new_PairContainerSet(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_apply(self, sm):
        """do_apply(PairContainerSet self, PairModifier sm)"""
        return _IMP_container.PairContainerSet_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(PairContainerSet self) -> VersionInfo"""
        return _IMP_container.PairContainerSet_get_version_info(self)


    def remove_pair_container(self, d):
        """remove_pair_container(PairContainerSet self, PairContainer d)"""
        return _IMP_container.PairContainerSet_remove_pair_container(self, d)


    def remove_pair_containers(self, d):
        """remove_pair_containers(PairContainerSet self, IMP::PairContainers const & d)"""
        return _IMP_container.PairContainerSet_remove_pair_containers(self, d)


    def set_pair_containers(self, ps):
        """set_pair_containers(PairContainerSet self, IMP::PairContainers const & ps)"""
        return _IMP_container.PairContainerSet_set_pair_containers(self, ps)


    def set_pair_containers_order(self, objs):
        """set_pair_containers_order(PairContainerSet self, IMP::PairContainers const & objs)"""
        return _IMP_container.PairContainerSet_set_pair_containers_order(self, objs)


    def add_pair_container(self, obj):
        """add_pair_container(PairContainerSet self, PairContainer obj) -> unsigned int"""
        return _IMP_container.PairContainerSet_add_pair_container(self, obj)


    def add_pair_containers(self, objs):
        """add_pair_containers(PairContainerSet self, IMP::PairContainers const & objs)"""
        return _IMP_container.PairContainerSet_add_pair_containers(self, objs)


    def clear_pair_containers(self):
        """clear_pair_containers(PairContainerSet self)"""
        return _IMP_container.PairContainerSet_clear_pair_containers(self)


    def get_number_of_pair_containers(self):
        """get_number_of_pair_containers(PairContainerSet self) -> unsigned int"""
        return _IMP_container.PairContainerSet_get_number_of_pair_containers(self)


    def get_has_pair_containers(self):
        """get_has_pair_containers(PairContainerSet self) -> bool"""
        return _IMP_container.PairContainerSet_get_has_pair_containers(self)


    def get_pair_container(self, i):
        """get_pair_container(PairContainerSet self, unsigned int i) -> PairContainer"""
        return _IMP_container.PairContainerSet_get_pair_container(self, i)


    def get_pair_containers(self):
        """get_pair_containers(PairContainerSet self) -> IMP::PairContainers"""
        return _IMP_container.PairContainerSet_get_pair_containers(self)


    def reserve_pair_containers(self, sz):
        """reserve_pair_containers(PairContainerSet self, unsigned int sz)"""
        return _IMP_container.PairContainerSet_reserve_pair_containers(self, sz)


    def do_get_inputs(self):
        """do_get_inputs(PairContainerSet self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PairContainerSet_do_get_inputs(self)


    def __str__(self):
        """__str__(PairContainerSet self) -> std::string"""
        return _IMP_container.PairContainerSet___str__(self)


    def __repr__(self):
        """__repr__(PairContainerSet self) -> std::string"""
        return _IMP_container.PairContainerSet___repr__(self)

    def get_from(o):
       return _object_cast_to_PairContainerSet(o)
    get_from = staticmethod(get_from)

PairContainerSet_swigregister = _IMP_container.PairContainerSet_swigregister
PairContainerSet_swigregister(PairContainerSet)

class PairsConstraint(IMP.Constraint):
    """Proxy of C++ IMP::container::PairsConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::PairsConstraint self, PairModifier before, PairModifier after, _PairContainerAdaptor c, std::string name) -> PairsConstraint
        __init__(IMP::container::PairsConstraint self, PairModifier before, PairModifier after, _PairContainerAdaptor c) -> PairsConstraint
        """
        this = _IMP_container.new_PairsConstraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(PairsConstraint self) -> VersionInfo"""
        return _IMP_container.PairsConstraint_get_version_info(self)


    def __str__(self):
        """__str__(PairsConstraint self) -> std::string"""
        return _IMP_container.PairsConstraint___str__(self)


    def __repr__(self):
        """__repr__(PairsConstraint self) -> std::string"""
        return _IMP_container.PairsConstraint___repr__(self)

    def get_from(o):
       return _object_cast_to_PairsConstraint(o)
    get_from = staticmethod(get_from)

PairsConstraint_swigregister = _IMP_container.PairsConstraint_swigregister
PairsConstraint_swigregister(PairsConstraint)

class PairsOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::container::PairsOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::PairsOptimizerState self, _PairContainerAdaptor c, PairModifier gf, std::string name) -> PairsOptimizerState
        __init__(IMP::container::PairsOptimizerState self, _PairContainerAdaptor c, PairModifier gf) -> PairsOptimizerState
        """
        this = _IMP_container.new_PairsOptimizerState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(PairsOptimizerState self) -> VersionInfo"""
        return _IMP_container.PairsOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(PairsOptimizerState self) -> std::string"""
        return _IMP_container.PairsOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(PairsOptimizerState self) -> std::string"""
        return _IMP_container.PairsOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_PairsOptimizerState(o)
    get_from = staticmethod(get_from)

PairsOptimizerState_swigregister = _IMP_container.PairsOptimizerState_swigregister
PairsOptimizerState_swigregister(PairsOptimizerState)

class PairsRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::PairsRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::PairsRestraint self, PairScore ss, _PairContainerAdaptor pc, std::string name) -> PairsRestraint
        __init__(IMP::container::PairsRestraint self, PairScore ss, _PairContainerAdaptor pc) -> PairsRestraint
        """
        this = _IMP_container.new_PairsRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(PairsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PairsRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(PairsRestraint self) -> VersionInfo"""
        return _IMP_container.PairsRestraint_get_version_info(self)


    def __str__(self):
        """__str__(PairsRestraint self) -> std::string"""
        return _IMP_container.PairsRestraint___str__(self)


    def __repr__(self):
        """__repr__(PairsRestraint self) -> std::string"""
        return _IMP_container.PairsRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_PairsRestraint(o)
    get_from = staticmethod(get_from)

PairsRestraint_swigregister = _IMP_container.PairsRestraint_swigregister
PairsRestraint_swigregister(PairsRestraint)

class QuadContainerSet(IMP.QuadContainer):
    """Proxy of C++ IMP::container::QuadContainerSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::QuadContainerSet self, Model m, std::string name) -> QuadContainerSet
        __init__(IMP::container::QuadContainerSet self, Model m) -> QuadContainerSet
        __init__(IMP::container::QuadContainerSet self, IMP::QuadContainersTemp const & pc, std::string name) -> QuadContainerSet
        __init__(IMP::container::QuadContainerSet self, IMP::QuadContainersTemp const & pc) -> QuadContainerSet
        """
        this = _IMP_container.new_QuadContainerSet(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_apply(self, sm):
        """do_apply(QuadContainerSet self, QuadModifier sm)"""
        return _IMP_container.QuadContainerSet_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(QuadContainerSet self) -> VersionInfo"""
        return _IMP_container.QuadContainerSet_get_version_info(self)


    def remove_quad_container(self, d):
        """remove_quad_container(QuadContainerSet self, QuadContainer d)"""
        return _IMP_container.QuadContainerSet_remove_quad_container(self, d)


    def remove_quad_containers(self, d):
        """remove_quad_containers(QuadContainerSet self, IMP::QuadContainers const & d)"""
        return _IMP_container.QuadContainerSet_remove_quad_containers(self, d)


    def set_quad_containers(self, ps):
        """set_quad_containers(QuadContainerSet self, IMP::QuadContainers const & ps)"""
        return _IMP_container.QuadContainerSet_set_quad_containers(self, ps)


    def set_quad_containers_order(self, objs):
        """set_quad_containers_order(QuadContainerSet self, IMP::QuadContainers const & objs)"""
        return _IMP_container.QuadContainerSet_set_quad_containers_order(self, objs)


    def add_quad_container(self, obj):
        """add_quad_container(QuadContainerSet self, QuadContainer obj) -> unsigned int"""
        return _IMP_container.QuadContainerSet_add_quad_container(self, obj)


    def add_quad_containers(self, objs):
        """add_quad_containers(QuadContainerSet self, IMP::QuadContainers const & objs)"""
        return _IMP_container.QuadContainerSet_add_quad_containers(self, objs)


    def clear_quad_containers(self):
        """clear_quad_containers(QuadContainerSet self)"""
        return _IMP_container.QuadContainerSet_clear_quad_containers(self)


    def get_number_of_quad_containers(self):
        """get_number_of_quad_containers(QuadContainerSet self) -> unsigned int"""
        return _IMP_container.QuadContainerSet_get_number_of_quad_containers(self)


    def get_has_quad_containers(self):
        """get_has_quad_containers(QuadContainerSet self) -> bool"""
        return _IMP_container.QuadContainerSet_get_has_quad_containers(self)


    def get_quad_container(self, i):
        """get_quad_container(QuadContainerSet self, unsigned int i) -> QuadContainer"""
        return _IMP_container.QuadContainerSet_get_quad_container(self, i)


    def get_quad_containers(self):
        """get_quad_containers(QuadContainerSet self) -> IMP::QuadContainers"""
        return _IMP_container.QuadContainerSet_get_quad_containers(self)


    def reserve_quad_containers(self, sz):
        """reserve_quad_containers(QuadContainerSet self, unsigned int sz)"""
        return _IMP_container.QuadContainerSet_reserve_quad_containers(self, sz)


    def do_get_inputs(self):
        """do_get_inputs(QuadContainerSet self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.QuadContainerSet_do_get_inputs(self)


    def __str__(self):
        """__str__(QuadContainerSet self) -> std::string"""
        return _IMP_container.QuadContainerSet___str__(self)


    def __repr__(self):
        """__repr__(QuadContainerSet self) -> std::string"""
        return _IMP_container.QuadContainerSet___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadContainerSet(o)
    get_from = staticmethod(get_from)

QuadContainerSet_swigregister = _IMP_container.QuadContainerSet_swigregister
QuadContainerSet_swigregister(QuadContainerSet)

class QuadsConstraint(IMP.Constraint):
    """Proxy of C++ IMP::container::QuadsConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::QuadsConstraint self, QuadModifier before, QuadModifier after, _QuadContainerAdaptor c, std::string name) -> QuadsConstraint
        __init__(IMP::container::QuadsConstraint self, QuadModifier before, QuadModifier after, _QuadContainerAdaptor c) -> QuadsConstraint
        """
        this = _IMP_container.new_QuadsConstraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(QuadsConstraint self) -> VersionInfo"""
        return _IMP_container.QuadsConstraint_get_version_info(self)


    def __str__(self):
        """__str__(QuadsConstraint self) -> std::string"""
        return _IMP_container.QuadsConstraint___str__(self)


    def __repr__(self):
        """__repr__(QuadsConstraint self) -> std::string"""
        return _IMP_container.QuadsConstraint___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadsConstraint(o)
    get_from = staticmethod(get_from)

QuadsConstraint_swigregister = _IMP_container.QuadsConstraint_swigregister
QuadsConstraint_swigregister(QuadsConstraint)

class QuadsOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::container::QuadsOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::QuadsOptimizerState self, _QuadContainerAdaptor c, QuadModifier gf, std::string name) -> QuadsOptimizerState
        __init__(IMP::container::QuadsOptimizerState self, _QuadContainerAdaptor c, QuadModifier gf) -> QuadsOptimizerState
        """
        this = _IMP_container.new_QuadsOptimizerState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(QuadsOptimizerState self) -> VersionInfo"""
        return _IMP_container.QuadsOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(QuadsOptimizerState self) -> std::string"""
        return _IMP_container.QuadsOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(QuadsOptimizerState self) -> std::string"""
        return _IMP_container.QuadsOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadsOptimizerState(o)
    get_from = staticmethod(get_from)

QuadsOptimizerState_swigregister = _IMP_container.QuadsOptimizerState_swigregister
QuadsOptimizerState_swigregister(QuadsOptimizerState)

class QuadsRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::QuadsRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::QuadsRestraint self, QuadScore ss, _QuadContainerAdaptor pc, std::string name) -> QuadsRestraint
        __init__(IMP::container::QuadsRestraint self, QuadScore ss, _QuadContainerAdaptor pc) -> QuadsRestraint
        """
        this = _IMP_container.new_QuadsRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(QuadsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.QuadsRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(QuadsRestraint self) -> VersionInfo"""
        return _IMP_container.QuadsRestraint_get_version_info(self)


    def __str__(self):
        """__str__(QuadsRestraint self) -> std::string"""
        return _IMP_container.QuadsRestraint___str__(self)


    def __repr__(self):
        """__repr__(QuadsRestraint self) -> std::string"""
        return _IMP_container.QuadsRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadsRestraint(o)
    get_from = staticmethod(get_from)

QuadsRestraint_swigregister = _IMP_container.QuadsRestraint_swigregister
QuadsRestraint_swigregister(QuadsRestraint)

class SingletonContainerSet(IMP.SingletonContainer):
    """Proxy of C++ IMP::container::SingletonContainerSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::SingletonContainerSet self, Model m, std::string name) -> SingletonContainerSet
        __init__(IMP::container::SingletonContainerSet self, Model m) -> SingletonContainerSet
        __init__(IMP::container::SingletonContainerSet self, IMP::SingletonContainersTemp const & pc, std::string name) -> SingletonContainerSet
        __init__(IMP::container::SingletonContainerSet self, IMP::SingletonContainersTemp const & pc) -> SingletonContainerSet
        """
        this = _IMP_container.new_SingletonContainerSet(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_apply(self, sm):
        """do_apply(SingletonContainerSet self, SingletonModifier sm)"""
        return _IMP_container.SingletonContainerSet_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(SingletonContainerSet self) -> VersionInfo"""
        return _IMP_container.SingletonContainerSet_get_version_info(self)


    def remove_singleton_container(self, d):
        """remove_singleton_container(SingletonContainerSet self, SingletonContainer d)"""
        return _IMP_container.SingletonContainerSet_remove_singleton_container(self, d)


    def remove_singleton_containers(self, d):
        """remove_singleton_containers(SingletonContainerSet self, IMP::SingletonContainers const & d)"""
        return _IMP_container.SingletonContainerSet_remove_singleton_containers(self, d)


    def set_singleton_containers(self, ps):
        """set_singleton_containers(SingletonContainerSet self, IMP::SingletonContainers const & ps)"""
        return _IMP_container.SingletonContainerSet_set_singleton_containers(self, ps)


    def set_singleton_containers_order(self, objs):
        """set_singleton_containers_order(SingletonContainerSet self, IMP::SingletonContainers const & objs)"""
        return _IMP_container.SingletonContainerSet_set_singleton_containers_order(self, objs)


    def add_singleton_container(self, obj):
        """add_singleton_container(SingletonContainerSet self, SingletonContainer obj) -> unsigned int"""
        return _IMP_container.SingletonContainerSet_add_singleton_container(self, obj)


    def add_singleton_containers(self, objs):
        """add_singleton_containers(SingletonContainerSet self, IMP::SingletonContainers const & objs)"""
        return _IMP_container.SingletonContainerSet_add_singleton_containers(self, objs)


    def clear_singleton_containers(self):
        """clear_singleton_containers(SingletonContainerSet self)"""
        return _IMP_container.SingletonContainerSet_clear_singleton_containers(self)


    def get_number_of_singleton_containers(self):
        """get_number_of_singleton_containers(SingletonContainerSet self) -> unsigned int"""
        return _IMP_container.SingletonContainerSet_get_number_of_singleton_containers(self)


    def get_has_singleton_containers(self):
        """get_has_singleton_containers(SingletonContainerSet self) -> bool"""
        return _IMP_container.SingletonContainerSet_get_has_singleton_containers(self)


    def get_singleton_container(self, i):
        """get_singleton_container(SingletonContainerSet self, unsigned int i) -> SingletonContainer"""
        return _IMP_container.SingletonContainerSet_get_singleton_container(self, i)


    def get_singleton_containers(self):
        """get_singleton_containers(SingletonContainerSet self) -> IMP::SingletonContainers"""
        return _IMP_container.SingletonContainerSet_get_singleton_containers(self)


    def reserve_singleton_containers(self, sz):
        """reserve_singleton_containers(SingletonContainerSet self, unsigned int sz)"""
        return _IMP_container.SingletonContainerSet_reserve_singleton_containers(self, sz)


    def do_get_inputs(self):
        """do_get_inputs(SingletonContainerSet self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.SingletonContainerSet_do_get_inputs(self)


    def __str__(self):
        """__str__(SingletonContainerSet self) -> std::string"""
        return _IMP_container.SingletonContainerSet___str__(self)


    def __repr__(self):
        """__repr__(SingletonContainerSet self) -> std::string"""
        return _IMP_container.SingletonContainerSet___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonContainerSet(o)
    get_from = staticmethod(get_from)

SingletonContainerSet_swigregister = _IMP_container.SingletonContainerSet_swigregister
SingletonContainerSet_swigregister(SingletonContainerSet)

class SingletonsConstraint(IMP.Constraint):
    """Proxy of C++ IMP::container::SingletonsConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::SingletonsConstraint self, SingletonModifier before, SingletonModifier after, _SingletonContainerAdaptor c, std::string name) -> SingletonsConstraint
        __init__(IMP::container::SingletonsConstraint self, SingletonModifier before, SingletonModifier after, _SingletonContainerAdaptor c) -> SingletonsConstraint
        """
        this = _IMP_container.new_SingletonsConstraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(SingletonsConstraint self) -> VersionInfo"""
        return _IMP_container.SingletonsConstraint_get_version_info(self)


    def __str__(self):
        """__str__(SingletonsConstraint self) -> std::string"""
        return _IMP_container.SingletonsConstraint___str__(self)


    def __repr__(self):
        """__repr__(SingletonsConstraint self) -> std::string"""
        return _IMP_container.SingletonsConstraint___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonsConstraint(o)
    get_from = staticmethod(get_from)

SingletonsConstraint_swigregister = _IMP_container.SingletonsConstraint_swigregister
SingletonsConstraint_swigregister(SingletonsConstraint)

class SingletonsOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::container::SingletonsOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::SingletonsOptimizerState self, _SingletonContainerAdaptor c, SingletonModifier gf, std::string name) -> SingletonsOptimizerState
        __init__(IMP::container::SingletonsOptimizerState self, _SingletonContainerAdaptor c, SingletonModifier gf) -> SingletonsOptimizerState
        """
        this = _IMP_container.new_SingletonsOptimizerState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(SingletonsOptimizerState self) -> VersionInfo"""
        return _IMP_container.SingletonsOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(SingletonsOptimizerState self) -> std::string"""
        return _IMP_container.SingletonsOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(SingletonsOptimizerState self) -> std::string"""
        return _IMP_container.SingletonsOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonsOptimizerState(o)
    get_from = staticmethod(get_from)

SingletonsOptimizerState_swigregister = _IMP_container.SingletonsOptimizerState_swigregister
SingletonsOptimizerState_swigregister(SingletonsOptimizerState)

class SingletonsRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::SingletonsRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::SingletonsRestraint self, SingletonScore ss, _SingletonContainerAdaptor pc, std::string name) -> SingletonsRestraint
        __init__(IMP::container::SingletonsRestraint self, SingletonScore ss, _SingletonContainerAdaptor pc) -> SingletonsRestraint
        """
        this = _IMP_container.new_SingletonsRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(SingletonsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.SingletonsRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(SingletonsRestraint self) -> VersionInfo"""
        return _IMP_container.SingletonsRestraint_get_version_info(self)


    def __str__(self):
        """__str__(SingletonsRestraint self) -> std::string"""
        return _IMP_container.SingletonsRestraint___str__(self)


    def __repr__(self):
        """__repr__(SingletonsRestraint self) -> std::string"""
        return _IMP_container.SingletonsRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonsRestraint(o)
    get_from = staticmethod(get_from)

SingletonsRestraint_swigregister = _IMP_container.SingletonsRestraint_swigregister
SingletonsRestraint_swigregister(SingletonsRestraint)

class TripletContainerSet(IMP.TripletContainer):
    """Proxy of C++ IMP::container::TripletContainerSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::TripletContainerSet self, Model m, std::string name) -> TripletContainerSet
        __init__(IMP::container::TripletContainerSet self, Model m) -> TripletContainerSet
        __init__(IMP::container::TripletContainerSet self, IMP::TripletContainersTemp const & pc, std::string name) -> TripletContainerSet
        __init__(IMP::container::TripletContainerSet self, IMP::TripletContainersTemp const & pc) -> TripletContainerSet
        """
        this = _IMP_container.new_TripletContainerSet(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_apply(self, sm):
        """do_apply(TripletContainerSet self, TripletModifier sm)"""
        return _IMP_container.TripletContainerSet_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(TripletContainerSet self) -> VersionInfo"""
        return _IMP_container.TripletContainerSet_get_version_info(self)


    def remove_triplet_container(self, d):
        """remove_triplet_container(TripletContainerSet self, TripletContainer d)"""
        return _IMP_container.TripletContainerSet_remove_triplet_container(self, d)


    def remove_triplet_containers(self, d):
        """remove_triplet_containers(TripletContainerSet self, IMP::TripletContainers const & d)"""
        return _IMP_container.TripletContainerSet_remove_triplet_containers(self, d)


    def set_triplet_containers(self, ps):
        """set_triplet_containers(TripletContainerSet self, IMP::TripletContainers const & ps)"""
        return _IMP_container.TripletContainerSet_set_triplet_containers(self, ps)


    def set_triplet_containers_order(self, objs):
        """set_triplet_containers_order(TripletContainerSet self, IMP::TripletContainers const & objs)"""
        return _IMP_container.TripletContainerSet_set_triplet_containers_order(self, objs)


    def add_triplet_container(self, obj):
        """add_triplet_container(TripletContainerSet self, TripletContainer obj) -> unsigned int"""
        return _IMP_container.TripletContainerSet_add_triplet_container(self, obj)


    def add_triplet_containers(self, objs):
        """add_triplet_containers(TripletContainerSet self, IMP::TripletContainers const & objs)"""
        return _IMP_container.TripletContainerSet_add_triplet_containers(self, objs)


    def clear_triplet_containers(self):
        """clear_triplet_containers(TripletContainerSet self)"""
        return _IMP_container.TripletContainerSet_clear_triplet_containers(self)


    def get_number_of_triplet_containers(self):
        """get_number_of_triplet_containers(TripletContainerSet self) -> unsigned int"""
        return _IMP_container.TripletContainerSet_get_number_of_triplet_containers(self)


    def get_has_triplet_containers(self):
        """get_has_triplet_containers(TripletContainerSet self) -> bool"""
        return _IMP_container.TripletContainerSet_get_has_triplet_containers(self)


    def get_triplet_container(self, i):
        """get_triplet_container(TripletContainerSet self, unsigned int i) -> TripletContainer"""
        return _IMP_container.TripletContainerSet_get_triplet_container(self, i)


    def get_triplet_containers(self):
        """get_triplet_containers(TripletContainerSet self) -> IMP::TripletContainers"""
        return _IMP_container.TripletContainerSet_get_triplet_containers(self)


    def reserve_triplet_containers(self, sz):
        """reserve_triplet_containers(TripletContainerSet self, unsigned int sz)"""
        return _IMP_container.TripletContainerSet_reserve_triplet_containers(self, sz)


    def do_get_inputs(self):
        """do_get_inputs(TripletContainerSet self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.TripletContainerSet_do_get_inputs(self)


    def __str__(self):
        """__str__(TripletContainerSet self) -> std::string"""
        return _IMP_container.TripletContainerSet___str__(self)


    def __repr__(self):
        """__repr__(TripletContainerSet self) -> std::string"""
        return _IMP_container.TripletContainerSet___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletContainerSet(o)
    get_from = staticmethod(get_from)

TripletContainerSet_swigregister = _IMP_container.TripletContainerSet_swigregister
TripletContainerSet_swigregister(TripletContainerSet)

class TripletsConstraint(IMP.Constraint):
    """Proxy of C++ IMP::container::TripletsConstraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::TripletsConstraint self, TripletModifier before, TripletModifier after, _TripletContainerAdaptor c, std::string name) -> TripletsConstraint
        __init__(IMP::container::TripletsConstraint self, TripletModifier before, TripletModifier after, _TripletContainerAdaptor c) -> TripletsConstraint
        """
        this = _IMP_container.new_TripletsConstraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(TripletsConstraint self) -> VersionInfo"""
        return _IMP_container.TripletsConstraint_get_version_info(self)


    def __str__(self):
        """__str__(TripletsConstraint self) -> std::string"""
        return _IMP_container.TripletsConstraint___str__(self)


    def __repr__(self):
        """__repr__(TripletsConstraint self) -> std::string"""
        return _IMP_container.TripletsConstraint___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletsConstraint(o)
    get_from = staticmethod(get_from)

TripletsConstraint_swigregister = _IMP_container.TripletsConstraint_swigregister
TripletsConstraint_swigregister(TripletsConstraint)

class TripletsOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::container::TripletsOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::TripletsOptimizerState self, _TripletContainerAdaptor c, TripletModifier gf, std::string name) -> TripletsOptimizerState
        __init__(IMP::container::TripletsOptimizerState self, _TripletContainerAdaptor c, TripletModifier gf) -> TripletsOptimizerState
        """
        this = _IMP_container.new_TripletsOptimizerState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(TripletsOptimizerState self) -> VersionInfo"""
        return _IMP_container.TripletsOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(TripletsOptimizerState self) -> std::string"""
        return _IMP_container.TripletsOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(TripletsOptimizerState self) -> std::string"""
        return _IMP_container.TripletsOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletsOptimizerState(o)
    get_from = staticmethod(get_from)

TripletsOptimizerState_swigregister = _IMP_container.TripletsOptimizerState_swigregister
TripletsOptimizerState_swigregister(TripletsOptimizerState)

class TripletsRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::TripletsRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::TripletsRestraint self, TripletScore ss, _TripletContainerAdaptor pc, std::string name) -> TripletsRestraint
        __init__(IMP::container::TripletsRestraint self, TripletScore ss, _TripletContainerAdaptor pc) -> TripletsRestraint
        """
        this = _IMP_container.new_TripletsRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(TripletsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.TripletsRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(TripletsRestraint self) -> VersionInfo"""
        return _IMP_container.TripletsRestraint_get_version_info(self)


    def __str__(self):
        """__str__(TripletsRestraint self) -> std::string"""
        return _IMP_container.TripletsRestraint___str__(self)


    def __repr__(self):
        """__repr__(TripletsRestraint self) -> std::string"""
        return _IMP_container.TripletsRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletsRestraint(o)
    get_from = staticmethod(get_from)

TripletsRestraint_swigregister = _IMP_container.TripletsRestraint_swigregister
TripletsRestraint_swigregister(TripletsRestraint)

class InContainerSingletonFilter(IMP.SingletonPredicate):
    """Proxy of C++ IMP::container::InContainerSingletonFilter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::InContainerSingletonFilter self, SingletonContainer c, std::string name) -> InContainerSingletonFilter
        __init__(IMP::container::InContainerSingletonFilter self, SingletonContainer c) -> InContainerSingletonFilter
        __init__(IMP::container::InContainerSingletonFilter self, SingletonContainer c, bool handle_permutations, std::string name) -> InContainerSingletonFilter
        __init__(IMP::container::InContainerSingletonFilter self, SingletonContainer c, bool handle_permutations) -> InContainerSingletonFilter
        """
        this = _IMP_container.new_InContainerSingletonFilter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(InContainerSingletonFilter self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_container.InContainerSingletonFilter_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(InContainerSingletonFilter self, Particle a) -> int
        get_value(InContainerSingletonFilter self, IMP::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerSingletonFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(InContainerSingletonFilter self, Model arg2, ParticleIndex vt) -> int
        get_value_index(InContainerSingletonFilter self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerSingletonFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(InContainerSingletonFilter self) -> VersionInfo"""
        return _IMP_container.InContainerSingletonFilter_get_version_info(self)


    def __str__(self):
        """__str__(InContainerSingletonFilter self) -> std::string"""
        return _IMP_container.InContainerSingletonFilter___str__(self)


    def __repr__(self):
        """__repr__(InContainerSingletonFilter self) -> std::string"""
        return _IMP_container.InContainerSingletonFilter___repr__(self)

    def get_from(o):
       return _object_cast_to_InContainerSingletonFilter(o)
    get_from = staticmethod(get_from)

InContainerSingletonFilter_swigregister = _IMP_container.InContainerSingletonFilter_swigregister
InContainerSingletonFilter_swigregister(InContainerSingletonFilter)

class InContainerPairFilter(IMP.PairPredicate):
    """Proxy of C++ IMP::container::InContainerPairFilter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::InContainerPairFilter self, PairContainer c, std::string name) -> InContainerPairFilter
        __init__(IMP::container::InContainerPairFilter self, PairContainer c) -> InContainerPairFilter
        __init__(IMP::container::InContainerPairFilter self, PairContainer c, bool handle_permutations, std::string name) -> InContainerPairFilter
        __init__(IMP::container::InContainerPairFilter self, PairContainer c, bool handle_permutations) -> InContainerPairFilter
        """
        this = _IMP_container.new_InContainerPairFilter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(InContainerPairFilter self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_container.InContainerPairFilter_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(InContainerPairFilter self, IMP::ParticlePair const & a) -> int
        get_value(InContainerPairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerPairFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(InContainerPairFilter self, Model arg2, IMP::ParticleIndexPair const & vt) -> int
        get_value_index(InContainerPairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerPairFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(InContainerPairFilter self) -> VersionInfo"""
        return _IMP_container.InContainerPairFilter_get_version_info(self)


    def __str__(self):
        """__str__(InContainerPairFilter self) -> std::string"""
        return _IMP_container.InContainerPairFilter___str__(self)


    def __repr__(self):
        """__repr__(InContainerPairFilter self) -> std::string"""
        return _IMP_container.InContainerPairFilter___repr__(self)

    def get_from(o):
       return _object_cast_to_InContainerPairFilter(o)
    get_from = staticmethod(get_from)

InContainerPairFilter_swigregister = _IMP_container.InContainerPairFilter_swigregister
InContainerPairFilter_swigregister(InContainerPairFilter)

class InContainerTripletFilter(IMP.TripletPredicate):
    """Proxy of C++ IMP::container::InContainerTripletFilter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::InContainerTripletFilter self, TripletContainer c, std::string name) -> InContainerTripletFilter
        __init__(IMP::container::InContainerTripletFilter self, TripletContainer c) -> InContainerTripletFilter
        __init__(IMP::container::InContainerTripletFilter self, TripletContainer c, bool handle_permutations, std::string name) -> InContainerTripletFilter
        __init__(IMP::container::InContainerTripletFilter self, TripletContainer c, bool handle_permutations) -> InContainerTripletFilter
        """
        this = _IMP_container.new_InContainerTripletFilter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(InContainerTripletFilter self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_container.InContainerTripletFilter_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(InContainerTripletFilter self, IMP::ParticleTriplet const & a) -> int
        get_value(InContainerTripletFilter self, IMP::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerTripletFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(InContainerTripletFilter self, Model arg2, IMP::ParticleIndexTriplet const & vt) -> int
        get_value_index(InContainerTripletFilter self, Model m, IMP::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerTripletFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(InContainerTripletFilter self) -> VersionInfo"""
        return _IMP_container.InContainerTripletFilter_get_version_info(self)


    def __str__(self):
        """__str__(InContainerTripletFilter self) -> std::string"""
        return _IMP_container.InContainerTripletFilter___str__(self)


    def __repr__(self):
        """__repr__(InContainerTripletFilter self) -> std::string"""
        return _IMP_container.InContainerTripletFilter___repr__(self)

    def get_from(o):
       return _object_cast_to_InContainerTripletFilter(o)
    get_from = staticmethod(get_from)

InContainerTripletFilter_swigregister = _IMP_container.InContainerTripletFilter_swigregister
InContainerTripletFilter_swigregister(InContainerTripletFilter)

class InContainerQuadFilter(IMP.QuadPredicate):
    """Proxy of C++ IMP::container::InContainerQuadFilter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::InContainerQuadFilter self, QuadContainer c, std::string name) -> InContainerQuadFilter
        __init__(IMP::container::InContainerQuadFilter self, QuadContainer c) -> InContainerQuadFilter
        __init__(IMP::container::InContainerQuadFilter self, QuadContainer c, bool handle_permutations, std::string name) -> InContainerQuadFilter
        __init__(IMP::container::InContainerQuadFilter self, QuadContainer c, bool handle_permutations) -> InContainerQuadFilter
        """
        this = _IMP_container.new_InContainerQuadFilter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, m, pi):
        """do_get_inputs(InContainerQuadFilter self, Model m, IMP::ParticleIndexes const & pi) -> IMP::ModelObjectsTemp"""
        return _IMP_container.InContainerQuadFilter_do_get_inputs(self, m, pi)


    def get_value(self, *args):
        """
        get_value(InContainerQuadFilter self, IMP::ParticleQuad const & a) -> int
        get_value(InContainerQuadFilter self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerQuadFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(InContainerQuadFilter self, Model arg2, IMP::ParticleIndexQuad const & vt) -> int
        get_value_index(InContainerQuadFilter self, Model m, IMP::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerQuadFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(InContainerQuadFilter self) -> VersionInfo"""
        return _IMP_container.InContainerQuadFilter_get_version_info(self)


    def __str__(self):
        """__str__(InContainerQuadFilter self) -> std::string"""
        return _IMP_container.InContainerQuadFilter___str__(self)


    def __repr__(self):
        """__repr__(InContainerQuadFilter self) -> std::string"""
        return _IMP_container.InContainerQuadFilter___repr__(self)

    def get_from(o):
       return _object_cast_to_InContainerQuadFilter(o)
    get_from = staticmethod(get_from)

InContainerQuadFilter_swigregister = _IMP_container.InContainerQuadFilter_swigregister
InContainerQuadFilter_swigregister(InContainerQuadFilter)

class SingletonContainerStatistics(IMP.ScoreState):
    """Proxy of C++ IMP::container::SingletonContainerStatistics class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, c):
        """__init__(IMP::container::SingletonContainerStatistics self, _SingletonContainerAdaptor c) -> SingletonContainerStatistics"""
        this = _IMP_container.new_SingletonContainerStatistics(c)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show_statistics(self, out):
        """show_statistics(SingletonContainerStatistics self, _ostream out)"""
        return _IMP_container.SingletonContainerStatistics_show_statistics(self, out)


    def set_track_unique(self, tf):
        """set_track_unique(SingletonContainerStatistics self, bool tf)"""
        return _IMP_container.SingletonContainerStatistics_set_track_unique(self, tf)


    def do_before_evaluate(self):
        """do_before_evaluate(SingletonContainerStatistics self)"""
        return _IMP_container.SingletonContainerStatistics_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(SingletonContainerStatistics self, DerivativeAccumulator da)"""
        return _IMP_container.SingletonContainerStatistics_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(SingletonContainerStatistics self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.SingletonContainerStatistics_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(SingletonContainerStatistics self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.SingletonContainerStatistics_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(SingletonContainerStatistics self) -> VersionInfo"""
        return _IMP_container.SingletonContainerStatistics_get_version_info(self)


    def __str__(self):
        """__str__(SingletonContainerStatistics self) -> std::string"""
        return _IMP_container.SingletonContainerStatistics___str__(self)


    def __repr__(self):
        """__repr__(SingletonContainerStatistics self) -> std::string"""
        return _IMP_container.SingletonContainerStatistics___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonContainerStatistics(o)
    get_from = staticmethod(get_from)

SingletonContainerStatistics_swigregister = _IMP_container.SingletonContainerStatistics_swigregister
SingletonContainerStatistics_swigregister(SingletonContainerStatistics)

class PairContainerStatistics(IMP.ScoreState):
    """Proxy of C++ IMP::container::PairContainerStatistics class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, c):
        """__init__(IMP::container::PairContainerStatistics self, _PairContainerAdaptor c) -> PairContainerStatistics"""
        this = _IMP_container.new_PairContainerStatistics(c)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show_statistics(self, out):
        """show_statistics(PairContainerStatistics self, _ostream out)"""
        return _IMP_container.PairContainerStatistics_show_statistics(self, out)


    def set_track_unique(self, tf):
        """set_track_unique(PairContainerStatistics self, bool tf)"""
        return _IMP_container.PairContainerStatistics_set_track_unique(self, tf)


    def do_before_evaluate(self):
        """do_before_evaluate(PairContainerStatistics self)"""
        return _IMP_container.PairContainerStatistics_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(PairContainerStatistics self, DerivativeAccumulator da)"""
        return _IMP_container.PairContainerStatistics_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(PairContainerStatistics self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PairContainerStatistics_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(PairContainerStatistics self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PairContainerStatistics_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(PairContainerStatistics self) -> VersionInfo"""
        return _IMP_container.PairContainerStatistics_get_version_info(self)


    def __str__(self):
        """__str__(PairContainerStatistics self) -> std::string"""
        return _IMP_container.PairContainerStatistics___str__(self)


    def __repr__(self):
        """__repr__(PairContainerStatistics self) -> std::string"""
        return _IMP_container.PairContainerStatistics___repr__(self)

    def get_from(o):
       return _object_cast_to_PairContainerStatistics(o)
    get_from = staticmethod(get_from)

PairContainerStatistics_swigregister = _IMP_container.PairContainerStatistics_swigregister
PairContainerStatistics_swigregister(PairContainerStatistics)

class TripletContainerStatistics(IMP.ScoreState):
    """Proxy of C++ IMP::container::TripletContainerStatistics class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, c):
        """__init__(IMP::container::TripletContainerStatistics self, _TripletContainerAdaptor c) -> TripletContainerStatistics"""
        this = _IMP_container.new_TripletContainerStatistics(c)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show_statistics(self, out):
        """show_statistics(TripletContainerStatistics self, _ostream out)"""
        return _IMP_container.TripletContainerStatistics_show_statistics(self, out)


    def set_track_unique(self, tf):
        """set_track_unique(TripletContainerStatistics self, bool tf)"""
        return _IMP_container.TripletContainerStatistics_set_track_unique(self, tf)


    def do_before_evaluate(self):
        """do_before_evaluate(TripletContainerStatistics self)"""
        return _IMP_container.TripletContainerStatistics_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(TripletContainerStatistics self, DerivativeAccumulator da)"""
        return _IMP_container.TripletContainerStatistics_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(TripletContainerStatistics self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.TripletContainerStatistics_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(TripletContainerStatistics self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.TripletContainerStatistics_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(TripletContainerStatistics self) -> VersionInfo"""
        return _IMP_container.TripletContainerStatistics_get_version_info(self)


    def __str__(self):
        """__str__(TripletContainerStatistics self) -> std::string"""
        return _IMP_container.TripletContainerStatistics___str__(self)


    def __repr__(self):
        """__repr__(TripletContainerStatistics self) -> std::string"""
        return _IMP_container.TripletContainerStatistics___repr__(self)

    def get_from(o):
       return _object_cast_to_TripletContainerStatistics(o)
    get_from = staticmethod(get_from)

TripletContainerStatistics_swigregister = _IMP_container.TripletContainerStatistics_swigregister
TripletContainerStatistics_swigregister(TripletContainerStatistics)

class QuadContainerStatistics(IMP.ScoreState):
    """Proxy of C++ IMP::container::QuadContainerStatistics class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, c):
        """__init__(IMP::container::QuadContainerStatistics self, _QuadContainerAdaptor c) -> QuadContainerStatistics"""
        this = _IMP_container.new_QuadContainerStatistics(c)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show_statistics(self, out):
        """show_statistics(QuadContainerStatistics self, _ostream out)"""
        return _IMP_container.QuadContainerStatistics_show_statistics(self, out)


    def set_track_unique(self, tf):
        """set_track_unique(QuadContainerStatistics self, bool tf)"""
        return _IMP_container.QuadContainerStatistics_set_track_unique(self, tf)


    def do_before_evaluate(self):
        """do_before_evaluate(QuadContainerStatistics self)"""
        return _IMP_container.QuadContainerStatistics_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(QuadContainerStatistics self, DerivativeAccumulator da)"""
        return _IMP_container.QuadContainerStatistics_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(QuadContainerStatistics self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.QuadContainerStatistics_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(QuadContainerStatistics self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.QuadContainerStatistics_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(QuadContainerStatistics self) -> VersionInfo"""
        return _IMP_container.QuadContainerStatistics_get_version_info(self)


    def __str__(self):
        """__str__(QuadContainerStatistics self) -> std::string"""
        return _IMP_container.QuadContainerStatistics___str__(self)


    def __repr__(self):
        """__repr__(QuadContainerStatistics self) -> std::string"""
        return _IMP_container.QuadContainerStatistics___repr__(self)

    def get_from(o):
       return _object_cast_to_QuadContainerStatistics(o)
    get_from = staticmethod(get_from)

QuadContainerStatistics_swigregister = _IMP_container.QuadContainerStatistics_swigregister
QuadContainerStatistics_swigregister(QuadContainerStatistics)

class EventSingletonsOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::container::EventSingletonsOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::EventSingletonsOptimizerState self, SingletonPredicate pred, _SingletonContainerAdaptor container, int value, int min_count, int max_count, std::string name) -> EventSingletonsOptimizerState
        __init__(IMP::container::EventSingletonsOptimizerState self, SingletonPredicate pred, _SingletonContainerAdaptor container, int value, int min_count, int max_count) -> EventSingletonsOptimizerState
        """
        this = _IMP_container.new_EventSingletonsOptimizerState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(EventSingletonsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventSingletonsOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(EventSingletonsOptimizerState self) -> std::string"""
        return _IMP_container.EventSingletonsOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(EventSingletonsOptimizerState self) -> std::string"""
        return _IMP_container.EventSingletonsOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_EventSingletonsOptimizerState(o)
    get_from = staticmethod(get_from)

EventSingletonsOptimizerState_swigregister = _IMP_container.EventSingletonsOptimizerState_swigregister
EventSingletonsOptimizerState_swigregister(EventSingletonsOptimizerState)

class EventPairsOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::container::EventPairsOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::EventPairsOptimizerState self, PairPredicate pred, _PairContainerAdaptor container, int value, int min_count, int max_count, std::string name) -> EventPairsOptimizerState
        __init__(IMP::container::EventPairsOptimizerState self, PairPredicate pred, _PairContainerAdaptor container, int value, int min_count, int max_count) -> EventPairsOptimizerState
        """
        this = _IMP_container.new_EventPairsOptimizerState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(EventPairsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventPairsOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(EventPairsOptimizerState self) -> std::string"""
        return _IMP_container.EventPairsOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(EventPairsOptimizerState self) -> std::string"""
        return _IMP_container.EventPairsOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_EventPairsOptimizerState(o)
    get_from = staticmethod(get_from)

EventPairsOptimizerState_swigregister = _IMP_container.EventPairsOptimizerState_swigregister
EventPairsOptimizerState_swigregister(EventPairsOptimizerState)

class EventTripletsOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::container::EventTripletsOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::EventTripletsOptimizerState self, TripletPredicate pred, _TripletContainerAdaptor container, int value, int min_count, int max_count, std::string name) -> EventTripletsOptimizerState
        __init__(IMP::container::EventTripletsOptimizerState self, TripletPredicate pred, _TripletContainerAdaptor container, int value, int min_count, int max_count) -> EventTripletsOptimizerState
        """
        this = _IMP_container.new_EventTripletsOptimizerState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(EventTripletsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventTripletsOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(EventTripletsOptimizerState self) -> std::string"""
        return _IMP_container.EventTripletsOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(EventTripletsOptimizerState self) -> std::string"""
        return _IMP_container.EventTripletsOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_EventTripletsOptimizerState(o)
    get_from = staticmethod(get_from)

EventTripletsOptimizerState_swigregister = _IMP_container.EventTripletsOptimizerState_swigregister
EventTripletsOptimizerState_swigregister(EventTripletsOptimizerState)

class EventQuadsOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::container::EventQuadsOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::EventQuadsOptimizerState self, QuadPredicate pred, _QuadContainerAdaptor container, int value, int min_count, int max_count, std::string name) -> EventQuadsOptimizerState
        __init__(IMP::container::EventQuadsOptimizerState self, QuadPredicate pred, _QuadContainerAdaptor container, int value, int min_count, int max_count) -> EventQuadsOptimizerState
        """
        this = _IMP_container.new_EventQuadsOptimizerState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(EventQuadsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventQuadsOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(EventQuadsOptimizerState self) -> std::string"""
        return _IMP_container.EventQuadsOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(EventQuadsOptimizerState self) -> std::string"""
        return _IMP_container.EventQuadsOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_EventQuadsOptimizerState(o)
    get_from = staticmethod(get_from)

EventQuadsOptimizerState_swigregister = _IMP_container.EventQuadsOptimizerState_swigregister
EventQuadsOptimizerState_swigregister(EventQuadsOptimizerState)

class PredicateSingletonsRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::PredicateSingletonsRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::PredicateSingletonsRestraint self, SingletonPredicate pred, _SingletonContainerAdaptor input, std::string name) -> PredicateSingletonsRestraint
        __init__(IMP::container::PredicateSingletonsRestraint self, SingletonPredicate pred, _SingletonContainerAdaptor input) -> PredicateSingletonsRestraint
        """
        this = _IMP_container.new_PredicateSingletonsRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_score(self, predicate_value, score):
        """set_score(PredicateSingletonsRestraint self, int predicate_value, SingletonScore score)"""
        return _IMP_container.PredicateSingletonsRestraint_set_score(self, predicate_value, score)


    def set_unknown_score(self, score):
        """set_unknown_score(PredicateSingletonsRestraint self, SingletonScore score)"""
        return _IMP_container.PredicateSingletonsRestraint_set_unknown_score(self, score)


    def set_is_complete(self, tf):
        """set_is_complete(PredicateSingletonsRestraint self, bool tf)"""
        return _IMP_container.PredicateSingletonsRestraint_set_is_complete(self, tf)


    def get_indexes(self, predicate_value):
        """get_indexes(PredicateSingletonsRestraint self, int predicate_value) -> IMP::ParticleIndexes"""
        return _IMP_container.PredicateSingletonsRestraint_get_indexes(self, predicate_value)


    def do_add_score_and_derivatives(self, sa):
        """do_add_score_and_derivatives(PredicateSingletonsRestraint self, ScoreAccumulator sa)"""
        return _IMP_container.PredicateSingletonsRestraint_do_add_score_and_derivatives(self, sa)


    def do_get_inputs(self):
        """do_get_inputs(PredicateSingletonsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PredicateSingletonsRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(PredicateSingletonsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateSingletonsRestraint_get_version_info(self)


    def __str__(self):
        """__str__(PredicateSingletonsRestraint self) -> std::string"""
        return _IMP_container.PredicateSingletonsRestraint___str__(self)


    def __repr__(self):
        """__repr__(PredicateSingletonsRestraint self) -> std::string"""
        return _IMP_container.PredicateSingletonsRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_PredicateSingletonsRestraint(o)
    get_from = staticmethod(get_from)

PredicateSingletonsRestraint_swigregister = _IMP_container.PredicateSingletonsRestraint_swigregister
PredicateSingletonsRestraint_swigregister(PredicateSingletonsRestraint)

class PredicatePairsRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::PredicatePairsRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::PredicatePairsRestraint self, PairPredicate pred, _PairContainerAdaptor input, std::string name) -> PredicatePairsRestraint
        __init__(IMP::container::PredicatePairsRestraint self, PairPredicate pred, _PairContainerAdaptor input) -> PredicatePairsRestraint
        """
        this = _IMP_container.new_PredicatePairsRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_score(self, predicate_value, score):
        """set_score(PredicatePairsRestraint self, int predicate_value, PairScore score)"""
        return _IMP_container.PredicatePairsRestraint_set_score(self, predicate_value, score)


    def set_unknown_score(self, score):
        """set_unknown_score(PredicatePairsRestraint self, PairScore score)"""
        return _IMP_container.PredicatePairsRestraint_set_unknown_score(self, score)


    def set_is_complete(self, tf):
        """set_is_complete(PredicatePairsRestraint self, bool tf)"""
        return _IMP_container.PredicatePairsRestraint_set_is_complete(self, tf)


    def get_indexes(self, predicate_value):
        """get_indexes(PredicatePairsRestraint self, int predicate_value) -> IMP::ParticleIndexPairs"""
        return _IMP_container.PredicatePairsRestraint_get_indexes(self, predicate_value)


    def do_add_score_and_derivatives(self, sa):
        """do_add_score_and_derivatives(PredicatePairsRestraint self, ScoreAccumulator sa)"""
        return _IMP_container.PredicatePairsRestraint_do_add_score_and_derivatives(self, sa)


    def do_get_inputs(self):
        """do_get_inputs(PredicatePairsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PredicatePairsRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(PredicatePairsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicatePairsRestraint_get_version_info(self)


    def __str__(self):
        """__str__(PredicatePairsRestraint self) -> std::string"""
        return _IMP_container.PredicatePairsRestraint___str__(self)


    def __repr__(self):
        """__repr__(PredicatePairsRestraint self) -> std::string"""
        return _IMP_container.PredicatePairsRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_PredicatePairsRestraint(o)
    get_from = staticmethod(get_from)

PredicatePairsRestraint_swigregister = _IMP_container.PredicatePairsRestraint_swigregister
PredicatePairsRestraint_swigregister(PredicatePairsRestraint)

class PredicateTripletsRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::PredicateTripletsRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::PredicateTripletsRestraint self, TripletPredicate pred, _TripletContainerAdaptor input, std::string name) -> PredicateTripletsRestraint
        __init__(IMP::container::PredicateTripletsRestraint self, TripletPredicate pred, _TripletContainerAdaptor input) -> PredicateTripletsRestraint
        """
        this = _IMP_container.new_PredicateTripletsRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_score(self, predicate_value, score):
        """set_score(PredicateTripletsRestraint self, int predicate_value, TripletScore score)"""
        return _IMP_container.PredicateTripletsRestraint_set_score(self, predicate_value, score)


    def set_unknown_score(self, score):
        """set_unknown_score(PredicateTripletsRestraint self, TripletScore score)"""
        return _IMP_container.PredicateTripletsRestraint_set_unknown_score(self, score)


    def set_is_complete(self, tf):
        """set_is_complete(PredicateTripletsRestraint self, bool tf)"""
        return _IMP_container.PredicateTripletsRestraint_set_is_complete(self, tf)


    def get_indexes(self, predicate_value):
        """get_indexes(PredicateTripletsRestraint self, int predicate_value) -> IMP::ParticleIndexTriplets"""
        return _IMP_container.PredicateTripletsRestraint_get_indexes(self, predicate_value)


    def do_add_score_and_derivatives(self, sa):
        """do_add_score_and_derivatives(PredicateTripletsRestraint self, ScoreAccumulator sa)"""
        return _IMP_container.PredicateTripletsRestraint_do_add_score_and_derivatives(self, sa)


    def do_get_inputs(self):
        """do_get_inputs(PredicateTripletsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PredicateTripletsRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(PredicateTripletsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateTripletsRestraint_get_version_info(self)


    def __str__(self):
        """__str__(PredicateTripletsRestraint self) -> std::string"""
        return _IMP_container.PredicateTripletsRestraint___str__(self)


    def __repr__(self):
        """__repr__(PredicateTripletsRestraint self) -> std::string"""
        return _IMP_container.PredicateTripletsRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_PredicateTripletsRestraint(o)
    get_from = staticmethod(get_from)

PredicateTripletsRestraint_swigregister = _IMP_container.PredicateTripletsRestraint_swigregister
PredicateTripletsRestraint_swigregister(PredicateTripletsRestraint)

class PredicateQuadsRestraint(IMP.Restraint):
    """Proxy of C++ IMP::container::PredicateQuadsRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::PredicateQuadsRestraint self, QuadPredicate pred, _QuadContainerAdaptor input, std::string name) -> PredicateQuadsRestraint
        __init__(IMP::container::PredicateQuadsRestraint self, QuadPredicate pred, _QuadContainerAdaptor input) -> PredicateQuadsRestraint
        """
        this = _IMP_container.new_PredicateQuadsRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_score(self, predicate_value, score):
        """set_score(PredicateQuadsRestraint self, int predicate_value, QuadScore score)"""
        return _IMP_container.PredicateQuadsRestraint_set_score(self, predicate_value, score)


    def set_unknown_score(self, score):
        """set_unknown_score(PredicateQuadsRestraint self, QuadScore score)"""
        return _IMP_container.PredicateQuadsRestraint_set_unknown_score(self, score)


    def set_is_complete(self, tf):
        """set_is_complete(PredicateQuadsRestraint self, bool tf)"""
        return _IMP_container.PredicateQuadsRestraint_set_is_complete(self, tf)


    def get_indexes(self, predicate_value):
        """get_indexes(PredicateQuadsRestraint self, int predicate_value) -> IMP::ParticleIndexQuads"""
        return _IMP_container.PredicateQuadsRestraint_get_indexes(self, predicate_value)


    def do_add_score_and_derivatives(self, sa):
        """do_add_score_and_derivatives(PredicateQuadsRestraint self, ScoreAccumulator sa)"""
        return _IMP_container.PredicateQuadsRestraint_do_add_score_and_derivatives(self, sa)


    def do_get_inputs(self):
        """do_get_inputs(PredicateQuadsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PredicateQuadsRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(PredicateQuadsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateQuadsRestraint_get_version_info(self)


    def __str__(self):
        """__str__(PredicateQuadsRestraint self) -> std::string"""
        return _IMP_container.PredicateQuadsRestraint___str__(self)


    def __repr__(self):
        """__repr__(PredicateQuadsRestraint self) -> std::string"""
        return _IMP_container.PredicateQuadsRestraint___repr__(self)

    def get_from(o):
       return _object_cast_to_PredicateQuadsRestraint(o)
    get_from = staticmethod(get_from)

PredicateQuadsRestraint_swigregister = _IMP_container.PredicateQuadsRestraint_swigregister
PredicateQuadsRestraint_swigregister(PredicateQuadsRestraint)

class DistributeSingletonsScoreState(IMP.ScoreState):
    """Proxy of C++ IMP::container::DistributeSingletonsScoreState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::DistributeSingletonsScoreState self, _SingletonContainerAdaptor input, std::string name) -> DistributeSingletonsScoreState
        __init__(IMP::container::DistributeSingletonsScoreState self, _SingletonContainerAdaptor input) -> DistributeSingletonsScoreState
        """
        this = _IMP_container.new_DistributeSingletonsScoreState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_predicate(self, predicate, value):
        """add_predicate(DistributeSingletonsScoreState self, SingletonPredicate predicate, int value) -> DynamicListSingletonContainer"""
        return _IMP_container.DistributeSingletonsScoreState_add_predicate(self, predicate, value)


    def do_before_evaluate(self):
        """do_before_evaluate(DistributeSingletonsScoreState self)"""
        return _IMP_container.DistributeSingletonsScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(DistributeSingletonsScoreState self, DerivativeAccumulator da)"""
        return _IMP_container.DistributeSingletonsScoreState_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(DistributeSingletonsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DistributeSingletonsScoreState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(DistributeSingletonsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DistributeSingletonsScoreState_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(DistributeSingletonsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeSingletonsScoreState_get_version_info(self)


    def __str__(self):
        """__str__(DistributeSingletonsScoreState self) -> std::string"""
        return _IMP_container.DistributeSingletonsScoreState___str__(self)


    def __repr__(self):
        """__repr__(DistributeSingletonsScoreState self) -> std::string"""
        return _IMP_container.DistributeSingletonsScoreState___repr__(self)

    def get_from(o):
       return _object_cast_to_DistributeSingletonsScoreState(o)
    get_from = staticmethod(get_from)

DistributeSingletonsScoreState_swigregister = _IMP_container.DistributeSingletonsScoreState_swigregister
DistributeSingletonsScoreState_swigregister(DistributeSingletonsScoreState)

class DistributePairsScoreState(IMP.ScoreState):
    """Proxy of C++ IMP::container::DistributePairsScoreState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::DistributePairsScoreState self, _PairContainerAdaptor input, std::string name) -> DistributePairsScoreState
        __init__(IMP::container::DistributePairsScoreState self, _PairContainerAdaptor input) -> DistributePairsScoreState
        """
        this = _IMP_container.new_DistributePairsScoreState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_predicate(self, predicate, value):
        """add_predicate(DistributePairsScoreState self, PairPredicate predicate, int value) -> DynamicListPairContainer"""
        return _IMP_container.DistributePairsScoreState_add_predicate(self, predicate, value)


    def do_before_evaluate(self):
        """do_before_evaluate(DistributePairsScoreState self)"""
        return _IMP_container.DistributePairsScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(DistributePairsScoreState self, DerivativeAccumulator da)"""
        return _IMP_container.DistributePairsScoreState_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(DistributePairsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DistributePairsScoreState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(DistributePairsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DistributePairsScoreState_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(DistributePairsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributePairsScoreState_get_version_info(self)


    def __str__(self):
        """__str__(DistributePairsScoreState self) -> std::string"""
        return _IMP_container.DistributePairsScoreState___str__(self)


    def __repr__(self):
        """__repr__(DistributePairsScoreState self) -> std::string"""
        return _IMP_container.DistributePairsScoreState___repr__(self)

    def get_from(o):
       return _object_cast_to_DistributePairsScoreState(o)
    get_from = staticmethod(get_from)

DistributePairsScoreState_swigregister = _IMP_container.DistributePairsScoreState_swigregister
DistributePairsScoreState_swigregister(DistributePairsScoreState)

class DistributeTripletsScoreState(IMP.ScoreState):
    """Proxy of C++ IMP::container::DistributeTripletsScoreState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::DistributeTripletsScoreState self, _TripletContainerAdaptor input, std::string name) -> DistributeTripletsScoreState
        __init__(IMP::container::DistributeTripletsScoreState self, _TripletContainerAdaptor input) -> DistributeTripletsScoreState
        """
        this = _IMP_container.new_DistributeTripletsScoreState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_predicate(self, predicate, value):
        """add_predicate(DistributeTripletsScoreState self, TripletPredicate predicate, int value) -> DynamicListTripletContainer"""
        return _IMP_container.DistributeTripletsScoreState_add_predicate(self, predicate, value)


    def do_before_evaluate(self):
        """do_before_evaluate(DistributeTripletsScoreState self)"""
        return _IMP_container.DistributeTripletsScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(DistributeTripletsScoreState self, DerivativeAccumulator da)"""
        return _IMP_container.DistributeTripletsScoreState_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(DistributeTripletsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DistributeTripletsScoreState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(DistributeTripletsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DistributeTripletsScoreState_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(DistributeTripletsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeTripletsScoreState_get_version_info(self)


    def __str__(self):
        """__str__(DistributeTripletsScoreState self) -> std::string"""
        return _IMP_container.DistributeTripletsScoreState___str__(self)


    def __repr__(self):
        """__repr__(DistributeTripletsScoreState self) -> std::string"""
        return _IMP_container.DistributeTripletsScoreState___repr__(self)

    def get_from(o):
       return _object_cast_to_DistributeTripletsScoreState(o)
    get_from = staticmethod(get_from)

DistributeTripletsScoreState_swigregister = _IMP_container.DistributeTripletsScoreState_swigregister
DistributeTripletsScoreState_swigregister(DistributeTripletsScoreState)

class DistributeQuadsScoreState(IMP.ScoreState):
    """Proxy of C++ IMP::container::DistributeQuadsScoreState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::container::DistributeQuadsScoreState self, _QuadContainerAdaptor input, std::string name) -> DistributeQuadsScoreState
        __init__(IMP::container::DistributeQuadsScoreState self, _QuadContainerAdaptor input) -> DistributeQuadsScoreState
        """
        this = _IMP_container.new_DistributeQuadsScoreState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_predicate(self, predicate, value):
        """add_predicate(DistributeQuadsScoreState self, QuadPredicate predicate, int value) -> DynamicListQuadContainer"""
        return _IMP_container.DistributeQuadsScoreState_add_predicate(self, predicate, value)


    def do_before_evaluate(self):
        """do_before_evaluate(DistributeQuadsScoreState self)"""
        return _IMP_container.DistributeQuadsScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(DistributeQuadsScoreState self, DerivativeAccumulator da)"""
        return _IMP_container.DistributeQuadsScoreState_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(DistributeQuadsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DistributeQuadsScoreState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(DistributeQuadsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.DistributeQuadsScoreState_do_get_outputs(self)


    def get_version_info(self):
        """get_version_info(DistributeQuadsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeQuadsScoreState_get_version_info(self)


    def __str__(self):
        """__str__(DistributeQuadsScoreState self) -> std::string"""
        return _IMP_container.DistributeQuadsScoreState___str__(self)


    def __repr__(self):
        """__repr__(DistributeQuadsScoreState self) -> std::string"""
        return _IMP_container.DistributeQuadsScoreState___repr__(self)

    def get_from(o):
       return _object_cast_to_DistributeQuadsScoreState(o)
    get_from = staticmethod(get_from)

DistributeQuadsScoreState_swigregister = _IMP_container.DistributeQuadsScoreState_swigregister
DistributeQuadsScoreState_swigregister(DistributeQuadsScoreState)


def create_restraint(*args):
    """
    create_restraint(PairScore ps, IMP::ParticlePair pp) -> Restraint
    create_restraint(PairScore ps, PairContainer pp) -> Restraint
    """
    return _IMP_container.create_restraint(*args)

def get_module_version():
    """get_module_version() -> std::string const"""
    return _IMP_container.get_module_version()

def get_example_path(fname):
    """get_example_path(std::string fname) -> std::string"""
    return _IMP_container.get_example_path(fname)

def get_data_path(fname):
    """get_data_path(std::string fname) -> std::string"""
    return _IMP_container.get_data_path(fname)
from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()