container/__init__.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.5.0
#
# 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-2026 IMP Inventors. All rights reserved.



import warnings



import typing
import _IMP_container

import builtins as __builtin__

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


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


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


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


import weakref

class IMP_CONTAINER_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_CONTAINER_SwigPyIterator class."""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        r"""
        __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

# Register IMP_CONTAINER_SwigPyIterator in _IMP_container:
_IMP_container.IMP_CONTAINER_SwigPyIterator_swigregister(IMP_CONTAINER_SwigPyIterator)

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

IMP_DEBUG = _IMP_container.IMP_DEBUG

IMP_RELEASE = _IMP_container.IMP_RELEASE

IMP_SILENT = _IMP_container.IMP_SILENT

IMP_PROGRESS = _IMP_container.IMP_PROGRESS

IMP_TERSE = _IMP_container.IMP_TERSE

IMP_VERBOSE = _IMP_container.IMP_VERBOSE

IMP_MEMORY = _IMP_container.IMP_MEMORY

IMP_NONE = _IMP_container.IMP_NONE

IMP_USAGE = _IMP_container.IMP_USAGE

IMP_INTERNAL = _IMP_container.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_container.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_container.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_container.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_container.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_container.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_container.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_container.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_container.IMP_KERNEL_HAS_BOOST_SYSTEM

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_container.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_container.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_container.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_container.IMPKERNEL_SHOW_WARNINGS


import sys
class _DirectorObjects:
    """@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):
    r"""Proxy of C++ std::ostream class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

# Register _ostream in _IMP_container:
_IMP_container._ostream_swigregister(_ostream)
IMP_C_OPEN_BINARY = _IMP_container.IMP_C_OPEN_BINARY

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_container.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_NUMPY = _IMP_container.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_container.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_container.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_container.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_CGAL = _IMP_container.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_container.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_container.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_container.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_container.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_container.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_CGAL = _IMP_container.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_container.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_container.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_container.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_container.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_container.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_container.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_container.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_CORE_HAS_IMP_CGAL = _IMP_container.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_container.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_container.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_CGAL = _IMP_container.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_container.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_container.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_container.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_container.IMP_CONTAINER_HAS_IMP_ALGEBRA

IMP_CONTAINER_HAS_IMP_CGAL = _IMP_container.IMP_CONTAINER_HAS_IMP_CGAL

IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_container.IMP_CONTAINER_HAS_IMP_DISPLAY

IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_container.IMP_CONTAINER_HAS_IMP_KERNEL

IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_container.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_container.IMP_CONTAINER_HAS_BOOST_RANDOM

IMP_CONTAINER_HAS_CGAL = _IMP_container.IMP_CONTAINER_HAS_CGAL

IMP_CONTAINER_HAS_HDF5 = _IMP_container.IMP_CONTAINER_HAS_HDF5

IMP_CONTAINER_HAS_NUMPY = _IMP_container.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_container.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_container.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_container.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_container.IMPCONTAINER_SHOW_WARNINGS


_object_types.append("AllBipartitePairContainer")


def _object_cast_to_AllBipartitePairContainer(o):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_object_cast_to_DistributeQuadsScoreState(Object o) -> DistributeQuadsScoreState"""
    return _IMP_container._object_cast_to_DistributeQuadsScoreState(o)
class AllBipartitePairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::AllBipartitePairContainer class."""

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

    def __init__(self, *args):
        r"""__init__(AllBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, std::string name="AllBipartitePairContainer%1%") -> AllBipartitePairContainer"""
        _IMP_container.AllBipartitePairContainer_swiginit(self, _IMP_container.new_AllBipartitePairContainer(*args))

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(AllBipartitePairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.AllBipartitePairContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(AllBipartitePairContainer self) -> VersionInfo"""
        return _IMP_container.AllBipartitePairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_AllBipartitePairContainer

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

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

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


    def _get_static_contents(self):
        return self.get_contents()


# Register AllBipartitePairContainer in _IMP_container:
_IMP_container.AllBipartitePairContainer_swigregister(AllBipartitePairContainer)
class AllPairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::AllPairContainer class."""

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

    def __init__(self, *args):
        r"""__init__(AllPairContainer self, _SingletonContainerAdaptor c, std::string name="AllPairContainer%1%") -> AllPairContainer"""
        _IMP_container.AllPairContainer_swiginit(self, _IMP_container.new_AllPairContainer(*args))

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(AllPairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.AllPairContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(AllPairContainer self) -> VersionInfo"""
        return _IMP_container.AllPairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_AllPairContainer

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

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

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


    def _get_static_contents(self):
        return self.get_contents()


# Register AllPairContainer in _IMP_container:
_IMP_container.AllPairContainer_swigregister(AllPairContainer)
class CloseBipartitePairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::CloseBipartitePairContainer class."""

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

    def __init__(self, *args):
        r"""
        __init__(CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, double slack=1, std::string name="CloseBipartitePairContainer%1%") -> CloseBipartitePairContainer
        __init__(CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, ClosePairsFinder cpf, double slack=1, std::string name="CloseBipartitePairContainer%1%") -> CloseBipartitePairContainer
        __init__(CloseBipartitePairContainer self) -> CloseBipartitePairContainer
        """
        _IMP_container.CloseBipartitePairContainer_swiginit(self, _IMP_container.new_CloseBipartitePairContainer(*args))
    def __get_pair_filters(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_pair_filters,  getfunc=self.get_pair_filter, erasefunc=self.erase_pair_filter,  appendfunc=self.add_pair_filter, extendfunc=self.add_pair_filters,  clearfunc=self.clear_pair_filters, indexfunc=self._python_index_pair_filter)  
    def __set_pair_filters(self, obj): IMP._list_util.set_varlist(self.pair_filters, obj)  
    def __del_pair_filters(self): IMP._list_util.del_varlist(self.pair_filters)       
    pair_filters = property(__get_pair_filters, __set_pair_filters, __del_pair_filters, doc="List of ##ucnames")  

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

    def _python_index_pair_filter(self, d, start, stop):
        r"""_python_index_pair_filter(CloseBipartitePairContainer self, PairPredicate d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_container.CloseBipartitePairContainer__python_index_pair_filter(self, d, start, stop)

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

    def set_pair_filters(self, ps):
        r"""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):
        r"""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):
        r"""add_pair_filter(CloseBipartitePairContainer self, PairPredicate obj) -> unsigned int"""
        return _IMP_container.CloseBipartitePairContainer_add_pair_filter(self, obj)

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

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

    def get_number_of_pair_filters(self):
        r"""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):
        r"""get_has_pair_filters(CloseBipartitePairContainer self) -> bool"""
        return _IMP_container.CloseBipartitePairContainer_get_has_pair_filters(self)

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

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

    def erase_pair_filter(self, i):
        r"""erase_pair_filter(CloseBipartitePairContainer self, unsigned int i)"""
        return _IMP_container.CloseBipartitePairContainer_erase_pair_filter(self, i)

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

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

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

    def get_version_info(self):
        r"""get_version_info(CloseBipartitePairContainer self) -> VersionInfo"""
        return _IMP_container.CloseBipartitePairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_CloseBipartitePairContainer

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(CloseBipartitePairContainer self) -> PyObject *"""
        return _IMP_container.CloseBipartitePairContainer__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(CloseBipartitePairContainer self, PyObject * p)"""
        return _IMP_container.CloseBipartitePairContainer__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_static_contents(self):
        warnings.warn("No JAX support for close pairs, so using all "
                      "possible pairs; this may be slow.", IMP.JAXWarning)
        return self.get_range_indexes()


# Register CloseBipartitePairContainer in _IMP_container:
_IMP_container.CloseBipartitePairContainer_swigregister(CloseBipartitePairContainer)
class ClosePairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::ClosePairContainer class."""

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

    def __init__(self, *args):
        r"""
        __init__(ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, double slack=1, std::string name="ClosePairContainer%1%") -> ClosePairContainer
        __init__(ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, ClosePairsFinder cpf, double slack=1, std::string name="ClosePairContainer%1%") -> ClosePairContainer
        __init__(ClosePairContainer self) -> ClosePairContainer
        """
        _IMP_container.ClosePairContainer_swiginit(self, _IMP_container.new_ClosePairContainer(*args))
    def __get_pair_filters(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_pair_filters,  getfunc=self.get_pair_filter, erasefunc=self.erase_pair_filter,  appendfunc=self.add_pair_filter, extendfunc=self.add_pair_filters,  clearfunc=self.clear_pair_filters, indexfunc=self._python_index_pair_filter)  
    def __set_pair_filters(self, obj): IMP._list_util.set_varlist(self.pair_filters, obj)  
    def __del_pair_filters(self): IMP._list_util.del_varlist(self.pair_filters)       
    pair_filters = property(__get_pair_filters, __set_pair_filters, __del_pair_filters, doc="List of ##ucnames")  

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

    def _python_index_pair_filter(self, d, start, stop):
        r"""_python_index_pair_filter(ClosePairContainer self, PairPredicate d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_container.ClosePairContainer__python_index_pair_filter(self, d, start, stop)

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

    def set_pair_filters(self, ps):
        r"""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):
        r"""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):
        r"""add_pair_filter(ClosePairContainer self, PairPredicate obj) -> unsigned int"""
        return _IMP_container.ClosePairContainer_add_pair_filter(self, obj)

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

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

    def get_number_of_pair_filters(self):
        r"""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):
        r"""get_has_pair_filters(ClosePairContainer self) -> bool"""
        return _IMP_container.ClosePairContainer_get_has_pair_filters(self)

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

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

    def erase_pair_filter(self, i):
        r"""erase_pair_filter(ClosePairContainer self, unsigned int i)"""
        return _IMP_container.ClosePairContainer_erase_pair_filter(self, i)

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

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

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

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

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

    def get_number_of_update_calls(self):
        r"""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):
        r"""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):
        r"""get_number_of_partial_rebuilds(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_partial_rebuilds(self)

    def get_version_info(self):
        r"""get_version_info(ClosePairContainer self) -> VersionInfo"""
        return _IMP_container.ClosePairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ClosePairContainer

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(ClosePairContainer self) -> PyObject *"""
        return _IMP_container.ClosePairContainer__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ClosePairContainer self, PyObject * p)"""
        return _IMP_container.ClosePairContainer__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_static_contents(self):
        warnings.warn("No JAX support for close pairs, so using all "
                      "possible pairs; this may be slow.", IMP.JAXWarning)
        return self.get_range_indexes()


# Register ClosePairContainer in _IMP_container:
_IMP_container.ClosePairContainer_swigregister(ClosePairContainer)

def get_slack_estimate(m, ps, upper_bound, step, restraints, derivatives, opt, cpc):
    r"""get_slack_estimate(Model m, IMP::ParticleIndexes ps, double upper_bound, double step, IMP::RestraintsTemp const & restraints, bool derivatives, Optimizer opt, ClosePairContainer cpc) -> double"""
    return _IMP_container.get_slack_estimate(m, ps, upper_bound, step, restraints, derivatives, opt, cpc)
class ConnectingPairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::ConnectingPairContainer class."""

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

    def __init__(self, sc, error):
        r"""__init__(ConnectingPairContainer self, SingletonContainer sc, double error) -> ConnectingPairContainer"""
        _IMP_container.ConnectingPairContainer_swiginit(self, _IMP_container.new_ConnectingPairContainer(sc, error))

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

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

    def get_version_info(self):
        r"""get_version_info(ConnectingPairContainer self) -> VersionInfo"""
        return _IMP_container.ConnectingPairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ConnectingPairContainer

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

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

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


# Register ConnectingPairContainer in _IMP_container:
_IMP_container.ConnectingPairContainer_swigregister(ConnectingPairContainer)
class ConsecutivePairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::ConsecutivePairContainer class."""

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

    def __init__(self, *args):
        r"""__init__(ConsecutivePairContainer self, Model m, IMP::ParticleIndexes const & ps, std::string name="ConsecutivePairContainer%1%") -> ConsecutivePairContainer"""
        _IMP_container.ConsecutivePairContainer_swiginit(self, _IMP_container.new_ConsecutivePairContainer(*args))

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(ConsecutivePairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.ConsecutivePairContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(ConsecutivePairContainer self) -> VersionInfo"""
        return _IMP_container.ConsecutivePairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ConsecutivePairContainer

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

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

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


# Register ConsecutivePairContainer in _IMP_container:
_IMP_container.ConsecutivePairContainer_swigregister(ConsecutivePairContainer)
class ConsecutivePairFilter(IMP.PairPredicate):
    r"""Proxy of C++ IMP::container::ConsecutivePairFilter class."""

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

    def __init__(self, cpc):
        r"""__init__(ConsecutivePairFilter self, ConsecutivePairContainer cpc) -> ConsecutivePairFilter"""
        _IMP_container.ConsecutivePairFilter_swiginit(self, _IMP_container.new_ConsecutivePairFilter(cpc))

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(ConsecutivePairFilter self) -> VersionInfo"""
        return _IMP_container.ConsecutivePairFilter_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ConsecutivePairFilter

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

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

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


# Register ConsecutivePairFilter in _IMP_container:
_IMP_container.ConsecutivePairFilter_swigregister(ConsecutivePairFilter)
class ExclusiveConsecutivePairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::ExclusiveConsecutivePairContainer class."""

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

    def __init__(self, *args):
        r"""__init__(ExclusiveConsecutivePairContainer self, Model m, IMP::ParticleIndexes const & ps, std::string name="ExclusiveConsecutivePairContainer%1%") -> ExclusiveConsecutivePairContainer"""
        _IMP_container.ExclusiveConsecutivePairContainer_swiginit(self, _IMP_container.new_ExclusiveConsecutivePairContainer(*args))

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(ExclusiveConsecutivePairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.ExclusiveConsecutivePairContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(ExclusiveConsecutivePairContainer self) -> VersionInfo"""
        return _IMP_container.ExclusiveConsecutivePairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ExclusiveConsecutivePairContainer

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

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

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


# Register ExclusiveConsecutivePairContainer in _IMP_container:
_IMP_container.ExclusiveConsecutivePairContainer_swigregister(ExclusiveConsecutivePairContainer)
class ExclusiveConsecutivePairFilter(IMP.PairPredicate):
    r"""Proxy of C++ IMP::container::ExclusiveConsecutivePairFilter class."""

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

    def __init__(self):
        r"""__init__(ExclusiveConsecutivePairFilter self) -> ExclusiveConsecutivePairFilter"""
        _IMP_container.ExclusiveConsecutivePairFilter_swiginit(self, _IMP_container.new_ExclusiveConsecutivePairFilter())

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(ExclusiveConsecutivePairFilter self) -> VersionInfo"""
        return _IMP_container.ExclusiveConsecutivePairFilter_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ExclusiveConsecutivePairFilter

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

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

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


# Register ExclusiveConsecutivePairFilter in _IMP_container:
_IMP_container.ExclusiveConsecutivePairFilter_swigregister(ExclusiveConsecutivePairFilter)
class ListPairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::ListPairContainer class."""

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

    def __init__(self, *args):
        r"""
        __init__(ListPairContainer self, Model m, IMP::ParticleIndexPairs const & contents, std::string name="ListPairContainer%1%") -> ListPairContainer
        __init__(ListPairContainer self, Model m, std::string name="ListPairContainer %1%") -> ListPairContainer
        __init__(ListPairContainer self, Model m, char const * name) -> ListPairContainer
        __init__(ListPairContainer self) -> ListPairContainer
        """
        _IMP_container.ListPairContainer_swiginit(self, _IMP_container.new_ListPairContainer(*args))

    def add(self, *args):
        r"""
        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):
        r"""set(ListPairContainer self, IMP::ParticleIndexPairs cp)"""
        return _IMP_container.ListPairContainer_set(self, cp)

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

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(ListPairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.ListPairContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(ListPairContainer self) -> VersionInfo"""
        return _IMP_container.ListPairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ListPairContainer

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(ListPairContainer self) -> PyObject *"""
        return _IMP_container.ListPairContainer__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ListPairContainer self, PyObject * p)"""
        return _IMP_container.ListPairContainer__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_static_contents(self):
        return self.get_contents()


# Register ListPairContainer in _IMP_container:
_IMP_container.ListPairContainer_swigregister(ListPairContainer)
class ListQuadContainer(IMP.QuadContainer):
    r"""Proxy of C++ IMP::container::ListQuadContainer class."""

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

    def __init__(self, *args):
        r"""
        __init__(ListQuadContainer self, Model m, IMP::ParticleIndexQuads const & contents, std::string name="ListQuadContainer%1%") -> ListQuadContainer
        __init__(ListQuadContainer self, Model m, std::string name="ListQuadContainer %1%") -> ListQuadContainer
        __init__(ListQuadContainer self, Model m, char const * name) -> ListQuadContainer
        __init__(ListQuadContainer self) -> ListQuadContainer
        """
        _IMP_container.ListQuadContainer_swiginit(self, _IMP_container.new_ListQuadContainer(*args))

    def add(self, *args):
        r"""
        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):
        r"""set(ListQuadContainer self, IMP::ParticleIndexQuads cp)"""
        return _IMP_container.ListQuadContainer_set(self, cp)

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

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(ListQuadContainer self, QuadModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.ListQuadContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(ListQuadContainer self) -> VersionInfo"""
        return _IMP_container.ListQuadContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ListQuadContainer

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(ListQuadContainer self) -> PyObject *"""
        return _IMP_container.ListQuadContainer__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ListQuadContainer self, PyObject * p)"""
        return _IMP_container.ListQuadContainer__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ListQuadContainer in _IMP_container:
_IMP_container.ListQuadContainer_swigregister(ListQuadContainer)
class ListSingletonContainer(IMP.SingletonContainer):
    r"""Proxy of C++ IMP::container::ListSingletonContainer class."""

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

    def __init__(self, *args):
        r"""
        __init__(ListSingletonContainer self, Model m, IMP::ParticleIndexes const & contents, std::string name="ListSingletonContainer%1%") -> ListSingletonContainer
        __init__(ListSingletonContainer self, Model m, std::string name="ListSingletonContainer %1%") -> ListSingletonContainer
        __init__(ListSingletonContainer self, Model m, char const * name) -> ListSingletonContainer
        __init__(ListSingletonContainer self) -> ListSingletonContainer
        """
        _IMP_container.ListSingletonContainer_swiginit(self, _IMP_container.new_ListSingletonContainer(*args))

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

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

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

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(ListSingletonContainer self, SingletonModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.ListSingletonContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(ListSingletonContainer self) -> VersionInfo"""
        return _IMP_container.ListSingletonContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ListSingletonContainer

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(ListSingletonContainer self) -> PyObject *"""
        return _IMP_container.ListSingletonContainer__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ListSingletonContainer self, PyObject * p)"""
        return _IMP_container.ListSingletonContainer__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_static_contents(self):
        return self.get_contents()


# Register ListSingletonContainer in _IMP_container:
_IMP_container.ListSingletonContainer_swigregister(ListSingletonContainer)
class ListTripletContainer(IMP.TripletContainer):
    r"""Proxy of C++ IMP::container::ListTripletContainer class."""

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

    def __init__(self, *args):
        r"""
        __init__(ListTripletContainer self, Model m, IMP::ParticleIndexTriplets const & contents, std::string name="ListTripletContainer%1%") -> ListTripletContainer
        __init__(ListTripletContainer self, Model m, std::string name="ListTripletContainer %1%") -> ListTripletContainer
        __init__(ListTripletContainer self, Model m, char const * name) -> ListTripletContainer
        __init__(ListTripletContainer self) -> ListTripletContainer
        """
        _IMP_container.ListTripletContainer_swiginit(self, _IMP_container.new_ListTripletContainer(*args))

    def add(self, *args):
        r"""
        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):
        r"""set(ListTripletContainer self, IMP::ParticleIndexTriplets cp)"""
        return _IMP_container.ListTripletContainer_set(self, cp)

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

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(ListTripletContainer self, TripletModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.ListTripletContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(ListTripletContainer self) -> VersionInfo"""
        return _IMP_container.ListTripletContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_ListTripletContainer

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(ListTripletContainer self) -> PyObject *"""
        return _IMP_container.ListTripletContainer__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ListTripletContainer self, PyObject * p)"""
        return _IMP_container.ListTripletContainer__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ListTripletContainer in _IMP_container:
_IMP_container.ListTripletContainer_swigregister(ListTripletContainer)
class DynamicListPairContainer(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::DynamicListPairContainer class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")

    def add(self, *args):
        r"""
        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):
        r"""set(DynamicListPairContainer self, IMP::ParticleIndexPairs cp)"""
        return _IMP_container.DynamicListPairContainer_set(self, cp)

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

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(DynamicListPairContainer self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.DynamicListPairContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(DynamicListPairContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListPairContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_DynamicListPairContainer

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

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

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


# Register DynamicListPairContainer in _IMP_container:
_IMP_container.DynamicListPairContainer_swigregister(DynamicListPairContainer)
class DynamicListQuadContainer(IMP.QuadContainer):
    r"""Proxy of C++ IMP::container::DynamicListQuadContainer class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")

    def add(self, *args):
        r"""
        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):
        r"""set(DynamicListQuadContainer self, IMP::ParticleIndexQuads cp)"""
        return _IMP_container.DynamicListQuadContainer_set(self, cp)

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

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(DynamicListQuadContainer self, QuadModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.DynamicListQuadContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(DynamicListQuadContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListQuadContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_DynamicListQuadContainer

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

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

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


# Register DynamicListQuadContainer in _IMP_container:
_IMP_container.DynamicListQuadContainer_swigregister(DynamicListQuadContainer)
class DynamicListSingletonContainer(IMP.SingletonContainer):
    r"""Proxy of C++ IMP::container::DynamicListSingletonContainer class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")

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

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

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

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(DynamicListSingletonContainer self, SingletonModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.DynamicListSingletonContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(DynamicListSingletonContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListSingletonContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_DynamicListSingletonContainer

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

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

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


# Register DynamicListSingletonContainer in _IMP_container:
_IMP_container.DynamicListSingletonContainer_swigregister(DynamicListSingletonContainer)
class DynamicListTripletContainer(IMP.TripletContainer):
    r"""Proxy of C++ IMP::container::DynamicListTripletContainer class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")

    def add(self, *args):
        r"""
        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):
        r"""set(DynamicListTripletContainer self, IMP::ParticleIndexTriplets cp)"""
        return _IMP_container.DynamicListTripletContainer_set(self, cp)

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

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

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(DynamicListTripletContainer self, TripletModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.DynamicListTripletContainer_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(DynamicListTripletContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListTripletContainer_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_DynamicListTripletContainer

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

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

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


# Register DynamicListTripletContainer in _IMP_container:
_IMP_container.DynamicListTripletContainer_swigregister(DynamicListTripletContainer)
class MinimumPairRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::MinimumPairRestraint class."""

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

    def __init__(self, *args):
        r"""__init__(MinimumPairRestraint self, PairScore f, _PairContainerAdaptor c, unsigned int n=1, std::string name="MinimumPairRestraint %1%") -> MinimumPairRestraint"""
        _IMP_container.MinimumPairRestraint_swiginit(self, _IMP_container.new_MinimumPairRestraint(*args))

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

    def get_version_info(self):
        r"""get_version_info(MinimumPairRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumPairRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_MinimumPairRestraint

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

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

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

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

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


# Register MinimumPairRestraint in _IMP_container:
_IMP_container.MinimumPairRestraint_swigregister(MinimumPairRestraint)
class MinimumPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::container::MinimumPairScore class."""

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

    def __init__(self, *args):
        r"""__init__(MinimumPairScore self, IMP::PairScoresTemp const & scores, unsigned int n=1, std::string name="PairScore %1%") -> MinimumPairScore"""
        _IMP_container.MinimumPairScore_swiginit(self, _IMP_container.new_MinimumPairScore(*args))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(MinimumPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(MinimumPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(MinimumPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(MinimumPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(MinimumPairScore self) -> VersionInfo"""
        return _IMP_container.MinimumPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_MinimumPairScore

    def do_create_current_decomposition(self, m, vt):
        r"""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):
        r"""__str__(MinimumPairScore self) -> std::string"""
        return _IMP_container.MinimumPairScore___str__(self)

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

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


# Register MinimumPairScore in _IMP_container:
_IMP_container.MinimumPairScore_swigregister(MinimumPairScore)
class MinimumQuadRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::MinimumQuadRestraint class."""

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

    def __init__(self, *args):
        r"""__init__(MinimumQuadRestraint self, QuadScore f, _QuadContainerAdaptor c, unsigned int n=1, std::string name="MinimumQuadRestraint %1%") -> MinimumQuadRestraint"""
        _IMP_container.MinimumQuadRestraint_swiginit(self, _IMP_container.new_MinimumQuadRestraint(*args))

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

    def get_version_info(self):
        r"""get_version_info(MinimumQuadRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumQuadRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_MinimumQuadRestraint

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

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

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

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

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


# Register MinimumQuadRestraint in _IMP_container:
_IMP_container.MinimumQuadRestraint_swigregister(MinimumQuadRestraint)
class MinimumQuadScore(IMP.QuadScore):
    r"""Proxy of C++ IMP::container::MinimumQuadScore class."""

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

    def __init__(self, *args):
        r"""__init__(MinimumQuadScore self, IMP::QuadScoresTemp const & scores, unsigned int n=1, std::string name="QuadScore %1%") -> MinimumQuadScore"""
        _IMP_container.MinimumQuadScore_swiginit(self, _IMP_container.new_MinimumQuadScore(*args))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(MinimumQuadScore self, Model m, IMP::ParticleIndexQuads const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumQuadScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(MinimumQuadScore self, Model m, IMP::ParticleIndexQuads const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumQuadScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(MinimumQuadScore self, Model m, IMP::ParticleIndexQuads const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumQuadScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(MinimumQuadScore self, Model m, IMP::ParticleIndexQuads const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumQuadScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(MinimumQuadScore self) -> VersionInfo"""
        return _IMP_container.MinimumQuadScore_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_MinimumQuadScore

    def do_create_current_decomposition(self, m, vt):
        r"""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):
        r"""__str__(MinimumQuadScore self) -> std::string"""
        return _IMP_container.MinimumQuadScore___str__(self)

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

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


# Register MinimumQuadScore in _IMP_container:
_IMP_container.MinimumQuadScore_swigregister(MinimumQuadScore)
class MinimumSingletonRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::MinimumSingletonRestraint class."""

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

    def __init__(self, *args):
        r"""__init__(MinimumSingletonRestraint self, SingletonScore f, _SingletonContainerAdaptor c, unsigned int n=1, std::string name="MinimumSingletonRestraint %1%") -> MinimumSingletonRestraint"""
        _IMP_container.MinimumSingletonRestraint_swiginit(self, _IMP_container.new_MinimumSingletonRestraint(*args))

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

    def get_version_info(self):
        r"""get_version_info(MinimumSingletonRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumSingletonRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_MinimumSingletonRestraint

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

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

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

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

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


# Register MinimumSingletonRestraint in _IMP_container:
_IMP_container.MinimumSingletonRestraint_swigregister(MinimumSingletonRestraint)
class MinimumSingletonScore(IMP.SingletonScore):
    r"""Proxy of C++ IMP::container::MinimumSingletonScore class."""

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

    def __init__(self, *args):
        r"""__init__(MinimumSingletonScore self, IMP::SingletonScoresTemp const & scores, unsigned int n=1, std::string name="SingletonScore %1%") -> MinimumSingletonScore"""
        _IMP_container.MinimumSingletonScore_swiginit(self, _IMP_container.new_MinimumSingletonScore(*args))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(MinimumSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumSingletonScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(MinimumSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumSingletonScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(MinimumSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumSingletonScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(MinimumSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumSingletonScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(MinimumSingletonScore self) -> VersionInfo"""
        return _IMP_container.MinimumSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_MinimumSingletonScore

    def do_create_current_decomposition(self, m, vt):
        r"""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):
        r"""__str__(MinimumSingletonScore self) -> std::string"""
        return _IMP_container.MinimumSingletonScore___str__(self)

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

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


# Register MinimumSingletonScore in _IMP_container:
_IMP_container.MinimumSingletonScore_swigregister(MinimumSingletonScore)
class MinimumTripletRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::MinimumTripletRestraint class."""

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

    def __init__(self, *args):
        r"""__init__(MinimumTripletRestraint self, TripletScore f, _TripletContainerAdaptor c, unsigned int n=1, std::string name="MinimumTripletRestraint %1%") -> MinimumTripletRestraint"""
        _IMP_container.MinimumTripletRestraint_swiginit(self, _IMP_container.new_MinimumTripletRestraint(*args))

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

    def get_version_info(self):
        r"""get_version_info(MinimumTripletRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumTripletRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_MinimumTripletRestraint

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

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

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

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

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


# Register MinimumTripletRestraint in _IMP_container:
_IMP_container.MinimumTripletRestraint_swigregister(MinimumTripletRestraint)
class MinimumTripletScore(IMP.TripletScore):
    r"""Proxy of C++ IMP::container::MinimumTripletScore class."""

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

    def __init__(self, *args):
        r"""__init__(MinimumTripletScore self, IMP::TripletScoresTemp const & scores, unsigned int n=1, std::string name="TripletScore %1%") -> MinimumTripletScore"""
        _IMP_container.MinimumTripletScore_swiginit(self, _IMP_container.new_MinimumTripletScore(*args))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(MinimumTripletScore self, Model m, IMP::ParticleIndexTriplets const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumTripletScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(MinimumTripletScore self, Model m, IMP::ParticleIndexTriplets const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumTripletScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(MinimumTripletScore self, Model m, IMP::ParticleIndexTriplets const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumTripletScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(MinimumTripletScore self, Model m, IMP::ParticleIndexTriplets const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_container.MinimumTripletScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(MinimumTripletScore self) -> VersionInfo"""
        return _IMP_container.MinimumTripletScore_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_MinimumTripletScore

    def do_create_current_decomposition(self, m, vt):
        r"""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):
        r"""__str__(MinimumTripletScore self) -> std::string"""
        return _IMP_container.MinimumTripletScore___str__(self)

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

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


# Register MinimumTripletScore in _IMP_container:
_IMP_container.MinimumTripletScore_swigregister(MinimumTripletScore)
class PairContainerSet(IMP.PairContainer):
    r"""Proxy of C++ IMP::container::PairContainerSet class."""

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

    def __init__(self, *args):
        r"""
        __init__(PairContainerSet self, Model m, std::string name="PairContainerSet %1%") -> PairContainerSet
        __init__(PairContainerSet self, IMP::PairContainersTemp const & pc, std::string name="PairContainerSet %1%") -> PairContainerSet
        """
        _IMP_container.PairContainerSet_swiginit(self, _IMP_container.new_PairContainerSet(*args))

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(PairContainerSet self, PairModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.PairContainerSet_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(PairContainerSet self) -> VersionInfo"""
        return _IMP_container.PairContainerSet_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PairContainerSet
    def __get_pair_containers(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_pair_containers,  getfunc=self.get_pair_container, erasefunc=self.erase_pair_container,  appendfunc=self.add_pair_container, extendfunc=self.add_pair_containers,  clearfunc=self.clear_pair_containers, indexfunc=self._python_index_pair_container)  
    def __set_pair_containers(self, obj): IMP._list_util.set_varlist(self.pair_containers, obj)  
    def __del_pair_containers(self): IMP._list_util.del_varlist(self.pair_containers)       
    pair_containers = property(__get_pair_containers, __set_pair_containers, __del_pair_containers, doc="List of ##ucnames")  

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

    def _python_index_pair_container(self, d, start, stop):
        r"""_python_index_pair_container(PairContainerSet self, PairContainer d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_container.PairContainerSet__python_index_pair_container(self, d, start, stop)

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

    def set_pair_containers(self, ps):
        r"""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):
        r"""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):
        r"""add_pair_container(PairContainerSet self, PairContainer obj) -> unsigned int"""
        return _IMP_container.PairContainerSet_add_pair_container(self, obj)

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

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

    def get_number_of_pair_containers(self):
        r"""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):
        r"""get_has_pair_containers(PairContainerSet self) -> bool"""
        return _IMP_container.PairContainerSet_get_has_pair_containers(self)

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

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

    def erase_pair_container(self, i):
        r"""erase_pair_container(PairContainerSet self, unsigned int i)"""
        return _IMP_container.PairContainerSet_erase_pair_container(self, i)

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

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

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

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

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


# Register PairContainerSet in _IMP_container:
_IMP_container.PairContainerSet_swigregister(PairContainerSet)
class PairsConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::container::PairsConstraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(PairsConstraint self, PairModifier before, PairModifier after, _PairContainerAdaptor c, std::string name="PairsConstraint %1%") -> PairsConstraint
        __init__(PairsConstraint self) -> PairsConstraint
        """
        _IMP_container.PairsConstraint_swiginit(self, _IMP_container.new_PairsConstraint(*args))

    def get_before_modifier(self):
        r"""get_before_modifier(PairsConstraint self) -> PairModifier"""
        return _IMP_container.PairsConstraint_get_before_modifier(self)

    def get_container(self):
        r"""get_container(PairsConstraint self) -> PairContainer"""
        return _IMP_container.PairsConstraint_get_container(self)

    def get_version_info(self):
        r"""get_version_info(PairsConstraint self) -> VersionInfo"""
        return _IMP_container.PairsConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PairsConstraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(PairsConstraint self) -> PyObject *"""
        return _IMP_container.PairsConstraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PairsConstraint self, PyObject * p)"""
        return _IMP_container.PairsConstraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register PairsConstraint in _IMP_container:
_IMP_container.PairsConstraint_swigregister(PairsConstraint)
class PairsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::container::PairsOptimizerState class."""

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

    def __init__(self, *args):
        r"""__init__(PairsOptimizerState self, _PairContainerAdaptor c, PairModifier gf, std::string name="PairsOptimizerState %1%") -> PairsOptimizerState"""
        _IMP_container.PairsOptimizerState_swiginit(self, _IMP_container.new_PairsOptimizerState(*args))

    def do_update(self, call):
        r"""do_update(PairsOptimizerState self, unsigned int call)"""
        return _IMP_container.PairsOptimizerState_do_update(self, call)

    def get_version_info(self):
        r"""get_version_info(PairsOptimizerState self) -> VersionInfo"""
        return _IMP_container.PairsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PairsOptimizerState

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

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

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


# Register PairsOptimizerState in _IMP_container:
_IMP_container.PairsOptimizerState_swigregister(PairsOptimizerState)
class PairsRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::PairsRestraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(PairsRestraint self, PairScore ss, _PairContainerAdaptor pc, std::string name="PairsRestraint %1%") -> PairsRestraint
        __init__(PairsRestraint self) -> PairsRestraint
        """
        _IMP_container.PairsRestraint_swiginit(self, _IMP_container.new_PairsRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(PairsRestraint self) -> PairScore"""
        return _IMP_container.PairsRestraint_get_score_object(self)

    def get_container(self):
        r"""get_container(PairsRestraint self) -> PairContainer"""
        return _IMP_container.PairsRestraint_get_container(self)

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

    def get_version_info(self):
        r"""get_version_info(PairsRestraint self) -> VersionInfo"""
        return _IMP_container.PairsRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PairsRestraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(PairsRestraint self) -> PyObject *"""
        return _IMP_container.PairsRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PairsRestraint self, PyObject * p)"""
        return _IMP_container.PairsRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        from . import _jax_util
        return _jax_util._get_jax_container_restraint(self)


# Register PairsRestraint in _IMP_container:
_IMP_container.PairsRestraint_swigregister(PairsRestraint)
class QuadContainerSet(IMP.QuadContainer):
    r"""Proxy of C++ IMP::container::QuadContainerSet class."""

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

    def __init__(self, *args):
        r"""
        __init__(QuadContainerSet self, Model m, std::string name="QuadContainerSet %1%") -> QuadContainerSet
        __init__(QuadContainerSet self, IMP::QuadContainersTemp const & pc, std::string name="QuadContainerSet %1%") -> QuadContainerSet
        """
        _IMP_container.QuadContainerSet_swiginit(self, _IMP_container.new_QuadContainerSet(*args))

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(QuadContainerSet self, QuadModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.QuadContainerSet_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(QuadContainerSet self) -> VersionInfo"""
        return _IMP_container.QuadContainerSet_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_QuadContainerSet
    def __get_quad_containers(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_quad_containers,  getfunc=self.get_quad_container, erasefunc=self.erase_quad_container,  appendfunc=self.add_quad_container, extendfunc=self.add_quad_containers,  clearfunc=self.clear_quad_containers, indexfunc=self._python_index_quad_container)  
    def __set_quad_containers(self, obj): IMP._list_util.set_varlist(self.quad_containers, obj)  
    def __del_quad_containers(self): IMP._list_util.del_varlist(self.quad_containers)       
    quad_containers = property(__get_quad_containers, __set_quad_containers, __del_quad_containers, doc="List of ##ucnames")  

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

    def _python_index_quad_container(self, d, start, stop):
        r"""_python_index_quad_container(QuadContainerSet self, QuadContainer d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_container.QuadContainerSet__python_index_quad_container(self, d, start, stop)

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

    def set_quad_containers(self, ps):
        r"""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):
        r"""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):
        r"""add_quad_container(QuadContainerSet self, QuadContainer obj) -> unsigned int"""
        return _IMP_container.QuadContainerSet_add_quad_container(self, obj)

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

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

    def get_number_of_quad_containers(self):
        r"""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):
        r"""get_has_quad_containers(QuadContainerSet self) -> bool"""
        return _IMP_container.QuadContainerSet_get_has_quad_containers(self)

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

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

    def erase_quad_container(self, i):
        r"""erase_quad_container(QuadContainerSet self, unsigned int i)"""
        return _IMP_container.QuadContainerSet_erase_quad_container(self, i)

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

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

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

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

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


# Register QuadContainerSet in _IMP_container:
_IMP_container.QuadContainerSet_swigregister(QuadContainerSet)
class QuadsConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::container::QuadsConstraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(QuadsConstraint self, QuadModifier before, QuadModifier after, _QuadContainerAdaptor c, std::string name="QuadsConstraint %1%") -> QuadsConstraint
        __init__(QuadsConstraint self) -> QuadsConstraint
        """
        _IMP_container.QuadsConstraint_swiginit(self, _IMP_container.new_QuadsConstraint(*args))

    def get_before_modifier(self):
        r"""get_before_modifier(QuadsConstraint self) -> QuadModifier"""
        return _IMP_container.QuadsConstraint_get_before_modifier(self)

    def get_container(self):
        r"""get_container(QuadsConstraint self) -> QuadContainer"""
        return _IMP_container.QuadsConstraint_get_container(self)

    def get_version_info(self):
        r"""get_version_info(QuadsConstraint self) -> VersionInfo"""
        return _IMP_container.QuadsConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_QuadsConstraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(QuadsConstraint self) -> PyObject *"""
        return _IMP_container.QuadsConstraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(QuadsConstraint self, PyObject * p)"""
        return _IMP_container.QuadsConstraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register QuadsConstraint in _IMP_container:
_IMP_container.QuadsConstraint_swigregister(QuadsConstraint)
class QuadsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::container::QuadsOptimizerState class."""

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

    def __init__(self, *args):
        r"""__init__(QuadsOptimizerState self, _QuadContainerAdaptor c, QuadModifier gf, std::string name="QuadsOptimizerState %1%") -> QuadsOptimizerState"""
        _IMP_container.QuadsOptimizerState_swiginit(self, _IMP_container.new_QuadsOptimizerState(*args))

    def do_update(self, call):
        r"""do_update(QuadsOptimizerState self, unsigned int call)"""
        return _IMP_container.QuadsOptimizerState_do_update(self, call)

    def get_version_info(self):
        r"""get_version_info(QuadsOptimizerState self) -> VersionInfo"""
        return _IMP_container.QuadsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_QuadsOptimizerState

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

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

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


# Register QuadsOptimizerState in _IMP_container:
_IMP_container.QuadsOptimizerState_swigregister(QuadsOptimizerState)
class QuadsRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::QuadsRestraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(QuadsRestraint self, QuadScore ss, _QuadContainerAdaptor pc, std::string name="QuadsRestraint %1%") -> QuadsRestraint
        __init__(QuadsRestraint self) -> QuadsRestraint
        """
        _IMP_container.QuadsRestraint_swiginit(self, _IMP_container.new_QuadsRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(QuadsRestraint self) -> QuadScore"""
        return _IMP_container.QuadsRestraint_get_score_object(self)

    def get_container(self):
        r"""get_container(QuadsRestraint self) -> QuadContainer"""
        return _IMP_container.QuadsRestraint_get_container(self)

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

    def get_version_info(self):
        r"""get_version_info(QuadsRestraint self) -> VersionInfo"""
        return _IMP_container.QuadsRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_QuadsRestraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(QuadsRestraint self) -> PyObject *"""
        return _IMP_container.QuadsRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(QuadsRestraint self, PyObject * p)"""
        return _IMP_container.QuadsRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register QuadsRestraint in _IMP_container:
_IMP_container.QuadsRestraint_swigregister(QuadsRestraint)
class SingletonContainerSet(IMP.SingletonContainer):
    r"""Proxy of C++ IMP::container::SingletonContainerSet class."""

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

    def __init__(self, *args):
        r"""
        __init__(SingletonContainerSet self, Model m, std::string name="SingletonContainerSet %1%") -> SingletonContainerSet
        __init__(SingletonContainerSet self, IMP::SingletonContainersTemp const & pc, std::string name="SingletonContainerSet %1%") -> SingletonContainerSet
        """
        _IMP_container.SingletonContainerSet_swiginit(self, _IMP_container.new_SingletonContainerSet(*args))

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(SingletonContainerSet self, SingletonModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.SingletonContainerSet_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(SingletonContainerSet self) -> VersionInfo"""
        return _IMP_container.SingletonContainerSet_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_SingletonContainerSet
    def __get_singleton_containers(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_singleton_containers,  getfunc=self.get_singleton_container, erasefunc=self.erase_singleton_container,  appendfunc=self.add_singleton_container, extendfunc=self.add_singleton_containers,  clearfunc=self.clear_singleton_containers, indexfunc=self._python_index_singleton_container)  
    def __set_singleton_containers(self, obj): IMP._list_util.set_varlist(self.singleton_containers, obj)  
    def __del_singleton_containers(self): IMP._list_util.del_varlist(self.singleton_containers)       
    singleton_containers = property(__get_singleton_containers, __set_singleton_containers, __del_singleton_containers, doc="List of ##ucnames")  

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

    def _python_index_singleton_container(self, d, start, stop):
        r"""_python_index_singleton_container(SingletonContainerSet self, SingletonContainer d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_container.SingletonContainerSet__python_index_singleton_container(self, d, start, stop)

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

    def set_singleton_containers(self, ps):
        r"""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):
        r"""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):
        r"""add_singleton_container(SingletonContainerSet self, SingletonContainer obj) -> unsigned int"""
        return _IMP_container.SingletonContainerSet_add_singleton_container(self, obj)

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

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

    def get_number_of_singleton_containers(self):
        r"""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):
        r"""get_has_singleton_containers(SingletonContainerSet self) -> bool"""
        return _IMP_container.SingletonContainerSet_get_has_singleton_containers(self)

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

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

    def erase_singleton_container(self, i):
        r"""erase_singleton_container(SingletonContainerSet self, unsigned int i)"""
        return _IMP_container.SingletonContainerSet_erase_singleton_container(self, i)

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

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

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

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

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


# Register SingletonContainerSet in _IMP_container:
_IMP_container.SingletonContainerSet_swigregister(SingletonContainerSet)
class SingletonsConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::container::SingletonsConstraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(SingletonsConstraint self, SingletonModifier before, SingletonModifier after, _SingletonContainerAdaptor c, std::string name="SingletonsConstraint %1%") -> SingletonsConstraint
        __init__(SingletonsConstraint self) -> SingletonsConstraint
        """
        _IMP_container.SingletonsConstraint_swiginit(self, _IMP_container.new_SingletonsConstraint(*args))

    def get_before_modifier(self):
        r"""get_before_modifier(SingletonsConstraint self) -> SingletonModifier"""
        return _IMP_container.SingletonsConstraint_get_before_modifier(self)

    def get_container(self):
        r"""get_container(SingletonsConstraint self) -> SingletonContainer"""
        return _IMP_container.SingletonsConstraint_get_container(self)

    def get_version_info(self):
        r"""get_version_info(SingletonsConstraint self) -> VersionInfo"""
        return _IMP_container.SingletonsConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_SingletonsConstraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(SingletonsConstraint self) -> PyObject *"""
        return _IMP_container.SingletonsConstraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SingletonsConstraint self, PyObject * p)"""
        return _IMP_container.SingletonsConstraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        from . import _jax_util
        return _jax_util._get_jax_container_constraint(self)


# Register SingletonsConstraint in _IMP_container:
_IMP_container.SingletonsConstraint_swigregister(SingletonsConstraint)
class SingletonsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::container::SingletonsOptimizerState class."""

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

    def __init__(self, *args):
        r"""__init__(SingletonsOptimizerState self, _SingletonContainerAdaptor c, SingletonModifier gf, std::string name="SingletonsOptimizerState %1%") -> SingletonsOptimizerState"""
        _IMP_container.SingletonsOptimizerState_swiginit(self, _IMP_container.new_SingletonsOptimizerState(*args))

    def do_update(self, call):
        r"""do_update(SingletonsOptimizerState self, unsigned int call)"""
        return _IMP_container.SingletonsOptimizerState_do_update(self, call)

    def get_version_info(self):
        r"""get_version_info(SingletonsOptimizerState self) -> VersionInfo"""
        return _IMP_container.SingletonsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_SingletonsOptimizerState

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

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

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


# Register SingletonsOptimizerState in _IMP_container:
_IMP_container.SingletonsOptimizerState_swigregister(SingletonsOptimizerState)
class SingletonsRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::SingletonsRestraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(SingletonsRestraint self, SingletonScore ss, _SingletonContainerAdaptor pc, std::string name="SingletonsRestraint %1%") -> SingletonsRestraint
        __init__(SingletonsRestraint self) -> SingletonsRestraint
        """
        _IMP_container.SingletonsRestraint_swiginit(self, _IMP_container.new_SingletonsRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(SingletonsRestraint self) -> SingletonScore"""
        return _IMP_container.SingletonsRestraint_get_score_object(self)

    def get_container(self):
        r"""get_container(SingletonsRestraint self) -> SingletonContainer"""
        return _IMP_container.SingletonsRestraint_get_container(self)

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

    def get_version_info(self):
        r"""get_version_info(SingletonsRestraint self) -> VersionInfo"""
        return _IMP_container.SingletonsRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_SingletonsRestraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(SingletonsRestraint self) -> PyObject *"""
        return _IMP_container.SingletonsRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SingletonsRestraint self, PyObject * p)"""
        return _IMP_container.SingletonsRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        from . import _jax_util
        return _jax_util._get_jax_container_restraint(self)


# Register SingletonsRestraint in _IMP_container:
_IMP_container.SingletonsRestraint_swigregister(SingletonsRestraint)
class TripletContainerSet(IMP.TripletContainer):
    r"""Proxy of C++ IMP::container::TripletContainerSet class."""

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

    def __init__(self, *args):
        r"""
        __init__(TripletContainerSet self, Model m, std::string name="TripletContainerSet %1%") -> TripletContainerSet
        __init__(TripletContainerSet self, IMP::TripletContainersTemp const & pc, std::string name="TripletContainerSet %1%") -> TripletContainerSet
        """
        _IMP_container.TripletContainerSet_swiginit(self, _IMP_container.new_TripletContainerSet(*args))

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

    def do_apply_moved(self, sm, moved_pis, reset_pis):
        r"""do_apply_moved(TripletContainerSet self, TripletModifier sm, IMP::ParticleIndexes const & moved_pis, IMP::ParticleIndexes const & reset_pis)"""
        return _IMP_container.TripletContainerSet_do_apply_moved(self, sm, moved_pis, reset_pis)

    def get_version_info(self):
        r"""get_version_info(TripletContainerSet self) -> VersionInfo"""
        return _IMP_container.TripletContainerSet_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_TripletContainerSet
    def __get_triplet_containers(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_triplet_containers,  getfunc=self.get_triplet_container, erasefunc=self.erase_triplet_container,  appendfunc=self.add_triplet_container, extendfunc=self.add_triplet_containers,  clearfunc=self.clear_triplet_containers, indexfunc=self._python_index_triplet_container)  
    def __set_triplet_containers(self, obj): IMP._list_util.set_varlist(self.triplet_containers, obj)  
    def __del_triplet_containers(self): IMP._list_util.del_varlist(self.triplet_containers)       
    triplet_containers = property(__get_triplet_containers, __set_triplet_containers, __del_triplet_containers, doc="List of ##ucnames")  

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

    def _python_index_triplet_container(self, d, start, stop):
        r"""_python_index_triplet_container(TripletContainerSet self, TripletContainer d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_container.TripletContainerSet__python_index_triplet_container(self, d, start, stop)

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

    def set_triplet_containers(self, ps):
        r"""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):
        r"""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):
        r"""add_triplet_container(TripletContainerSet self, TripletContainer obj) -> unsigned int"""
        return _IMP_container.TripletContainerSet_add_triplet_container(self, obj)

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

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

    def get_number_of_triplet_containers(self):
        r"""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):
        r"""get_has_triplet_containers(TripletContainerSet self) -> bool"""
        return _IMP_container.TripletContainerSet_get_has_triplet_containers(self)

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

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

    def erase_triplet_container(self, i):
        r"""erase_triplet_container(TripletContainerSet self, unsigned int i)"""
        return _IMP_container.TripletContainerSet_erase_triplet_container(self, i)

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

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

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

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

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


# Register TripletContainerSet in _IMP_container:
_IMP_container.TripletContainerSet_swigregister(TripletContainerSet)
class TripletsConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::container::TripletsConstraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(TripletsConstraint self, TripletModifier before, TripletModifier after, _TripletContainerAdaptor c, std::string name="TripletsConstraint %1%") -> TripletsConstraint
        __init__(TripletsConstraint self) -> TripletsConstraint
        """
        _IMP_container.TripletsConstraint_swiginit(self, _IMP_container.new_TripletsConstraint(*args))

    def get_before_modifier(self):
        r"""get_before_modifier(TripletsConstraint self) -> TripletModifier"""
        return _IMP_container.TripletsConstraint_get_before_modifier(self)

    def get_container(self):
        r"""get_container(TripletsConstraint self) -> TripletContainer"""
        return _IMP_container.TripletsConstraint_get_container(self)

    def get_version_info(self):
        r"""get_version_info(TripletsConstraint self) -> VersionInfo"""
        return _IMP_container.TripletsConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_TripletsConstraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(TripletsConstraint self) -> PyObject *"""
        return _IMP_container.TripletsConstraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(TripletsConstraint self, PyObject * p)"""
        return _IMP_container.TripletsConstraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register TripletsConstraint in _IMP_container:
_IMP_container.TripletsConstraint_swigregister(TripletsConstraint)
class TripletsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::container::TripletsOptimizerState class."""

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

    def __init__(self, *args):
        r"""__init__(TripletsOptimizerState self, _TripletContainerAdaptor c, TripletModifier gf, std::string name="TripletsOptimizerState %1%") -> TripletsOptimizerState"""
        _IMP_container.TripletsOptimizerState_swiginit(self, _IMP_container.new_TripletsOptimizerState(*args))

    def do_update(self, call):
        r"""do_update(TripletsOptimizerState self, unsigned int call)"""
        return _IMP_container.TripletsOptimizerState_do_update(self, call)

    def get_version_info(self):
        r"""get_version_info(TripletsOptimizerState self) -> VersionInfo"""
        return _IMP_container.TripletsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_TripletsOptimizerState

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

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

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


# Register TripletsOptimizerState in _IMP_container:
_IMP_container.TripletsOptimizerState_swigregister(TripletsOptimizerState)
class TripletsRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::TripletsRestraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(TripletsRestraint self, TripletScore ss, _TripletContainerAdaptor pc, std::string name="TripletsRestraint %1%") -> TripletsRestraint
        __init__(TripletsRestraint self) -> TripletsRestraint
        """
        _IMP_container.TripletsRestraint_swiginit(self, _IMP_container.new_TripletsRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(TripletsRestraint self) -> TripletScore"""
        return _IMP_container.TripletsRestraint_get_score_object(self)

    def get_container(self):
        r"""get_container(TripletsRestraint self) -> TripletContainer"""
        return _IMP_container.TripletsRestraint_get_container(self)

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

    def get_version_info(self):
        r"""get_version_info(TripletsRestraint self) -> VersionInfo"""
        return _IMP_container.TripletsRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_TripletsRestraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(TripletsRestraint self) -> PyObject *"""
        return _IMP_container.TripletsRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(TripletsRestraint self, PyObject * p)"""
        return _IMP_container.TripletsRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register TripletsRestraint in _IMP_container:
_IMP_container.TripletsRestraint_swigregister(TripletsRestraint)
class InContainerSingletonFilter(IMP.SingletonPredicate):
    r"""Proxy of C++ IMP::container::InContainerSingletonFilter class."""

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

    def __init__(self, *args):
        r"""
        __init__(InContainerSingletonFilter self, SingletonContainer c, std::string name="SingletonFilter %1%") -> InContainerSingletonFilter
        __init__(InContainerSingletonFilter self, SingletonContainer c, bool handle_permutations, std::string name="SingletonFilter %1%") -> InContainerSingletonFilter
        """
        _IMP_container.InContainerSingletonFilter_swiginit(self, _IMP_container.new_InContainerSingletonFilter(*args))

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(InContainerSingletonFilter self) -> VersionInfo"""
        return _IMP_container.InContainerSingletonFilter_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_InContainerSingletonFilter

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

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

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


# Register InContainerSingletonFilter in _IMP_container:
_IMP_container.InContainerSingletonFilter_swigregister(InContainerSingletonFilter)
class InContainerPairFilter(IMP.PairPredicate):
    r"""Proxy of C++ IMP::container::InContainerPairFilter class."""

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

    def __init__(self, *args):
        r"""
        __init__(InContainerPairFilter self, PairContainer c, std::string name="PairFilter %1%") -> InContainerPairFilter
        __init__(InContainerPairFilter self, PairContainer c, bool handle_permutations, std::string name="PairFilter %1%") -> InContainerPairFilter
        """
        _IMP_container.InContainerPairFilter_swiginit(self, _IMP_container.new_InContainerPairFilter(*args))

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(InContainerPairFilter self) -> VersionInfo"""
        return _IMP_container.InContainerPairFilter_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_InContainerPairFilter

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

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

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


# Register InContainerPairFilter in _IMP_container:
_IMP_container.InContainerPairFilter_swigregister(InContainerPairFilter)
class InContainerTripletFilter(IMP.TripletPredicate):
    r"""Proxy of C++ IMP::container::InContainerTripletFilter class."""

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

    def __init__(self, *args):
        r"""
        __init__(InContainerTripletFilter self, TripletContainer c, std::string name="TripletFilter %1%") -> InContainerTripletFilter
        __init__(InContainerTripletFilter self, TripletContainer c, bool handle_permutations, std::string name="TripletFilter %1%") -> InContainerTripletFilter
        """
        _IMP_container.InContainerTripletFilter_swiginit(self, _IMP_container.new_InContainerTripletFilter(*args))

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(InContainerTripletFilter self) -> VersionInfo"""
        return _IMP_container.InContainerTripletFilter_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_InContainerTripletFilter

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

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

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


# Register InContainerTripletFilter in _IMP_container:
_IMP_container.InContainerTripletFilter_swigregister(InContainerTripletFilter)
class InContainerQuadFilter(IMP.QuadPredicate):
    r"""Proxy of C++ IMP::container::InContainerQuadFilter class."""

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

    def __init__(self, *args):
        r"""
        __init__(InContainerQuadFilter self, QuadContainer c, std::string name="QuadFilter %1%") -> InContainerQuadFilter
        __init__(InContainerQuadFilter self, QuadContainer c, bool handle_permutations, std::string name="QuadFilter %1%") -> InContainerQuadFilter
        """
        _IMP_container.InContainerQuadFilter_swiginit(self, _IMP_container.new_InContainerQuadFilter(*args))

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(InContainerQuadFilter self) -> VersionInfo"""
        return _IMP_container.InContainerQuadFilter_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_InContainerQuadFilter

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

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

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


# Register InContainerQuadFilter in _IMP_container:
_IMP_container.InContainerQuadFilter_swigregister(InContainerQuadFilter)
class SingletonContainerStatistics(IMP.ScoreState):
    r"""Proxy of C++ IMP::container::SingletonContainerStatistics class."""

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

    def __init__(self, c):
        r"""__init__(SingletonContainerStatistics self, _SingletonContainerAdaptor c) -> SingletonContainerStatistics"""
        _IMP_container.SingletonContainerStatistics_swiginit(self, _IMP_container.new_SingletonContainerStatistics(c))

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

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(SingletonContainerStatistics self) -> VersionInfo"""
        return _IMP_container.SingletonContainerStatistics_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_SingletonContainerStatistics

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

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

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


# Register SingletonContainerStatistics in _IMP_container:
_IMP_container.SingletonContainerStatistics_swigregister(SingletonContainerStatistics)
class PairContainerStatistics(IMP.ScoreState):
    r"""Proxy of C++ IMP::container::PairContainerStatistics class."""

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

    def __init__(self, c):
        r"""__init__(PairContainerStatistics self, _PairContainerAdaptor c) -> PairContainerStatistics"""
        _IMP_container.PairContainerStatistics_swiginit(self, _IMP_container.new_PairContainerStatistics(c))

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

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(PairContainerStatistics self) -> VersionInfo"""
        return _IMP_container.PairContainerStatistics_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PairContainerStatistics

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

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

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


# Register PairContainerStatistics in _IMP_container:
_IMP_container.PairContainerStatistics_swigregister(PairContainerStatistics)
class TripletContainerStatistics(IMP.ScoreState):
    r"""Proxy of C++ IMP::container::TripletContainerStatistics class."""

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

    def __init__(self, c):
        r"""__init__(TripletContainerStatistics self, _TripletContainerAdaptor c) -> TripletContainerStatistics"""
        _IMP_container.TripletContainerStatistics_swiginit(self, _IMP_container.new_TripletContainerStatistics(c))

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

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(TripletContainerStatistics self) -> VersionInfo"""
        return _IMP_container.TripletContainerStatistics_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_TripletContainerStatistics

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

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

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


# Register TripletContainerStatistics in _IMP_container:
_IMP_container.TripletContainerStatistics_swigregister(TripletContainerStatistics)
class QuadContainerStatistics(IMP.ScoreState):
    r"""Proxy of C++ IMP::container::QuadContainerStatistics class."""

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

    def __init__(self, c):
        r"""__init__(QuadContainerStatistics self, _QuadContainerAdaptor c) -> QuadContainerStatistics"""
        _IMP_container.QuadContainerStatistics_swiginit(self, _IMP_container.new_QuadContainerStatistics(c))

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

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(QuadContainerStatistics self) -> VersionInfo"""
        return _IMP_container.QuadContainerStatistics_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_QuadContainerStatistics

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

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

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


# Register QuadContainerStatistics in _IMP_container:
_IMP_container.QuadContainerStatistics_swigregister(QuadContainerStatistics)
class EventSingletonsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::container::EventSingletonsOptimizerState class."""

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

    def __init__(self, *args):
        r"""__init__(EventSingletonsOptimizerState self, SingletonPredicate pred, _SingletonContainerAdaptor container, int value, int min_count, int max_count, std::string name="ConstSingletonPredicate%1%") -> EventSingletonsOptimizerState"""
        _IMP_container.EventSingletonsOptimizerState_swiginit(self, _IMP_container.new_EventSingletonsOptimizerState(*args))

    def do_update(self, call):
        r"""do_update(EventSingletonsOptimizerState self, unsigned int call)"""
        return _IMP_container.EventSingletonsOptimizerState_do_update(self, call)

    def get_version_info(self):
        r"""get_version_info(EventSingletonsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventSingletonsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_EventSingletonsOptimizerState

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

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

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


# Register EventSingletonsOptimizerState in _IMP_container:
_IMP_container.EventSingletonsOptimizerState_swigregister(EventSingletonsOptimizerState)
class EventPairsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::container::EventPairsOptimizerState class."""

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

    def __init__(self, *args):
        r"""__init__(EventPairsOptimizerState self, PairPredicate pred, _PairContainerAdaptor container, int value, int min_count, int max_count, std::string name="ConstPairPredicate%1%") -> EventPairsOptimizerState"""
        _IMP_container.EventPairsOptimizerState_swiginit(self, _IMP_container.new_EventPairsOptimizerState(*args))

    def do_update(self, call):
        r"""do_update(EventPairsOptimizerState self, unsigned int call)"""
        return _IMP_container.EventPairsOptimizerState_do_update(self, call)

    def get_version_info(self):
        r"""get_version_info(EventPairsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventPairsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_EventPairsOptimizerState

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

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

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


# Register EventPairsOptimizerState in _IMP_container:
_IMP_container.EventPairsOptimizerState_swigregister(EventPairsOptimizerState)
class EventTripletsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::container::EventTripletsOptimizerState class."""

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

    def __init__(self, *args):
        r"""__init__(EventTripletsOptimizerState self, TripletPredicate pred, _TripletContainerAdaptor container, int value, int min_count, int max_count, std::string name="ConstTripletPredicate%1%") -> EventTripletsOptimizerState"""
        _IMP_container.EventTripletsOptimizerState_swiginit(self, _IMP_container.new_EventTripletsOptimizerState(*args))

    def do_update(self, call):
        r"""do_update(EventTripletsOptimizerState self, unsigned int call)"""
        return _IMP_container.EventTripletsOptimizerState_do_update(self, call)

    def get_version_info(self):
        r"""get_version_info(EventTripletsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventTripletsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_EventTripletsOptimizerState

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

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

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


# Register EventTripletsOptimizerState in _IMP_container:
_IMP_container.EventTripletsOptimizerState_swigregister(EventTripletsOptimizerState)
class EventQuadsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::container::EventQuadsOptimizerState class."""

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

    def __init__(self, *args):
        r"""__init__(EventQuadsOptimizerState self, QuadPredicate pred, _QuadContainerAdaptor container, int value, int min_count, int max_count, std::string name="ConstQuadPredicate%1%") -> EventQuadsOptimizerState"""
        _IMP_container.EventQuadsOptimizerState_swiginit(self, _IMP_container.new_EventQuadsOptimizerState(*args))

    def do_update(self, call):
        r"""do_update(EventQuadsOptimizerState self, unsigned int call)"""
        return _IMP_container.EventQuadsOptimizerState_do_update(self, call)

    def get_version_info(self):
        r"""get_version_info(EventQuadsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventQuadsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_EventQuadsOptimizerState

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

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

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


# Register EventQuadsOptimizerState in _IMP_container:
_IMP_container.EventQuadsOptimizerState_swigregister(EventQuadsOptimizerState)
class PredicateSingletonsRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::PredicateSingletonsRestraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(PredicateSingletonsRestraint self, SingletonPredicate pred, _SingletonContainerAdaptor input, std::string name="PredicateSingletonsRestraint %1%") -> PredicateSingletonsRestraint
        __init__(PredicateSingletonsRestraint self) -> PredicateSingletonsRestraint
        """
        _IMP_container.PredicateSingletonsRestraint_swiginit(self, _IMP_container.new_PredicateSingletonsRestraint(*args))

    def set_score(self, predicate_value, score):
        r"""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):
        r"""set_unknown_score(PredicateSingletonsRestraint self, SingletonScore score)"""
        return _IMP_container.PredicateSingletonsRestraint_set_unknown_score(self, score)

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

    def get_indexes(self, predicate_value):
        r"""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):
        r"""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):
        r"""do_get_inputs(PredicateSingletonsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PredicateSingletonsRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(PredicateSingletonsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateSingletonsRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PredicateSingletonsRestraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(PredicateSingletonsRestraint self) -> PyObject *"""
        return _IMP_container.PredicateSingletonsRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PredicateSingletonsRestraint self, PyObject * p)"""
        return _IMP_container.PredicateSingletonsRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register PredicateSingletonsRestraint in _IMP_container:
_IMP_container.PredicateSingletonsRestraint_swigregister(PredicateSingletonsRestraint)
class PredicatePairsRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::PredicatePairsRestraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(PredicatePairsRestraint self, PairPredicate pred, _PairContainerAdaptor input, std::string name="PredicatePairsRestraint %1%") -> PredicatePairsRestraint
        __init__(PredicatePairsRestraint self) -> PredicatePairsRestraint
        """
        _IMP_container.PredicatePairsRestraint_swiginit(self, _IMP_container.new_PredicatePairsRestraint(*args))

    def set_score(self, predicate_value, score):
        r"""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):
        r"""set_unknown_score(PredicatePairsRestraint self, PairScore score)"""
        return _IMP_container.PredicatePairsRestraint_set_unknown_score(self, score)

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

    def get_indexes(self, predicate_value):
        r"""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):
        r"""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):
        r"""do_get_inputs(PredicatePairsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PredicatePairsRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(PredicatePairsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicatePairsRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PredicatePairsRestraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(PredicatePairsRestraint self) -> PyObject *"""
        return _IMP_container.PredicatePairsRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PredicatePairsRestraint self, PyObject * p)"""
        return _IMP_container.PredicatePairsRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register PredicatePairsRestraint in _IMP_container:
_IMP_container.PredicatePairsRestraint_swigregister(PredicatePairsRestraint)
class PredicateTripletsRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::PredicateTripletsRestraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(PredicateTripletsRestraint self, TripletPredicate pred, _TripletContainerAdaptor input, std::string name="PredicateTripletsRestraint %1%") -> PredicateTripletsRestraint
        __init__(PredicateTripletsRestraint self) -> PredicateTripletsRestraint
        """
        _IMP_container.PredicateTripletsRestraint_swiginit(self, _IMP_container.new_PredicateTripletsRestraint(*args))

    def set_score(self, predicate_value, score):
        r"""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):
        r"""set_unknown_score(PredicateTripletsRestraint self, TripletScore score)"""
        return _IMP_container.PredicateTripletsRestraint_set_unknown_score(self, score)

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

    def get_indexes(self, predicate_value):
        r"""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):
        r"""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):
        r"""do_get_inputs(PredicateTripletsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PredicateTripletsRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(PredicateTripletsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateTripletsRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PredicateTripletsRestraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(PredicateTripletsRestraint self) -> PyObject *"""
        return _IMP_container.PredicateTripletsRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PredicateTripletsRestraint self, PyObject * p)"""
        return _IMP_container.PredicateTripletsRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register PredicateTripletsRestraint in _IMP_container:
_IMP_container.PredicateTripletsRestraint_swigregister(PredicateTripletsRestraint)
class PredicateQuadsRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::container::PredicateQuadsRestraint class."""

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

    def __init__(self, *args):
        r"""
        __init__(PredicateQuadsRestraint self, QuadPredicate pred, _QuadContainerAdaptor input, std::string name="PredicateQuadsRestraint %1%") -> PredicateQuadsRestraint
        __init__(PredicateQuadsRestraint self) -> PredicateQuadsRestraint
        """
        _IMP_container.PredicateQuadsRestraint_swiginit(self, _IMP_container.new_PredicateQuadsRestraint(*args))

    def set_score(self, predicate_value, score):
        r"""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):
        r"""set_unknown_score(PredicateQuadsRestraint self, QuadScore score)"""
        return _IMP_container.PredicateQuadsRestraint_set_unknown_score(self, score)

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

    def get_indexes(self, predicate_value):
        r"""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):
        r"""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):
        r"""do_get_inputs(PredicateQuadsRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_container.PredicateQuadsRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(PredicateQuadsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateQuadsRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_PredicateQuadsRestraint

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(PredicateQuadsRestraint self) -> PyObject *"""
        return _IMP_container.PredicateQuadsRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PredicateQuadsRestraint self, PyObject * p)"""
        return _IMP_container.PredicateQuadsRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register PredicateQuadsRestraint in _IMP_container:
_IMP_container.PredicateQuadsRestraint_swigregister(PredicateQuadsRestraint)
class DistributeSingletonsScoreState(IMP.ScoreState):
    r"""Proxy of C++ IMP::container::DistributeSingletonsScoreState class."""

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

    def __init__(self, *args):
        r"""__init__(DistributeSingletonsScoreState self, _SingletonContainerAdaptor input, std::string name="DistributeSingletonsScoreState %1%") -> DistributeSingletonsScoreState"""
        _IMP_container.DistributeSingletonsScoreState_swiginit(self, _IMP_container.new_DistributeSingletonsScoreState(*args))

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(DistributeSingletonsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeSingletonsScoreState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_DistributeSingletonsScoreState

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

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

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


# Register DistributeSingletonsScoreState in _IMP_container:
_IMP_container.DistributeSingletonsScoreState_swigregister(DistributeSingletonsScoreState)
class DistributePairsScoreState(IMP.ScoreState):
    r"""Proxy of C++ IMP::container::DistributePairsScoreState class."""

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

    def __init__(self, *args):
        r"""__init__(DistributePairsScoreState self, _PairContainerAdaptor input, std::string name="DistributePairsScoreState %1%") -> DistributePairsScoreState"""
        _IMP_container.DistributePairsScoreState_swiginit(self, _IMP_container.new_DistributePairsScoreState(*args))

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(DistributePairsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributePairsScoreState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_DistributePairsScoreState

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

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

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


# Register DistributePairsScoreState in _IMP_container:
_IMP_container.DistributePairsScoreState_swigregister(DistributePairsScoreState)
class DistributeTripletsScoreState(IMP.ScoreState):
    r"""Proxy of C++ IMP::container::DistributeTripletsScoreState class."""

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

    def __init__(self, *args):
        r"""__init__(DistributeTripletsScoreState self, _TripletContainerAdaptor input, std::string name="DistributeTripletsScoreState %1%") -> DistributeTripletsScoreState"""
        _IMP_container.DistributeTripletsScoreState_swiginit(self, _IMP_container.new_DistributeTripletsScoreState(*args))

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(DistributeTripletsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeTripletsScoreState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_DistributeTripletsScoreState

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

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

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


# Register DistributeTripletsScoreState in _IMP_container:
_IMP_container.DistributeTripletsScoreState_swigregister(DistributeTripletsScoreState)
class DistributeQuadsScoreState(IMP.ScoreState):
    r"""Proxy of C++ IMP::container::DistributeQuadsScoreState class."""

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

    def __init__(self, *args):
        r"""__init__(DistributeQuadsScoreState self, _QuadContainerAdaptor input, std::string name="DistributeQuadsScoreState %1%") -> DistributeQuadsScoreState"""
        _IMP_container.DistributeQuadsScoreState_swiginit(self, _IMP_container.new_DistributeQuadsScoreState(*args))

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(DistributeQuadsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeQuadsScoreState_get_version_info(self)
    __swig_destroy__ = _IMP_container.delete_DistributeQuadsScoreState

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

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

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


# Register DistributeQuadsScoreState in _IMP_container:
_IMP_container.DistributeQuadsScoreState_swigregister(DistributeQuadsScoreState)

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

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

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

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

def get_data_path(fname):
    r"""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()