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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _coot
else:
    import _coot

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "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


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


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


class SwigPyIterator(object):
    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__ = _coot.delete_SwigPyIterator

    def value(self):
        return _coot.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _coot.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _coot.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _coot.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _coot.SwigPyIterator_equal(self, x)

    def copy(self):
        return _coot.SwigPyIterator_copy(self)

    def next(self):
        return _coot.SwigPyIterator_next(self)

    def __next__(self):
        return _coot.SwigPyIterator___next__(self)

    def previous(self):
        return _coot.SwigPyIterator_previous(self)

    def advance(self, n):
        return _coot.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _coot.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _coot.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _coot.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _coot.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _coot.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _coot.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _coot:
_coot.SwigPyIterator_swigregister(SwigPyIterator)
class vector_string(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _coot.vector_string_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _coot.vector_string___nonzero__(self)

    def __bool__(self):
        return _coot.vector_string___bool__(self)

    def __len__(self):
        return _coot.vector_string___len__(self)

    def __getslice__(self, i, j):
        return _coot.vector_string___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _coot.vector_string___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _coot.vector_string___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _coot.vector_string___delitem__(self, *args)

    def __getitem__(self, *args):
        return _coot.vector_string___getitem__(self, *args)

    def __setitem__(self, *args):
        return _coot.vector_string___setitem__(self, *args)

    def pop(self):
        return _coot.vector_string_pop(self)

    def append(self, x):
        return _coot.vector_string_append(self, x)

    def empty(self):
        return _coot.vector_string_empty(self)

    def size(self):
        return _coot.vector_string_size(self)

    def swap(self, v):
        return _coot.vector_string_swap(self, v)

    def begin(self):
        return _coot.vector_string_begin(self)

    def end(self):
        return _coot.vector_string_end(self)

    def rbegin(self):
        return _coot.vector_string_rbegin(self)

    def rend(self):
        return _coot.vector_string_rend(self)

    def clear(self):
        return _coot.vector_string_clear(self)

    def get_allocator(self):
        return _coot.vector_string_get_allocator(self)

    def pop_back(self):
        return _coot.vector_string_pop_back(self)

    def erase(self, *args):
        return _coot.vector_string_erase(self, *args)

    def __init__(self, *args):
        _coot.vector_string_swiginit(self, _coot.new_vector_string(*args))

    def push_back(self, x):
        return _coot.vector_string_push_back(self, x)

    def front(self):
        return _coot.vector_string_front(self)

    def back(self):
        return _coot.vector_string_back(self)

    def assign(self, n, x):
        return _coot.vector_string_assign(self, n, x)

    def resize(self, *args):
        return _coot.vector_string_resize(self, *args)

    def insert(self, *args):
        return _coot.vector_string_insert(self, *args)

    def reserve(self, n):
        return _coot.vector_string_reserve(self, n)

    def capacity(self):
        return _coot.vector_string_capacity(self)
    __swig_destroy__ = _coot.delete_vector_string

# Register vector_string in _coot:
_coot.vector_string_swigregister(vector_string)
class pairbf(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _coot.pairbf_swiginit(self, _coot.new_pairbf(*args))
    first = property(_coot.pairbf_first_get, _coot.pairbf_first_set)
    second = property(_coot.pairbf_second_get, _coot.pairbf_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _coot.delete_pairbf

# Register pairbf in _coot:
_coot.pairbf_swigregister(pairbf)
class IntVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _coot.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _coot.IntVector___nonzero__(self)

    def __bool__(self):
        return _coot.IntVector___bool__(self)

    def __len__(self):
        return _coot.IntVector___len__(self)

    def __getslice__(self, i, j):
        return _coot.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _coot.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _coot.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _coot.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _coot.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _coot.IntVector___setitem__(self, *args)

    def pop(self):
        return _coot.IntVector_pop(self)

    def append(self, x):
        return _coot.IntVector_append(self, x)

    def empty(self):
        return _coot.IntVector_empty(self)

    def size(self):
        return _coot.IntVector_size(self)

    def swap(self, v):
        return _coot.IntVector_swap(self, v)

    def begin(self):
        return _coot.IntVector_begin(self)

    def end(self):
        return _coot.IntVector_end(self)

    def rbegin(self):
        return _coot.IntVector_rbegin(self)

    def rend(self):
        return _coot.IntVector_rend(self)

    def clear(self):
        return _coot.IntVector_clear(self)

    def get_allocator(self):
        return _coot.IntVector_get_allocator(self)

    def pop_back(self):
        return _coot.IntVector_pop_back(self)

    def erase(self, *args):
        return _coot.IntVector_erase(self, *args)

    def __init__(self, *args):
        _coot.IntVector_swiginit(self, _coot.new_IntVector(*args))

    def push_back(self, x):
        return _coot.IntVector_push_back(self, x)

    def front(self):
        return _coot.IntVector_front(self)

    def back(self):
        return _coot.IntVector_back(self)

    def assign(self, n, x):
        return _coot.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _coot.IntVector_resize(self, *args)

    def insert(self, *args):
        return _coot.IntVector_insert(self, *args)

    def reserve(self, n):
        return _coot.IntVector_reserve(self, n)

    def capacity(self):
        return _coot.IntVector_capacity(self)
    __swig_destroy__ = _coot.delete_IntVector

# Register IntVector in _coot:
_coot.IntVector_swigregister(IntVector)
class vector_atom_spec(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _coot.vector_atom_spec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _coot.vector_atom_spec___nonzero__(self)

    def __bool__(self):
        return _coot.vector_atom_spec___bool__(self)

    def __len__(self):
        return _coot.vector_atom_spec___len__(self)

    def __getslice__(self, i, j):
        return _coot.vector_atom_spec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _coot.vector_atom_spec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _coot.vector_atom_spec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _coot.vector_atom_spec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _coot.vector_atom_spec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _coot.vector_atom_spec___setitem__(self, *args)

    def pop(self):
        return _coot.vector_atom_spec_pop(self)

    def append(self, x):
        return _coot.vector_atom_spec_append(self, x)

    def empty(self):
        return _coot.vector_atom_spec_empty(self)

    def size(self):
        return _coot.vector_atom_spec_size(self)

    def swap(self, v):
        return _coot.vector_atom_spec_swap(self, v)

    def begin(self):
        return _coot.vector_atom_spec_begin(self)

    def end(self):
        return _coot.vector_atom_spec_end(self)

    def rbegin(self):
        return _coot.vector_atom_spec_rbegin(self)

    def rend(self):
        return _coot.vector_atom_spec_rend(self)

    def clear(self):
        return _coot.vector_atom_spec_clear(self)

    def get_allocator(self):
        return _coot.vector_atom_spec_get_allocator(self)

    def pop_back(self):
        return _coot.vector_atom_spec_pop_back(self)

    def erase(self, *args):
        return _coot.vector_atom_spec_erase(self, *args)

    def __init__(self, *args):
        _coot.vector_atom_spec_swiginit(self, _coot.new_vector_atom_spec(*args))

    def push_back(self, x):
        return _coot.vector_atom_spec_push_back(self, x)

    def front(self):
        return _coot.vector_atom_spec_front(self)

    def back(self):
        return _coot.vector_atom_spec_back(self)

    def assign(self, n, x):
        return _coot.vector_atom_spec_assign(self, n, x)

    def resize(self, *args):
        return _coot.vector_atom_spec_resize(self, *args)

    def insert(self, *args):
        return _coot.vector_atom_spec_insert(self, *args)

    def reserve(self, n):
        return _coot.vector_atom_spec_reserve(self, n)

    def capacity(self):
        return _coot.vector_atom_spec_capacity(self)
    __swig_destroy__ = _coot.delete_vector_atom_spec

# Register vector_atom_spec in _coot:
_coot.vector_atom_spec_swigregister(vector_atom_spec)
class vector_mtz_type_label(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _coot.vector_mtz_type_label_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _coot.vector_mtz_type_label___nonzero__(self)

    def __bool__(self):
        return _coot.vector_mtz_type_label___bool__(self)

    def __len__(self):
        return _coot.vector_mtz_type_label___len__(self)

    def __getslice__(self, i, j):
        return _coot.vector_mtz_type_label___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _coot.vector_mtz_type_label___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _coot.vector_mtz_type_label___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _coot.vector_mtz_type_label___delitem__(self, *args)

    def __getitem__(self, *args):
        return _coot.vector_mtz_type_label___getitem__(self, *args)

    def __setitem__(self, *args):
        return _coot.vector_mtz_type_label___setitem__(self, *args)

    def pop(self):
        return _coot.vector_mtz_type_label_pop(self)

    def append(self, x):
        return _coot.vector_mtz_type_label_append(self, x)

    def empty(self):
        return _coot.vector_mtz_type_label_empty(self)

    def size(self):
        return _coot.vector_mtz_type_label_size(self)

    def swap(self, v):
        return _coot.vector_mtz_type_label_swap(self, v)

    def begin(self):
        return _coot.vector_mtz_type_label_begin(self)

    def end(self):
        return _coot.vector_mtz_type_label_end(self)

    def rbegin(self):
        return _coot.vector_mtz_type_label_rbegin(self)

    def rend(self):
        return _coot.vector_mtz_type_label_rend(self)

    def clear(self):
        return _coot.vector_mtz_type_label_clear(self)

    def get_allocator(self):
        return _coot.vector_mtz_type_label_get_allocator(self)

    def pop_back(self):
        return _coot.vector_mtz_type_label_pop_back(self)

    def erase(self, *args):
        return _coot.vector_mtz_type_label_erase(self, *args)

    def __init__(self, *args):
        _coot.vector_mtz_type_label_swiginit(self, _coot.new_vector_mtz_type_label(*args))

    def push_back(self, x):
        return _coot.vector_mtz_type_label_push_back(self, x)

    def front(self):
        return _coot.vector_mtz_type_label_front(self)

    def back(self):
        return _coot.vector_mtz_type_label_back(self)

    def assign(self, n, x):
        return _coot.vector_mtz_type_label_assign(self, n, x)

    def resize(self, *args):
        return _coot.vector_mtz_type_label_resize(self, *args)

    def insert(self, *args):
        return _coot.vector_mtz_type_label_insert(self, *args)

    def reserve(self, n):
        return _coot.vector_mtz_type_label_reserve(self, n)

    def capacity(self):
        return _coot.vector_mtz_type_label_capacity(self)
    __swig_destroy__ = _coot.delete_vector_mtz_type_label

# Register vector_mtz_type_label in _coot:
_coot.vector_mtz_type_label_swigregister(vector_mtz_type_label)
class pair_string_string(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _coot.pair_string_string_swiginit(self, _coot.new_pair_string_string(*args))
    first = property(_coot.pair_string_string_first_get, _coot.pair_string_string_first_set)
    second = property(_coot.pair_string_string_second_get, _coot.pair_string_string_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _coot.delete_pair_string_string

# Register pair_string_string in _coot:
_coot.pair_string_string_swigregister(pair_string_string)
class vector_pair_string_string(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _coot.vector_pair_string_string_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _coot.vector_pair_string_string___nonzero__(self)

    def __bool__(self):
        return _coot.vector_pair_string_string___bool__(self)

    def __len__(self):
        return _coot.vector_pair_string_string___len__(self)

    def __getslice__(self, i, j):
        return _coot.vector_pair_string_string___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _coot.vector_pair_string_string___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _coot.vector_pair_string_string___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _coot.vector_pair_string_string___delitem__(self, *args)

    def __getitem__(self, *args):
        return _coot.vector_pair_string_string___getitem__(self, *args)

    def __setitem__(self, *args):
        return _coot.vector_pair_string_string___setitem__(self, *args)

    def pop(self):
        return _coot.vector_pair_string_string_pop(self)

    def append(self, x):
        return _coot.vector_pair_string_string_append(self, x)

    def empty(self):
        return _coot.vector_pair_string_string_empty(self)

    def size(self):
        return _coot.vector_pair_string_string_size(self)

    def swap(self, v):
        return _coot.vector_pair_string_string_swap(self, v)

    def begin(self):
        return _coot.vector_pair_string_string_begin(self)

    def end(self):
        return _coot.vector_pair_string_string_end(self)

    def rbegin(self):
        return _coot.vector_pair_string_string_rbegin(self)

    def rend(self):
        return _coot.vector_pair_string_string_rend(self)

    def clear(self):
        return _coot.vector_pair_string_string_clear(self)

    def get_allocator(self):
        return _coot.vector_pair_string_string_get_allocator(self)

    def pop_back(self):
        return _coot.vector_pair_string_string_pop_back(self)

    def erase(self, *args):
        return _coot.vector_pair_string_string_erase(self, *args)

    def __init__(self, *args):
        _coot.vector_pair_string_string_swiginit(self, _coot.new_vector_pair_string_string(*args))

    def push_back(self, x):
        return _coot.vector_pair_string_string_push_back(self, x)

    def front(self):
        return _coot.vector_pair_string_string_front(self)

    def back(self):
        return _coot.vector_pair_string_string_back(self)

    def assign(self, n, x):
        return _coot.vector_pair_string_string_assign(self, n, x)

    def resize(self, *args):
        return _coot.vector_pair_string_string_resize(self, *args)

    def insert(self, *args):
        return _coot.vector_pair_string_string_insert(self, *args)

    def reserve(self, n):
        return _coot.vector_pair_string_string_reserve(self, n)

    def capacity(self):
        return _coot.vector_pair_string_string_capacity(self)
    __swig_destroy__ = _coot.delete_vector_pair_string_string

# Register vector_pair_string_string in _coot:
_coot.vector_pair_string_string_swigregister(vector_pair_string_string)
COOT_SCHEME_DIR = _coot.COOT_SCHEME_DIR

COOT_PYTHON_DIR = _coot.COOT_PYTHON_DIR


def try_load_python_extras_dir():
    r"""try_load_python_extras_dir()"""
    return _coot.try_load_python_extras_dir()

def set_prefer_python():
    r"""
    set_prefer_python()

    tell coot that you prefer to run python scripts if/when there is an option to do so.

    """
    return _coot.set_prefer_python()

def prefer_python():
    r"""
    prefer_python() -> int

    the python-prefered mode.

    This is available so that the scripting functions know whether on not to put themselves onto in as menu items.

    If you consider using this, consider in preference use_gui_qm == 2, which is used elsewhere to stop python functions adding to the gui, when guile-gtk functions have alread done so. We should clean up this (rather obscure) interface at some stage.

    1 for python is prefered, 0 for not.

    """
    return _coot.prefer_python()

def set_show_paths_in_display_manager(i):
    r"""
    set_show_paths_in_display_manager(int i)

    Show Paths in Display Manager?

    Some people don't like to see the full path names in the display manager here is the way to turn them off, with an argument of 1.

    Parameters
    ----------
    i : int

    """
    return _coot.set_show_paths_in_display_manager(i)

def show_paths_in_display_manager_state():
    r"""
    show_paths_in_display_manager_state() -> int

    return the internal state

    What is the internal flag?

    1 for "yes, display paths", 0 for not

    """
    return _coot.show_paths_in_display_manager_state()

def add_coordinates_glob_extension(ext):
    r"""
    add_coordinates_glob_extension(char const * ext)

    add an extension to be treated as coordinate files

      ext  the extension to be added

    Parameters
    ----------
    ext : str
        the extension to be added

    """
    return _coot.add_coordinates_glob_extension(ext)

def add_data_glob_extension(ext):
    r"""
    add_data_glob_extension(char const * ext)

    add an extension to be treated as data (reflection) files

      ext  the extension to be added

    Parameters
    ----------
    ext : str
        the extension to be added

    """
    return _coot.add_data_glob_extension(ext)

def add_dictionary_glob_extension(ext):
    r"""
    add_dictionary_glob_extension(char const * ext)

    add an extension to be treated as geometry dictionary files

      ext  the extension to be added

    Parameters
    ----------
    ext : str
        the extension to be added

    """
    return _coot.add_dictionary_glob_extension(ext)

def add_map_glob_extension(ext):
    r"""
    add_map_glob_extension(char const * ext)

    add an extension to be treated as geometry map files

    Parameters
    ----------
    ext : str

    """
    return _coot.add_map_glob_extension(ext)

def remove_coordinates_glob_extension(ext):
    r"""
    remove_coordinates_glob_extension(char const * ext)

    remove an extension to be treated as coordinate files

      ext  the extension to be added

    Parameters
    ----------
    ext : str
        the extension to be added

    """
    return _coot.remove_coordinates_glob_extension(ext)

def remove_data_glob_extension(ext):
    r"""
    remove_data_glob_extension(char const * ext)

    remove an extension to be treated as data (reflection) files

      ext  the extension to be removed

    Parameters
    ----------
    ext : str
        the extension to be removed

    """
    return _coot.remove_data_glob_extension(ext)

def remove_dictionary_glob_extension(ext):
    r"""
    remove_dictionary_glob_extension(char const * ext)

    remove an extension to be treated as geometry dictionary files

      ext  the extension to be removed

    Parameters
    ----------
    ext : str
        the extension to be removed

    """
    return _coot.remove_dictionary_glob_extension(ext)

def remove_map_glob_extension(ext):
    r"""
    remove_map_glob_extension(char const * ext)

    remove an extension to be treated as geometry map files

    Parameters
    ----------
    ext : str

    """
    return _coot.remove_map_glob_extension(ext)

def set_sticky_sort_by_date():
    r"""
    set_sticky_sort_by_date()

    sort files in the file selection by date?

    some people like to have their files sorted by date by default

    """
    return _coot.set_sticky_sort_by_date()

def unset_sticky_sort_by_date():
    r"""
    unset_sticky_sort_by_date()

    do not sort files in the file selection by date?

    removes the sorting of files by date

    """
    return _coot.unset_sticky_sort_by_date()

def set_filter_fileselection_filenames(istate):
    r"""
    set_filter_fileselection_filenames(int istate)

    on opening a file selection dialog, pre-filter the files.

    set to 1 to pre-filter, [0 (off, non-pre-filtering) is the default

    Parameters
    ----------
    istate : int

    """
    return _coot.set_filter_fileselection_filenames(istate)

def filter_fileselection_filenames_state():
    r"""
    filter_fileselection_filenames_state() -> int

    , return the state of the above variable

    """
    return _coot.filter_fileselection_filenames_state()

def file_type_coords(file_name):
    r"""
    file_type_coords(char const * file_name) -> short

    is the given file name suitable to be read as coordinates?

    Parameters
    ----------
    file_name : str

    """
    return _coot.file_type_coords(file_name)

def open_coords_dialog():
    r"""
    open_coords_dialog()

    display the open coordinates dialog

    """
    return _coot.open_coords_dialog()

def set_file_chooser_selector(istate):
    r"""
    set_file_chooser_selector(int istate)

    this flag set chooser as default for windows, otherwise use selector 0 is selector 1 is chooser

    Parameters
    ----------
    istate : int

    """
    return _coot.set_file_chooser_selector(istate)

def file_chooser_selector_state():
    r"""file_chooser_selector_state() -> int"""
    return _coot.file_chooser_selector_state()

def set_file_chooser_overwrite(istate):
    r"""
    set_file_chooser_overwrite(int istate)


    Parameters
    ----------
    istate : int

    """
    return _coot.set_file_chooser_overwrite(istate)

def file_chooser_overwrite_state():
    r"""file_chooser_overwrite_state() -> int"""
    return _coot.file_chooser_overwrite_state()

def export_map_gui(export_map_fragment):
    r"""
    export_map_gui(short export_map_fragment)

    show the export map GUI

    Parameters
    ----------
    export_map_fragment : int

    """
    return _coot.export_map_gui(export_map_fragment)

def set_main_window_title(s):
    r"""
    set_main_window_title(char const * s)

    set the main window title.

    function added for Lothar Esser

    Parameters
    ----------
    s : str

    """
    return _coot.set_main_window_title(s)

def set_validation_graphs_is_docked(state):
    r"""
    set_validation_graphs_is_docked(short state)

    set the state of the validation graphs box

    By "docked" I mean, in the main window. The alternative is a floating dialog.

      state  0 is not docked, 1 is docked

    Parameters
    ----------
    state : int
        0 is not docked, 1 is docked

    """
    return _coot.set_validation_graphs_is_docked(state)

def manage_column_selector(filename):
    r"""
    manage_column_selector(char const * filename)

    given a filename, try to read it as a data file

    We try as .phs and .cif files first

    Parameters
    ----------
    filename : str

    """
    return _coot.manage_column_selector(filename)

def chain_n_residues(chain_id, imol):
    r"""
    chain_n_residues(char const * chain_id, int imol) -> int

    the number of residues in chain chain_id and molecule number imol

    the number of residues

    Parameters
    ----------
    chain_id : str
    imol : int

    """
    return _coot.chain_n_residues(chain_id, imol)

def molecule_centre_internal(imol, iaxis):
    r"""
    molecule_centre_internal(int imol, int iaxis) -> float

    internal function for molecule centre

    status, less than -9999 is for failure (eg. bad imol);

    Parameters
    ----------
    imol : int
    iaxis : int

    """
    return _coot.molecule_centre_internal(imol, iaxis)

def seqnum_from_serial_number(imol, chain_id, serial_num):
    r"""
    seqnum_from_serial_number(int imol, char const * chain_id, int serial_num) -> int

    a residue seqnum (normal residue number) from a residue serial number

    < -9999 on failure

    Parameters
    ----------
    imol : int
    chain_id : str
    serial_num : int

    """
    return _coot.seqnum_from_serial_number(imol, chain_id, serial_num)

def insertion_code_from_serial_number(imol, chain_id, serial_num):
    r"""
    insertion_code_from_serial_number(int imol, char const * chain_id, int serial_num) -> char *

    the insertion code of the residue.

    NULL (scheme False) on failure.

    Parameters
    ----------
    imol : int
    chain_id : str
    serial_num : int

    """
    return _coot.insertion_code_from_serial_number(imol, chain_id, serial_num)

def python_representation_kk(imol):
    r"""
    python_representation_kk(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.python_representation_kk(imol)

def chain_id_py(imol, ichain):
    r"""
    chain_id_py(int imol, int ichain) -> PyObject *


    Parameters
    ----------
    imol : int
    ichain : int

    """
    return _coot.chain_id_py(imol, ichain)

def n_models(imol):
    r"""
    n_models(int imol) -> int

    return the number of models in molecule number imol

    useful for NMR or other such multi-model molecules.

    return the number of models or -1 if there was a problem with the given molecule.

    Parameters
    ----------
    imol : int

    """
    return _coot.n_models(imol)

def n_chains(imol):
    r"""
    n_chains(int imol) -> int

    get the number of chains in molecule number imol

      imol  is the molecule index the number of chains

    Parameters
    ----------
    imol : int
        is the molecule index

    """
    return _coot.n_chains(imol)

def get_chain_ids_py(imol):
    r"""
    get_chain_ids_py(int imol) -> PyObject *

    get the chain ids of molecule number imol

      imol  is the molecule index a list of the the chain ids or False on failure

    Parameters
    ----------
    imol : int
        is the molecule index

    """
    return _coot.get_chain_ids_py(imol)

def is_solvent_chain_p(imol, chain_id):
    r"""
    is_solvent_chain_p(int imol, char const * chain_id) -> int

    is this a solvent chain? [Raw function]

    This is a raw interface function, you should generally not use this, but instead use (is-solvent-chain? imol chain-id)

    This wraps the mmdb function isSolventChain().

      imol  is the molecule index   chain_id  is the chain id (e.g. "A" or "B") -1 on error, 0 for no, 1 for is "a solvent chain". We wouldn't want to be doing rotamer searches and the like on such a chain.

    Parameters
    ----------
    imol : int
        is the molecule index
    chain_id : str
        is the chain id (e.g. "A" or "B")

    """
    return _coot.is_solvent_chain_p(imol, chain_id)

def is_protein_chain_p(imol, chain_id):
    r"""
    is_protein_chain_p(int imol, char const * chain_id) -> int

    is this a protein chain? [Raw function]

    This is a raw interface function, you should generally not use this, but instead use (is-protein-chain? imol chain-id)

    -1 on error, 0 for no, 1 for is "a protein chain". We wouldn't want to be doing rotamer searches and the like on such a chain. This wraps the mmdb function isAminoacidChain().

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.is_protein_chain_p(imol, chain_id)

def is_nucleotide_chain_p(imol, chain_id):
    r"""
    is_nucleotide_chain_p(int imol, char const * chain_id) -> int

    is this a nucleic acid chain? [Raw function]

    This is a raw interface function, you should generally not use this, but instead use (is-nucleicacid-chain? imol chain-id)

    -1 on error, 0 for no, 1 for is "a nucleicacid chain". We wouldn't want to be doing rotamer searches and the like on such a chain. This wraps the mmdb function isNucleotideChain(). For completeness.

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.is_nucleotide_chain_p(imol, chain_id)

def n_residues(imol):
    r"""
    n_residues(int imol) -> int

    return the number of residues in the molecule,

    return -1 if this is a map or closed.

    Parameters
    ----------
    imol : int

    """
    return _coot.n_residues(imol)

def n_atoms(imol):
    r"""
    n_atoms(int imol) -> int

    return the ATOMs of residues in the molecule,

    return -1 if this is a map or closed. HETATMs are not counted.

    Parameters
    ----------
    imol : int

    """
    return _coot.n_atoms(imol)

def remarks_py(imol):
    r"""
    remarks_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.remarks_py(imol)

def residue_centre_py(imol, chain_id, resno, ins_code):
    r"""
    residue_centre_py(int imol, char const * chain_id, int resno, char const * ins_code) -> PyObject *


    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.residue_centre_py(imol, chain_id, resno, ins_code)

def model_composition_statistics_py(imol):
    r"""
    model_composition_statistics_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.model_composition_statistics_py(imol)

def sort_chains(imol):
    r"""
    sort_chains(int imol)

    sort the chain ids of the imol-th molecule in lexographical order

    Parameters
    ----------
    imol : int

    """
    return _coot.sort_chains(imol)

def sort_residues(imol):
    r"""
    sort_residues(int imol)

    sort the residues of the imol-th molecule

    Parameters
    ----------
    imol : int

    """
    return _coot.sort_residues(imol)

def remarks_dialog(imol):
    r"""
    remarks_dialog(int imol)

    a gui dialog showing remarks header info (for a model molecule).

    Parameters
    ----------
    imol : int

    """
    return _coot.remarks_dialog(imol)

def print_header_secondary_structure_info(imol):
    r"""
    print_header_secondary_structure_info(int imol)

    simply print secondary structure info to the terminal/console. In future, this could/should return the info.

    Parameters
    ----------
    imol : int

    """
    return _coot.print_header_secondary_structure_info(imol)

def get_header_secondary_structure_info(imol):
    r"""
    get_header_secondary_structure_info(int imol) -> PyObject *

    get the secondary structure from the header

      imol  the molecule index a dictionary of header info Returns: {'helices': [...], 'strands': [...]} Each helix dict contains: serNum, helixID, initChainID, initSeqNum, endChainID, endSeqNum, length, comment

    Each strand dict contains: SheetID, strandNo, initChainID, initSeqNum, endChainID, endSeqNum

    Parameters
    ----------
    imol : int
        the molecule index

    """
    return _coot.get_header_secondary_structure_info(imol)

def add_header_secondary_structure_info(imol):
    r"""
    add_header_secondary_structure_info(int imol)

    add secondary structure info to the internal representation of the model

    Parameters
    ----------
    imol : int

    """
    return _coot.add_header_secondary_structure_info(imol)

def write_header_secondary_structure_info(imol, file_name):
    r"""
    write_header_secondary_structure_info(int imol, char const * file_name)


    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.write_header_secondary_structure_info(imol, file_name)

def copy_molecule(imol):
    r"""
    copy_molecule(int imol) -> int

    copy molecule imol

    the new molecule number. Return -1 on failure to copy molecule (out of range, or molecule is closed)

    Parameters
    ----------
    imol : int

    """
    return _coot.copy_molecule(imol)

def add_ligand_delete_residue_copy_molecule(imol_ligand_new, chain_id_ligand_new, resno_ligand_new, imol_current, chain_id_ligand_current, resno_ligand_current):
    r"""
    add_ligand_delete_residue_copy_molecule(int imol_ligand_new, char const * chain_id_ligand_new, int resno_ligand_new, int imol_current, char const * chain_id_ligand_current, int resno_ligand_current) -> int

    Copy a molecule with addition of a ligand and a deletion of current ligand.

    This function is used when adding a new (modified) ligand to a structure. It creates a new molecule that is a copy of the current molecule except that the new ligand is added and the current ligand/residue is deleted.

    Parameters
    ----------
    imol_ligand_new : int
    chain_id_ligand_new : str
    resno_ligand_new : int
    imol_current : int
    chain_id_ligand_current : str
    resno_ligand_current : int

    """
    return _coot.add_ligand_delete_residue_copy_molecule(imol_ligand_new, chain_id_ligand_new, resno_ligand_new, imol_current, chain_id_ligand_current, resno_ligand_current)

def exchange_chain_ids_for_seg_ids(imol):
    r"""
    exchange_chain_ids_for_seg_ids(int imol) -> int

    Experimental interface for Ribosome People.

    Ribosome People have many chains in their pdb file, they prefer segids to chainids (chainids are only 1 character). But coot uses the concept of chain ids and not seg-ids. mmdb allow us to use more than one char in the chainid, so after we read in a pdb, let's replace the chain ids with the segids. Will that help?

    Parameters
    ----------
    imol : int

    """
    return _coot.exchange_chain_ids_for_seg_ids(imol)

def show_remarks_browswer():
    r"""
    show_remarks_browswer()

    show the remarks browser

    """
    return _coot.show_remarks_browswer()

def coot_sys_build_type_py():
    r"""coot_sys_build_type_py() -> PyObject *"""
    return _coot.coot_sys_build_type_py()

def git_revision_count():
    r"""
    git_revision_count() -> int

    return the git revision count for for this build.

    """
    return _coot.git_revision_count()

def svn_revision():
    r"""
    svn_revision() -> int

    an alias to git_revision_count() for backwards compatibility

    """
    return _coot.svn_revision()

def molecule_name(imol):
    r"""
    molecule_name(int imol) -> char const *

    return the name of molecule number imol

    0 if not a valid name ( -> False in scheme) e.g. "/a/b/c.pdb" for "d/e/f.mtz FWT PHWT"

    Parameters
    ----------
    imol : int

    """
    return _coot.molecule_name(imol)

def molecule_name_stub_py(imol, include_path_flag):
    r"""
    molecule_name_stub_py(int imol, int include_path_flag) -> PyObject *

    return the molecule name without file extension

    Parameters
    ----------
    imol : int
    include_path_flag : int

    """
    return _coot.molecule_name_stub_py(imol, include_path_flag)

def set_molecule_name(imol, new_name):
    r"""
    set_molecule_name(int imol, char const * new_name)

    set the molecule name of the imol-th molecule

    Parameters
    ----------
    imol : int
    new_name : str

    """
    return _coot.set_molecule_name(imol, new_name)

def coot_checked_exit(retval):
    r"""
    coot_checked_exit(int retval) -> int


    Parameters
    ----------
    retval : int

    """
    return _coot.coot_checked_exit(retval)

def coot_real_exit(retval):
    r"""
    coot_real_exit(int retval)

    exit from coot, give return value retval back to invoking process.

    Parameters
    ----------
    retval : int

    """
    return _coot.coot_real_exit(retval)

def coot_no_state_real_exit(retval):
    r"""
    coot_no_state_real_exit(int retval)

    exit without writing a state file

    Parameters
    ----------
    retval : int

    """
    return _coot.coot_no_state_real_exit(retval)

def coot_clear_backup_or_real_exit(retval):
    r"""
    coot_clear_backup_or_real_exit(int retval)

    exit coot doing clear-backup maybe

    Parameters
    ----------
    retval : int

    """
    return _coot.coot_clear_backup_or_real_exit(retval)

def coot_save_state_and_exit(retval, save_state_flag):
    r"""
    coot_save_state_and_exit(int retval, int save_state_flag)

    exit coot, write a state file

    Parameters
    ----------
    retval : int
    save_state_flag : int

    """
    return _coot.coot_save_state_and_exit(retval, save_state_flag)

def run_clear_backups_py(retval):
    r"""
    run_clear_backups_py(int retval)


    Parameters
    ----------
    retval : int

    """
    return _coot.run_clear_backups_py(retval)

def first_coords_imol():
    r"""
    first_coords_imol() -> int

    What is the molecule number of first coordinates molecule?

    return -1 when there is none.

    """
    return _coot.first_coords_imol()

def first_small_coords_imol():
    r"""
    first_small_coords_imol() -> int

    molecule number of first small (<400 atoms) molecule.

    return -1 on no such molecule

    """
    return _coot.first_small_coords_imol()

def first_unsaved_coords_imol():
    r"""
    first_unsaved_coords_imol() -> int

    What is the molecule number of first unsaved coordinates molecule?

    return -1 when there is none.

    """
    return _coot.first_unsaved_coords_imol()

def mmcif_sfs_to_mtz(cif_file_name, mtz_file_name):
    r"""
    mmcif_sfs_to_mtz(char const * cif_file_name, char const * mtz_file_name) -> int

    convert the structure factors in cif_file_name to an mtz file.

    Return 1 on success. Return 0 on a file without Rfree, return -1 on complete failure to write a file.

    Parameters
    ----------
    cif_file_name : str
    mtz_file_name : str

    """
    return _coot.mmcif_sfs_to_mtz(cif_file_name, mtz_file_name)

def set_do_anti_aliasing(state):
    r"""
    set_do_anti_aliasing(int state)

    set the bond lines to be antialiased

    Parameters
    ----------
    state : int

    """
    return _coot.set_do_anti_aliasing(state)

def do_anti_aliasing_state():
    r"""
    do_anti_aliasing_state() -> int

    return the flag for antialiasing the bond lines

    """
    return _coot.do_anti_aliasing_state()

def set_do_GL_lighting(state):
    r"""
    set_do_GL_lighting(int state)

    turn the GL lighting on (state = 1) or off (state = 0)

    slows down the display of simple lines

    Parameters
    ----------
    state : int

    """
    return _coot.set_do_GL_lighting(state)

def do_GL_lighting_state():
    r"""
    do_GL_lighting_state() -> int

    return the flag for GL lighting

    """
    return _coot.do_GL_lighting_state()

def use_graphics_interface_state():
    r"""
    use_graphics_interface_state() -> short

    shall we start up the Gtk and the graphics window?

    if passed the command line argument no-graphics, coot will not start up gtk itself.

    An interface function for Ralf.

    """
    return _coot.use_graphics_interface_state()

def set_use_dark_mode(state):
    r"""
    set_use_dark_mode(short state)

    set the GUI dark mode state

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_dark_mode(state)

def python_at_prompt_at_startup_state():
    r"""
    python_at_prompt_at_startup_state() -> short

    is the python interpreter at the prompt?

    1 for yes, 0 for no.

    """
    return _coot.python_at_prompt_at_startup_state()

def reset_view():
    r"""
    reset_view() -> int

    "Reset" the view

    return 1 if we moved, else return 0.

    centre on last-read molecule with zoom 100. If we are there, then go to the previous molecule, if we are there, then go to the origin.

    """
    return _coot.reset_view()

def set_view_rotation_scale_factor(f):
    r"""
    set_view_rotation_scale_factor(float f)

    set the view rotation scale factor

    Useful/necessary for high resolution displayed, where, without this factor the view doesn't rotate enough

    Parameters
    ----------
    f : float

    """
    return _coot.set_view_rotation_scale_factor(f)

def get_number_of_molecules():
    r"""
    get_number_of_molecules() -> int

    return the number of molecules (coordinates molecules and map molecules combined) that are currently in coot

    the number of molecules (closed molecules are not counted)

    """
    return _coot.get_number_of_molecules()

def graphics_n_molecules():
    r"""
    graphics_n_molecules() -> int

    As above, return the number of molecules (coordinates molecules and map molecules combined) that are currently in coot.

    This is the old name for the function.

    the number of molecules (closed molecules are not counted)

    """
    return _coot.graphics_n_molecules()

def molecule_has_hydrogens_raw(imol):
    r"""
    molecule_has_hydrogens_raw(int imol) -> int


    Parameters
    ----------
    imol : int

    """
    return _coot.molecule_has_hydrogens_raw(imol)

def own_molecule_number(imol):
    r"""
    own_molecule_number(int imol) -> int


    Parameters
    ----------
    imol : int

    """
    return _coot.own_molecule_number(imol)

def toggle_idle_spin_function():
    r"""
    toggle_idle_spin_function()

    Spin spin spin (or not)

    """
    return _coot.toggle_idle_spin_function()

def toggle_idle_rock_function():
    r"""
    toggle_idle_rock_function()

    Rock (not roll) (self-timed)

    """
    return _coot.toggle_idle_rock_function()

def get_idle_function_rock_target_angle():
    r"""get_idle_function_rock_target_angle() -> double"""
    return _coot.get_idle_function_rock_target_angle()

def set_rocking_factors(width_scale, frequency_scale):
    r"""
    set_rocking_factors(float width_scale, float frequency_scale)

    Settings for the inevitable discontents who dislike the default rocking rates (defaults 1 and 1)

    Parameters
    ----------
    width_scale : float
    frequency_scale : float

    """
    return _coot.set_rocking_factors(width_scale, frequency_scale)

def set_idle_function_rotate_angle(f):
    r"""
    set_idle_function_rotate_angle(float f)

    how far should we rotate when (auto) spinning? Fast computer? set this to 0.1

    Parameters
    ----------
    f : float

    """
    return _coot.set_idle_function_rotate_angle(f)

def idle_function_rotate_angle():
    r"""
    idle_function_rotate_angle() -> float

    what is the idle function rotation angle?

    """
    return _coot.idle_function_rotate_angle()

def make_updating_model_molecule(filename):
    r"""
    make_updating_model_molecule(char const * filename) -> int

    make a model molecule from the give file name.

    If the file updates, then the model will be updated.

    Parameters
    ----------
    filename : str

    """
    return _coot.make_updating_model_molecule(filename)

def show_calculate_updating_maps_pythonic_gui():
    r"""
    show_calculate_updating_maps_pythonic_gui()

    show the updating maps gui

    this function is called from callbacks.c and calls a python gui function

    """
    return _coot.show_calculate_updating_maps_pythonic_gui()

def allow_duplicate_sequence_numbers():
    r"""
    allow_duplicate_sequence_numbers()

    enable reading PDB/pdbx files with duplicate sequence numbers

    """
    return _coot.allow_duplicate_sequence_numbers()

def set_convert_to_v2_atom_names(state):
    r"""
    set_convert_to_v2_atom_names(short state)

    shall we convert nucleotides to match the old dictionary names?

    Usually (after 2006 or so) we do not want to do this (given current Coot architecture). Coot should handle the residue synonyms transparently.

    default off (0).

    Parameters
    ----------
    state : int

    """
    return _coot.set_convert_to_v2_atom_names(state)

def get_input_molecule_was_in_mmcif_state_py(imol):
    r"""
    get_input_molecule_was_in_mmcif_state_py(int imol) -> PyObject *

    get the name state of the input model

    Parameters
    ----------
    imol : int

    """
    return _coot.get_input_molecule_was_in_mmcif_state_py(imol)

def assign_hetatms(imol):
    r"""
    assign_hetatms(int imol) -> int

    some programs produce PDB files with ATOMs where there should be HETATMs. This is a function to assign HETATMs as per the PDB definition.

    Parameters
    ----------
    imol : int

    """
    return _coot.assign_hetatms(imol)

def hetify_residue(imol, chain_id, resno, ins_code):
    r"""
    hetify_residue(int imol, char const * chain_id, int resno, char const * ins_code) -> int

    if this is not a standard group, then turn the atoms to HETATMs.

    Return 1 on atoms changes, 0 on not. Return -1 if residue not found.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.hetify_residue(imol, chain_id, resno, ins_code)

def residue_has_hetatms(imol, chain_id, resno, ins_code):
    r"""
    residue_has_hetatms(int imol, char const * chain_id, int resno, char const * ins_code) -> int

    residue has HETATMs?

    return 1 if all atoms of the specified residue are HETATMs, else, return 0. If residue not found, return -1.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.residue_has_hetatms(imol, chain_id, resno, ins_code)

def het_group_residues_py(imol):
    r"""
    het_group_residues_py(int imol) -> PyObject *

    get the specs for hetgroups - waters are not counted as het-groups.

    Parameters
    ----------
    imol : int

    """
    return _coot.het_group_residues_py(imol)

def het_group_n_atoms(comp_id):
    r"""
    het_group_n_atoms(char const * comp_id) -> int

    return the number of non-hydrogen atoms in the given het-group (comp-id).

    Return -1 on comp-id not found in dictionary.

    Parameters
    ----------
    comp_id : str

    """
    return _coot.het_group_n_atoms(comp_id)

def replace_fragment(imol_target, imol_fragment, atom_selection):
    r"""
    replace_fragment(int imol_target, int imol_fragment, char const * atom_selection) -> int

    replace the parts of molecule number imol that are duplicated in molecule number imol_frag

    Parameters
    ----------
    imol_target : int
    imol_fragment : int
    atom_selection : str

    """
    return _coot.replace_fragment(imol_target, imol_fragment, atom_selection)

def copy_residue_range(imol_target, chain_id_target, imol_reference, chain_id_reference, resno_range_start, resno_range_end):
    r"""
    copy_residue_range(int imol_target, char const * chain_id_target, int imol_reference, char const * chain_id_reference, int resno_range_start, int resno_range_end) -> int

    copy the given residue range from the reference chain to the target chain

    resno_range_start and resno_range_end are inclusive.

    Parameters
    ----------
    imol_target : int
    chain_id_target : str
    imol_reference : int
    chain_id_reference : str
    resno_range_start : int
    resno_range_end : int

    """
    return _coot.copy_residue_range(imol_target, chain_id_target, imol_reference, chain_id_reference, resno_range_start, resno_range_end)

def replace_residues_from_mol_py(imol_target, imol_ref, residue_specs_list_ref_py):
    r"""
    replace_residues_from_mol_py(int imol_target, int imol_ref, PyObject * residue_specs_list_ref_py) -> int


    Parameters
    ----------
    imol_target : int
    imol_ref : int
    residue_specs_list_ref_py : object

    """
    return _coot.replace_residues_from_mol_py(imol_target, imol_ref, residue_specs_list_ref_py)

def clear_and_update_model_molecule_from_file(molecule_number, file_name):
    r"""
    clear_and_update_model_molecule_from_file(int molecule_number, char const * file_name) -> int

    replace pdb. Fail if molecule_number is not a valid model molecule. Return -1 on failure. Else return molecule_number

    Parameters
    ----------
    molecule_number : int
    file_name : str

    """
    return _coot.clear_and_update_model_molecule_from_file(molecule_number, file_name)

def screendump_image(tga_filename):
    r"""
    screendump_image(char const * tga_filename)

    dump the current screen image to a file. Format ppm

    You can use this, in conjunction with spinning and view moving functions to make movies

    Parameters
    ----------
    filename : str

    """
    return _coot.screendump_image(tga_filename)

def check_for_dark_blue_density():
    r"""
    check_for_dark_blue_density()

    give a warning dialog if density it too dark (blue)

    """
    return _coot.check_for_dark_blue_density()

def set_draw_solid_density_surface(imol, state):
    r"""
    set_draw_solid_density_surface(int imol, short state)

    sets the density map of the given molecule to be drawn as a (transparent) solid surface.

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_draw_solid_density_surface(imol, state)

def set_draw_map_standard_lines(imol, state):
    r"""
    set_draw_map_standard_lines(int imol, short state)

    toggle for standard lines representation of map.

    This turns off/on standard lines representation of map. transparent surface is another representation type.

    If you want to just turn off a map, don't use this, use set_map_displayed() .

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_draw_map_standard_lines(imol, state)

def set_solid_density_surface_opacity(imol, opacity):
    r"""
    set_solid_density_surface_opacity(int imol, float opacity)

    set the opacity of density surface representation of the given map.

    0.0 is totally transparent, 1.0 is completely opaque and (because the objects are no longer depth sorted) considerably faster to render. 0.3 is a reasonable number.

    Parameters
    ----------
    imol : int
    opacity : float

    """
    return _coot.set_solid_density_surface_opacity(imol, opacity)

def get_solid_density_surface_opacity(imol):
    r"""
    get_solid_density_surface_opacity(int imol) -> float


    Parameters
    ----------
    imol : int

    """
    return _coot.get_solid_density_surface_opacity(imol)

def set_flat_shading_for_solid_density_surface(state):
    r"""
    set_flat_shading_for_solid_density_surface(short state)

    set the flag to do flat shading rather than smooth shading for solid density surface.

    Default is 1 (on.

    Parameters
    ----------
    state : int

    """
    return _coot.set_flat_shading_for_solid_density_surface(state)

def test_internal_py():
    r"""test_internal_py() -> PyObject *"""
    return _coot.test_internal_py()

def test_internal_single_py():
    r"""test_internal_single_py() -> PyObject *"""
    return _coot.test_internal_single_py()

def set_scroll_by_wheel_mouse(istate):
    r"""
    set_scroll_by_wheel_mouse(int istate)

    Some people (like Phil Evans) don't want to scroll their map with the mouse-wheel.

    To turn off mouse wheel recontouring call this with istate value of 0

    Parameters
    ----------
    istate : int

    """
    return _coot.set_scroll_by_wheel_mouse(istate)

def scroll_by_wheel_mouse_state():
    r"""
    scroll_by_wheel_mouse_state() -> int

    return the internal state of the scroll-wheel map contouring

    """
    return _coot.scroll_by_wheel_mouse_state()

def set_auto_recontour_map(state):
    r"""
    set_auto_recontour_map(int state)

    turn off (0) or on (1) auto recontouring (on screen centre change) (default it on)

    Parameters
    ----------
    state : int

    """
    return _coot.set_auto_recontour_map(state)

def get_auto_recontour_map():
    r"""
    get_auto_recontour_map() -> int

    return the auto-recontour state

    """
    return _coot.get_auto_recontour_map()

def set_default_initial_contour_level_for_map(n_sigma):
    r"""
    set_default_initial_contour_level_for_map(float n_sigma)

    set the default inital contour for 2FoFc-style map

    in sigma

    Parameters
    ----------
    n_sigma : float

    """
    return _coot.set_default_initial_contour_level_for_map(n_sigma)

def set_default_initial_contour_level_for_difference_map(n_sigma):
    r"""
    set_default_initial_contour_level_for_difference_map(float n_sigma)

    set the default inital contour for FoFc-style map

    in sigma

    Parameters
    ----------
    n_sigma : float

    """
    return _coot.set_default_initial_contour_level_for_difference_map(n_sigma)

def print_view_matrix():
    r"""
    print_view_matrix()

    print the view matrix to the console, useful for molscript, perhaps

    """
    return _coot.print_view_matrix()

def get_view_matrix_element(row, col):
    r"""
    get_view_matrix_element(int row, int col) -> float


    Parameters
    ----------
    row : int
    col : int

    """
    return _coot.get_view_matrix_element(row, col)

def get_view_quaternion_internal(element):
    r"""
    get_view_quaternion_internal(int element) -> float

    internal function to get an element of the view quaternion. The whole quaternion is returned by the scheme function view-quaternion

    Parameters
    ----------
    element : int

    """
    return _coot.get_view_quaternion_internal(element)

def set_view_quaternion(i, j, k, l):
    r"""
    set_view_quaternion(float i, float j, float k, float l)

    Set the view quaternion.

    Parameters
    ----------
    i : float
    j : float
    k : float
    l : float

    """
    return _coot.set_view_quaternion(i, j, k, l)

def apply_ncs_to_view_orientation(imol, current_chain, next_ncs_chain):
    r"""
    apply_ncs_to_view_orientation(int imol, char const * current_chain, char const * next_ncs_chain)

    Given that we are in chain current_chain, apply the NCS operator that maps current_chain on to next_ncs_chain, so that the relative view is preserved. For NCS skipping.

    Parameters
    ----------
    imol : int
    current_chain : str
    next_ncs_chain : str

    """
    return _coot.apply_ncs_to_view_orientation(imol, current_chain, next_ncs_chain)

def apply_ncs_to_view_orientation_and_screen_centre(imol, current_chain, next_ncs_chain, forward_flag):
    r"""
    apply_ncs_to_view_orientation_and_screen_centre(int imol, char const * current_chain, char const * next_ncs_chain, short forward_flag)

    as above, but shift the screen centre also.

    Parameters
    ----------
    imol : int
    current_chain : str
    next_ncs_chain : str
    forward_flag : int

    """
    return _coot.apply_ncs_to_view_orientation_and_screen_centre(imol, current_chain, next_ncs_chain, forward_flag)

def set_show_fps(t):
    r"""
    set_show_fps(int t)

    set show frame-per-second flag

    Parameters
    ----------
    t : int

    """
    return _coot.set_show_fps(t)

def set_fps_flag(t):
    r"""
    set_fps_flag(int t)

    the old name for set_show_fps()

    Parameters
    ----------
    t : int

    """
    return _coot.set_fps_flag(t)

def get_fps_flag():
    r"""
    get_fps_flag() -> int

    set the state of show frames-per-second flag

    """
    return _coot.get_fps_flag()

def set_show_origin_marker(istate):
    r"""
    set_show_origin_marker(int istate)

    set a flag: is the origin marker to be shown? 1 for yes, 0 for no.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_show_origin_marker(istate)

def show_origin_marker_state():
    r"""
    show_origin_marker_state() -> int

    return the origin marker shown? state

    """
    return _coot.show_origin_marker_state()

def hide_main_toolbar():
    r"""
    hide_main_toolbar()

    hide the horizontal main toolbar in the GTK2 version

    """
    return _coot.hide_main_toolbar()

def show_main_toolbar():
    r"""
    show_main_toolbar()

    show the horizontal main toolbar in the GTK2 version (the toolbar is shown by default)

    """
    return _coot.show_main_toolbar()

def suck_model_fit_dialog():
    r"""
    suck_model_fit_dialog() -> int

    reparent the Model/Fit/Refine dialog so that it becomes part of the main window, next to the GL graphics context

    """
    return _coot.suck_model_fit_dialog()

def suck_model_fit_dialog_bl():
    r"""suck_model_fit_dialog_bl() -> int"""
    return _coot.suck_model_fit_dialog_bl()

def set_model_fit_refine_dialog_stays_on_top(istate):
    r"""
    set_model_fit_refine_dialog_stays_on_top(int istate)

    model-fit-refine dialog stays on top

    Parameters
    ----------
    istate : int

    """
    return _coot.set_model_fit_refine_dialog_stays_on_top(istate)

def model_fit_refine_dialog_stays_on_top_state():
    r"""
    model_fit_refine_dialog_stays_on_top_state() -> int

    return the state model-fit-refine dialog stays on top

    """
    return _coot.model_fit_refine_dialog_stays_on_top_state()

def set_accept_reject_dialog_docked(state):
    r"""
    set_accept_reject_dialog_docked(int state)

    set the accept/reject dialog docked state - no longer functional

    Parameters
    ----------
    state : int

    """
    return _coot.set_accept_reject_dialog_docked(state)

def set_accept_reject_dialog_docked_show(state):
    r"""
    set_accept_reject_dialog_docked_show(int state)

    set the accept/reject dialog docked show state - no longer functional

    Parameters
    ----------
    state : int

    """
    return _coot.set_accept_reject_dialog_docked_show(state)

def quanta_buttons():
    r"""
    quanta_buttons()

    quanta-like buttons

    Note, when you have set these, there is no way to turn them of again (other than restarting).

    """
    return _coot.quanta_buttons()

def quanta_like_zoom():
    r"""
    quanta_like_zoom()

    quanta-like zoom buttons

    Note, when you have set these, there is no way to turn them of again (other than restarting).

    """
    return _coot.quanta_like_zoom()

def set_control_key_for_rotate(state):
    r"""
    set_control_key_for_rotate(int state)

    Alternate mode for rotation.

    Prefered by some, including Dirk Kostrewa. I don't think this mode works properly yet

    Parameters
    ----------
    state : int

    """
    return _coot.set_control_key_for_rotate(state)

def control_key_for_rotate_state():
    r"""
    control_key_for_rotate_state() -> int

    return the control key rotate state

    """
    return _coot.control_key_for_rotate_state()

def blob_under_pointer_to_screen_centre():
    r"""
    blob_under_pointer_to_screen_centre() -> int

    Put the blob under the cursor to the screen centre. Check only positive blobs. Useful function if bound to a key.

    The refinement map must be set. (We can't check all maps because they are not (or may not be) on the same scale).

    Not useful for MCP. For interactive use only.

    1 if successfully found a blob and moved there. return 0 if no move.

    """
    return _coot.blob_under_pointer_to_screen_centre()

def select_atom_under_pointer_py():
    r"""
    select_atom_under_pointer_py() -> PyObject *

    return Python false or a list of molecule number and an atom spec

    Not useful for MCP. For interactive use only.

    """
    return _coot.select_atom_under_pointer_py()

def normal_cursor():
    r"""
    normal_cursor()

    normal cursor

    """
    return _coot.normal_cursor()

def fleur_cursor():
    r"""
    fleur_cursor()

    fleur cursor

    """
    return _coot.fleur_cursor()

def pick_cursor_maybe():
    r"""
    pick_cursor_maybe()

    pick cursor maybe

    """
    return _coot.pick_cursor_maybe()

def rotate_cursor():
    r"""
    rotate_cursor()

    rotate cursor

    """
    return _coot.rotate_cursor()

def set_pick_cursor_index(icursor_index):
    r"""
    set_pick_cursor_index(int icursor_index)

    let the user have a different pick cursor

    sometimes (the default) GDK_CROSSHAIR is hard to see, let the user set their own

    Parameters
    ----------
    icursor_index : int

    """
    return _coot.set_pick_cursor_index(icursor_index)

def show_select_map_frame():
    r"""
    show_select_map_frame()

    display the Display Manager dialog

    """
    return _coot.show_select_map_frame()

def set_model_fit_refine_rotate_translate_zone_label(txt):
    r"""
    set_model_fit_refine_rotate_translate_zone_label(char const * txt)

    Allow the changing of Model/Fit/Refine button label from "Rotate/Translate Zone".

    Parameters
    ----------
    txt : str

    """
    return _coot.set_model_fit_refine_rotate_translate_zone_label(txt)

def set_model_fit_refine_place_atom_at_pointer_label(txt):
    r"""
    set_model_fit_refine_place_atom_at_pointer_label(char const * txt)

    Allow the changing of Model/Fit/Refine button label from "Place Atom at Pointer".

    Parameters
    ----------
    txt : str

    """
    return _coot.set_model_fit_refine_place_atom_at_pointer_label(txt)

def set_refinement_move_atoms_with_zero_occupancy(state):
    r"""
    set_refinement_move_atoms_with_zero_occupancy(int state)

    shall atoms with zero occupancy be moved when refining? (default 1, yes)

    Parameters
    ----------
    state : int

    """
    return _coot.set_refinement_move_atoms_with_zero_occupancy(state)

def refinement_move_atoms_with_zero_occupancy_state():
    r"""
    refinement_move_atoms_with_zero_occupancy_state() -> int

    return the state of "shall atoms with zero occupancy be moved
    when refining?"

    """
    return _coot.refinement_move_atoms_with_zero_occupancy_state()

def make_backup(imol):
    r"""
    make_backup(int imol)

    make backup for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.make_backup(imol)

def turn_off_backup(imol):
    r"""
    turn_off_backup(int imol)

    turn off backups for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.turn_off_backup(imol)

def turn_on_backup(imol):
    r"""
    turn_on_backup(int imol)

    turn on backups for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.turn_on_backup(imol)

def backup_state(imol):
    r"""
    backup_state(int imol) -> int

    return the backup state for molecule number imol

    return 0 for backups off, 1 for backups on, -1 for unknown

    Parameters
    ----------
    imol : int

    """
    return _coot.backup_state(imol)

def apply_undo():
    r"""
    apply_undo() -> int

    apply undo - the "Undo" button callback

    undo the most recent modification on the model set in set_undo_molecule() .

    1 on succesful undo, 0 on failed to undo.

    """
    return _coot.apply_undo()

def apply_redo():
    r"""
    apply_redo() -> int

    apply redo - the "Redo" button callback

    """
    return _coot.apply_redo()

def set_have_unsaved_changes(imol):
    r"""
    set_have_unsaved_changes(int imol)

    set the molecule number imol to be marked as having unsaved changes

    Parameters
    ----------
    imol : int

    """
    return _coot.set_have_unsaved_changes(imol)

def have_unsaved_changes_p(imol):
    r"""
    have_unsaved_changes_p(int imol) -> int

    does molecule number imol have unsaved changes?

    -1 on bad imol, 0 on no unsaved changes, 1 on has unsaved changes

    Parameters
    ----------
    imol : int

    """
    return _coot.have_unsaved_changes_p(imol)

def set_undo_molecule(imol):
    r"""
    set_undo_molecule(int imol)

    set the molecule to which undo operations are done to molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.set_undo_molecule(imol)

def show_set_undo_molecule_chooser():
    r"""
    show_set_undo_molecule_chooser()

    show the Undo Molecule chooser - i.e. choose the molecule to which the "Undo" button applies.

    """
    return _coot.show_set_undo_molecule_chooser()

def set_unpathed_backup_file_names(state):
    r"""
    set_unpathed_backup_file_names(int state)

    set the state for adding paths to backup file names

    by default directories names are added into the filename for backup (with / to _ mapping). call this with state=1 to turn off directory names

    Parameters
    ----------
    state : int

    """
    return _coot.set_unpathed_backup_file_names(state)

def unpathed_backup_file_names_state():
    r"""
    unpathed_backup_file_names_state() -> int

    return the state for adding paths to backup file names

    """
    return _coot.unpathed_backup_file_names_state()

def set_decoloned_backup_file_names(state):
    r"""
    set_decoloned_backup_file_names(int state)

    set the state for adding paths to backup file names

    by default directories names are added into the filename for backup (with / to _ mapping). call this with state=1 to turn off directory names

    Parameters
    ----------
    state : int

    """
    return _coot.set_decoloned_backup_file_names(state)

def decoloned_backup_file_names_state():
    r"""
    decoloned_backup_file_names_state() -> int

    return the state for adding paths to backup file names

    """
    return _coot.decoloned_backup_file_names_state()

def backup_compress_files_state():
    r"""
    backup_compress_files_state() -> int

    return the state for compression of backup files

    """
    return _coot.backup_compress_files_state()

def set_backup_compress_files(state):
    r"""
    set_backup_compress_files(int state)

    set if backup files will be compressed or not using gzip

    Parameters
    ----------
    state : int

    """
    return _coot.set_backup_compress_files(state)

def make_backup_checkpoint(imol, description):
    r"""
    make_backup_checkpoint(int imol, char const * description) -> int

    Make a backup for a model molecule.

      imol  the model molecule index @description a description that goes along with this back point the index of the backup, or -1 on failure

    Parameters
    ----------
    imol : int
        the model molecule index @description a description that goes along with this back point
    description : str

    """
    return _coot.make_backup_checkpoint(imol, description)

def restore_to_backup_checkpoint(imol, backup_index):
    r"""
    restore_to_backup_checkpoint(int imol, int backup_index) -> int

    Restore molecule from backup.

    restore model imol to checkpoint backup backup_index

      imol  the model molecule index   backup_index  the backup index to restore to the index of the backup, or -1 on failure

    Parameters
    ----------
    imol : int
        the model molecule index
    backup_index : int
        the backup index to restore to

    """
    return _coot.restore_to_backup_checkpoint(imol, backup_index)

def compare_current_model_to_backup(imol, backup_index):
    r"""
    compare_current_model_to_backup(int imol, int backup_index) -> PyObject *

    Compare current model to backup.

      imol  the model molecule index   backup_index  the backup index to restore to a Python dict, with 2 items, a "status" which is either "ok" or "error" or "bad-index". The other key is "moved-residues-list", the value for which is a list of residue specs for residues that have at least one atom in a different place (which might be empty).

    Parameters
    ----------
    imol : int
        the model molecule index
    backup_index : int
        the backup index to restore to

    """
    return _coot.compare_current_model_to_backup(imol, backup_index)

def print_backup_history_info(imol):
    r"""
    print_backup_history_info(int imol)

    Print the history info.

    Parameters
    ----------
    imol : int

    """
    return _coot.print_backup_history_info(imol)

def get_backup_info(imol, backup_index):
    r"""
    get_backup_info(int imol, int backup_index) -> PyObject *

    Get backup info.

      imol  the model molecule index   backup_index  the backup index to restore to a Python list of the given description (str) and a timestamp (str).

    Parameters
    ----------
    imol : int
        the model molecule index
    backup_index : int
        the backup index to restore to

    """
    return _coot.get_backup_info(imol, backup_index)

def recover_session():
    r"""
    recover_session()

    recover session

    After a crash, we provide this convenient interface to restore the session. It runs through all the molecules with models and looks at the coot backup directory looking for related backup files that are more recent that the read file. (Not very good, because you need to remember which files you read in before the crash - should be improved.)

    """
    return _coot.recover_session()

def calc_phases_generic(mtz_file_name):
    r"""
    calc_phases_generic(char const * mtz_file_name)

    fire up a GUI, which asks us which model molecule we want to calc phases from. On "OK" button there, we call map_from_mtz_by_refmac_calc_phases()

    Parameters
    ----------
    mtz_file_name : str

    """
    return _coot.calc_phases_generic(mtz_file_name)

def map_from_mtz_by_refmac_calc_phases(mtz_file_name, f_col, sigf_col, imol_coords):
    r"""
    map_from_mtz_by_refmac_calc_phases(char const * mtz_file_name, char const * f_col, char const * sigf_col, int imol_coords) -> int

    Calculate SFs (using refmac optionally) from an MTZ file and generate a map. Get F and SIGF automatically (first of their type) from the mtz file.

    the new molecule number, -1 on a problem.

    Parameters
    ----------
    mtz_file_name : str
    f_col : str
    sigf_col : str
    imol_coords : int

    """
    return _coot.map_from_mtz_by_refmac_calc_phases(mtz_file_name, f_col, sigf_col, imol_coords)

def map_from_mtz_by_calc_phases(mtz_file_name, f_col, sigf_col, imol_coords):
    r"""
    map_from_mtz_by_calc_phases(char const * mtz_file_name, char const * f_col, char const * sigf_col, int imol_coords) -> int

    Calculate SFs from an MTZ file and generate a map.

    the new molecule number.

    Parameters
    ----------
    mtz_file_name : str
    f_col : str
    sigf_col : str
    imol_coords : int

    """
    return _coot.map_from_mtz_by_calc_phases(mtz_file_name, f_col, sigf_col, imol_coords)

def calculate_maps_and_stats_py(imol_model, imol_map_with_data_attached, imol_map_2fofc, imol_map_fofc):
    r"""
    calculate_maps_and_stats_py(int imol_model, int imol_map_with_data_attached, int imol_map_2fofc, int imol_map_fofc) -> PyObject *

    Calculate structure factors and make a 2FoFC map and a Fo-Fc map updating the given molecule numbers for those maps - if thase molecule ids are not valid maps, them generate new maps (return the model number information in the returned object)

    Parameters
    ----------
    imol_model : int
    imol_map_with_data_attached : int
    imol_map_2fofc : int
    imol_map_fofc : int

    """
    return _coot.calculate_maps_and_stats_py(imol_model, imol_map_with_data_attached, imol_map_2fofc, imol_map_fofc)

def sfcalc_genmap(imol_model, imol_map_with_data_attached, imol_updating_difference_map):
    r"""
    sfcalc_genmap(int imol_model, int imol_map_with_data_attached, int imol_updating_difference_map)

    Calculate structure factors from the model and update the given difference map accordingly.

    Parameters
    ----------
    imol_model : int
    imol_map_with_data_attached : int
    imol_updating_difference_map : int

    """
    return _coot.sfcalc_genmap(imol_model, imol_map_with_data_attached, imol_updating_difference_map)

def set_auto_updating_sfcalc_genmap(imol_model, imol_map_with_data_attached, imol_updating_difference_map):
    r"""
    set_auto_updating_sfcalc_genmap(int imol_model, int imol_map_with_data_attached, int imol_updating_difference_map)

    As above, calculate structure factors from the model and update the given difference map accordingly - but difference map gets updated automatically on modification of the imol_model molecule.

    Parameters
    ----------
    imol_model : int
    imol_map_with_data_attached : int
    imol_updating_difference_map : int

    """
    return _coot.set_auto_updating_sfcalc_genmap(imol_model, imol_map_with_data_attached, imol_updating_difference_map)

def set_auto_updating_sfcalc_genmaps(imol_model, imol_map_with_data_attached, imol_updating_2fofc_map, imol_updating_difference_map):
    r"""
    set_auto_updating_sfcalc_genmaps(int imol_model, int imol_map_with_data_attached, int imol_updating_2fofc_map, int imol_updating_difference_map)

    As above, calculate structure factors from the model and update the given difference map accordingly - but the 2fofc and difference map get updated automatically on modification of the imol_model molecule.

    Parameters
    ----------
    imol_model : int
    imol_map_with_data_attached : int
    imol_updating_2fofc_map : int
    imol_updating_difference_map : int

    """
    return _coot.set_auto_updating_sfcalc_genmaps(imol_model, imol_map_with_data_attached, imol_updating_2fofc_map, imol_updating_difference_map)

def get_map_colour_py(imol):
    r"""
    get_map_colour_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.get_map_colour_py(imol)

def set_scroll_wheel_map(imap):
    r"""
    set_scroll_wheel_map(int imap)

    set the map that is moved by changing the scroll wheel and change_contour_level() .

    Parameters
    ----------
    imap : int

    """
    return _coot.set_scroll_wheel_map(imap)

def set_scrollable_map(imol):
    r"""
    set_scrollable_map(int imol)

    return the molecule number to which the mouse scroll wheel is attached

    set the map that has its contour level changed by the scrolling the mouse wheel to molecule number imol (same as set_scroll_wheel_map() ).

    Parameters
    ----------
    imol : int

    """
    return _coot.set_scrollable_map(imol)

def scroll_wheel_map():
    r"""
    scroll_wheel_map() -> int

    the contouring of which map is altered when the scroll wheel changes?

    """
    return _coot.scroll_wheel_map()

def save_previous_map_colour(imol):
    r"""
    save_previous_map_colour(int imol)

    save previous colour map for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.save_previous_map_colour(imol)

def restore_previous_map_colour(imol):
    r"""
    restore_previous_map_colour(int imol)

    restore previous colour map for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.restore_previous_map_colour(imol)

def set_active_map_drag_flag(t):
    r"""
    set_active_map_drag_flag(int t)

    set the state of immediate map upate on map drag.

    By default, it is on (t=1). On slower computers it might be better to set t=0.

    Parameters
    ----------
    t : int

    """
    return _coot.set_active_map_drag_flag(t)

def get_active_map_drag_flag():
    r"""
    get_active_map_drag_flag() -> short

    return the state of the dragged map flag

    """
    return _coot.get_active_map_drag_flag()

def set_last_map_colour(f1, f2, f3):
    r"""
    set_last_map_colour(double f1, double f2, double f3)

    set the colour of the last (highest molecule number) map

    Parameters
    ----------
    f1 : float
    f2 : float
    f3 : float

    """
    return _coot.set_last_map_colour(f1, f2, f3)

def set_map_colour(imol, red, green, blue):
    r"""
    set_map_colour(int imol, float red, float green, float blue)

    set the colour of the imolth map

    Parameters
    ----------
    imol : int
    red : float
    green : float
    blue : float

    """
    return _coot.set_map_colour(imol, red, green, blue)

def set_map_hexcolour(imol, hex_colour):
    r"""
    set_map_hexcolour(int imol, char const * hex_colour)

    set the colour of the imolth map using a (7-character) hex colour

    Parameters
    ----------
    imol : int
    hex_colour : str

    """
    return _coot.set_map_hexcolour(imol, hex_colour)

def set_contour_level_absolute(imol_map, level):
    r"""
    set_contour_level_absolute(int imol_map, float level)

    set the contour level, direct control

    Parameters
    ----------
    imol_map : int
    level : float

    """
    return _coot.set_contour_level_absolute(imol_map, level)

def set_contour_level_in_sigma(imol_map, level):
    r"""
    set_contour_level_in_sigma(int imol_map, float level)

    set the contour level, direct control in r.m.s.d. (if you like that sort of thing)

    Parameters
    ----------
    imol_map : int
    level : float

    """
    return _coot.set_contour_level_in_sigma(imol_map, level)

def get_contour_level_absolute(imol):
    r"""
    get_contour_level_absolute(int imol) -> float

    get the contour level

    Parameters
    ----------
    imol : int

    """
    return _coot.get_contour_level_absolute(imol)

def get_contour_level_in_sigma(imol):
    r"""
    get_contour_level_in_sigma(int imol) -> float

    get the contour level in rmd above 0.

    Parameters
    ----------
    imol : int

    """
    return _coot.get_contour_level_in_sigma(imol)

def set_last_map_sigma_step(f):
    r"""
    set_last_map_sigma_step(float f)

    set the sigma step of the last map to f sigma

    Parameters
    ----------
    f : float

    """
    return _coot.set_last_map_sigma_step(f)

def set_contour_by_sigma_step_by_mol(imol, f, state):
    r"""
    set_contour_by_sigma_step_by_mol(int imol, float f, short state)

    set the contour level step

    set the contour level step of molecule number imol to f and variable state (setting state to 0 turns off contouring by sigma level)

    Parameters
    ----------
    imol : int
    f : float
    state : int

    """
    return _coot.set_contour_by_sigma_step_by_mol(imol, f, state)

def data_resolution(imol):
    r"""
    data_resolution(int imol) -> float

    return the resolution of the data for molecule number imol. Return negative number on error, otherwise resolution in A (eg. 2.0)

    Parameters
    ----------
    imol : int

    """
    return _coot.data_resolution(imol)

def model_resolution(imol):
    r"""
    model_resolution(int imol) -> float

    return the resolution set in the header of the model/coordinates file. If this number is not available, return a number less than 0.

    Parameters
    ----------
    imol : int

    """
    return _coot.model_resolution(imol)

def export_map(imol, filename):
    r"""
    export_map(int imol, char const * filename) -> int

    export (write to disk) the map of molecule number imol to filename.

    Return 0 on failure, 1 on success.

    Parameters
    ----------
    imol : int
    filename : str

    """
    return _coot.export_map(imol, filename)

def export_map_fragment(imol, x, y, z, radius, filename):
    r"""
    export_map_fragment(int imol, float x, float y, float z, float radius, char const * filename) -> int

    export a fragment of the map about (x,y,z)

    Parameters
    ----------
    imol : int
    x : float
    y : float
    z : float
    radius : float
    filename : str

    """
    return _coot.export_map_fragment(imol, x, y, z, radius, filename)

def export_map_fragment_with_text_radius(imol, radius_text, filename):
    r"""
    export_map_fragment_with_text_radius(int imol, char const * radius_text, char const * filename)

    convenience function, called from callbacks.c

    Parameters
    ----------
    imol : int
    radius_text : str
    filename : str

    """
    return _coot.export_map_fragment_with_text_radius(imol, radius_text, filename)

def export_map_fragment_with_origin_shift(imol, x, y, z, radius, filename):
    r"""
    export_map_fragment_with_origin_shift(int imol, float x, float y, float z, float radius, char const * filename) -> int

    export a fragment of the map about (x,y,z)

    Parameters
    ----------
    imol : int
    x : float
    y : float
    z : float
    radius : float
    filename : str

    """
    return _coot.export_map_fragment_with_origin_shift(imol, x, y, z, radius, filename)

def export_map_fragment_to_plain_file(imol, x, y, z, radius, filename):
    r"""
    export_map_fragment_to_plain_file(int imol, float x, float y, float z, float radius, char const * filename) -> int

    tmp interface for Hamish

    Parameters
    ----------
    imol : int
    x : float
    y : float
    z : float
    radius : float
    filename : str

    """
    return _coot.export_map_fragment_to_plain_file(imol, x, y, z, radius, filename)

def transform_map_raw(imol, r00, r01, r02, r10, r11, r12, r20, r21, r22, t0, t1, t2, pt0, pt1, pt2, box_half_size, ref_space_group, cell_a, cell_b, cell_c, alpha, beta, gamma):
    r"""
    transform_map_raw(int imol, double r00, double r01, double r02, double r10, double r11, double r12, double r20, double r21, double r22, double t0, double t1, double t2, double pt0, double pt1, double pt2, double box_half_size, char const * ref_space_group, double cell_a, double cell_b, double cell_c, double alpha, double beta, double gamma) -> int


    Parameters
    ----------
    imol : int
    r00 : float
    r01 : float
    r02 : float
    r10 : float
    r11 : float
    r12 : float
    r20 : float
    r21 : float
    r22 : float
    t0 : float
    t1 : float
    t2 : float
    pt0 : float
    pt1 : float
    pt2 : float
    box_half_size : float
    ref_space_group : str
    cell_a : float
    cell_b : float
    cell_c : float
    alpha : float
    beta : float
    gamma : float

    """
    return _coot.transform_map_raw(imol, r00, r01, r02, r10, r11, r12, r20, r21, r22, t0, t1, t2, pt0, pt1, pt2, box_half_size, ref_space_group, cell_a, cell_b, cell_c, alpha, beta, gamma)

def difference_map(imol1, imol2, map_scale):
    r"""
    difference_map(int imol1, int imol2, float map_scale) -> int

    make a difference map, taking map_scale * imap2 from imap1, on the grid of imap1. Return the new molecule number. Return -1 on failure.

    Parameters
    ----------
    imol1 : int
    imol2 : int
    map_scale : float

    """
    return _coot.difference_map(imol1, imol2, map_scale)

def set_map_has_symmetry(imol, state):
    r"""
    set_map_has_symmetry(int imol, int state)

    by default, maps that are P1 and have 90 degree angles are considered as maps without symmetry (i.e. EM maps). In some cases though P1 maps do/should have symmetry - and this is the means by you can tell Coot that.

      imol  is the moleculle number to be acted on   state  the desired state, a value of 1 turns on map symmetry

    Parameters
    ----------
    imol : int
        is the moleculle number to be acted on
    state : int
        the desired state, a value of 1 turns on map symmetry

    """
    return _coot.set_map_has_symmetry(imol, state)

def reinterp_map(map_no, reference_map_no):
    r"""
    reinterp_map(int map_no, int reference_map_no) -> int

    make a new map (a copy of map_no) that is in the cell, spacegroup and gridding of the map in reference_map_no.

    Return the new map molecule number - return -1 on failure

    Parameters
    ----------
    map_no : int
    reference_map_no : int

    """
    return _coot.reinterp_map(map_no, reference_map_no)

def smooth_map(map_no, sampling_multiplier):
    r"""
    smooth_map(int map_no, float sampling_multiplier) -> int

    make a new map (a copy of map_no) that is in the cell, spacegroup and a multiple of the sampling of the input map (a sampling factor of more than 1 makes the output maps smoother)

    Parameters
    ----------
    map_no : int
    sampling_multiplier : float

    """
    return _coot.smooth_map(map_no, sampling_multiplier)

def average_map_py(map_number_and_scales):
    r"""
    average_map_py(PyObject * map_number_and_scales) -> int

    make an average map from the map_number_and_scales (which is a list of pairs [map_number, scale_factor] (the scale factors are typically 1.0 of course). The output map is in the same grid as the first (valid) map. Return -1 on failure to make an averaged map, otherwise return the new map molecule number.

    Parameters
    ----------
    map_number_and_scales : object

    """
    return _coot.average_map_py(map_number_and_scales)

def regen_map_py(imol_map, map_number_and_scales):
    r"""
    regen_map_py(int imol_map, PyObject * map_number_and_scales)

    Somewhat similar to the above function, except in this case we overwrite the imol_map and we also presume that the grid sampling of the contributing maps match. This makes it much faster to generate than an average map.

    Parameters
    ----------
    imol_map : int
    map_number_and_scales : object

    """
    return _coot.regen_map_py(imol_map, map_number_and_scales)

def get_text_for_iso_level_increment_entry(imol):
    r"""
    get_text_for_iso_level_increment_entry(int imol) -> char *


    Parameters
    ----------
    imol : int

    """
    return _coot.get_text_for_iso_level_increment_entry(imol)

def get_text_for_diff_map_iso_level_increment_entry(imol):
    r"""
    get_text_for_diff_map_iso_level_increment_entry(int imol) -> char *


    Parameters
    ----------
    imol : int

    """
    return _coot.get_text_for_diff_map_iso_level_increment_entry(imol)

def set_iso_level_increment(val):
    r"""
    set_iso_level_increment(float val)

    set the contour scroll step (in absolute e/A3) for 2Fo-Fc-style maps to val

    The is only activated when scrolling by sigma is turned off

    Parameters
    ----------
    val : float

    """
    return _coot.set_iso_level_increment(val)

def get_iso_level_increment():
    r"""get_iso_level_increment() -> float"""
    return _coot.get_iso_level_increment()

def set_iso_level_increment_from_text(text, imol):
    r"""
    set_iso_level_increment_from_text(char const * text, int imol)


    Parameters
    ----------
    text : str
    imol : int

    """
    return _coot.set_iso_level_increment_from_text(text, imol)

def set_diff_map_iso_level_increment(val):
    r"""
    set_diff_map_iso_level_increment(float val)

    set the contour scroll step for difference map (in absolute e/A3) to val

    The is only activated when scrolling by sigma is turned off

    Parameters
    ----------
    val : float

    """
    return _coot.set_diff_map_iso_level_increment(val)

def get_diff_map_iso_level_increment():
    r"""
    get_diff_map_iso_level_increment() -> float

    return difference maps iso-map level increment

    """
    return _coot.get_diff_map_iso_level_increment()

def set_diff_map_iso_level_increment_from_text(text, imol):
    r"""
    set_diff_map_iso_level_increment_from_text(char const * text, int imol)

    set the difference maps iso-map level increment

    Parameters
    ----------
    text : str
    imol : int

    """
    return _coot.set_diff_map_iso_level_increment_from_text(text, imol)

def set_map_sampling_rate_text(text):
    r"""
    set_map_sampling_rate_text(char const * text)

    sampling rate

    find the molecule for which the single map dialog applies and set the contour level and redraw. This is for use by a GUI callback - not for user use

    Parameters
    ----------
    text : str

    """
    return _coot.set_map_sampling_rate_text(text)

def set_map_sampling_rate(r):
    r"""
    set_map_sampling_rate(float r)

    set the map sampling rate (default 1.8)

    set_map_sampling_rate(float r)

    Set the Shannon Limit multiplier for map sampling (default 1.8).

    The Shannon (Nyquist) sampling theorem requires that a map be sampled at least twice per resolution cycle (d_min/2) to faithfully represent all frequencies present. This parameter sets the multiplier above that theoretical minimum — so the default of 1.5 means maps are sampled at 1.5 × the Shannon limit (i.e., grid spacing = d_min / 3.0).

    Higher values (e.g. 2.0–2.5) produce more finely sampled maps, which can be useful for low-resolution baton-building or visual inspection, since they are more visually attractive-looking, at the cost of larger map files and slower computation.

    Set to something like 2.0 or 2.5 for more finely sampled maps. Useful for baton-building low resolution maps.

    Parameters
    ----------
    r : float

    """
    return _coot.set_map_sampling_rate(r)

def get_text_for_map_sampling_rate_text():
    r"""get_text_for_map_sampling_rate_text() -> char *"""
    return _coot.get_text_for_map_sampling_rate_text()

def get_map_sampling_rate():
    r"""
    get_map_sampling_rate() -> float

    return the map sampling rate

    """
    return _coot.get_map_sampling_rate()

def change_contour_level(is_increment):
    r"""
    change_contour_level(short is_increment)

    change the contour level of the current map by a step

    if is_increment=1 the contour level is increased. If is_increment=0 the map contour level is decreased.

    Parameters
    ----------
    is_increment : int

    """
    return _coot.change_contour_level(is_increment)

def set_last_map_contour_level(level):
    r"""
    set_last_map_contour_level(float level)

    set the contour level of the map with the highest molecule number to level

    Parameters
    ----------
    level : float

    """
    return _coot.set_last_map_contour_level(level)

def set_last_map_contour_level_by_sigma(n_sigma):
    r"""
    set_last_map_contour_level_by_sigma(float n_sigma)

    set the contour level of the map with the highest molecule number to n_sigma sigma

    Parameters
    ----------
    n_sigma : float

    """
    return _coot.set_last_map_contour_level_by_sigma(n_sigma)

def set_stop_scroll_diff_map(i):
    r"""
    set_stop_scroll_diff_map(int i)

    create a lower limit to the "Fo-Fc-style" map contour level changing

    (default 1 on)

    Parameters
    ----------
    i : int

    """
    return _coot.set_stop_scroll_diff_map(i)

def set_stop_scroll_iso_map(i):
    r"""
    set_stop_scroll_iso_map(int i)

    create a lower limit to the "2Fo-Fc-style" map contour level changing

    (default 1 on)

    Parameters
    ----------
    i : int

    """
    return _coot.set_stop_scroll_iso_map(i)

def set_stop_scroll_iso_map_level(f):
    r"""
    set_stop_scroll_iso_map_level(float f)

    set the actual map level changing limit

    (default 0.0)

    Parameters
    ----------
    f : float

    """
    return _coot.set_stop_scroll_iso_map_level(f)

def set_stop_scroll_diff_map_level(f):
    r"""
    set_stop_scroll_diff_map_level(float f)

    set the actual difference map level changing limit

    (default 0.0)

    Parameters
    ----------
    f : float

    """
    return _coot.set_stop_scroll_diff_map_level(f)

def set_residue_density_fit_scale_factor(f):
    r"""
    set_residue_density_fit_scale_factor(float f)

    set the scale factor for the Residue Density fit analysis

    Parameters
    ----------
    f : float

    """
    return _coot.set_residue_density_fit_scale_factor(f)

def set_map_line_width(w):
    r"""
    set_map_line_width(int w)

    draw the lines of the chickenwire density in width w

    Parameters
    ----------
    w : int

    """
    return _coot.set_map_line_width(w)

def map_line_width_state():
    r"""
    map_line_width_state() -> int

    return the width in which density contours are drawn

    """
    return _coot.map_line_width_state()

def make_and_draw_map(mtz_file_name, f_col, phi_col, weight, use_weights, is_diff_map):
    r"""
    make_and_draw_map(char const * mtz_file_name, char const * f_col, char const * phi_col, char const * weight, int use_weights, int is_diff_map) -> int

    make a map from an mtz file (simple interface)

    given mtz file mtz_file_name and F column f_col and phases column phi_col and optional weight column weight_col (pass use_weights=0 if weights are not to be used). Also mark the map as a difference map (is_diff_map=1) or not (is_diff_map=0) because they are handled differently inside coot.

    -1 on error, else return the new molecule number

    Parameters
    ----------
    mtz_file_name : str
    f_col : str
    phi_col : str
    weight : str
    use_weights : int
    is_diff_map : int

    """
    return _coot.make_and_draw_map(mtz_file_name, f_col, phi_col, weight, use_weights, is_diff_map)

def read_mtz(mtz_file_name, f_col, phi_col, weight, use_weights, is_diff_map):
    r"""
    read_mtz(char const * mtz_file_name, char const * f_col, char const * phi_col, char const * weight, int use_weights, int is_diff_map) -> int

    the function is a synonym of the above function - which now has an archaic-style name

    Parameters
    ----------
    mtz_file_name : str
    f_col : str
    phi_col : str
    weight : str
    use_weights : int
    is_diff_map : int

    """
    return _coot.read_mtz(mtz_file_name, f_col, phi_col, weight, use_weights, is_diff_map)

def make_and_draw_map_with_refmac_params(mtz_file_name, a, b, weight, use_weights, is_diff_map, have_refmac_params, fobs_col, sigfobs_col, r_free_col, sensible_f_free_col):
    r"""
    make_and_draw_map_with_refmac_params(char const * mtz_file_name, char const * a, char const * b, char const * weight, int use_weights, int is_diff_map, short have_refmac_params, char const * fobs_col, char const * sigfobs_col, char const * r_free_col, short sensible_f_free_col) -> int

    as the above function, execpt set refmac parameters too

    pass along the refmac column labels for storage (not used in the creation of the map)

    -1 on error, else return imol

    Parameters
    ----------
    mtz_file_name : str
    a : str
    b : str
    weight : str
    use_weights : int
    is_diff_map : int
    have_refmac_params : int
    fobs_col : str
    sigfobs_col : str
    r_free_col : str
    sensible_f_free_col : int

    """
    return _coot.make_and_draw_map_with_refmac_params(mtz_file_name, a, b, weight, use_weights, is_diff_map, have_refmac_params, fobs_col, sigfobs_col, r_free_col, sensible_f_free_col)

def make_and_draw_map_with_reso_with_refmac_params(mtz_file_name, a, b, weight, use_weights, is_diff_map, have_refmac_params, fobs_col, sigfobs_col, r_free_col, sensible_f_free_col, is_anomalous, use_reso_limits, low_reso_limit, high_reso_lim):
    r"""
    make_and_draw_map_with_reso_with_refmac_params(char const * mtz_file_name, char const * a, char const * b, char const * weight, int use_weights, int is_diff_map, short have_refmac_params, char const * fobs_col, char const * sigfobs_col, char const * r_free_col, short sensible_f_free_col, short is_anomalous, short use_reso_limits, float low_reso_limit, float high_reso_lim) -> int

    as the above function, except set expert options too.

    Parameters
    ----------
    mtz_file_name : str
    a : str
    b : str
    weight : str
    use_weights : int
    is_diff_map : int
    have_refmac_params : int
    fobs_col : str
    sigfobs_col : str
    r_free_col : str
    sensible_f_free_col : int
    is_anomalous : int
    use_reso_limits : int
    low_reso_limit : float
    high_reso_lim : float

    """
    return _coot.make_and_draw_map_with_reso_with_refmac_params(mtz_file_name, a, b, weight, use_weights, is_diff_map, have_refmac_params, fobs_col, sigfobs_col, r_free_col, sensible_f_free_col, is_anomalous, use_reso_limits, low_reso_limit, high_reso_lim)

def make_updating_map(mtz_file_name, f_col, phi_col, weight, use_weights, is_diff_map):
    r"""
    make_updating_map(char const * mtz_file_name, char const * f_col, char const * phi_col, char const * weight, int use_weights, int is_diff_map) -> int

    make a map molecule from the give file name.

    If the file updates, then the map will be updated.

    Parameters
    ----------
    mtz_file_name : str
    f_col : str
    phi_col : str
    weight : str
    use_weights : int
    is_diff_map : int

    """
    return _coot.make_updating_map(mtz_file_name, f_col, phi_col, weight, use_weights, is_diff_map)

def stop_updating_molecule(imol):
    r"""
    stop_updating_molecule(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.stop_updating_molecule(imol)

def refmac_parameters_py(imol):
    r"""
    refmac_parameters_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.refmac_parameters_py(imol)

def mtz_file_has_phases_p(mtz_file_name):
    r"""
    mtz_file_has_phases_p(char const * mtz_file_name) -> int

    does the mtz file have phases?

    Parameters
    ----------
    mtz_file_name : str

    """
    return _coot.mtz_file_has_phases_p(mtz_file_name)

def is_mtz_file_p(filename):
    r"""
    is_mtz_file_p(char const * filename) -> int

    is the given filename an mtz file?

    Parameters
    ----------
    filename : str

    """
    return _coot.is_mtz_file_p(filename)

def cns_file_has_phases_p(cns_file_name):
    r"""
    cns_file_has_phases_p(char const * cns_file_name) -> int

    does the given file have cns phases?

    Parameters
    ----------
    cns_file_name : str

    """
    return _coot.cns_file_has_phases_p(cns_file_name)

def wrapped_auto_read_make_and_draw_maps(filename):
    r"""
    wrapped_auto_read_make_and_draw_maps(char const * filename)


    Parameters
    ----------
    filename : str

    """
    return _coot.wrapped_auto_read_make_and_draw_maps(filename)

def set_auto_read_do_difference_map_too(i):
    r"""
    set_auto_read_do_difference_map_too(int i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_auto_read_do_difference_map_too(i)

def auto_read_do_difference_map_too_state():
    r"""
    auto_read_do_difference_map_too_state() -> int

    return the flag to do a difference map (too) on auto-read MTZ

    0 means no, 1 means yes.

    """
    return _coot.auto_read_do_difference_map_too_state()

def set_auto_read_column_labels(fwt, phwt, is_for_diff_map_flag):
    r"""
    set_auto_read_column_labels(char const * fwt, char const * phwt, int is_for_diff_map_flag)

    set the expected MTZ columns for Auto-reading MTZ file.

    Not every program uses the default refmac labels ("FWT"/"PHWT") for its MTZ file. Here we can tell coot to expect other labels so that coot can "Auto-open" such MTZ files.

    e.g. (set-auto-read-column-labels "2FOFCWT" "PH2FOFCWT" 0)

    Parameters
    ----------
    fwt : str
    phwt : str
    is_for_diff_map_flag : int

    """
    return _coot.set_auto_read_column_labels(fwt, phwt, is_for_diff_map_flag)

def get_text_for_density_size_widget():
    r"""get_text_for_density_size_widget() -> char *"""
    return _coot.get_text_for_density_size_widget()

def set_density_size_from_widget(text):
    r"""
    set_density_size_from_widget(char const * text)


    Parameters
    ----------
    text : str

    """
    return _coot.set_density_size_from_widget(text)

def get_text_for_density_size_em_widget():
    r"""get_text_for_density_size_em_widget() -> char *"""
    return _coot.get_text_for_density_size_em_widget()

def set_density_size_em_from_widget(text):
    r"""
    set_density_size_em_from_widget(char const * text)


    Parameters
    ----------
    text : str

    """
    return _coot.set_density_size_em_from_widget(text)

def set_map_radius(f):
    r"""
    set_map_radius(float f)

    set the extent of the box/radius of electron density contours for x-ray maps

    Parameters
    ----------
    f : float

    """
    return _coot.set_map_radius(f)

def set_map_radius_em(radius):
    r"""
    set_map_radius_em(float radius)

    set the extent of the box/radius of electron density contours for EM map

    Parameters
    ----------
    radius : float

    """
    return _coot.set_map_radius_em(radius)

def set_density_size(f):
    r"""
    set_density_size(float f)

    another (old) way of setting the radius of the map

    Parameters
    ----------
    f : float

    """
    return _coot.set_density_size(f)

def set_map_radius_slider_max(f):
    r"""
    set_map_radius_slider_max(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_map_radius_slider_max(f)

def set_display_intro_string(str):
    r"""
    set_display_intro_string(char const * str)

    Give me this nice message str when I start coot.

    Parameters
    ----------
    str : str

    """
    return _coot.set_display_intro_string(str)

def get_map_radius():
    r"""
    get_map_radius() -> float

    return the extent of the box/radius of electron density contours

    """
    return _coot.get_map_radius()

def get_map_radius_em():
    r"""get_map_radius_em() -> float"""
    return _coot.get_map_radius_em()

def set_esoteric_depth_cue(istate):
    r"""
    set_esoteric_depth_cue(int istate)

    not everyone likes coot's esoteric depth cueing system

    Pass an argument istate=1 to turn it off

    (this function is currently disabled).

    Parameters
    ----------
    istate : int

    """
    return _coot.set_esoteric_depth_cue(istate)

def esoteric_depth_cue_state():
    r"""
    esoteric_depth_cue_state() -> int

    native depth cueing system

    return the state of the esoteric depth cueing flag

    """
    return _coot.esoteric_depth_cue_state()

def set_swap_difference_map_colours(i):
    r"""
    set_swap_difference_map_colours(int i)

    not everone likes coot's default difference map colouring.

    Pass an argument i=1 to swap the difference map colouring so that red is positive and green is negative.

    Parameters
    ----------
    i : int

    """
    return _coot.set_swap_difference_map_colours(i)

def swap_difference_map_colours_state():
    r"""swap_difference_map_colours_state() -> int"""
    return _coot.swap_difference_map_colours_state()

def set_map_is_difference_map(imol, bool_flag):
    r"""
    set_map_is_difference_map(int imol, short bool_flag) -> int

    post-hoc set the map of molecule number imol to be a difference map

    success status, 0 -> failure (imol does not have a map)

    Parameters
    ----------
    imol : int
    bool_flag : int

    """
    return _coot.set_map_is_difference_map(imol, bool_flag)

def map_is_difference_map(imol):
    r"""
    map_is_difference_map(int imol) -> int

    map is difference map?

    Parameters
    ----------
    imol : int

    """
    return _coot.map_is_difference_map(imol)

def another_level():
    r"""
    another_level() -> int

    Add another contour level for the last added map.

    Currently, the map must have been generated from an MTZ file. the molecule number of the new molecule or -1 on failure

    """
    return _coot.another_level()

def another_level_from_map_molecule_number(imap):
    r"""
    another_level_from_map_molecule_number(int imap) -> int

    Add another contour level for the given map.

    Currently, the map must have been generated from an MTZ file. the molecule number of the new molecule or -1 on failure

    Parameters
    ----------
    imap : int

    """
    return _coot.another_level_from_map_molecule_number(imap)

def residue_density_fit_scale_factor():
    r"""
    residue_density_fit_scale_factor() -> float

    return the scale factor for the Residue Density fit analysis

    """
    return _coot.residue_density_fit_scale_factor()

def density_at_point(imol_map, x, y, z):
    r"""
    density_at_point(int imol_map, float x, float y, float z) -> float

    return the density at the given point for the given map. Return 0 for bad imol

    Parameters
    ----------
    imol_map : int
    x : float
    y : float
    z : float

    """
    return _coot.density_at_point(imol_map, x, y, z)

def mtz_hklin_for_map(imol_map):
    r"""
    mtz_hklin_for_map(int imol_map) -> char const *

    return the mtz file that was use to generate the map

    return 0 when there is no mtz file associated with that map (it was generated from a CCP4 map file say).

    Parameters
    ----------
    imol_map : int

    """
    return _coot.mtz_hklin_for_map(imol_map)

def mtz_fp_for_map(imol_map):
    r"""
    mtz_fp_for_map(int imol_map) -> char const *

    return the FP column in the file that was use to generate the map

    return 0 when there is no mtz file associated with that map (it was generated from a CCP4 map file say).

    Caller should dispose of returned pointer.

    Parameters
    ----------
    imol_map : int

    """
    return _coot.mtz_fp_for_map(imol_map)

def mtz_phi_for_map(imol_map):
    r"""
    mtz_phi_for_map(int imol_map) -> char const *

    return the phases column in mtz file that was use to generate the map

    return 0 when there is no mtz file associated with that map (it was generated from a CCP4 map file say). Caller should dispose of returned pointer.

    Parameters
    ----------
    imol_map : int

    """
    return _coot.mtz_phi_for_map(imol_map)

def mtz_weight_for_map(imol_map):
    r"""
    mtz_weight_for_map(int imol_map) -> char const *

    return the weight column in the mtz file that was use to generate the map

    return 0 when there is no mtz file associated with that map (it was generated from a CCP4 map file say) or no weights were used. Caller should dispose of returned pointer.

    Parameters
    ----------
    imol_map : int

    """
    return _coot.mtz_weight_for_map(imol_map)

def mtz_use_weight_for_map(imol_map):
    r"""
    mtz_use_weight_for_map(int imol_map) -> short

    return flag for whether weights were used that was use to generate the map

    return 0 when no weights were used or there is no mtz file associated with that map.

    Parameters
    ----------
    imol_map : int

    """
    return _coot.mtz_use_weight_for_map(imol_map)

def map_parameters_py(imol):
    r"""
    map_parameters_py(int imol) -> PyObject *

    return the parameter of the molecule, something like (45 46 47 90 90 120), angles in degress

    return the parameter that made the map,

    False or something like ["xxx.mtz", "FPH", "PHWT", "", False]

    Parameters
    ----------
    imol : int

    """
    return _coot.map_parameters_py(imol)

def cell_py(imol):
    r"""
    cell_py(int imol) -> PyObject *

    return the parameter that made the map,

    False or something like [45, 46, 47, 90, 90, 120], angles in degress

    Parameters
    ----------
    imol : int

    """
    return _coot.cell_py(imol)

def write_pdb_file(imol, file_name):
    r"""
    write_pdb_file(int imol, char const * file_name) -> int

    write molecule number imol as a PDB to file file_name

    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.write_pdb_file(imol, file_name)

def write_cif_file(imol, file_name):
    r"""
    write_cif_file(int imol, char const * file_name) -> int

    write molecule number imol as a mmCIF to file file_name

    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.write_cif_file(imol, file_name)

def write_residue_range_to_pdb_file(imol, chainid, resno_start, resno_end, filename):
    r"""
    write_residue_range_to_pdb_file(int imol, char const * chainid, int resno_start, int resno_end, char const * filename) -> int

    write molecule number imol's residue range as a PDB to file file_name

    Parameters
    ----------
    imol : int
    chainid : str
    resno_start : int
    resno_end : int
    filename : str

    """
    return _coot.write_residue_range_to_pdb_file(imol, chainid, resno_start, resno_end, filename)

def write_chain_to_pdb_file(imol, chainid, filename):
    r"""
    write_chain_to_pdb_file(int imol, char const * chainid, char const * filename) -> int


    Parameters
    ----------
    imol : int
    chainid : str
    filename : str

    """
    return _coot.write_chain_to_pdb_file(imol, chainid, filename)

def quick_save():
    r"""
    quick_save() -> int

    save all modified coordinates molecules to the default names and save the state too.

    """
    return _coot.quick_save()

def get_write_conect_record_state():
    r"""
    get_write_conect_record_state() -> int

    return the state of the write_conect_records_flag.

    """
    return _coot.get_write_conect_record_state()

def set_write_conect_record_state(state):
    r"""
    set_write_conect_record_state(int state)

    set the flag to write (or not) conect records to the PDB file.

    Parameters
    ----------
    state : int

    """
    return _coot.set_write_conect_record_state(state)

def info_dialog(txt):
    r"""
    info_dialog(char const * txt)

    create a dialog with information

    create a dialog with information string txt. User has to click to dismiss it, but it is not modal (nothing in coot is modal).

    Parameters
    ----------
    txt : str

    """
    return _coot.info_dialog(txt)

def info_dialog_and_text(txt):
    r"""
    info_dialog_and_text(char const * txt)

    create a dialog with information and print to console

    as info_dialog but print to console as well.

    Parameters
    ----------
    txt : str

    """
    return _coot.info_dialog_and_text(txt)

def info_dialog_with_markup(txt):
    r"""
    info_dialog_with_markup(char const * txt)

    as above, create a dialog with information

    This dialog is left-justified and can use markup such as angled bracketted tt or i

    Parameters
    ----------
    txt : str

    """
    return _coot.info_dialog_with_markup(txt)

def ephemeral_overlay_label(txt):
    r"""
    ephemeral_overlay_label(char const * txt)

    created an ephemeral label in the graphics window

    the text stays on screen for about 2 sesconds.

      txt  the text

    Parameters
    ----------
    txt : str
        the text

    """
    return _coot.ephemeral_overlay_label(txt)

def set_refmac_counter(imol, refmac_count):
    r"""
    set_refmac_counter(int imol, int refmac_count)

    set counter for runs of refmac so that this can be used to construct a unique filename for new output

    Parameters
    ----------
    imol : int
    refmac_count : int

    """
    return _coot.set_refmac_counter(imol, refmac_count)

def get_refmac_sad_atom_info_py():
    r"""get_refmac_sad_atom_info_py() -> PyObject *"""
    return _coot.get_refmac_sad_atom_info_py()

def swap_map_colours(imol1, imol2):
    r"""
    swap_map_colours(int imol1, int imol2)

    swap the colours of maps

    swap the colour of maps imol1 and imol2. Useful to some after running refmac, so that the map to be build into is always the same colour

    Parameters
    ----------
    imol1 : int
    imol2 : int

    """
    return _coot.swap_map_colours(imol1, imol2)

def set_keep_map_colour_after_refmac(istate):
    r"""
    set_keep_map_colour_after_refmac(int istate)

    flag to enable above

    call this with istate=1

    Parameters
    ----------
    istate : int

    """
    return _coot.set_keep_map_colour_after_refmac(istate)

def keep_map_colour_after_refmac_state():
    r"""
    keep_map_colour_after_refmac_state() -> int

    the keep-map-colour-after-refmac internal state

    1 for "yes", 0 for "no"

    """
    return _coot.keep_map_colour_after_refmac_state()

def refmac_runs_with_nolabels():
    r"""
    refmac_runs_with_nolabels() -> int


    Parameters
    ----------
     : None

    """
    return _coot.refmac_runs_with_nolabels()

def get_text_for_symmetry_size_widget():
    r"""get_text_for_symmetry_size_widget() -> char *"""
    return _coot.get_text_for_symmetry_size_widget()

def set_symmetry_size_from_widget(text):
    r"""
    set_symmetry_size_from_widget(char const * text)


    Parameters
    ----------
    text : str

    """
    return _coot.set_symmetry_size_from_widget(text)

def set_symmetry_size(f):
    r"""
    set_symmetry_size(float f)

    set the size of the displayed symmetry

    Parameters
    ----------
    f : float

    """
    return _coot.set_symmetry_size(f)

def get_symmetry_bonds_colour(imol):
    r"""
    get_symmetry_bonds_colour(int imol) -> double *


    Parameters
    ----------
    imol : int

    """
    return _coot.get_symmetry_bonds_colour(imol)

def get_show_symmetry():
    r"""
    get_show_symmetry() -> short

    is symmetry master display control on?

    """
    return _coot.get_show_symmetry()

def set_show_symmetry_master(state):
    r"""
    set_show_symmetry_master(short state)

    set display symmetry, master controller

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_symmetry_master(state)

def set_show_symmetry_molecule(mol_no, state):
    r"""
    set_show_symmetry_molecule(int mol_no, short state)

    set display symmetry for molecule number mol_no

    pass with state=0 for off, state=1 for on

    Parameters
    ----------
    mol_no : int
    state : int

    """
    return _coot.set_show_symmetry_molecule(mol_no, state)

def symmetry_as_calphas(mol_no, state):
    r"""
    symmetry_as_calphas(int mol_no, short state)

    display symmetry as CAs?

    pass with state=0 for off, state=1 for on

    Parameters
    ----------
    mol_no : int
    state : int

    """
    return _coot.symmetry_as_calphas(mol_no, state)

def get_symmetry_as_calphas_state(imol):
    r"""
    get_symmetry_as_calphas_state(int imol) -> short

    what is state of display CAs for molecule number mol_no?

    return state=0 for off, state=1 for on

    Parameters
    ----------
    imol : int

    """
    return _coot.get_symmetry_as_calphas_state(imol)

def set_symmetry_molecule_rotate_colour_map(imol, state):
    r"""
    set_symmetry_molecule_rotate_colour_map(int imol, int state)

    set the colour map rotation (i.e. the hue) for the symmetry atoms of molecule number imol

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_symmetry_molecule_rotate_colour_map(imol, state)

def symmetry_molecule_rotate_colour_map_state(imol):
    r"""
    symmetry_molecule_rotate_colour_map_state(int imol) -> int

    should there be colour map rotation (i.e. the hue) change for the symmetry atoms of molecule number imol?

    return state=0 for off, state=1 for on

    Parameters
    ----------
    imol : int

    """
    return _coot.symmetry_molecule_rotate_colour_map_state(imol)

def set_symmetry_colour_by_symop(imol, state):
    r"""
    set_symmetry_colour_by_symop(int imol, int state)

    set symmetry colour by symop mode

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_symmetry_colour_by_symop(imol, state)

def set_symmetry_whole_chain(imol, state):
    r"""
    set_symmetry_whole_chain(int imol, int state)

    set symmetry colour for the chain

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_symmetry_whole_chain(imol, state)

def set_symmetry_atom_labels_expanded(state):
    r"""
    set_symmetry_atom_labels_expanded(int state)

    set use expanded symmetry atom labels

    Parameters
    ----------
    state : int

    """
    return _coot.set_symmetry_atom_labels_expanded(state)

def has_unit_cell_state(imol):
    r"""
    has_unit_cell_state(int imol) -> int

    molecule number imol has a unit cell?

    1 on "yes, it has a cell", 0 for "no"

    Parameters
    ----------
    imol : int

    """
    return _coot.has_unit_cell_state(imol)

def add_symmetry_on_to_preferences_and_apply():
    r"""add_symmetry_on_to_preferences_and_apply()"""
    return _coot.add_symmetry_on_to_preferences_and_apply()

def undo_symmetry_view():
    r"""
    undo_symmetry_view() -> int

    Undo symmetry view. Translate back to main molecule from this symmetry position.

    """
    return _coot.undo_symmetry_view()

def first_molecule_with_symmetry_displayed():
    r"""
    first_molecule_with_symmetry_displayed() -> int

    return the molecule number.

    -1 if there is no molecule with symmetry displayed.

    """
    return _coot.first_molecule_with_symmetry_displayed()

def save_symmetry_coords(imol, filename, symop_no, shift_a, shift_b, shift_c, pre_shift_to_origin_na, pre_shift_to_origin_nb, pre_shift_to_origin_nc):
    r"""
    save_symmetry_coords(int imol, char const * filename, int symop_no, int shift_a, int shift_b, int shift_c, int pre_shift_to_origin_na, int pre_shift_to_origin_nb, int pre_shift_to_origin_nc)

    save the symmetry coordinates of molecule number imol to filename

    Allow a shift of the coordinates to the origin before symmetry expansion is apllied (this is how symmetry works in Coot internals).

    Parameters
    ----------
    imol : int
    filename : str
    symop_no : int
    shift_a : int
    shift_b : int
    shift_c : int
    pre_shift_to_origin_na : int
    pre_shift_to_origin_nb : int
    pre_shift_to_origin_nc : int

    """
    return _coot.save_symmetry_coords(imol, filename, symop_no, shift_a, shift_b, shift_c, pre_shift_to_origin_na, pre_shift_to_origin_nb, pre_shift_to_origin_nc)

def new_molecule_by_symmetry(imol, name, m11, m12, m13, m21, m22, m23, m31, m32, m33, tx, ty, tz, pre_shift_to_origin_na, pre_shift_to_origin_nb, pre_shift_to_origin_nc):
    r"""
    new_molecule_by_symmetry(int imol, char const * name, double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33, double tx, double ty, double tz, int pre_shift_to_origin_na, int pre_shift_to_origin_nb, int pre_shift_to_origin_nc) -> int

    create a new molecule (molecule number is the return value) from imol.

    The rotation/translation matrix components are given in orthogonal coordinates.

    Allow a shift of the coordinates to the origin before symmetry expansion is aplied.

    Pass "" as the name-in and a name will be constructed for you.

    Return -1 on failure.

    Parameters
    ----------
    imol : int
    name : str
    m11 : float
    m12 : float
    m13 : float
    m21 : float
    m22 : float
    m23 : float
    m31 : float
    m32 : float
    m33 : float
    tx : float
    ty : float
    tz : float
    pre_shift_to_origin_na : int
    pre_shift_to_origin_nb : int
    pre_shift_to_origin_nc : int

    """
    return _coot.new_molecule_by_symmetry(imol, name, m11, m12, m13, m21, m22, m23, m31, m32, m33, tx, ty, tz, pre_shift_to_origin_na, pre_shift_to_origin_nb, pre_shift_to_origin_nc)

def new_molecule_by_symmetry_with_atom_selection(imol, name, mmdb_atom_selection_string, m11, m12, m13, m21, m22, m23, m31, m32, m33, tx, ty, tz, pre_shift_to_origin_na, pre_shift_to_origin_nb, pre_shift_to_origin_nc):
    r"""
    new_molecule_by_symmetry_with_atom_selection(int imol, char const * name, char const * mmdb_atom_selection_string, double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33, double tx, double ty, double tz, int pre_shift_to_origin_na, int pre_shift_to_origin_nb, int pre_shift_to_origin_nc) -> int

    create a new molecule (molecule number is the return value) from imol, but only for atom that match the mmdb_atom_selection_string.

    The rotation/translation matrix components are given in orthogonal coordinates.

    Allow a shift of the coordinates to the origin before symmetry expansion is aplied.

    Pass "" as the name-in and a name will be constructed for you.

    Return -1 on failure.

    Parameters
    ----------
    imol : int
    name : str
    mmdb_atom_selection_string : str
    m11 : float
    m12 : float
    m13 : float
    m21 : float
    m22 : float
    m23 : float
    m31 : float
    m32 : float
    m33 : float
    tx : float
    ty : float
    tz : float
    pre_shift_to_origin_na : int
    pre_shift_to_origin_nb : int
    pre_shift_to_origin_nc : int

    """
    return _coot.new_molecule_by_symmetry_with_atom_selection(imol, name, mmdb_atom_selection_string, m11, m12, m13, m21, m22, m23, m31, m32, m33, tx, ty, tz, pre_shift_to_origin_na, pre_shift_to_origin_nb, pre_shift_to_origin_nc)

def new_molecule_by_symop(imol, symop_string, pre_shift_to_origin_na, pre_shift_to_origin_nb, pre_shift_to_origin_nc):
    r"""
    new_molecule_by_symop(int imol, char const * symop_string, int pre_shift_to_origin_na, int pre_shift_to_origin_nb, int pre_shift_to_origin_nc) -> int

    create a new molecule (molecule number is the return value) from imol.

    Parameters
    ----------
    imol : int
    symop_string : str
    pre_shift_to_origin_na : int
    pre_shift_to_origin_nb : int
    pre_shift_to_origin_nc : int

    """
    return _coot.new_molecule_by_symop(imol, symop_string, pre_shift_to_origin_na, pre_shift_to_origin_nb, pre_shift_to_origin_nc)

def n_symops(imol):
    r"""
    n_symops(int imol) -> int

    return the number of symmetry operators for the given molecule

    return -1 on no-symmetry for molecule or inappropriate imol number

    Parameters
    ----------
    imol : int

    """
    return _coot.n_symops(imol)

def move_reference_chain_to_symm_chain_position():
    r"""move_reference_chain_to_symm_chain_position() -> int"""
    return _coot.move_reference_chain_to_symm_chain_position()

def origin_pre_shift_py(imol):
    r"""
    origin_pre_shift_py(int imol) -> PyObject *

    return the pre-shift (the shift that translates the centre of the molecule as close as possible to the origin) as a list of ints or Python false on failure

    Parameters
    ----------
    imol : int

    """
    return _coot.origin_pre_shift_py(imol)

def setup_save_symmetry_coords():
    r"""setup_save_symmetry_coords()"""
    return _coot.setup_save_symmetry_coords()

def set_space_group(imol, spg):
    r"""
    set_space_group(int imol, char const * spg) -> short

    set the space group for a coordinates molecule

    for shelx FA pdb files, there is no space group. So allow the user to set it. This can be initted with a HM symbol or a symm list for clipper.

    This will only work on model molecules.

    the success status of the setting (1 good, 0 fail).

    Parameters
    ----------
    imol : int
    spg : str

    """
    return _coot.set_space_group(imol, spg)

def set_unit_cell_and_space_group(imol, a, b, c, alpha, beta, gamma, space_group):
    r"""
    set_unit_cell_and_space_group(int imol, float a, float b, float c, float alpha, float beta, float gamma, char const * space_group) -> int

    set the unit cell for a given model molecule

    Angles in degress, cell lengths in Angstroms.

    the success status of the setting (1 good, 0 fail).

    Parameters
    ----------
    imol : int
    a : float
    b : float
    c : float
    alpha : float
    beta : float
    gamma : float
    space_group : str

    """
    return _coot.set_unit_cell_and_space_group(imol, a, b, c, alpha, beta, gamma, space_group)

def set_unit_cell_and_space_group_using_molecule(imol, imol_from):
    r"""
    set_unit_cell_and_space_group_using_molecule(int imol, int imol_from) -> int

    set the unit cell for a given model molecule using the cell of moecule imol_from

    This will only work on model molecules. the success status of the setting (1 good, 0 fail).

    Parameters
    ----------
    imol : int
    imol_from : int

    """
    return _coot.set_unit_cell_and_space_group_using_molecule(imol, imol_from)

def set_symmetry_shift_search_size(shift):
    r"""
    set_symmetry_shift_search_size(int shift)

    set the cell shift search size for symmetry searching.

    When the coordinates for one (or some) symmetry operator are missing (which happens sometimes, but rarely), try changing setting this to 2 (default is 1). It slows symmetry searching, which is why it is not set to 2 by default.

    Parameters
    ----------
    shift : int

    """
    return _coot.set_symmetry_shift_search_size(shift)

def save_coords_name_suggestion_py(imol):
    r"""
    save_coords_name_suggestion_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.save_coords_name_suggestion_py(imol)

def print_all_history_in_scheme():
    r"""
    print_all_history_in_scheme()

    print the history in scheme format

    """
    return _coot.print_all_history_in_scheme()

def print_all_history_in_python():
    r"""
    print_all_history_in_python()

    print the history in python format

    """
    return _coot.print_all_history_in_python()

def set_console_display_commands_state(istate):
    r"""
    set_console_display_commands_state(short istate)

    set a flag to show the text command equivalent of gui commands in the console as they happen.

    1 for on, 0 for off.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_console_display_commands_state(istate)

def set_console_display_commands_hilights(bold_flag, colour_flag, colour_index):
    r"""
    set_console_display_commands_hilights(short bold_flag, short colour_flag, int colour_index)

    set a flag to show the text command equivalent of gui commands in the console as they happen in bold and colours.

    colour_flag: pass 1 for on, 0 for off.

    colour_index 0 to 7 inclusive for various different colourings.

    Parameters
    ----------
    bold_flag : int
    colour_flag : int
    colour_index : int

    """
    return _coot.set_console_display_commands_hilights(bold_flag, colour_flag, colour_index)

def scale_up_graphics():
    r"""scale_up_graphics()"""
    return _coot.scale_up_graphics()

def scale_down_graphics():
    r"""scale_down_graphics()"""
    return _coot.scale_down_graphics()

def save_state():
    r"""
    save_state()

    save the current state to the default filename

    """
    return _coot.save_state()

def save_state_file(filename):
    r"""
    save_state_file(char const * filename)

    save the current state to file filename

    Parameters
    ----------
    filename : str

    """
    return _coot.save_state_file(filename)

def save_state_file_py(filename):
    r"""
    save_state_file_py(char const * filename)

    save the current state to file filename

    Parameters
    ----------
    filename : str

    """
    return _coot.save_state_file_py(filename)

def set_save_state_file_name(filename):
    r"""
    set_save_state_file_name(char const * filename)

    set the default state file name (default 0-coot.state.scm)

    Parameters
    ----------
    filename : str

    """
    return _coot.set_save_state_file_name(filename)

def save_state_file_name_py():
    r"""
    save_state_file_name_py() -> PyObject *

    the save state file name

    the save state file name

    """
    return _coot.save_state_file_name_py()

def save_state_file_name_raw():
    r"""save_state_file_name_raw() -> char const *"""
    return _coot.save_state_file_name_raw()

def set_run_state_file_status(istat):
    r"""
    set_run_state_file_status(short istat)

    set run state file status

    0: never run it 1: ask to run it 2: run it, no questions

    Parameters
    ----------
    istat : int

    """
    return _coot.set_run_state_file_status(istat)

def run_state_file():
    r"""
    run_state_file()

    run the state file (reading from default filenname)

    """
    return _coot.run_state_file()

def run_state_file_py():
    r"""run_state_file_py()"""
    return _coot.run_state_file_py()

def run_state_file_maybe():
    r"""
    run_state_file_maybe()

    run the state file depending on the state variables

    """
    return _coot.run_state_file_maybe()
VT_FLAT = _coot.VT_FLAT

VT_SPHERICAL = _coot.VT_SPHERICAL


def vt_surface(mode):
    r"""
    vt_surface(int mode)

      mode  1 for "Flat", 2 for "Spherical Surface"

    Parameters
    ----------
    mode : int
        1 for "Flat", 2 for "Spherical Surface"

    """
    return _coot.vt_surface(mode)

def vt_surface_status():
    r"""
    vt_surface_status() -> int

    the status, mode=1 for "Flat", mode=2 for "Spherical Surface"

    """
    return _coot.vt_surface_status()

def increase_clipping_front():
    r"""
    increase_clipping_front()

    increase the amount of clipping, that is (independent of projection matrix)

    """
    return _coot.increase_clipping_front()

def increase_clipping_back():
    r"""
    increase_clipping_back()

    increase the amount of clipping, that is (independent of projection matrix)

    """
    return _coot.increase_clipping_back()

def decrease_clipping_front():
    r"""
    decrease_clipping_front()

    decrease the amount of clipping, that is (independent of projection matrix)

    """
    return _coot.decrease_clipping_front()

def decrease_clipping_back():
    r"""
    decrease_clipping_back()

    decrease the amount of clipping, that is (independent of projection matrix)

    """
    return _coot.decrease_clipping_back()

def set_clipping_back(v):
    r"""
    set_clipping_back(float v)

    set clipping plane back - this goes in differnent directions for orthographics vs perspective

    Parameters
    ----------
    v : float

    """
    return _coot.set_clipping_back(v)

def set_clipping_front(v):
    r"""
    set_clipping_front(float v)

    set clipping plane front - this goes in differnent directions for orthographics vs perspective

    Parameters
    ----------
    v : float

    """
    return _coot.set_clipping_front(v)

def get_clipping_plane_front():
    r"""
    get_clipping_plane_front() -> float

    get clipping plane front

    """
    return _coot.get_clipping_plane_front()

def get_clipping_plane_back():
    r"""
    get_clipping_plane_back() -> float

    get clipping plane back

    """
    return _coot.get_clipping_plane_back()

def get_show_unit_cell(imol):
    r"""
    get_show_unit_cell(int imol) -> short

    return the stage of show unit cell for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.get_show_unit_cell(imol)

def set_show_unit_cells_all(istate):
    r"""
    set_show_unit_cells_all(short istate)

    set the state of show unit cell for all molecules

    1 for displayed 0 for undisplayed

    Parameters
    ----------
    istate : int

    """
    return _coot.set_show_unit_cells_all(istate)

def set_show_unit_cell(imol, istate):
    r"""
    set_show_unit_cell(int imol, short istate)

    set the state of show unit cell for the particular molecule number imol

    1 for displayed 0 for undisplayed

    Parameters
    ----------
    imol : int
    istate : int

    """
    return _coot.set_show_unit_cell(imol, istate)

def set_unit_cell_colour(red, green, blue):
    r"""
    set_unit_cell_colour(float red, float green, float blue)


    Parameters
    ----------
    red : float
    green : float
    blue : float

    """
    return _coot.set_unit_cell_colour(red, green, blue)

def set_symmetry_colour_merge(v):
    r"""
    set_symmetry_colour_merge(float v)


    Parameters
    ----------
    v : float

    """
    return _coot.set_symmetry_colour_merge(v)

def set_colour_map_rotation_on_read_pdb(f):
    r"""
    set_colour_map_rotation_on_read_pdb(float f)

    set the hue change step on reading a new molecule

    Parameters
    ----------
    f : float

    """
    return _coot.set_colour_map_rotation_on_read_pdb(f)

def set_colour_map_rotation_on_read_pdb_flag(i):
    r"""
    set_colour_map_rotation_on_read_pdb_flag(short i)

    shall the hue change step be used?

      i  0 for no, 1 for yes

    Parameters
    ----------
    i : int
        0 for no, 1 for yes

    """
    return _coot.set_colour_map_rotation_on_read_pdb_flag(i)

def set_colour_map_rotation_on_read_pdb_c_only_flag(i):
    r"""
    set_colour_map_rotation_on_read_pdb_c_only_flag(short i)

    shall the colour map rotation apply only to C atoms?

      i  0 for no, 1 for yes

    Parameters
    ----------
    i : int
        0 for no, 1 for yes

    """
    return _coot.set_colour_map_rotation_on_read_pdb_c_only_flag(i)

def set_colour_by_chain(imol):
    r"""
    set_colour_by_chain(int imol)

    colour molecule number imol by chain type

    Parameters
    ----------
    imol : int

    """
    return _coot.set_colour_by_chain(imol)

def set_colour_by_ncs_chain(imol, goodsell_mode):
    r"""
    set_colour_by_ncs_chain(int imol, short goodsell_mode)

    colour molecule number imol by chain type

    Parameters
    ----------
    imol : int
    goodsell_mode : int

    """
    return _coot.set_colour_by_ncs_chain(imol, goodsell_mode)

def set_colour_by_chain_goodsell_mode(imol):
    r"""
    set_colour_by_chain_goodsell_mode(int imol)

    colour molecule number imol by chain type, goodsell-like colour scheme

    Parameters
    ----------
    imol : int

    """
    return _coot.set_colour_by_chain_goodsell_mode(imol)

def set_goodsell_chain_colour_wheel_step(s):
    r"""
    set_goodsell_chain_colour_wheel_step(float s)

    set the goodsell chain colour colour wheel step (default 0.22)

    Parameters
    ----------
    s : float

    """
    return _coot.set_goodsell_chain_colour_wheel_step(s)

def set_colour_by_molecule(imol):
    r"""
    set_colour_by_molecule(int imol)

    colour molecule number imol by molecule

    Parameters
    ----------
    imol : int

    """
    return _coot.set_colour_by_molecule(imol)

def get_colour_map_rotation_on_read_pdb_c_only_flag():
    r"""get_colour_map_rotation_on_read_pdb_c_only_flag() -> int"""
    return _coot.get_colour_map_rotation_on_read_pdb_c_only_flag()

def set_symmetry_colour(r, g, b):
    r"""
    set_symmetry_colour(float r, float g, float b)

    set the symmetry colour base

    Parameters
    ----------
    r : float
    g : float
    b : float

    """
    return _coot.set_symmetry_colour(r, g, b)

def set_colour_map_rotation_for_map(f):
    r"""
    set_colour_map_rotation_for_map(float f)

    set the colour map rotation (hue change) for maps

    default: for maps is 14 degrees.

    Parameters
    ----------
    f : float

    """
    return _coot.set_colour_map_rotation_for_map(f)

def set_molecule_bonds_colour_map_rotation(imol, theta):
    r"""
    set_molecule_bonds_colour_map_rotation(int imol, float theta)

    set the colour map rotation for molecule number imol

    theta is in degrees

    Parameters
    ----------
    imol : int
    theta : float

    """
    return _coot.set_molecule_bonds_colour_map_rotation(imol, theta)

def get_molecule_bonds_colour_map_rotation(imol):
    r"""
    get_molecule_bonds_colour_map_rotation(int imol) -> float

    Get the colour map rotation for molecule number imol.

    Parameters
    ----------
    imol : int

    """
    return _coot.get_molecule_bonds_colour_map_rotation(imol)

def get_limit_aniso():
    r"""
    get_limit_aniso() -> float

    get the aniso radius limit

    """
    return _coot.get_limit_aniso()

def get_show_limit_aniso():
    r"""
    get_show_limit_aniso() -> short

    get show the aniso limit

    """
    return _coot.get_show_limit_aniso()

def get_show_aniso():
    r"""
    get_show_aniso() -> short

    return show-aniso-atoms state - FIXME- per molecule

    """
    return _coot.get_show_aniso()

def set_limit_aniso(state):
    r"""
    set_limit_aniso(short state)

    set the aniso atom limit

    Parameters
    ----------
    state : int

    """
    return _coot.set_limit_aniso(state)

def set_show_aniso(state):
    r"""
    set_show_aniso(int state)

    does nothing

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_aniso(state)

def set_show_aniso_atoms(imol, state):
    r"""
    set_show_aniso_atoms(int imol, int state)

    set show aniso atoms

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_show_aniso_atoms(imol, state)

def set_show_aniso_atoms_as_ortep(imol, state):
    r"""
    set_show_aniso_atoms_as_ortep(int imol, int state)

    set show aniso atoms as ortep

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_show_aniso_atoms_as_ortep(imol, state)

def set_show_aniso_atoms_as_empty(imol, state):
    r"""
    set_show_aniso_atoms_as_empty(int imol, int state)

    set show aniso atoms as ortep

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_show_aniso_atoms_as_empty(imol, state)

def set_aniso_limit_size_from_widget(text):
    r"""
    set_aniso_limit_size_from_widget(char const * text)


    Parameters
    ----------
    text : str

    """
    return _coot.set_aniso_limit_size_from_widget(text)

def get_text_for_aniso_limit_radius_entry():
    r"""get_text_for_aniso_limit_radius_entry() -> char *"""
    return _coot.get_text_for_aniso_limit_radius_entry()

def set_aniso_probability(f):
    r"""
    set_aniso_probability(float f)

    DELETE-ME

    Parameters
    ----------
    f : float

    """
    return _coot.set_aniso_probability(f)

def get_aniso_probability():
    r"""
    get_aniso_probability() -> float

    DELETE-ME

    """
    return _coot.get_aniso_probability()

def set_graphics_window_size(x_size, y_size):
    r"""
    set_graphics_window_size(int x_size, int y_size)

    set the window size

    Parameters
    ----------
    x_size : int
    y_size : int

    """
    return _coot.set_graphics_window_size(x_size, y_size)

def set_graphics_window_size_internal(x_size, y_size, as_widget_flag):
    r"""
    set_graphics_window_size_internal(int x_size, int y_size, int as_widget_flag)

    set the window size as gtk_widget (flag=1) or gtk_window (flag=0)

    Parameters
    ----------
    x_size : int
    y_size : int
    as_widget_flag : int

    """
    return _coot.set_graphics_window_size_internal(x_size, y_size, as_widget_flag)

def set_graphics_window_position(x_pos, y_pos):
    r"""
    set_graphics_window_position(int x_pos, int y_pos)

    set the graphics window position

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_graphics_window_position(x_pos, y_pos)

def store_graphics_window_position(x_pos, y_pos):
    r"""
    store_graphics_window_position(int x_pos, int y_pos)

    store the graphics window position

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.store_graphics_window_position(x_pos, y_pos)

def graphics_window_size_and_position_to_preferences():
    r"""
    graphics_window_size_and_position_to_preferences()

    store the graphics window position and size to zenops-graphics-window-size-and-postion.scm in the preferences directory.

    """
    return _coot.graphics_window_size_and_position_to_preferences()

def graphics_draw():
    r"""
    graphics_draw()

    draw a frame

    """
    return _coot.graphics_draw()

def zalman_stereo_mode():
    r"""
    zalman_stereo_mode()

    try to turn on Zalman stereo mode

    """
    return _coot.zalman_stereo_mode()

def hardware_stereo_mode():
    r"""
    hardware_stereo_mode()

    try to turn on stereo mode

    """
    return _coot.hardware_stereo_mode()

def set_stereo_style(mode):
    r"""
    set_stereo_style(int mode)

    set the stereo mode (the relative view of the eyes)

    0 is 2010-mode 1 is modern mode

    Parameters
    ----------
    mode : int

    """
    return _coot.set_stereo_style(mode)

def stereo_mode_state():
    r"""
    stereo_mode_state() -> int

    what is the stero state?

    1 for in hardware stereo, 2 for side by side stereo, else return 0.

    """
    return _coot.stereo_mode_state()

def mono_mode():
    r"""
    mono_mode()

    try to turn on mono mode

    """
    return _coot.mono_mode()

def side_by_side_stereo_mode(use_wall_eye_mode):
    r"""
    side_by_side_stereo_mode(short use_wall_eye_mode)

    turn on side bye side stereo mode

      use_wall_eye_mode  1 mean wall-eyed, 0 means cross-eyed

    Parameters
    ----------
    use_wall_eye_mode : int
        1 mean wall-eyed, 0 means cross-eyed

    """
    return _coot.side_by_side_stereo_mode(use_wall_eye_mode)

def set_dti_stereo_mode(state):
    r"""
    set_dti_stereo_mode(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_dti_stereo_mode(state)

def set_stereo_angle(angle):
    r"""
    set_stereo_angle(float angle)

    set the stereo angle

      angle  stereo angle in degrees - default is 6 degrees

    Parameters
    ----------
    angle : float
        stereo angle in degrees - default is 6 degrees

    """
    return _coot.set_stereo_angle(angle)

def hardware_stereo_angle_factor_state():
    r"""
    hardware_stereo_angle_factor_state() -> float

    return the hardware stereo angle factor

    """
    return _coot.hardware_stereo_angle_factor_state()

def set_model_display_radius(state, radius):
    r"""
    set_model_display_radius(int state, float radius)


    Parameters
    ----------
    state : int
    radius : float

    """
    return _coot.set_model_display_radius(state, radius)

def set_model_fit_refine_dialog_position(x_pos, y_pos):
    r"""
    set_model_fit_refine_dialog_position(int x_pos, int y_pos)

    set position of Model/Fit/Refine dialog

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_model_fit_refine_dialog_position(x_pos, y_pos)

def set_display_control_dialog_position(x_pos, y_pos):
    r"""
    set_display_control_dialog_position(int x_pos, int y_pos)

    set position of Display Control dialog

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_display_control_dialog_position(x_pos, y_pos)

def set_go_to_atom_window_position(x_pos, y_pos):
    r"""
    set_go_to_atom_window_position(int x_pos, int y_pos)

    set position of Go To Atom dialog

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_go_to_atom_window_position(x_pos, y_pos)

def set_delete_dialog_position(x_pos, y_pos):
    r"""
    set_delete_dialog_position(int x_pos, int y_pos)

    set position of Delete dialog

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_delete_dialog_position(x_pos, y_pos)

def set_rotate_translate_dialog_position(x_pos, y_pos):
    r"""
    set_rotate_translate_dialog_position(int x_pos, int y_pos)

    set position of the Rotate/Translate Residue Range dialog

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_rotate_translate_dialog_position(x_pos, y_pos)

def set_accept_reject_dialog_position(x_pos, y_pos):
    r"""
    set_accept_reject_dialog_position(int x_pos, int y_pos)

    set position of the Accept/Reject dialog

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_accept_reject_dialog_position(x_pos, y_pos)

def set_ramachandran_plot_dialog_position(x_pos, y_pos):
    r"""
    set_ramachandran_plot_dialog_position(int x_pos, int y_pos)

    set position of the Ramachadran Plot dialog

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_ramachandran_plot_dialog_position(x_pos, y_pos)

def set_edit_chi_angles_dialog_position(x_pos, y_pos):
    r"""
    set_edit_chi_angles_dialog_position(int x_pos, int y_pos)

    set edit chi angles dialog position

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_edit_chi_angles_dialog_position(x_pos, y_pos)

def set_rotamer_selection_dialog_position(x_pos, y_pos):
    r"""
    set_rotamer_selection_dialog_position(int x_pos, int y_pos)

    set rotamer selection dialog position

    Parameters
    ----------
    x_pos : int
    y_pos : int

    """
    return _coot.set_rotamer_selection_dialog_position(x_pos, y_pos)

def set_smooth_scroll_flag(v):
    r"""
    set_smooth_scroll_flag(int v)

    set smooth scrolling

      v  use v=1 to turn on smooth scrolling, v=0 for off (default on).

    Parameters
    ----------
    v : int
        use v=1 to turn on smooth scrolling, v=0 for off (default on).

    """
    return _coot.set_smooth_scroll_flag(v)

def get_smooth_scroll():
    r"""
    get_smooth_scroll() -> int

    return the smooth scrolling state

    """
    return _coot.get_smooth_scroll()

def set_smooth_scroll_steps_str(t):
    r"""
    set_smooth_scroll_steps_str(char const * t)


    Parameters
    ----------
    t : str

    """
    return _coot.set_smooth_scroll_steps_str(t)

def set_smooth_scroll_steps(i):
    r"""
    set_smooth_scroll_steps(int i)

    set the number of steps in the smooth scroll

    Set more steps (e.g. 50) for more smoothness (default 10).

    Parameters
    ----------
    i : int

    """
    return _coot.set_smooth_scroll_steps(i)

def get_text_for_smooth_scroll_steps():
    r"""get_text_for_smooth_scroll_steps() -> char *"""
    return _coot.get_text_for_smooth_scroll_steps()

def set_smooth_scroll_limit_str(t):
    r"""
    set_smooth_scroll_limit_str(char const * t)


    Parameters
    ----------
    t : str

    """
    return _coot.set_smooth_scroll_limit_str(t)

def set_smooth_scroll_limit(lim):
    r"""
    set_smooth_scroll_limit(float lim)

    do not scroll for distances greater this limit

    Parameters
    ----------
    lim : float

    """
    return _coot.set_smooth_scroll_limit(lim)

def get_text_for_smooth_scroll_limit():
    r"""get_text_for_smooth_scroll_limit() -> char *"""
    return _coot.get_text_for_smooth_scroll_limit()

def set_font_size(i):
    r"""
    set_font_size(int i)

    set the font size

      i  1 (small) 2 (medium, default) 3 (large)

    Parameters
    ----------
    i : int
        1 (small) 2 (medium, default) 3 (large)

    """
    return _coot.set_font_size(i)

def get_font_size():
    r"""
    get_font_size() -> int

    return the font size

    1 (small) 2 (medium, default) 3 (large)

    """
    return _coot.get_font_size()

def set_font_colour(red, green, blue):
    r"""
    set_font_colour(float red, float green, float blue)

    set the colour of the atom label font - the arguments are in the range 0->1

    Parameters
    ----------
    red : float
    green : float
    blue : float

    """
    return _coot.set_font_colour(red, green, blue)

def set_use_stroke_characters(state):
    r"""
    set_use_stroke_characters(int state)

    set use stroke characters

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_stroke_characters(state)

def set_rotation_centre_size_from_widget(text):
    r"""
    set_rotation_centre_size_from_widget(gchar const * text)


    Parameters
    ----------
    text : const gchar *

    """
    return _coot.set_rotation_centre_size_from_widget(text)

def get_text_for_rotation_centre_cube_size():
    r"""get_text_for_rotation_centre_cube_size() -> gchar *"""
    return _coot.get_text_for_rotation_centre_cube_size()

def set_rotation_centre_size(f):
    r"""
    set_rotation_centre_size(float f)

    set the rotation centre marker size

    Parameters
    ----------
    f : float

    """
    return _coot.set_rotation_centre_size(f)

def set_user_defined_rotation_centre_crosshairs_size_scale_factor(f):
    r"""
    set_user_defined_rotation_centre_crosshairs_size_scale_factor(float f)

    set the rotation centre marker size

    Parameters
    ----------
    f : float

    """
    return _coot.set_user_defined_rotation_centre_crosshairs_size_scale_factor(f)

def set_rotation_centre_cross_hairs_colour(r, g, b, alpha):
    r"""
    set_rotation_centre_cross_hairs_colour(float r, float g, float b, float alpha)

    set rotation centre colour

    This is the colour for a dark background - if the background colour is not dark, then the cross-hair colour becomes the inverse colour

    Parameters
    ----------
    r : float
    g : float
    b : float
    alpha : float

    """
    return _coot.set_rotation_centre_cross_hairs_colour(r, g, b, alpha)

def recentre_on_read_pdb():
    r"""
    recentre_on_read_pdb() -> short

    return the recentre-on-pdb state

    """
    return _coot.recentre_on_read_pdb()

def set_recentre_on_read_pdb(arg1):
    r"""
    set_recentre_on_read_pdb(short arg1)

    set the recentre-on-pdb state

    Parameters
    ----------
     : int

    """
    return _coot.set_recentre_on_read_pdb(arg1)

def set_rotation_centre_internal(x, y, z):
    r"""
    set_rotation_centre_internal(float x, float y, float z)


    Parameters
    ----------
    x : float
    y : float
    z : float

    """
    return _coot.set_rotation_centre_internal(x, y, z)

def rotation_centre_position(axis):
    r"""
    rotation_centre_position(int axis) -> float


    Parameters
    ----------
    axis : int

    """
    return _coot.rotation_centre_position(axis)

def go_to_ligand():
    r"""
    go_to_ligand()

    centre on the ligand of the "active molecule", if we are already there, centre on the next hetgroup (etc)

    """
    return _coot.go_to_ligand()

def go_to_ligand_py():
    r"""go_to_ligand_py() -> PyObject *"""
    return _coot.go_to_ligand_py()

def set_go_to_ligand_n_atoms_limit(n_atom_min):
    r"""
    set_go_to_ligand_n_atoms_limit(int n_atom_min)

    go to the ligand that has more than n_atom_min atoms

    Parameters
    ----------
    n_atom_min : int

    """
    return _coot.set_go_to_ligand_n_atoms_limit(n_atom_min)

def set_reorienting_next_residue_mode(state):
    r"""
    set_reorienting_next_residue_mode(int state)

    rotate the view so that the next main-chain atoms are oriented in the same direction as the previous - hence side-chain always seems to be "up" - set this mode to 1 for reorientation-mode - and 0 for off (standard translation)

    Parameters
    ----------
    state : int

    """
    return _coot.set_reorienting_next_residue_mode(state)

def set_draw_axes(i):
    r"""
    set_draw_axes(int i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_draw_axes(i)

def get_model_molecule_list_py():
    r"""get_model_molecule_list_py() -> PyObject *"""
    return _coot.get_model_molecule_list_py()

def atom_index(imol, chain_id, iresno, atom_id):
    r"""
    atom_index(int imol, char const * chain_id, int iresno, char const * atom_id) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    iresno : int
    atom_id : str

    """
    return _coot.atom_index(imol, chain_id, iresno, atom_id)

def atom_index_full(imol, chain_id, iresno, inscode, atom_id, altconf):
    r"""
    atom_index_full(int imol, char const * chain_id, int iresno, char const * inscode, char const * atom_id, char const * altconf) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    iresno : int
    inscode : str
    atom_id : str
    altconf : str

    """
    return _coot.atom_index_full(imol, chain_id, iresno, inscode, atom_id, altconf)

def atom_index_first_atom_in_residue(imol, chain_id, iresno, ins_code):
    r"""
    atom_index_first_atom_in_residue(int imol, char const * chain_id, int iresno, char const * ins_code) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    iresno : int
    ins_code : str

    """
    return _coot.atom_index_first_atom_in_residue(imol, chain_id, iresno, ins_code)

def atom_index_first_atom_in_residue_with_altconf(imol, chain_id, iresno, ins_code, alt_conf):
    r"""
    atom_index_first_atom_in_residue_with_altconf(int imol, char const * chain_id, int iresno, char const * ins_code, char const * alt_conf) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    iresno : int
    ins_code : str
    alt_conf : str

    """
    return _coot.atom_index_first_atom_in_residue_with_altconf(imol, chain_id, iresno, ins_code, alt_conf)

def min_resno_in_chain(imol, chain_id):
    r"""
    min_resno_in_chain(int imol, char const * chain_id) -> int

    return the minimum residue number for imol chain chain_id

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.min_resno_in_chain(imol, chain_id)

def max_resno_in_chain(imol, chain_id):
    r"""
    max_resno_in_chain(int imol, char const * chain_id) -> int

    return the maximum residue number for imol chain chain_id

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.max_resno_in_chain(imol, chain_id)

def median_temperature_factor(imol):
    r"""
    median_temperature_factor(int imol) -> float

    return the median temperature factor for imol

    Parameters
    ----------
    imol : int

    """
    return _coot.median_temperature_factor(imol)

def average_temperature_factor(imol):
    r"""
    average_temperature_factor(int imol) -> float

    return the average temperature factor for the atoms in imol

    Parameters
    ----------
    imol : int

    """
    return _coot.average_temperature_factor(imol)

def standard_deviation_temperature_factor(imol):
    r"""
    standard_deviation_temperature_factor(int imol) -> float

    return the standard deviation of the atom temperature factors for imol

    Parameters
    ----------
    imol : int

    """
    return _coot.standard_deviation_temperature_factor(imol)

def clear_pending_picks():
    r"""
    clear_pending_picks()

    clear pending picks (stop coot thinking that the user is about to pick an atom).

    """
    return _coot.clear_pending_picks()

def centre_of_mass_string(imol):
    r"""
    centre_of_mass_string(int imol) -> char *


    Parameters
    ----------
    imol : int

    """
    return _coot.centre_of_mass_string(imol)

def centre_of_mass_string_py(imol):
    r"""
    centre_of_mass_string_py(int imol) -> char *


    Parameters
    ----------
    imol : int

    """
    return _coot.centre_of_mass_string_py(imol)

def set_default_temperature_factor_for_new_atoms(new_b):
    r"""
    set_default_temperature_factor_for_new_atoms(float new_b)

    set the default temperature factor for newly created atoms (initial default 20)

    Parameters
    ----------
    new_b : float

    """
    return _coot.set_default_temperature_factor_for_new_atoms(new_b)

def default_new_atoms_b_factor():
    r"""
    default_new_atoms_b_factor() -> float

    return the default temperature factor for newly created atoms

    """
    return _coot.default_new_atoms_b_factor()

def set_reset_b_factor_moved_atoms(state):
    r"""
    set_reset_b_factor_moved_atoms(int state)

    reset temperature factor for all moved atoms to the default for new atoms (usually 30)

    Parameters
    ----------
    state : int

    """
    return _coot.set_reset_b_factor_moved_atoms(state)

def get_reset_b_factor_moved_atoms_state():
    r"""
    get_reset_b_factor_moved_atoms_state() -> int

    return the state if temperature factors shoudl be reset for moved atoms

    """
    return _coot.get_reset_b_factor_moved_atoms_state()

def get_residue_alt_confs_py(imol, chain_id, res_no, ins_code):
    r"""
    get_residue_alt_confs_py(int imol, char const * chain_id, int res_no, char const * ins_code) -> PyObject *

    Return either False (on failure) or a list of alt-conf strings (might be [""])

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str

    """
    return _coot.get_residue_alt_confs_py(imol, chain_id, res_no, ins_code)

def swap_atom_alt_conf(imol, chain_id, res_no, ins_code, atom_name, alt_conf):
    r"""
    swap_atom_alt_conf(int imol, char const * chain_id, int res_no, char const * ins_code, char const * atom_name, char const * alt_conf) -> int

    swap atom alt-confs

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    atom_name : str
    alt_conf : str

    """
    return _coot.swap_atom_alt_conf(imol, chain_id, res_no, ins_code, atom_name, alt_conf)

def swap_residue_alt_confs(imol, chain_id, res_no, ins_code):
    r"""
    swap_residue_alt_confs(int imol, char const * chain_id, int res_no, char const * ins_code) -> int

    swap atom alt-confs

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str

    """
    return _coot.swap_residue_alt_confs(imol, chain_id, res_no, ins_code)

def set_atom_attribute(imol, chain_id, resno, ins_code, atom_name, alt_conf, attribute_name, val):
    r"""
    set_atom_attribute(int imol, char const * chain_id, int resno, char const * ins_code, char const * atom_name, char const * alt_conf, char const * attribute_name, float val) -> int

    set a numberical attibute to the atom with the given specifier.

    Attributes can be "x", "y","z", "B", "occ" and the attribute val is a floating point number

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    atom_name : str
    alt_conf : str
    attribute_name : str
    val : float

    """
    return _coot.set_atom_attribute(imol, chain_id, resno, ins_code, atom_name, alt_conf, attribute_name, val)

def set_atom_string_attribute(imol, chain_id, resno, ins_code, atom_name, alt_conf, attribute_name, attribute_value):
    r"""
    set_atom_string_attribute(int imol, char const * chain_id, int resno, char const * ins_code, char const * atom_name, char const * alt_conf, char const * attribute_name, char const * attribute_value) -> int

    set a string attibute to the atom with the given specifier.

    Attributes can be "atom-name", "alt-conf", "element" or "segid".

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    atom_name : str
    alt_conf : str
    attribute_name : str
    attribute_value : str

    """
    return _coot.set_atom_string_attribute(imol, chain_id, resno, ins_code, atom_name, alt_conf, attribute_name, attribute_value)

def set_atom_attributes_py(attribute_expression_list):
    r"""
    set_atom_attributes_py(PyObject * attribute_expression_list) -> int


    Parameters
    ----------
    attribute_expression_list : object

    """
    return _coot.set_atom_attributes_py(attribute_expression_list)

def set_residue_name(imol, chain_id, res_no, ins_code, new_residue_name):
    r"""
    set_residue_name(int imol, char const * chain_id, int res_no, char const * ins_code, char const * new_residue_name)

    set the residue name of the specified residue

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    new_residue_name : str

    """
    return _coot.set_residue_name(imol, chain_id, res_no, ins_code, new_residue_name)

def skel_greer_on():
    r"""skel_greer_on()"""
    return _coot.skel_greer_on()

def skel_greer_off():
    r"""skel_greer_off()"""
    return _coot.skel_greer_off()

def skeletonize_map(imol, prune_flag):
    r"""
    skeletonize_map(int imol, short prune_flag) -> int

    skeletonize molecule number imol

    the prune_flag should almost always be 0.

    NOTE:: The arguments to have been reversed for coot 0.8.3 and later (now the molecule number comes first).

    Parameters
    ----------
    imol : int
    prune_flag : int

    """
    return _coot.skeletonize_map(imol, prune_flag)

def unskeletonize_map(imol):
    r"""
    unskeletonize_map(int imol) -> int

    undisplay the skeleton on molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.unskeletonize_map(imol)

def set_initial_map_for_skeletonize():
    r"""set_initial_map_for_skeletonize()"""
    return _coot.set_initial_map_for_skeletonize()

def set_max_skeleton_search_depth(v):
    r"""
    set_max_skeleton_search_depth(int v)

    set the skeleton search depth, used in baton building

    For high resolution maps, you need to search deeper down the skeleton tree. This limit needs to be increased to 20 or so for high res maps (it is 10 by default)

    Parameters
    ----------
    v : int

    """
    return _coot.set_max_skeleton_search_depth(v)

def get_text_for_skeletonization_level_entry():
    r"""get_text_for_skeletonization_level_entry() -> gchar *"""
    return _coot.get_text_for_skeletonization_level_entry()

def set_skeletonization_level_from_widget(txt):
    r"""
    set_skeletonization_level_from_widget(char const * txt)


    Parameters
    ----------
    txt : str

    """
    return _coot.set_skeletonization_level_from_widget(txt)

def get_text_for_skeleton_box_size_entry():
    r"""get_text_for_skeleton_box_size_entry() -> gchar *"""
    return _coot.get_text_for_skeleton_box_size_entry()

def set_skeleton_box_size_from_widget(txt):
    r"""
    set_skeleton_box_size_from_widget(char const * txt)


    Parameters
    ----------
    txt : str

    """
    return _coot.set_skeleton_box_size_from_widget(txt)

def set_skeleton_box_size(f):
    r"""
    set_skeleton_box_size(float f)

    the box size (in Angstroms) for which the skeleton is displayed

    Parameters
    ----------
    f : float

    """
    return _coot.set_skeleton_box_size(f)

def save_coordinates(imol, filename):
    r"""
    save_coordinates(int imol, char const * filename) -> int

    save coordinates of molecule number imol in filename

    status 1 is good (success), 0 is fail.

    Parameters
    ----------
    imol : int
    filename : str

    """
    return _coot.save_coordinates(imol, filename)

def set_save_coordinates_in_original_directory(i):
    r"""
    set_save_coordinates_in_original_directory(int i)

    set save coordinates in the starting directory

    Parameters
    ----------
    i : int

    """
    return _coot.set_save_coordinates_in_original_directory(i)

def save_molecule_number_from_option_menu():
    r"""save_molecule_number_from_option_menu() -> int"""
    return _coot.save_molecule_number_from_option_menu()

def set_save_molecule_number(imol):
    r"""
    set_save_molecule_number(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.set_save_molecule_number(imol)

def read_phs_and_coords_and_make_map(pdb_filename):
    r"""
    read_phs_and_coords_and_make_map(char const * pdb_filename)

    read phs file use coords to get cell and symm to make map

    uses pending data to make the map.

    Parameters
    ----------
    pdb_filename : str

    """
    return _coot.read_phs_and_coords_and_make_map(pdb_filename)

def read_phs_and_make_map_using_cell_symm_from_previous_mol(phs_filename):
    r"""
    read_phs_and_make_map_using_cell_symm_from_previous_mol(char const * phs_filename) -> int

    read a phs file, the cell and symm information is from previously read (most recently read) coordinates file

    For use with phs data filename provided on the command line

    Parameters
    ----------
    phs_filename : str

    """
    return _coot.read_phs_and_make_map_using_cell_symm_from_previous_mol(phs_filename)

def read_phs_and_make_map_using_cell_symm_from_mol(phs_filename, imol):
    r"""
    read_phs_and_make_map_using_cell_symm_from_mol(char const * phs_filename, int imol) -> int

    read phs file and use a previously read molecule to provide the cell and symmetry information

    the new molecule number, return -1 if problem creating the map (e.g. not phs data, file not found etc).

    Parameters
    ----------
    phs_filename : str
    imol : int

    """
    return _coot.read_phs_and_make_map_using_cell_symm_from_mol(phs_filename, imol)

def read_phs_and_make_map_using_cell_symm_from_mol_using_implicit_phs_filename(imol):
    r"""
    read_phs_and_make_map_using_cell_symm_from_mol_using_implicit_phs_filename(int imol) -> int


    Parameters
    ----------
    imol : int

    """
    return _coot.read_phs_and_make_map_using_cell_symm_from_mol_using_implicit_phs_filename(imol)

def read_phs_and_make_map_using_cell_symm(phs_file_name, hm_spacegroup, a, b, c, alpha, beta, gamma):
    r"""
    read_phs_and_make_map_using_cell_symm(char const * phs_file_name, char const * hm_spacegroup, float a, float b, float c, float alpha, float beta, float gamma) -> int

    read phs file use coords to use cell and symm to make map

    in degrees

    Parameters
    ----------
    phs_file_name : str
    hm_spacegroup : str
    a : float
    b : float
    c : float
    alpha : float
    beta : float
    gamma : float

    """
    return _coot.read_phs_and_make_map_using_cell_symm(phs_file_name, hm_spacegroup, a, b, c, alpha, beta, gamma)

def read_phs_and_make_map_with_reso_limits(imol, phs_file_name, reso_lim_low, reso_lim_high):
    r"""
    read_phs_and_make_map_with_reso_limits(int imol, char const * phs_file_name, float reso_lim_low, float reso_lim_high) -> int

    read a phs file and use the cell and symm in molecule number imol and use the resolution limits reso_lim_high (in Angstroems).

      imol  is the molecule number of the reference (coordinates) molecule from which the cell and symmetry can be obtained.   phs_file_name  is the name of the phs data file.   reso_lim_high  is the high resolution limit in Angstroems.   reso_lim_low  the low resoluion limit (currently ignored).

    Parameters
    ----------
    imol : int
        is the molecule number of the reference (coordinates) molecule from which the cell and symmetry can be obtained.
    phs_file_name : str
        is the name of the phs data file.
    reso_lim_low : float
        the low resoluion limit (currently ignored).
    reso_lim_high : float
        is the high resolution limit in Angstroems.

    """
    return _coot.read_phs_and_make_map_with_reso_limits(imol, phs_file_name, reso_lim_low, reso_lim_high)

def graphics_store_phs_filename(phs_filename):
    r"""
    graphics_store_phs_filename(gchar const * phs_filename)


    Parameters
    ----------
    phs_filename : const gchar *

    """
    return _coot.graphics_store_phs_filename(phs_filename)

def possible_cell_symm_for_phs_file():
    r"""possible_cell_symm_for_phs_file() -> short"""
    return _coot.possible_cell_symm_for_phs_file()

def get_text_for_phs_cell_chooser(imol, field):
    r"""
    get_text_for_phs_cell_chooser(int imol, char const * field) -> gchar *


    Parameters
    ----------
    imol : int
    field : str

    """
    return _coot.get_text_for_phs_cell_chooser(imol, field)

def undo_last_move():
    r"""
    undo_last_move()

    undo last move

    """
    return _coot.undo_last_move()

def translate_molecule_by(imol, x, y, z):
    r"""
    translate_molecule_by(int imol, float x, float y, float z)

    translate molecule number imol by (x,y,z) in Angstroms

    Parameters
    ----------
    imol : int
    x : float
    y : float
    z : float

    """
    return _coot.translate_molecule_by(imol, x, y, z)

def transform_molecule_by(imol, m11, m12, m13, m21, m22, m23, m31, m32, m33, x, y, z):
    r"""
    transform_molecule_by(int imol, float m11, float m12, float m13, float m21, float m22, float m23, float m31, float m32, float m33, float x, float y, float z)

    transform molecule number imol by the given rotation matrix, then translate by (x,y,z) in Angstroms

    Parameters
    ----------
    imol : int
    m11 : float
    m12 : float
    m13 : float
    m21 : float
    m22 : float
    m23 : float
    m31 : float
    m32 : float
    m33 : float
    x : float
    y : float
    z : float

    """
    return _coot.transform_molecule_by(imol, m11, m12, m13, m21, m22, m23, m31, m32, m33, x, y, z)

def transform_zone(imol, chain_id, resno_start, resno_end, ins_code, m11, m12, m13, m21, m22, m23, m31, m32, m33, x, y, z):
    r"""
    transform_zone(int imol, char const * chain_id, int resno_start, int resno_end, char const * ins_code, float m11, float m12, float m13, float m21, float m22, float m23, float m31, float m32, float m33, float x, float y, float z)

    transform fragment of molecule number imol by the given rotation matrix, then translate by (x,y,z) in Angstroms

    Parameters
    ----------
    imol : int
    chain_id : str
    resno_start : int
    resno_end : int
    ins_code : str
    m11 : float
    m12 : float
    m13 : float
    m21 : float
    m22 : float
    m23 : float
    m31 : float
    m32 : float
    m33 : float
    x : float
    y : float
    z : float

    """
    return _coot.transform_zone(imol, chain_id, resno_start, resno_end, ins_code, m11, m12, m13, m21, m22, m23, m31, m32, m33, x, y, z)

def post_go_to_atom_window():
    r"""
    post_go_to_atom_window()

    Post the Go To Atom Window.

    """
    return _coot.post_go_to_atom_window()

def go_to_atom_molecule_number():
    r"""
    go_to_atom_molecule_number() -> int

    the go-to-atom molecule number

    """
    return _coot.go_to_atom_molecule_number()

def go_to_atom_chain_id():
    r"""
    go_to_atom_chain_id() -> char *

    the go-to-atom chain-id

    """
    return _coot.go_to_atom_chain_id()

def go_to_atom_atom_name():
    r"""
    go_to_atom_atom_name() -> char *

    the go-to-atom atom name

    """
    return _coot.go_to_atom_atom_name()

def go_to_atom_residue_number():
    r"""
    go_to_atom_residue_number() -> int

    the go-to-atom residue number

    """
    return _coot.go_to_atom_residue_number()

def go_to_atom_ins_code():
    r"""
    go_to_atom_ins_code() -> char *

    the go-to-atom insertion code

    """
    return _coot.go_to_atom_ins_code()

def go_to_atom_alt_conf():
    r"""
    go_to_atom_alt_conf() -> char *

    the go-to-atom alt conf

    """
    return _coot.go_to_atom_alt_conf()

def set_go_to_atom_chain_residue_atom_name(t1_chain_id, iresno, t3_atom_name):
    r"""
    set_go_to_atom_chain_residue_atom_name(char const * t1_chain_id, int iresno, char const * t3_atom_name) -> int

    set the go to atom specification

    It seems important for swig that the char * arguments are const char * , not const gchar * (or else we get wrong type of argument error on (say) "A"

    the success status of the go to. 0 for fail, 1 for success.

    Parameters
    ----------
    t1_chain_id : str
    iresno : int
    t3_atom_name : str

    """
    return _coot.set_go_to_atom_chain_residue_atom_name(t1_chain_id, iresno, t3_atom_name)

def set_go_to_atom_chain_residue_atom_name_full(chain_id, resno, ins_code, atom_name, alt_conf):
    r"""
    set_go_to_atom_chain_residue_atom_name_full(char const * chain_id, int resno, char const * ins_code, char const * atom_name, char const * alt_conf) -> int

    set the go to (full) atom specification

    It seems important for swig that the char * arguments are const char * , not const gchar * (or else we get wrong type of argument error on (say) "A"

    the success status of the go to. 0 for fail, 1 for success.

    Parameters
    ----------
    chain_id : str
    resno : int
    ins_code : str
    atom_name : str
    alt_conf : str

    """
    return _coot.set_go_to_atom_chain_residue_atom_name_full(chain_id, resno, ins_code, atom_name, alt_conf)

def set_go_to_atom_chain_residue_atom_name_no_redraw(t1, iresno, t3, make_the_move_flag):
    r"""
    set_go_to_atom_chain_residue_atom_name_no_redraw(char const * t1, int iresno, char const * t3, short make_the_move_flag) -> int

    set go to atom but don't redraw

    Parameters
    ----------
    t1 : str
    iresno : int
    t3 : str
    make_the_move_flag : int

    """
    return _coot.set_go_to_atom_chain_residue_atom_name_no_redraw(t1, iresno, t3, make_the_move_flag)

def set_go_to_atom_chain_residue_atom_name_strings(t1, t2, txt):
    r"""
    set_go_to_atom_chain_residue_atom_name_strings(gchar const * t1, gchar const * t2, gchar const * txt) -> int


    Parameters
    ----------
    t1 : const gchar *
    t2 : const gchar *
    txt : const gchar *

    """
    return _coot.set_go_to_atom_chain_residue_atom_name_strings(t1, t2, txt)

def update_go_to_atom_from_current_position():
    r"""
    update_go_to_atom_from_current_position()

    update the Go To Atom widget entries to atom closest to screen centre.

    """
    return _coot.update_go_to_atom_from_current_position()

def update_go_to_atom_residue_list(imol):
    r"""
    update_go_to_atom_residue_list(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.update_go_to_atom_residue_list(imol)

def atom_spec_to_atom_index(mol, chain, resno, atom_name):
    r"""
    atom_spec_to_atom_index(int mol, char const * chain, int resno, char const * atom_name) -> int

    what is the atom index of the given atom?

    Parameters
    ----------
    mol : int
    chain : str
    resno : int
    atom_name : str

    """
    return _coot.atom_spec_to_atom_index(mol, chain, resno, atom_name)

def full_atom_spec_to_atom_index(imol, chain, resno, inscode, atom_name, altloc):
    r"""
    full_atom_spec_to_atom_index(int imol, char const * chain, int resno, char const * inscode, char const * atom_name, char const * altloc) -> int

    what is the atom index of the given atom?

    Parameters
    ----------
    imol : int
    chain : str
    resno : int
    inscode : str
    atom_name : str
    altloc : str

    """
    return _coot.full_atom_spec_to_atom_index(imol, chain, resno, inscode, atom_name, altloc)

def update_go_to_atom_window_on_changed_mol(imol):
    r"""
    update_go_to_atom_window_on_changed_mol(int imol)

    update the Go To Atom window

    Parameters
    ----------
    imol : int

    """
    return _coot.update_go_to_atom_window_on_changed_mol(imol)

def update_go_to_atom_window_on_new_mol():
    r"""
    update_go_to_atom_window_on_new_mol()

    update the Go To Atom window. This updates the option menu for the molecules.

    """
    return _coot.update_go_to_atom_window_on_new_mol()

def update_go_to_atom_window_on_other_molecule_chosen(imol):
    r"""
    update_go_to_atom_window_on_other_molecule_chosen(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.update_go_to_atom_window_on_other_molecule_chosen(imol)

def set_go_to_atom_molecule(imol):
    r"""
    set_go_to_atom_molecule(int imol)

    set the molecule for the Go To Atom

    For dynarama callback sake. The widget/class knows which molecule that it was generated from, so in order to go to the molecule from dynarama, we first need to the the molecule - because set_go_to_atom_chain_residue_atom_name() does not mention the molecule (see "Next/Previous Residue" for reasons for that). This function simply calls the graphics_info_t function of the same name.

    Also used in scripting, where go-to-atom-chain-residue-atom-name does not mention the molecule number.

    20090914-PE set-go-to-atom-molecule can be used in a script and it should change the go-to-atom-molecule in the Go To Atom dialog (if it is being displayed). This does mean, of course that using the ramachandran plot to centre on atoms will change the Go To Atom dialog. Maybe that is surprising (maybe not).

    Parameters
    ----------
    imol : int

    """
    return _coot.set_go_to_atom_molecule(imol)

def unset_go_to_atom_widget():
    r"""unset_go_to_atom_widget()"""
    return _coot.unset_go_to_atom_widget()

def autobuild_ca_off():
    r"""autobuild_ca_off()"""
    return _coot.autobuild_ca_off()

def test_fragment():
    r"""test_fragment()"""
    return _coot.test_fragment()

def do_skeleton_prune():
    r"""do_skeleton_prune()"""
    return _coot.do_skeleton_prune()

def test_function(i, j):
    r"""
    test_function(int i, int j) -> int


    Parameters
    ----------
    i : int
    j : int

    """
    return _coot.test_function(i, j)

def test_function_py(i, j):
    r"""
    test_function_py(PyObject * i, PyObject * j) -> PyObject *


    Parameters
    ----------
    i : object
    j : object

    """
    return _coot.test_function_py(i, j)

def glyco_tree_test():
    r"""glyco_tree_test()"""
    return _coot.glyco_tree_test()

def glyco_tree_py(imol, active_residue_py):
    r"""
    glyco_tree_py(int imol, PyObject * active_residue_py) -> PyObject *


    Parameters
    ----------
    imol : int
    active_residue_py : object

    """
    return _coot.glyco_tree_py(imol, active_residue_py)

def glyco_tree_residues_py(imol, active_residue_py):
    r"""
    glyco_tree_residues_py(int imol, PyObject * active_residue_py) -> PyObject *


    Parameters
    ----------
    imol : int
    active_residue_py : object

    """
    return _coot.glyco_tree_residues_py(imol, active_residue_py)

def glyco_tree_internal_distances_fn_py(imol, residue_spec, file_name):
    r"""
    glyco_tree_internal_distances_fn_py(int imol, PyObject * residue_spec, std::string const & file_name) -> PyObject *


    Parameters
    ----------
    imol : int
    residue_spec : object
    file_name : str

    """
    return _coot.glyco_tree_internal_distances_fn_py(imol, residue_spec, file_name)

def glyco_tree_residue_id_py(imol, residue_spec_py):
    r"""
    glyco_tree_residue_id_py(int imol, PyObject * residue_spec_py) -> PyObject *


    Parameters
    ----------
    imol : int
    residue_spec_py : object

    """
    return _coot.glyco_tree_residue_id_py(imol, residue_spec_py)

def glyco_tree_compare_trees_py(imol_1, res_spec_1, imol_2, res_spec_2):
    r"""
    glyco_tree_compare_trees_py(int imol_1, PyObject * res_spec_1, int imol_2, PyObject * res_spec_2) -> PyObject *


    Parameters
    ----------
    imol_1 : int
    res_spec_1 : object
    imol_2 : int
    res_spec_2 : object

    """
    return _coot.glyco_tree_compare_trees_py(imol_1, res_spec_1, imol_2, res_spec_2)

def glyco_tree_matched_residue_pairs_py(imol_1, res_spec_1, imol_2, res_spec_2):
    r"""
    glyco_tree_matched_residue_pairs_py(int imol_1, PyObject * res_spec_1, int imol_2, PyObject * res_spec_2) -> PyObject *


    Parameters
    ----------
    imol_1 : int
    res_spec_1 : object
    imol_2 : int
    res_spec_2 : object

    """
    return _coot.glyco_tree_matched_residue_pairs_py(imol_1, res_spec_1, imol_2, res_spec_2)

def post_display_control_window():
    r"""
    post_display_control_window()

    display the Display Constrol window

    """
    return _coot.post_display_control_window()

def add_map_display_control_widgets():
    r"""add_map_display_control_widgets()"""
    return _coot.add_map_display_control_widgets()

def add_mol_display_control_widgets():
    r"""add_mol_display_control_widgets()"""
    return _coot.add_mol_display_control_widgets()

def add_map_and_mol_display_control_widgets():
    r"""add_map_and_mol_display_control_widgets()"""
    return _coot.add_map_and_mol_display_control_widgets()

def reset_graphics_display_control_window():
    r"""reset_graphics_display_control_window()"""
    return _coot.reset_graphics_display_control_window()

def close_graphics_display_control_window():
    r"""close_graphics_display_control_window()"""
    return _coot.close_graphics_display_control_window()

def set_map_displayed(imol, state):
    r"""
    set_map_displayed(int imol, int state)

    make the map displayed/undisplayed, 0 for off, 1 for on

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_map_displayed(imol, state)

def set_mol_displayed(imol, state):
    r"""
    set_mol_displayed(int imol, int state)

    make the coordinates molecule displayed/undisplayed, 0 for off, 1 for on

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_mol_displayed(imol, state)

def set_display_only_model_mol(imol):
    r"""
    set_display_only_model_mol(int imol)

    from all the model molecules, display only imol

    This stops flashing/delayed animations with many molecules

    Parameters
    ----------
    imol : int

    """
    return _coot.set_display_only_model_mol(imol)

def set_mol_active(imol, state):
    r"""
    set_mol_active(int imol, int state)

    make the coordinates molecule active/inactve (clickable), 0 for off, 1 for on

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_mol_active(imol, state)

def display_maps_py(pyo):
    r"""
    display_maps_py(PyObject * pyo)


    Parameters
    ----------
    pyo : object

    """
    return _coot.display_maps_py(pyo)

def mol_is_displayed(imol):
    r"""
    mol_is_displayed(int imol) -> int

    return the display state of molecule number imol

    1 for on, 0 for off

    Parameters
    ----------
    imol : int

    """
    return _coot.mol_is_displayed(imol)

def mol_is_active(imol):
    r"""
    mol_is_active(int imol) -> int

    return the active state of molecule number imol

    1 for on, 0 for off

    Parameters
    ----------
    imol : int

    """
    return _coot.mol_is_active(imol)

def map_is_displayed(imol):
    r"""
    map_is_displayed(int imol) -> int

    return the display state of molecule number imol

    1 for on, 0 for off

    Parameters
    ----------
    imol : int

    """
    return _coot.map_is_displayed(imol)

def set_all_maps_displayed(on_or_off):
    r"""
    set_all_maps_displayed(int on_or_off)

    if on_or_off is 0 turn off all maps displayed, for other values of on_or_off turn on all maps

    Parameters
    ----------
    on_or_off : int

    """
    return _coot.set_all_maps_displayed(on_or_off)

def set_all_models_displayed_and_active(on_or_off):
    r"""
    set_all_models_displayed_and_active(int on_or_off)

    if on_or_off is 0 turn off all models displayed and active, for other values of on_or_off turn on all models.

    Parameters
    ----------
    on_or_off : int

    """
    return _coot.set_all_models_displayed_and_active(on_or_off)

def set_only_last_model_molecule_displayed():
    r"""
    set_only_last_model_molecule_displayed()

    only display the last model molecule

    """
    return _coot.set_only_last_model_molecule_displayed()

def display_only_active():
    r"""
    display_only_active()

    display only the active mol and the refinement map

    """
    return _coot.display_only_active()

def space_group_py(imol):
    r"""
    space_group_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.space_group_py(imol)

def show_spacegroup(imol):
    r"""
    show_spacegroup(int imol) -> char *

    return the spacegroup of molecule number imol . Deprecated.

    "No Spacegroup" when the spacegroup of a molecule has not been set.

    Parameters
    ----------
    imol : int

    """
    return _coot.show_spacegroup(imol)

def symmetry_operators_py(imol):
    r"""
    symmetry_operators_py(int imol) -> PyObject *

    return a list of symmetry operators as strings - or Python False if that is not possible.

    Parameters
    ----------
    imol : int

    """
    return _coot.symmetry_operators_py(imol)

def symmetry_operators_to_xHM_py(symmetry_operators):
    r"""
    symmetry_operators_to_xHM_py(PyObject * symmetry_operators) -> PyObject *


    Parameters
    ----------
    symmetry_operators : object

    """
    return _coot.symmetry_operators_to_xHM_py(symmetry_operators)

def merge_molecules_py(add_molecules, imol):
    r"""
    merge_molecules_py(PyObject * add_molecules, int imol) -> PyObject *

    merge molecules

    a pair, the first item of which is a status (1 is good) the second is a list of merge-infos (one for each of the items in add_molecules). If the molecule of an add_molecule item is just one residue, return a spec for the new residue, if it is many residues return a chain id. the first argument is a list of molecule numbers and the second is the target molecule into which the others should be merged

    Parameters
    ----------
    add_molecules : object
    imol : int

    """
    return _coot.merge_molecules_py(add_molecules, imol)

def set_merge_molecules_ligand_spec_py(ligand_spec_py):
    r"""
    set_merge_molecules_ligand_spec_py(PyObject * ligand_spec_py)


    Parameters
    ----------
    ligand_spec_py : object

    """
    return _coot.set_merge_molecules_ligand_spec_py(ligand_spec_py)

def align_and_mutate(imol, chain_id, fasta_maybe, renumber_residues_flag):
    r"""
    align_and_mutate(int imol, char const * chain_id, char const * fasta_maybe, short renumber_residues_flag)

    align and mutate the given chain to the given sequence

    Parameters
    ----------
    imol : int
    chain_id : str
    fasta_maybe : str
    renumber_residues_flag : int

    """
    return _coot.align_and_mutate(imol, chain_id, fasta_maybe, renumber_residues_flag)

def set_alignment_gap_and_space_penalty(wgap, wspace):
    r"""
    set_alignment_gap_and_space_penalty(float wgap, float wspace)

    set the penalty for affine gap and space when aligning, defaults -3.0 and -0.4

    Parameters
    ----------
    wgap : float
    wspace : float

    """
    return _coot.set_alignment_gap_and_space_penalty(wgap, wspace)

def alignment_results_py(imol, chain_id, seq):
    r"""
    alignment_results_py(int imol, char const * chain_id, char const * seq) -> PyObject *


    Parameters
    ----------
    imol : int
    chain_id : str
    seq : str

    """
    return _coot.alignment_results_py(imol, chain_id, seq)

def nearest_residue_by_sequence_py(imol, chain_id, resno, ins_code):
    r"""
    nearest_residue_by_sequence_py(int imol, char const * chain_id, int resno, char const * ins_code) -> PyObject *

    return the residue spec of the nearest residue by sequence numbering. Return Python False if not possible

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.nearest_residue_by_sequence_py(imol, chain_id, resno, ins_code)

def renumber_residue_range(imol, chain_id, start_res, last_res, offset):
    r"""
    renumber_residue_range(int imol, char const * chain_id, int start_res, int last_res, int offset) -> int

    renumber the given residue range by offset residues

    Parameters
    ----------
    imol : int
    chain_id : str
    start_res : int
    last_res : int
    offset : int

    """
    return _coot.renumber_residue_range(imol, chain_id, start_res, last_res, offset)

def change_residue_number(imol, chain_id, current_resno, current_inscode, new_resno, new_inscode):
    r"""
    change_residue_number(int imol, char const * chain_id, int current_resno, char const * current_inscode, int new_resno, char const * new_inscode) -> int

    change chain id, residue number or insertion code for given residue

    Parameters
    ----------
    imol : int
    chain_id : str
    current_resno : int
    current_inscode : str
    new_resno : int
    new_inscode : str

    """
    return _coot.change_residue_number(imol, chain_id, current_resno, current_inscode, new_resno, new_inscode)

def change_chain_id(imol, from_chain_id, to_chain_id, use_res_range_flag, from_resno, to_resno):
    r"""
    change_chain_id(int imol, char const * from_chain_id, char const * to_chain_id, short use_res_range_flag, int from_resno, int to_resno)

    change the chain id of the specified residue

    Parameters
    ----------
    imol : int
    from_chain_id : str
    to_chain_id : str
    use_res_range_flag : int
    from_resno : int
    to_resno : int

    """
    return _coot.change_chain_id(imol, from_chain_id, to_chain_id, use_res_range_flag, from_resno, to_resno)

def change_chain_id_with_result_py(imol, from_chain_id, to_chain_id, use_res_range_flag, from_resno, to_resno):
    r"""
    change_chain_id_with_result_py(int imol, char const * from_chain_id, char const * to_chain_id, short use_res_range_flag, int from_resno, int to_resno) -> PyObject *


    Parameters
    ----------
    imol : int
    from_chain_id : str
    to_chain_id : str
    use_res_range_flag : int
    from_resno : int
    to_resno : int

    """
    return _coot.change_chain_id_with_result_py(imol, from_chain_id, to_chain_id, use_res_range_flag, from_resno, to_resno)

def probe_available_p():
    r"""
    probe_available_p() -> int

    Can we run probe (was the executable variable set properly?) (predicate).

    1 for yes, 2 for no

    """
    return _coot.probe_available_p()

def probe_available_p_py():
    r"""probe_available_p_py() -> int"""
    return _coot.probe_available_p_py()

def post_scripting_window():
    r"""
    post_scripting_window()

    do nothing - compatibility function

    """
    return _coot.post_scripting_window()

def post_scheme_scripting_window():
    r"""
    post_scheme_scripting_window()

    pop-up a scripting window for scheming

    """
    return _coot.post_scheme_scripting_window()

def run_command_line_scripts():
    r"""run_command_line_scripts()"""
    return _coot.run_command_line_scripts()

def set_guile_gui_loaded_flag():
    r"""set_guile_gui_loaded_flag()"""
    return _coot.set_guile_gui_loaded_flag()

def set_python_gui_loaded_flag():
    r"""set_python_gui_loaded_flag()"""
    return _coot.set_python_gui_loaded_flag()

def set_found_coot_gui():
    r"""set_found_coot_gui()"""
    return _coot.set_found_coot_gui()

def set_found_coot_python_gui():
    r"""set_found_coot_python_gui()"""
    return _coot.set_found_coot_python_gui()

def get_monomer_for_molecule_by_index(dict_idx, imol_enc):
    r"""
    get_monomer_for_molecule_by_index(int dict_idx, int imol_enc) -> int


    Parameters
    ----------
    dict_idx : int
    imol_enc : int

    """
    return _coot.get_monomer_for_molecule_by_index(dict_idx, imol_enc)

def run_script(filename):
    r"""
    run_script(char const * filename)

    run script file

    Parameters
    ----------
    filename : str

    """
    return _coot.run_script(filename)

def run_guile_script(filename):
    r"""
    run_guile_script(char const * filename)

    guile run script file

    Parameters
    ----------
    filename : str

    """
    return _coot.run_guile_script(filename)

def run_python_script(filename):
    r"""
    run_python_script(char const * filename)

    run python script file

    Parameters
    ----------
    filename : str

    """
    return _coot.run_python_script(filename)

def import_python_module(module_name, use_namespace):
    r"""
    import_python_module(char const * module_name, int use_namespace) -> int

    import python module

    Parameters
    ----------
    module_name : str
    use_namespace : int

    """
    return _coot.import_python_module(module_name, use_namespace)

def auto_load_dictionary(comp_id):
    r"""
    auto_load_dictionary(char const * comp_id) -> int

    try to auto-load the dictionary for comp_id from the refmac monomer library.

    return 0 on failure. return 1 on successful auto-load. return 2 on already-read.

    Parameters
    ----------
    comp_id : str

    """
    return _coot.auto_load_dictionary(comp_id)

def reload_dictionary(comp_id):
    r"""
    reload_dictionary(char const * comp_id) -> int

    as above, but dictionary is cleared and re-read if it already exists

    Parameters
    ----------
    comp_id : str

    """
    return _coot.reload_dictionary(comp_id)

def add_non_auto_load_residue_name(s):
    r"""
    add_non_auto_load_residue_name(char const * s)

    add residue name to the list of residue names that don't get auto-loaded from the Refmac dictionary.

    Parameters
    ----------
    s : str

    """
    return _coot.add_non_auto_load_residue_name(s)

def remove_non_auto_load_residue_name(s):
    r"""
    remove_non_auto_load_residue_name(char const * s)

    remove residue name from the list of residue names that don't get auto-loaded from the Refmac dictionary.

    Parameters
    ----------
    s : str

    """
    return _coot.remove_non_auto_load_residue_name(s)

def matching_compound_names_from_dictionary_py(compound_name_fragment, allow_minimal_descriptions_flag):
    r"""
    matching_compound_names_from_dictionary_py(char const * compound_name_fragment, short allow_minimal_descriptions_flag) -> PyObject *

    return a list of compoundIDs in the dictionary which the given string is a substring of the compound name

    Parameters
    ----------
    compound_name_fragment : str
    allow_minimal_descriptions_flag : int

    """
    return _coot.matching_compound_names_from_dictionary_py(compound_name_fragment, allow_minimal_descriptions_flag)

def comp_id_to_name_py(comp_id):
    r"""
    comp_id_to_name_py(char const * comp_id) -> PyObject *

    return the monomer name

    return python false if not found

    Parameters
    ----------
    comp_id : str

    """
    return _coot.comp_id_to_name_py(comp_id)

def do_regularize(state):
    r"""
    do_regularize(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.do_regularize(state)

def do_refine(state):
    r"""
    do_refine(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.do_refine(state)

def add_planar_peptide_restraints():
    r"""
    add_planar_peptide_restraints()

    add a restraint on peptides to make them planar

    This adds a 5 atom restraint that includes both CA atoms of the peptide. Use this rather than editting the mon_lib_list.cif file.

    """
    return _coot.add_planar_peptide_restraints()

def remove_planar_peptide_restraints():
    r"""
    remove_planar_peptide_restraints()

    remove restraints on peptides to make them planar.

    """
    return _coot.remove_planar_peptide_restraints()

def make_tight_planar_peptide_restraints():
    r"""
    make_tight_planar_peptide_restraints()

    make the planar peptide restraints tight

    Useful when refining models with cryo-EM maps

    """
    return _coot.make_tight_planar_peptide_restraints()

def planar_peptide_restraints_state():
    r"""planar_peptide_restraints_state() -> int"""
    return _coot.planar_peptide_restraints_state()

def set_use_trans_peptide_restraints(on_off_state):
    r"""
    set_use_trans_peptide_restraints(short on_off_state)

    add a restraint on peptides to keep trans peptides trans

    i.e. omega in trans-peptides is restraints to 180 degrees.

    Parameters
    ----------
    on_off_state : int

    """
    return _coot.set_use_trans_peptide_restraints(on_off_state)

def add_omega_torsion_restriants():
    r"""
    add_omega_torsion_restriants()

    add restraints on the omega angle of the peptides

    (that is the torsion round the peptide bond). Omega angles that are closer to 0 than to 180 will be refined as cis peptides (and of course if omega is greater than 90 then the peptide will be refined as a trans peptide (this is the normal case).

    """
    return _coot.add_omega_torsion_restriants()

def remove_omega_torsion_restriants():
    r"""
    remove_omega_torsion_restriants()

    remove omega restraints on CIS and TRANS linked residues.

    """
    return _coot.remove_omega_torsion_restriants()

def set_refine_hydrogen_bonds(state):
    r"""
    set_refine_hydrogen_bonds(int state)

    add or remove auto H-bond restraints

    Parameters
    ----------
    state : int

    """
    return _coot.set_refine_hydrogen_bonds(state)

def set_refinement_immediate_replacement(istate):
    r"""
    set_refinement_immediate_replacement(int istate)

    set immediate replacement mode for refinement and regularization

    This can enable synchronous refinement (with istate = 1). You need this (call with istate=1) if you are scripting refinement/regularization

      istate  set the state of immediate-refinemnt

    Parameters
    ----------
    istate : int
        set the state of immediate-refinemnt

    """
    return _coot.set_refinement_immediate_replacement(istate)

def refinement_immediate_replacement_state():
    r"""
    refinement_immediate_replacement_state() -> int

    query the state of the immediate replacement mode

    """
    return _coot.refinement_immediate_replacement_state()

def set_refine_use_noughties_physics(state):
    r"""
    set_refine_use_noughties_physics(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_refine_use_noughties_physics(state)

def get_refine_use_noughties_physics_state():
    r"""get_refine_use_noughties_physics_state() -> int"""
    return _coot.get_refine_use_noughties_physics_state()

def set_residue_selection_flash_frames_number(i):
    r"""
    set_residue_selection_flash_frames_number(int i)

    set the number of frames for which the selected residue range flashes

    On fast computers, this can be set to higher than the default for more aesthetic appeal.

    Parameters
    ----------
    i : int

    """
    return _coot.set_residue_selection_flash_frames_number(i)

def c_accept_moving_atoms():
    r"""
    c_accept_moving_atoms()

    accept the new positions of the regularized or refined residues

    If you are scripting refinement and/or regularization, this is not the function that you need to call after refine-zone or regularize-zone. If you are using Python, use accept_moving_atoms_py() and that will provide a return value that may be of some use.

    """
    return _coot.c_accept_moving_atoms()

def accept_regularizement():
    r"""
    accept_regularizement()

    a hideously-named alias for c_accept_moving_atoms()

    """
    return _coot.accept_regularizement()

def clear_up_moving_atoms():
    r"""
    clear_up_moving_atoms()

    clear up moving atoms

    """
    return _coot.clear_up_moving_atoms()

def clear_moving_atoms_object():
    r"""
    clear_moving_atoms_object()

    remove just the bonds

    A redraw is done.

    """
    return _coot.clear_moving_atoms_object()

def refinement_already_ongoing_p():
    r"""
    refinement_already_ongoing_p() -> short

    If there is a refinement on-going already, we don't want to start a new one.

    The is the means to ask if that is the case. This needs a scheme wrapper to provide refinement-already-ongoing? The question is translated to "are the intermediate atoms being displayed?" so that might be a more accurate function name than the current one.

    1 for yes, 0 for no.

    """
    return _coot.refinement_already_ongoing_p()

def refine_residues_py(imol, rl):
    r"""
    refine_residues_py(int imol, PyObject * rl) -> PyObject *

    refine the residues in the given residue spec list

      imol  is the molecule index   rl  is a Python list of residue specs, where a residue spec is a list of [ chain_id , res_no , ins_code ] When using this function from scripting, make sure that set_refinement_immediate_replacement(1) is called first.

    False if restraints could not be set up, or a list of 3 elements on success:  [0] info_text (string): refinement information text [1] progress (int): refinement progress indicator. 0: GSL_SUCCESS: means refinement was successfully completed -2: GSL_CONTINUE: means refinement was successful, but didn't terminate (so more cycles needed) 27: GSL_ENOPROG: iteration is not making progress towards solution [2] lights (list or False): False if empty, otherwise a list of [ name , label , value ] triples where name and label are strings and value is a float

    Parameters
    ----------
    imol : int
        is the molecule index
    rl : object
        is a Python list of residue specs, where a residue spec is a list of [ chain_id , res_no , ins_code ]

    """
    return _coot.refine_residues_py(imol, rl)

def refine_residues_with_modes_with_alt_conf_py(imol, r, alt_conf, mode_1, mode_2, mode_3):
    r"""
    refine_residues_with_modes_with_alt_conf_py(int imol, PyObject * r, char const * alt_conf, PyObject * mode_1, PyObject * mode_2, PyObject * mode_3) -> PyObject *


    Parameters
    ----------
    imol : int
    r : object
    alt_conf : str
    mode_1 : object
    mode_2 : object
    mode_3 : object

    """
    return _coot.refine_residues_with_modes_with_alt_conf_py(imol, r, alt_conf, mode_1, mode_2, mode_3)

def refine_residues_with_alt_conf_py(imol, r, alt_conf):
    r"""
    refine_residues_with_alt_conf_py(int imol, PyObject * r, char const * alt_conf) -> PyObject *


    Parameters
    ----------
    imol : int
    r : object
    alt_conf : str

    """
    return _coot.refine_residues_with_alt_conf_py(imol, r, alt_conf)

def regularize_residues_py(imol, r):
    r"""
    regularize_residues_py(int imol, PyObject * r) -> PyObject *


    Parameters
    ----------
    imol : int
    r : object

    """
    return _coot.regularize_residues_py(imol, r)

def regularize_residues_with_alt_conf_py(imol, r, alt_conf):
    r"""
    regularize_residues_with_alt_conf_py(int imol, PyObject * r, char const * alt_conf) -> PyObject *


    Parameters
    ----------
    imol : int
    r : object
    alt_conf : str

    """
    return _coot.regularize_residues_with_alt_conf_py(imol, r, alt_conf)

def stop_refinement_internal():
    r"""stop_refinement_internal()"""
    return _coot.stop_refinement_internal()

def set_refinement_use_soft_mode_nbc_restraints(flag):
    r"""
    set_refinement_use_soft_mode_nbc_restraints(short flag)


    Parameters
    ----------
    flag : int

    """
    return _coot.set_refinement_use_soft_mode_nbc_restraints(flag)

def shiftfield_b_factor_refinement(imol):
    r"""
    shiftfield_b_factor_refinement(int imol)

    shiftfield B-factor refinement

    Parameters
    ----------
    imol : int

    """
    return _coot.shiftfield_b_factor_refinement(imol)

def shiftfield_xyz_factor_refinement(imol):
    r"""
    shiftfield_xyz_factor_refinement(int imol)

    shiftfield xyz refinement

    Parameters
    ----------
    imol : int

    """
    return _coot.shiftfield_xyz_factor_refinement(imol)

def set_refine_with_torsion_restraints(istate):
    r"""
    set_refine_with_torsion_restraints(int istate)

    turn on (or off) torsion restraints

    Pass with istate=1 for on, istate=0 for off.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_refine_with_torsion_restraints(istate)

def refine_with_torsion_restraints_state():
    r"""
    refine_with_torsion_restraints_state() -> int

    return the state of above

    """
    return _coot.refine_with_torsion_restraints_state()

def set_matrix(f):
    r"""
    set_matrix(float f)

    set the relative weight of the geometric terms to the map terms

    The default is 60.

    The higher the number the more weight that is given to the map terms but the resulting chi squared values are higher). This will be needed for maps generated from data not on (or close to) the absolute scale or maps that have been scaled (for example so that the sigma level has been scaled to 1.0).

    Parameters
    ----------
    f : float

    """
    return _coot.set_matrix(f)

def matrix_state():
    r"""
    matrix_state() -> float

    return the relative weight of the geometric terms to the map terms.

    """
    return _coot.matrix_state()

def get_map_weight():
    r"""
    get_map_weight() -> float

    return the relative weight of the geometric terms to the map terms.

    A more sensible name for the matrix_state() function)

    """
    return _coot.get_map_weight()

def estimate_map_weight(imol_map):
    r"""
    estimate_map_weight(int imol_map) -> float


    Parameters
    ----------
    imol_map : int

    """
    return _coot.estimate_map_weight(imol_map)

def set_refine_auto_range_step(i):
    r"""
    set_refine_auto_range_step(int i)

    change the +/- step for autoranging (default is 1)

    Auto-ranging alow you to select a range from one button press, this allows you to set the number of residues either side of the clicked residue that becomes the selected zone

    Parameters
    ----------
    i : int

    """
    return _coot.set_refine_auto_range_step(i)

def set_refine_max_residues(n):
    r"""
    set_refine_max_residues(int n)

    set the heuristic fencepost for the maximum number of residues in the refinement/regularization residue range

    Default is 20

    Parameters
    ----------
    n : int

    """
    return _coot.set_refine_max_residues(n)

def refine_zone_atom_index_define(imol, ind1, ind2):
    r"""
    refine_zone_atom_index_define(int imol, int ind1, int ind2)

    refine a zone based on atom indexing

    Parameters
    ----------
    imol : int
    ind1 : int
    ind2 : int

    """
    return _coot.refine_zone_atom_index_define(imol, ind1, ind2)

def refine_zone(imol, chain_id, resno1, resno2, altconf):
    r"""
    refine_zone(int imol, char const * chain_id, int resno1, int resno2, char const * altconf)

    refine a zone

    presumes that imol_Refinement_Map has been set

    Parameters
    ----------
    imol : int
    chain_id : str
    resno1 : int
    resno2 : int
    altconf : str

    """
    return _coot.refine_zone(imol, chain_id, resno1, resno2, altconf)

def repeat_refine_zone():
    r"""
    repeat_refine_zone()

    repeat the previous (user-selected) refine zone

    """
    return _coot.repeat_refine_zone()

def refine_zone_with_score_py(imol, chain_id, resno1, resno2, altconf):
    r"""
    refine_zone_with_score_py(int imol, char const * chain_id, int resno1, int resno2, char const * altconf) -> PyObject *


    Parameters
    ----------
    imol : int
    chain_id : str
    resno1 : int
    resno2 : int
    altconf : str

    """
    return _coot.refine_zone_with_score_py(imol, chain_id, resno1, resno2, altconf)

def regularize_zone_with_score_py(imol, chain_id, resno1, resno2, altconf):
    r"""
    regularize_zone_with_score_py(int imol, char const * chain_id, int resno1, int resno2, char const * altconf) -> PyObject *


    Parameters
    ----------
    imol : int
    chain_id : str
    resno1 : int
    resno2 : int
    altconf : str

    """
    return _coot.regularize_zone_with_score_py(imol, chain_id, resno1, resno2, altconf)

def refine_auto_range(imol, chain_id, resno1, altconf):
    r"""
    refine_auto_range(int imol, char const * chain_id, int resno1, char const * altconf)

    refine a zone using auto-range

    presumes that imol_Refinement_Map has been set

    Parameters
    ----------
    imol : int
    chain_id : str
    resno1 : int
    altconf : str

    """
    return _coot.refine_auto_range(imol, chain_id, resno1, altconf)

def regularize_zone(imol, chain_id, resno1, resno2, altconf):
    r"""
    regularize_zone(int imol, char const * chain_id, int resno1, int resno2, char const * altconf) -> int

    regularize a zone

    a status, whether the regularisation was done or not. 0 for no, 1 for yes.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno1 : int
    resno2 : int
    altconf : str

    """
    return _coot.regularize_zone(imol, chain_id, resno1, resno2, altconf)

def set_dragged_refinement_steps_per_frame(v):
    r"""
    set_dragged_refinement_steps_per_frame(int v)

    set the number of refinement steps applied to the intermediate atoms each frame of graphics.

    smaller numbers make the movement of the intermediate atoms slower, smoother, more elegant.

    Default: 80.

    Parameters
    ----------
    v : int

    """
    return _coot.set_dragged_refinement_steps_per_frame(v)

def dragged_refinement_steps_per_frame():
    r"""
    dragged_refinement_steps_per_frame() -> int

    return the number of steps per frame in dragged refinement

    """
    return _coot.dragged_refinement_steps_per_frame()

def set_refinement_refine_per_frame(istate):
    r"""
    set_refinement_refine_per_frame(int istate)

    allow refinement of intermediate atoms after dragging, before displaying (default: 0, off).

    An attempt to do something like xfit does, at the request of Frank von Delft.

    Pass with istate=1 to enable this option.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_refinement_refine_per_frame(istate)

def refinement_refine_per_frame_state():
    r"""
    refinement_refine_per_frame_state() -> int

    query the state of the above option

    """
    return _coot.refinement_refine_per_frame_state()

def set_refinement_drag_elasticity(e):
    r"""
    set_refinement_drag_elasticity(float e)

    the elasticity of the dragged atom in refinement mode.

    Default 0.33

    Bigger numbers mean bigger movement of the other atoms.

    Parameters
    ----------
    e : float

    """
    return _coot.set_refinement_drag_elasticity(e)

def set_refine_ramachandran_angles(state):
    r"""
    set_refine_ramachandran_angles(int state)

    turn on Ramachandran angles refinement in refinement and regularization

    name consistent with set_refine_with_torsion_restraints() !?

    Parameters
    ----------
    state : int

    """
    return _coot.set_refine_ramachandran_angles(state)

def set_refine_ramachandran_torsion_angles(state):
    r"""
    set_refine_ramachandran_torsion_angles(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_refine_ramachandran_torsion_angles(state)

def set_refine_ramachandran_restraints_type(type):
    r"""
    set_refine_ramachandran_restraints_type(int type)

    change the target function type

    Parameters
    ----------
    type : int

    """
    return _coot.set_refine_ramachandran_restraints_type(type)

def set_refine_ramachandran_restraints_weight(w):
    r"""
    set_refine_ramachandran_restraints_weight(float w)

    change the target function weight

    a big number means bad things

    Parameters
    ----------
    w : float

    """
    return _coot.set_refine_ramachandran_restraints_weight(w)

def refine_ramachandran_restraints_weight():
    r"""
    refine_ramachandran_restraints_weight() -> float

    ramachandran restraints weight

    weight as a float

    """
    return _coot.refine_ramachandran_restraints_weight()

def set_torsion_restraints_weight(w):
    r"""
    set_torsion_restraints_weight(double w)


    Parameters
    ----------
    w : float

    """
    return _coot.set_torsion_restraints_weight(w)

def set_refine_rotamers(state):
    r"""
    set_refine_rotamers(int state)

    set the state for using rotamer restraints "drive" mode

    1 in on, 0 is off (off by default)

    Parameters
    ----------
    state : int

    """
    return _coot.set_refine_rotamers(state)

def set_refinement_geman_mcclure_alpha_from_text(combobox_item_idx, t):
    r"""
    set_refinement_geman_mcclure_alpha_from_text(int combobox_item_idx, char const * t)


    Parameters
    ----------
    combobox_item_idx : int
    t : str

    """
    return _coot.set_refinement_geman_mcclure_alpha_from_text(combobox_item_idx, t)

def set_refinement_lennard_jones_epsilon_from_text(combobox_item_idx, t):
    r"""
    set_refinement_lennard_jones_epsilon_from_text(int combobox_item_idx, char const * t)


    Parameters
    ----------
    combobox_item_idx : int
    t : str

    """
    return _coot.set_refinement_lennard_jones_epsilon_from_text(combobox_item_idx, t)

def set_refinement_ramachandran_restraints_weight_from_text(combobox_item_idx, t):
    r"""
    set_refinement_ramachandran_restraints_weight_from_text(int combobox_item_idx, char const * t)


    Parameters
    ----------
    combobox_item_idx : int
    t : str

    """
    return _coot.set_refinement_ramachandran_restraints_weight_from_text(combobox_item_idx, t)

def set_refinement_overall_weight_from_text(t):
    r"""
    set_refinement_overall_weight_from_text(char const * t)


    Parameters
    ----------
    t : str

    """
    return _coot.set_refinement_overall_weight_from_text(t)

def set_refinement_torsion_weight_from_text(combobox_item_index, t):
    r"""
    set_refinement_torsion_weight_from_text(int combobox_item_index, char const * t)


    Parameters
    ----------
    combobox_item_index : int
    t : str

    """
    return _coot.set_refinement_torsion_weight_from_text(combobox_item_index, t)

def set_refine_params_dialog_more_control_frame_is_active(state):
    r"""
    set_refine_params_dialog_more_control_frame_is_active(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_refine_params_dialog_more_control_frame_is_active(state)

def refine_ramachandran_angles_state():
    r"""refine_ramachandran_angles_state() -> int"""
    return _coot.refine_ramachandran_angles_state()

def set_numerical_gradients(istate):
    r"""
    set_numerical_gradients(int istate)


    Parameters
    ----------
    istate : int

    """
    return _coot.set_numerical_gradients(istate)

def set_debug_refinement(state):
    r"""
    set_debug_refinement(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_debug_refinement(state)

def set_fix_chiral_volumes_before_refinement(istate):
    r"""
    set_fix_chiral_volumes_before_refinement(int istate)

    correct the sign of chiral volumes before commencing refinement?

    Do we want to fix chiral volumes (by moving the chiral atom to the other side of the chiral plane if necessary). Default yes (1). Note: doesn't work currently.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_fix_chiral_volumes_before_refinement(istate)

def check_chiral_volumes(imol):
    r"""
    check_chiral_volumes(int imol)

    query the state of the above option

    Parameters
    ----------
    imol : int

    """
    return _coot.check_chiral_volumes(imol)

def chiral_volume_errors_py(imol):
    r"""
    chiral_volume_errors_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.chiral_volume_errors_py(imol)

def set_show_chiral_volume_errors_dialog(istate):
    r"""
    set_show_chiral_volume_errors_dialog(short istate)

    For experienced Cooters who don't like Coot nannying about chiral volumes during refinement.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_show_chiral_volume_errors_dialog(istate)

def set_secondary_structure_restraints_type(itype):
    r"""
    set_secondary_structure_restraints_type(int itype)

    set the type of secondary structure restraints

    0 no sec str restraints

    1 alpha helix restraints

    2 beta strand restraints.

    Call this before refine_residues_py() to maintain secondary structure geometry during real-space refinement. Reset to 0 after refinement to avoid affecting subsequent refinement operations.

    Parameters
    ----------
    itype : int

    """
    return _coot.set_secondary_structure_restraints_type(itype)

def secondary_structure_restraints_type():
    r"""
    secondary_structure_restraints_type() -> int

    return the secondary structure restraints type

    """
    return _coot.secondary_structure_restraints_type()

def imol_refinement_map():
    r"""
    imol_refinement_map() -> int

    the molecule number of the map used for refinement

    the map number, if it has been set or there is only one map, otherwise return -1 on no map set (ambiguous) or no maps.

    """
    return _coot.imol_refinement_map()

def set_imol_refinement_map(imol):
    r"""
    set_imol_refinement_map(int imol) -> int

    set the molecule number of the map to be used for refinement/fitting.

    imol on success, -1 on failure

    Parameters
    ----------
    imol : int

    """
    return _coot.set_imol_refinement_map(imol)

def does_residue_exist_p(imol, chain_id, resno, inscode):
    r"""
    does_residue_exist_p(int imol, char const * chain_id, int resno, char const * inscode) -> int

    Does the residue exist? (Raw function)

    0 on not-exist, 1 on does exist.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    inscode : str

    """
    return _coot.does_residue_exist_p(imol, chain_id, resno, inscode)

def delete_restraints(comp_id):
    r"""
    delete_restraints(char const * comp_id) -> int

    delete the restraints for the given comp_id (i.e. residue name)

    success status (0 is failed, 1 is success)

    Parameters
    ----------
    comp_id : str

    """
    return _coot.delete_restraints(comp_id)

def add_extra_bond_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, chain_id_2, res_no_2, ins_code_2, atom_name_2, alt_conf_2, bond_dist, esd):
    r"""
    add_extra_bond_restraint(int imol, char const * chain_id_1, int res_no_1, char const * ins_code_1, char const * atom_name_1, char const * alt_conf_1, char const * chain_id_2, int res_no_2, char const * ins_code_2, char const * atom_name_2, char const * alt_conf_2, double bond_dist, double esd) -> int

    add a user-define bond restraint

    this extra restraint is used when the given atoms are selected in refinement or regularization.

    the index of the new restraint. -1 when the atoms were not found and no extra bond restraint was stored.

    Parameters
    ----------
    imol : int
    chain_id_1 : str
    res_no_1 : int
    ins_code_1 : str
    atom_name_1 : str
    alt_conf_1 : str
    chain_id_2 : str
    res_no_2 : int
    ins_code_2 : str
    atom_name_2 : str
    alt_conf_2 : str
    bond_dist : float
    esd : float

    """
    return _coot.add_extra_bond_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, chain_id_2, res_no_2, ins_code_2, atom_name_2, alt_conf_2, bond_dist, esd)

def add_extra_geman_mcclure_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, chain_id_2, res_no_2, ins_code_2, atom_name_2, alt_conf_2, bond_dist, esd):
    r"""
    add_extra_geman_mcclure_restraint(int imol, char const * chain_id_1, int res_no_1, char const * ins_code_1, char const * atom_name_1, char const * alt_conf_1, char const * chain_id_2, int res_no_2, char const * ins_code_2, char const * atom_name_2, char const * alt_conf_2, double bond_dist, double esd) -> int

    add a user-define GM distance restraint

    this extra restraint is used when the given atoms are selected in refinement or regularization.

    the index of the new restraint. -1 when the atoms were not found and no extra bond restraint was stored.

    Parameters
    ----------
    imol : int
    chain_id_1 : str
    res_no_1 : int
    ins_code_1 : str
    atom_name_1 : str
    alt_conf_1 : str
    chain_id_2 : str
    res_no_2 : int
    ins_code_2 : str
    atom_name_2 : str
    alt_conf_2 : str
    bond_dist : float
    esd : float

    """
    return _coot.add_extra_geman_mcclure_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, chain_id_2, res_no_2, ins_code_2, atom_name_2, alt_conf_2, bond_dist, esd)

def add_extra_bond_restraints_py(imol, extra_bond_restraints_py):
    r"""
    add_extra_bond_restraints_py(int imol, PyObject * extra_bond_restraints_py) -> int


    Parameters
    ----------
    imol : int
    extra_bond_restraints_py : object

    """
    return _coot.add_extra_bond_restraints_py(imol, extra_bond_restraints_py)

def set_show_extra_distance_restraints(state):
    r"""
    set_show_extra_distance_restraints(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_show_extra_distance_restraints(state)

def add_extra_angle_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, chain_id_2, res_no_2, ins_code_2, atom_name_2, alt_conf_2, chain_id_3, res_no_3, ins_code_3, atom_name_3, alt_conf_3, torsion_angle, esd):
    r"""
    add_extra_angle_restraint(int imol, char const * chain_id_1, int res_no_1, char const * ins_code_1, char const * atom_name_1, char const * alt_conf_1, char const * chain_id_2, int res_no_2, char const * ins_code_2, char const * atom_name_2, char const * alt_conf_2, char const * chain_id_3, int res_no_3, char const * ins_code_3, char const * atom_name_3, char const * alt_conf_3, double torsion_angle, double esd) -> int


    Parameters
    ----------
    imol : int
    chain_id_1 : str
    res_no_1 : int
    ins_code_1 : str
    atom_name_1 : str
    alt_conf_1 : str
    chain_id_2 : str
    res_no_2 : int
    ins_code_2 : str
    atom_name_2 : str
    alt_conf_2 : str
    chain_id_3 : str
    res_no_3 : int
    ins_code_3 : str
    atom_name_3 : str
    alt_conf_3 : str
    torsion_angle : float
    esd : float

    """
    return _coot.add_extra_angle_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, chain_id_2, res_no_2, ins_code_2, atom_name_2, alt_conf_2, chain_id_3, res_no_3, ins_code_3, atom_name_3, alt_conf_3, torsion_angle, esd)

def add_extra_torsion_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, chain_id_2, res_no_2, ins_code_2, atom_name_2, alt_conf_2, chain_id_3, res_no_3, ins_code_3, atom_name_3, alt_conf_3, chain_id_4, res_no_4, ins_code_4, atom_name_4, alt_conf_4, torsion_angle, esd, period):
    r"""
    add_extra_torsion_restraint(int imol, char const * chain_id_1, int res_no_1, char const * ins_code_1, char const * atom_name_1, char const * alt_conf_1, char const * chain_id_2, int res_no_2, char const * ins_code_2, char const * atom_name_2, char const * alt_conf_2, char const * chain_id_3, int res_no_3, char const * ins_code_3, char const * atom_name_3, char const * alt_conf_3, char const * chain_id_4, int res_no_4, char const * ins_code_4, char const * atom_name_4, char const * alt_conf_4, double torsion_angle, double esd, int period) -> int


    Parameters
    ----------
    imol : int
    chain_id_1 : str
    res_no_1 : int
    ins_code_1 : str
    atom_name_1 : str
    alt_conf_1 : str
    chain_id_2 : str
    res_no_2 : int
    ins_code_2 : str
    atom_name_2 : str
    alt_conf_2 : str
    chain_id_3 : str
    res_no_3 : int
    ins_code_3 : str
    atom_name_3 : str
    alt_conf_3 : str
    chain_id_4 : str
    res_no_4 : int
    ins_code_4 : str
    atom_name_4 : str
    alt_conf_4 : str
    torsion_angle : float
    esd : float
    period : int

    """
    return _coot.add_extra_torsion_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, chain_id_2, res_no_2, ins_code_2, atom_name_2, alt_conf_2, chain_id_3, res_no_3, ins_code_3, atom_name_3, alt_conf_3, chain_id_4, res_no_4, ins_code_4, atom_name_4, alt_conf_4, torsion_angle, esd, period)

def add_extra_start_pos_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, esd):
    r"""
    add_extra_start_pos_restraint(int imol, char const * chain_id_1, int res_no_1, char const * ins_code_1, char const * atom_name_1, char const * alt_conf_1, double esd) -> int


    Parameters
    ----------
    imol : int
    chain_id_1 : str
    res_no_1 : int
    ins_code_1 : str
    atom_name_1 : str
    alt_conf_1 : str
    esd : float

    """
    return _coot.add_extra_start_pos_restraint(imol, chain_id_1, res_no_1, ins_code_1, atom_name_1, alt_conf_1, esd)

def add_extra_target_position_restraint(imol, chain_id, res_no, ins_code, atom_name, alt_conf, x, y, z, weight):
    r"""
    add_extra_target_position_restraint(int imol, char const * chain_id, int res_no, char const * ins_code, char const * atom_name, char const * alt_conf, float x, float y, float z, float weight) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    atom_name : str
    alt_conf : str
    x : float
    y : float
    z : float
    weight : float

    """
    return _coot.add_extra_target_position_restraint(imol, chain_id, res_no, ins_code, atom_name, alt_conf, x, y, z, weight)

def delete_all_extra_restraints(imol):
    r"""
    delete_all_extra_restraints(int imol)

    clear out all the extra/user-defined restraints for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.delete_all_extra_restraints(imol)

def delete_extra_restraints_for_residue(imol, chain_id, res_no, ins_code):
    r"""
    delete_extra_restraints_for_residue(int imol, char const * chain_id, int res_no, char const * ins_code)

    clear out all the extra/user-defined restraints for this residue in molecule number imol

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str

    """
    return _coot.delete_extra_restraints_for_residue(imol, chain_id, res_no, ins_code)

def delete_extra_restraints_for_residue_spec_py(imol, residue_spec_in_py):
    r"""
    delete_extra_restraints_for_residue_spec_py(int imol, PyObject * residue_spec_in_py)


    Parameters
    ----------
    imol : int
    residue_spec_in_py : object

    """
    return _coot.delete_extra_restraints_for_residue_spec_py(imol, residue_spec_in_py)

def delete_extra_restraints_worse_than(imol, n_sigma):
    r"""
    delete_extra_restraints_worse_than(int imol, float n_sigma)


    Parameters
    ----------
    imol : int
    n_sigma : float

    """
    return _coot.delete_extra_restraints_worse_than(imol, n_sigma)

def add_refmac_extra_restraints(imol, file_name):
    r"""
    add_refmac_extra_restraints(int imol, char const * file_name)

    read in prosmart (typically) extra restraints

    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.add_refmac_extra_restraints(imol, file_name)

def set_show_extra_restraints(imol, state):
    r"""
    set_show_extra_restraints(int imol, int state)


    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_show_extra_restraints(imol, state)

def extra_restraints_are_shown(imol):
    r"""
    extra_restraints_are_shown(int imol) -> int


    Parameters
    ----------
    imol : int

    """
    return _coot.extra_restraints_are_shown(imol)

def set_extra_restraints_prosmart_sigma_limits(imol, limit_high, limit_low):
    r"""
    set_extra_restraints_prosmart_sigma_limits(int imol, double limit_high, double limit_low)

    often we don't want to see all prosmart restraints, just the (big) violations

    Parameters
    ----------
    imol : int
    limit_high : float
    limit_low : float

    """
    return _coot.set_extra_restraints_prosmart_sigma_limits(imol, limit_high, limit_low)

def generate_local_self_restraints(imol, chain_id, local_dist_max):
    r"""
    generate_local_self_restraints(int imol, char const * chain_id, float local_dist_max)

    generate external distance local self restraints

    Parameters
    ----------
    imol : int
    chain_id : str
    local_dist_max : float

    """
    return _coot.generate_local_self_restraints(imol, chain_id, local_dist_max)

def generate_self_restraints(imol, local_dist_max):
    r"""
    generate_self_restraints(int imol, float local_dist_max)

    generate external distance all-molecule self restraints

    Parameters
    ----------
    imol : int
    local_dist_max : float

    """
    return _coot.generate_self_restraints(imol, local_dist_max)

def generate_local_self_restraints_by_residues_py(imol, residue_specs, local_dist_max):
    r"""
    generate_local_self_restraints_by_residues_py(int imol, PyObject * residue_specs, float local_dist_max)


    Parameters
    ----------
    imol : int
    residue_specs : object
    local_dist_max : float

    """
    return _coot.generate_local_self_restraints_by_residues_py(imol, residue_specs, local_dist_max)

def write_interpolated_extra_restraints(imol_1, imol_2, n_steps, file_name_stub):
    r"""
    write_interpolated_extra_restraints(int imol_1, int imol_2, int n_steps, char const * file_name_stub)

    proSMART interpolated restraints for model morphing

    Parameters
    ----------
    imol_1 : int
    imol_2 : int
    n_steps : int
    file_name_stub : str

    """
    return _coot.write_interpolated_extra_restraints(imol_1, imol_2, n_steps, file_name_stub)

def write_interpolated_models_and_extra_restraints(imol_1, imol_2, n_steps, file_name_stub, interpolation_mode):
    r"""
    write_interpolated_models_and_extra_restraints(int imol_1, int imol_2, int n_steps, char const * file_name_stub, int interpolation_mode)

    proSMART interpolated restraints for model morphing and write interpolated model

    interpolation_mode is currently dummy - in due course I will addd torion angle interpolation.

    Parameters
    ----------
    imol_1 : int
    imol_2 : int
    n_steps : int
    file_name_stub : str
    interpolation_mode : int

    """
    return _coot.write_interpolated_models_and_extra_restraints(imol_1, imol_2, n_steps, file_name_stub, interpolation_mode)

def set_show_parallel_plane_restraints(imol, state):
    r"""
    set_show_parallel_plane_restraints(int imol, int state)


    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_show_parallel_plane_restraints(imol, state)

def parallel_plane_restraints_are_shown(imol):
    r"""
    parallel_plane_restraints_are_shown(int imol) -> int


    Parameters
    ----------
    imol : int

    """
    return _coot.parallel_plane_restraints_are_shown(imol)

def add_parallel_plane_restraint(imol, chain_id_1, re_no_1, ins_code_1, chain_id_2, re_no_2, ins_code_2):
    r"""
    add_parallel_plane_restraint(int imol, char const * chain_id_1, int re_no_1, char const * ins_code_1, char const * chain_id_2, int re_no_2, char const * ins_code_2)


    Parameters
    ----------
    imol : int
    chain_id_1 : str
    re_no_1 : int
    ins_code_1 : str
    chain_id_2 : str
    re_no_2 : int
    ins_code_2 : str

    """
    return _coot.add_parallel_plane_restraint(imol, chain_id_1, re_no_1, ins_code_1, chain_id_2, re_no_2, ins_code_2)

def set_extra_restraints_representation_for_bonds_go_to_CA(imol, state):
    r"""
    set_extra_restraints_representation_for_bonds_go_to_CA(int imol, short state)


    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_extra_restraints_representation_for_bonds_go_to_CA(imol, state)

def delete_extra_restraint_py(imol, restraint_spec):
    r"""
    delete_extra_restraint_py(int imol, PyObject * restraint_spec)


    Parameters
    ----------
    imol : int
    restraint_spec : object

    """
    return _coot.delete_extra_restraint_py(imol, restraint_spec)

def list_extra_restraints_py(imol):
    r"""
    list_extra_restraints_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.list_extra_restraints_py(imol)

def set_use_only_extra_torsion_restraints_for_torsions(state):
    r"""
    set_use_only_extra_torsion_restraints_for_torsions(short state)

    set use only extra torsion restraints for torsions

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_only_extra_torsion_restraints_for_torsions(state)

def use_only_extra_torsion_restraints_for_torsions_state():
    r"""
    use_only_extra_torsion_restraints_for_torsions_state() -> int

    return only-use-extra-torsion-restraints-for-torsions state

    """
    return _coot.use_only_extra_torsion_restraints_for_torsions_state()

def clear_all_atom_pull_restraints():
    r"""clear_all_atom_pull_restraints()"""
    return _coot.clear_all_atom_pull_restraints()

def set_auto_clear_atom_pull_restraint(state):
    r"""
    set_auto_clear_atom_pull_restraint(int state)

    set auto-clear atom pull restraint

    Parameters
    ----------
    state : int

    """
    return _coot.set_auto_clear_atom_pull_restraint(state)

def get_auto_clear_atom_pull_restraint_state():
    r"""
    get_auto_clear_atom_pull_restraint_state() -> int

    get auto-clear atom pull restraint state

    """
    return _coot.get_auto_clear_atom_pull_restraint_state()

def increase_proportional_editing_radius():
    r"""
    increase_proportional_editing_radius()

    iscrease the proportional editing radius

    """
    return _coot.increase_proportional_editing_radius()

def decrease_proportional_editing_radius():
    r"""
    decrease_proportional_editing_radius()

    descrease the proportional editing radius

    """
    return _coot.decrease_proportional_editing_radius()

def fit_residue_range_to_map_by_simplex(res1, res2, altloc, chain_id, imol, imol_for_map):
    r"""
    fit_residue_range_to_map_by_simplex(int res1, int res2, char const * altloc, char const * chain_id, int imol, int imol_for_map)

    refine residue range using simplex optimization

    Parameters
    ----------
    res1 : int
    res2 : int
    altloc : str
    chain_id : str
    imol : int
    imol_for_map : int

    """
    return _coot.fit_residue_range_to_map_by_simplex(res1, res2, altloc, chain_id, imol, imol_for_map)

def score_residue_range_fit_to_map(res1, res2, altloc, chain_id, imol, imol_for_map):
    r"""
    score_residue_range_fit_to_map(int res1, int res2, char const * altloc, char const * chain_id, int imol, int imol_for_map) -> float

    simply score the residue range fit to map

    Parameters
    ----------
    res1 : int
    res2 : int
    altloc : str
    chain_id : str
    imol : int
    imol_for_map : int

    """
    return _coot.score_residue_range_fit_to_map(res1, res2, altloc, chain_id, imol, imol_for_map)

def fix_nomenclature_errors(imol):
    r"""
    fix_nomenclature_errors(int imol) -> int

    fix nomenclature errors in molecule number imol

    the number of resides altered.

    Parameters
    ----------
    imol : int

    """
    return _coot.fix_nomenclature_errors(imol)

def set_nomenclature_errors_on_read(mode):
    r"""
    set_nomenclature_errors_on_read(char const * mode)

    set way nomenclature errors should be handled on reading coordinates.

    mode should be "auto-correct", "ignore", "prompt". The default is "prompt"

    Parameters
    ----------
    mode : str

    """
    return _coot.set_nomenclature_errors_on_read(mode)

def output_atom_info_as_text(imol, chain_id, resno, ins_code, atname, altconf):
    r"""
    output_atom_info_as_text(int imol, char const * chain_id, int resno, char const * ins_code, char const * atname, char const * altconf)

    output to the terminal the Atom Info for the give atom specs

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    atname : str
    altconf : str

    """
    return _coot.output_atom_info_as_text(imol, chain_id, resno, ins_code, atname, altconf)

def do_residue_info_dialog():
    r"""do_residue_info_dialog()"""
    return _coot.do_residue_info_dialog()

def output_residue_info_dialog(imol, atom_index):
    r"""
    output_residue_info_dialog(int imol, int atom_index)


    Parameters
    ----------
    imol : int
    atom_index : int

    """
    return _coot.output_residue_info_dialog(imol, atom_index)

def residue_info_dialog(imol, chain_id, resno, ins_code):
    r"""
    residue_info_dialog(int imol, char const * chain_id, int resno, char const * ins_code)

    show residue info dialog for given residue

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.residue_info_dialog(imol, chain_id, resno, ins_code)

def residue_info_dialog_is_displayed():
    r"""residue_info_dialog_is_displayed() -> int"""
    return _coot.residue_info_dialog_is_displayed()

def output_residue_info_as_text(atom_index, imol):
    r"""
    output_residue_info_as_text(int atom_index, int imol)


    Parameters
    ----------
    atom_index : int
    imol : int

    """
    return _coot.output_residue_info_as_text(atom_index, imol)

def set_show_distance_labels(state):
    r"""
    set_show_distance_labels(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_show_distance_labels(state)

def do_distance_define():
    r"""do_distance_define()"""
    return _coot.do_distance_define()

def do_angle_define():
    r"""do_angle_define()"""
    return _coot.do_angle_define()

def do_torsion_define():
    r"""do_torsion_define()"""
    return _coot.do_torsion_define()

def residue_info_apply_all_checkbutton_toggled():
    r"""residue_info_apply_all_checkbutton_toggled()"""
    return _coot.residue_info_apply_all_checkbutton_toggled()

def clear_residue_info_edit_list():
    r"""clear_residue_info_edit_list()"""
    return _coot.clear_residue_info_edit_list()

def unset_residue_info_widget():
    r"""unset_residue_info_widget()"""
    return _coot.unset_residue_info_widget()

def clear_measure_distances():
    r"""clear_measure_distances()"""
    return _coot.clear_measure_distances()

def clear_last_measure_distance():
    r"""clear_last_measure_distance()"""
    return _coot.clear_last_measure_distance()

def do_edit_copy_molecule():
    r"""do_edit_copy_molecule()"""
    return _coot.do_edit_copy_molecule()

def do_edit_copy_fragment():
    r"""do_edit_copy_fragment()"""
    return _coot.do_edit_copy_fragment()

def do_edit_replace_fragment():
    r"""do_edit_replace_fragment()"""
    return _coot.do_edit_replace_fragment()

def set_show_environment_distances(state):
    r"""
    set_show_environment_distances(int state)

    show environment distances. If state is 0, distances are turned off, otherwise distances are turned on.

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_environment_distances(state)

def set_show_environment_distances_bumps(state):
    r"""
    set_show_environment_distances_bumps(int state)

    show bumps environment distances. If state is 0, bump distances are turned off, otherwise bump distances are turned on.

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_environment_distances_bumps(state)

def set_show_environment_distances_h_bonds(state):
    r"""
    set_show_environment_distances_h_bonds(int state)

    show H-bond environment distances. If state is 0, bump distances are turned off, otherwise H-bond distances are turned on.

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_environment_distances_h_bonds(state)

def show_environment_distances_state():
    r"""
    show_environment_distances_state() -> int

    show the state of display of the environment distances

    """
    return _coot.show_environment_distances_state()

def set_environment_distances_distance_limits(min_dist, max_dist):
    r"""
    set_environment_distances_distance_limits(float min_dist, float max_dist)

    min and max distances for the environment distances

    Parameters
    ----------
    min_dist : float
    max_dist : float

    """
    return _coot.set_environment_distances_distance_limits(min_dist, max_dist)

def set_show_environment_distances_as_solid(state):
    r"""
    set_show_environment_distances_as_solid(int state)

    show the environment distances with solid modelling

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_environment_distances_as_solid(state)

def set_environment_distances_label_atom(state):
    r"""
    set_environment_distances_label_atom(int state)

    Label the atom on Environment Distances start/change.

    Parameters
    ----------
    state : int

    """
    return _coot.set_environment_distances_label_atom(state)

def label_neighbours():
    r"""
    label_neighbours()

    Label the atoms in the residues around the central residue.

    """
    return _coot.label_neighbours()

def label_atoms_in_residue():
    r"""
    label_atoms_in_residue()

    Label the atoms in the central residue.

    """
    return _coot.label_atoms_in_residue()

def set_show_local_b_factors(state):
    r"""
    set_show_local_b_factors(short state)

    Label the atoms with their B-factors.

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_local_b_factors(state)

def add_geometry_distance(imol_1, x_1, y_1, z_1, imol_2, x_2, y_2, z_2):
    r"""
    add_geometry_distance(int imol_1, float x_1, float y_1, float z_1, int imol_2, float x_2, float y_2, float z_2) -> double

    Add a geometry distance between points in a given molecule.

    the distance between the points

    Parameters
    ----------
    imol_1 : int
    x_1 : float
    y_1 : float
    z_1 : float
    imol_2 : int
    x_2 : float
    y_2 : float
    z_2 : float

    """
    return _coot.add_geometry_distance(imol_1, x_1, y_1, z_1, imol_2, x_2, y_2, z_2)

def add_atom_geometry_distance_py(imol_1, atom_spec_1, imol_2, atom_spec_2):
    r"""
    add_atom_geometry_distance_py(int imol_1, PyObject * atom_spec_1, int imol_2, PyObject * atom_spec_2) -> double


    Parameters
    ----------
    imol_1 : int
    atom_spec_1 : object
    imol_2 : int
    atom_spec_2 : object

    """
    return _coot.add_atom_geometry_distance_py(imol_1, atom_spec_1, imol_2, atom_spec_2)

def get_pointer_position_frac_py():
    r"""
    get_pointer_position_frac_py() -> PyObject *

    return the [x,y] position of the pointer in fractional coordinates.

    the origin is top-left. may return false if pointer is not available

    """
    return _coot.get_pointer_position_frac_py()

def set_show_pointer_distances(istate):
    r"""
    set_show_pointer_distances(int istate)

    turn on (or off) the pointer distance by passing 1 (or 0).

    Parameters
    ----------
    istate : int

    """
    return _coot.set_show_pointer_distances(istate)

def show_pointer_distances_state():
    r"""
    show_pointer_distances_state() -> int

    show the state of display of the pointer distances

    """
    return _coot.show_pointer_distances_state()

def scale_zoom(f):
    r"""
    scale_zoom(float f)

    scale the view by f

    Values outside the range 0.5 to 1.8 have no effect. external (scripting) interface (with redraw)   f  the smaller f, the bigger the zoom, typical value 1.3.

    Parameters
    ----------
    f : float
        the smaller f, the bigger the zoom, typical value 1.3.

    """
    return _coot.scale_zoom(f)

def scale_zoom_internal(f):
    r"""
    scale_zoom_internal(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.scale_zoom_internal(f)

def zoom_factor():
    r"""
    zoom_factor() -> float

    return the current zoom factor i.e. get_zoom_factor()

    """
    return _coot.zoom_factor()

def set_smooth_scroll_do_zoom(i):
    r"""
    set_smooth_scroll_do_zoom(int i)

    set smooth scroll with zoom

      i  0 means no, 1 means yes: (default 0)

    Parameters
    ----------
    i : int
        0 means no, 1 means yes: (default 0)

    """
    return _coot.set_smooth_scroll_do_zoom(i)

def smooth_scroll_do_zoom():
    r"""
    smooth_scroll_do_zoom() -> int

    return the state of the above system

    """
    return _coot.smooth_scroll_do_zoom()

def smooth_scroll_zoom_limit():
    r"""smooth_scroll_zoom_limit() -> float"""
    return _coot.smooth_scroll_zoom_limit()

def set_smooth_scroll_zoom_limit(f):
    r"""
    set_smooth_scroll_zoom_limit(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_smooth_scroll_zoom_limit(f)

def set_zoom(f):
    r"""
    set_zoom(float f)

    set the zoom factor (absolute value) - maybe should be called set_zoom_factor()

    Parameters
    ----------
    f : float

    """
    return _coot.set_zoom(f)

def handle_cns_data_file(filename, imol):
    r"""
    handle_cns_data_file(char const * filename, int imol) -> int

    read CNS data (currently only a placeholder)

    Parameters
    ----------
    filename : str
    imol : int

    """
    return _coot.handle_cns_data_file(filename, imol)

def handle_cns_data_file_with_cell(filename, imol, a, b, c, alpha, beta, gamma, spg_info):
    r"""
    handle_cns_data_file_with_cell(char const * filename, int imol, float a, float b, float c, float alpha, float beta, float gamma, char const * spg_info) -> int

    read CNS data (currently only a placeholder)

    a, b,c are in Angstroems. alpha, beta, gamma are in degrees. spg is the space group info, either ;-delimited symmetry operators or the space group name

    Parameters
    ----------
    filename : str
    imol : int
    a : float
    b : float
    c : float
    alpha : float
    beta : float
    gamma : float
    spg_info : str

    """
    return _coot.handle_cns_data_file_with_cell(filename, imol, a, b, c, alpha, beta, gamma, spg_info)

def auto_read_cif_data_with_phases(filename):
    r"""
    auto_read_cif_data_with_phases(char const * filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.auto_read_cif_data_with_phases(filename)

def read_cif_data_with_phases_sigmaa(filename):
    r"""
    read_cif_data_with_phases_sigmaa(char const * filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.read_cif_data_with_phases_sigmaa(filename)

def read_cif_data_with_phases_diff_sigmaa(filename):
    r"""
    read_cif_data_with_phases_diff_sigmaa(char const * filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.read_cif_data_with_phases_diff_sigmaa(filename)

def read_cif_data(filename, imol_coords):
    r"""
    read_cif_data(char const * filename, int imol_coords) -> int


    Parameters
    ----------
    filename : str
    imol_coords : int

    """
    return _coot.read_cif_data(filename, imol_coords)

def read_cif_data_2fofc_map(filename, imol_coords):
    r"""
    read_cif_data_2fofc_map(char const * filename, int imol_coords) -> int


    Parameters
    ----------
    filename : str
    imol_coords : int

    """
    return _coot.read_cif_data_2fofc_map(filename, imol_coords)

def read_cif_data_fofc_map(filename, imol_coords):
    r"""
    read_cif_data_fofc_map(char const * filename, int imol_coords) -> int


    Parameters
    ----------
    filename : str
    imol_coords : int

    """
    return _coot.read_cif_data_fofc_map(filename, imol_coords)

def read_cif_data_with_phases_fo_fc(filename):
    r"""
    read_cif_data_with_phases_fo_fc(char const * filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.read_cif_data_with_phases_fo_fc(filename)

def read_cif_data_with_phases_2fo_fc(filename):
    r"""
    read_cif_data_with_phases_2fo_fc(char const * filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.read_cif_data_with_phases_2fo_fc(filename)

def read_cif_data_with_phases_nfo_fc(filename, map_type):
    r"""
    read_cif_data_with_phases_nfo_fc(char const * filename, int map_type) -> int


    Parameters
    ----------
    filename : str
    map_type : int

    """
    return _coot.read_cif_data_with_phases_nfo_fc(filename, map_type)

def read_cif_data_with_phases_fo_alpha_calc(filename):
    r"""
    read_cif_data_with_phases_fo_alpha_calc(char const * filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.read_cif_data_with_phases_fo_alpha_calc(filename)

def write_connectivity(monomer_name, filename):
    r"""
    write_connectivity(char const * monomer_name, char const * filename) -> int


    Parameters
    ----------
    monomer_name : str
    filename : str

    """
    return _coot.write_connectivity(monomer_name, filename)

def open_cif_dictionary_file_selector_dialog():
    r"""
    open_cif_dictionary_file_selector_dialog()

    open the cif dictionary file selector dialog

    """
    return _coot.open_cif_dictionary_file_selector_dialog()

def non_standard_residue_names_py(imol):
    r"""
    non_standard_residue_names_py(int imol) -> PyObject *

    non-standard residue/monomer names (note HOH is not non-standard).

    Parameters
    ----------
    imol : int

    """
    return _coot.non_standard_residue_names_py(imol)

def import_all_refmac_cifs():
    r"""import_all_refmac_cifs()"""
    return _coot.import_all_refmac_cifs()

def read_small_molecule_cif(file_name):
    r"""
    read_small_molecule_cif(char const * file_name) -> int


    Parameters
    ----------
    file_name : str

    """
    return _coot.read_small_molecule_cif(file_name)

def read_small_molecule_data_cif(file_name):
    r"""
    read_small_molecule_data_cif(char const * file_name) -> int


    Parameters
    ----------
    file_name : str

    """
    return _coot.read_small_molecule_data_cif(file_name)

def read_small_molecule_data_cif_and_make_map_using_coords(file_name, imol_coords):
    r"""
    read_small_molecule_data_cif_and_make_map_using_coords(char const * file_name, int imol_coords) -> int


    Parameters
    ----------
    file_name : str
    imol_coords : int

    """
    return _coot.read_small_molecule_data_cif_and_make_map_using_coords(file_name, imol_coords)

def deviant_geometry(imol):
    r"""
    deviant_geometry(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.deviant_geometry(imol)

def is_valid_model_molecule(imol):
    r"""
    is_valid_model_molecule(int imol) -> short


    Parameters
    ----------
    imol : int

    """
    return _coot.is_valid_model_molecule(imol)

def is_valid_map_molecule(imol):
    r"""
    is_valid_map_molecule(int imol) -> short


    Parameters
    ----------
    imol : int

    """
    return _coot.is_valid_map_molecule(imol)

def difference_map_peaks(imol, imol_coords, level, max_closeness, do_positive_level_flag, do_negative_level_flag, around_model_only_flag):
    r"""
    difference_map_peaks(int imol, int imol_coords, float level, float max_closeness, int do_positive_level_flag, int do_negative_level_flag, int around_model_only_flag)

    generate a list of difference map peaks

    peaks within max_closeness (2.0 A typically) of a larger peak are not listed.

    the flag around_model_only_flag limits the peak list to those only within 4A of the selected model (useful for maps with molecular symmetry).

    Parameters
    ----------
    imol : int
    imol_coords : int
    level : float
    max_closeness : float
    do_positive_level_flag : int
    do_negative_level_flag : int
    around_model_only_flag : int

    """
    return _coot.difference_map_peaks(imol, imol_coords, level, max_closeness, do_positive_level_flag, do_negative_level_flag, around_model_only_flag)

def set_difference_map_peaks_max_closeness(m):
    r"""
    set_difference_map_peaks_max_closeness(float m)

    set the max closeness (i.e. no smaller peaks can be within max_closeness of a larger peak)

    In the GUI for difference map peaks, there is not a means to set the max_closeness, so here is a means to set it and query it.

    Parameters
    ----------
    m : float

    """
    return _coot.set_difference_map_peaks_max_closeness(m)

def difference_map_peaks_max_closeness():
    r"""difference_map_peaks_max_closeness() -> float"""
    return _coot.difference_map_peaks_max_closeness()

def clear_diff_map_peaks():
    r"""clear_diff_map_peaks()"""
    return _coot.clear_diff_map_peaks()

def gln_asn_b_factor_outliers(imol):
    r"""
    gln_asn_b_factor_outliers(int imol)

    Make a gui for GLN adn ASN B-factor outiers, compairing the O and N temperatur factors difference to the distribution of temperature factors from the other atoms.

    Parameters
    ----------
    imol : int

    """
    return _coot.gln_asn_b_factor_outliers(imol)

def gln_asn_b_factor_outliers_py(imol):
    r"""
    gln_asn_b_factor_outliers_py(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.gln_asn_b_factor_outliers_py(imol)

def map_peaks_py(imol_map, n_sigma):
    r"""
    map_peaks_py(int imol_map, float n_sigma) -> PyObject *

    return a list of map peaks of molecule number imol_map above n_sigma. There will be cluster filtering of the map peaks. Return a list of 3d cartestian coordinates or Python False if imol_map is not suitable for peak picking.

    Parameters
    ----------
    imol_map : int
    n_sigma : float

    """
    return _coot.map_peaks_py(imol_map, n_sigma)

def map_peaks_near_point_py(imol_map, n_sigma, x, y, z, radius):
    r"""
    map_peaks_near_point_py(int imol_map, float n_sigma, float x, float y, float z, float radius) -> PyObject *


    Parameters
    ----------
    imol_map : int
    n_sigma : float
    x : float
    y : float
    z : float
    radius : float

    """
    return _coot.map_peaks_near_point_py(imol_map, n_sigma, x, y, z, radius)

def map_peaks_near_point_from_list_py(imol_map, peak_list, x, y, z, radius):
    r"""
    map_peaks_near_point_from_list_py(int imol_map, PyObject * peak_list, float x, float y, float z, float radius) -> PyObject *


    Parameters
    ----------
    imol_map : int
    peak_list : object
    x : float
    y : float
    z : float
    radius : float

    """
    return _coot.map_peaks_near_point_from_list_py(imol_map, peak_list, x, y, z, radius)

def map_peaks_around_molecule_py(imol_map, sigma, negative_also_flag, imol_coords):
    r"""
    map_peaks_around_molecule_py(int imol_map, float sigma, int negative_also_flag, int imol_coords) -> PyObject *


    Parameters
    ----------
    imol_map : int
    sigma : float
    negative_also_flag : int
    imol_coords : int

    """
    return _coot.map_peaks_around_molecule_py(imol_map, sigma, negative_also_flag, imol_coords)

def screen_vectors_py():
    r"""screen_vectors_py() -> PyObject *"""
    return _coot.screen_vectors_py()

def get_torsion_py(imol, atom_spec_1, atom_spec_2, atom_spec_3, atom_spec_4):
    r"""
    get_torsion_py(int imol, PyObject * atom_spec_1, PyObject * atom_spec_2, PyObject * atom_spec_3, PyObject * atom_spec_4) -> PyObject *


    Parameters
    ----------
    imol : int
    atom_spec_1 : object
    atom_spec_2 : object
    atom_spec_3 : object
    atom_spec_4 : object

    """
    return _coot.get_torsion_py(imol, atom_spec_1, atom_spec_2, atom_spec_3, atom_spec_4)

def set_torsion_py(imol, chain_id, res_no, insertion_code, alt_conf, atom_name_1, atom_name_2, atom_name_3, atom_name_4, tors):
    r"""
    set_torsion_py(int imol, char const * chain_id, int res_no, char const * insertion_code, char const * alt_conf, char const * atom_name_1, char const * atom_name_2, char const * atom_name_3, char const * atom_name_4, double tors) -> PyObject *

    set the given torsion the given residue. tors is in degrees. Return the resulting torsion (also in degrees).

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    insertion_code : str
    alt_conf : str
    atom_name_1 : str
    atom_name_2 : str
    atom_name_3 : str
    atom_name_4 : str
    tors : float

    """
    return _coot.set_torsion_py(imol, chain_id, res_no, insertion_code, alt_conf, atom_name_1, atom_name_2, atom_name_3, atom_name_4, tors)

def multi_residue_torsion_py(imol, residues_specs_py):
    r"""
    multi_residue_torsion_py(int imol, PyObject * residues_specs_py)

    create a multi-residue torsion dialog (user manipulation of torsions)

    Parameters
    ----------
    imol : int
    residues_specs_py : object

    """
    return _coot.multi_residue_torsion_py(imol, residues_specs_py)

def clear_multi_residue_torsion_mode():
    r"""clear_multi_residue_torsion_mode()"""
    return _coot.clear_multi_residue_torsion_mode()

def set_multi_residue_torsion_reverse_mode(mode):
    r"""
    set_multi_residue_torsion_reverse_mode(short mode)


    Parameters
    ----------
    mode : int

    """
    return _coot.set_multi_residue_torsion_reverse_mode(mode)

def show_multi_residue_torsion_dialog():
    r"""show_multi_residue_torsion_dialog()"""
    return _coot.show_multi_residue_torsion_dialog()

def setup_multi_residue_torsion():
    r"""setup_multi_residue_torsion()"""
    return _coot.setup_multi_residue_torsion()

def atom_overlap_score(imol):
    r"""
    atom_overlap_score(int imol) -> float

    return the atom overlap score

    Parameters
    ----------
    imol : int

    """
    return _coot.atom_overlap_score(imol)

def set_show_chiral_volume_outliers(imol, state):
    r"""
    set_show_chiral_volume_outliers(int imol, int state)

    set the state of showing chiral volume outlier markers - of a model molecule that is, not the intermediate atoms (derived from restraints)

    set the state of showing non-bonded contact markers - of a model molecule that is, not the intermediate atoms (derived from restraints)

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_show_chiral_volume_outliers(imol, state)

def do_ramachandran_plot(imol):
    r"""
    do_ramachandran_plot(int imol)

    Ramachandran plot for molecule number imol.

    Parameters
    ----------
    imol : int

    """
    return _coot.do_ramachandran_plot(imol)

def set_kleywegt_plot_n_diffs(n_diffs):
    r"""
    set_kleywegt_plot_n_diffs(int n_diffs)

    set the number of biggest difference arrows on the Kleywegt plot.

    Parameters
    ----------
    n_diffs : int

    """
    return _coot.set_kleywegt_plot_n_diffs(n_diffs)

def set_ramachandran_plot_contour_levels(level_prefered, level_allowed):
    r"""
    set_ramachandran_plot_contour_levels(float level_prefered, float level_allowed)

    set the contour levels for the ramachandran plot, default values are 0.02 (prefered) 0.002 (allowed)

    Parameters
    ----------
    level_prefered : float
    level_allowed : float

    """
    return _coot.set_ramachandran_plot_contour_levels(level_prefered, level_allowed)

def set_ramachandran_plot_background_block_size(blocksize):
    r"""
    set_ramachandran_plot_background_block_size(float blocksize)

    set the ramachandran plot background block size.

    Smaller is smoother but slower. Should be divisible exactly into  Default value is 10.

    Parameters
    ----------
    blocksize : float

    """
    return _coot.set_ramachandran_plot_background_block_size(blocksize)

def set_ramachandran_psi_axis_mode(mode):
    r"""
    set_ramachandran_psi_axis_mode(int mode)

    set the psi axis for the ramachandran plot. Default (0) from -180 to 180. Alternative (1) from -120 to 240.

    Parameters
    ----------
    mode : int

    """
    return _coot.set_ramachandran_psi_axis_mode(mode)

def ramachandran_psi_axis_mode():
    r"""ramachandran_psi_axis_mode() -> int"""
    return _coot.ramachandran_psi_axis_mode()

def set_moving_atoms(phi, psi):
    r"""
    set_moving_atoms(double phi, double psi)


    Parameters
    ----------
    phi : float
    psi : float

    """
    return _coot.set_moving_atoms(phi, psi)

def accept_phi_psi_moving_atoms():
    r"""
    accept_phi_psi_moving_atoms()

    this does the same as accept_moving_atoms()

    """
    return _coot.accept_phi_psi_moving_atoms()

def setup_edit_phi_psi(state):
    r"""
    setup_edit_phi_psi(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_edit_phi_psi(state)

def setup_dynamic_distances(state):
    r"""
    setup_dynamic_distances(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_dynamic_distances(state)

def destroy_edit_backbone_rama_plot():
    r"""destroy_edit_backbone_rama_plot()"""
    return _coot.destroy_edit_backbone_rama_plot()

def ramachandran_plot_differences(imol1, imol2):
    r"""
    ramachandran_plot_differences(int imol1, int imol2)

    2 molecule ramachandran plot (NCS differences) a.k.a. A Kleywegt Plot.

    Parameters
    ----------
    imol1 : int
    imol2 : int

    """
    return _coot.ramachandran_plot_differences(imol1, imol2)

def ramachandran_plot_differences_by_chain(imol1, imol2, a_chain, b_chain):
    r"""
    ramachandran_plot_differences_by_chain(int imol1, int imol2, char const * a_chain, char const * b_chain)

    A chain-specific Kleywegt Plot.

    Parameters
    ----------
    imol1 : int
    imol2 : int
    a_chain : str
    b_chain : str

    """
    return _coot.ramachandran_plot_differences_by_chain(imol1, imol2, a_chain, b_chain)

def sequence_view(imol):
    r"""
    sequence_view(int imol)

    display the sequence view dialog for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.sequence_view(imol)

def do_sequence_view(imol):
    r"""
    do_sequence_view(int imol)

    old name for the above function

    Parameters
    ----------
    imol : int

    """
    return _coot.do_sequence_view(imol)

def update_sequence_view_current_position_highlight_from_active_atom():
    r"""
    update_sequence_view_current_position_highlight_from_active_atom()

    update the sequnce view current position highlight based on active atom

    """
    return _coot.update_sequence_view_current_position_highlight_from_active_atom()

def remove_sequence_view_from_sequence_view_box(imol):
    r"""remove_sequence_view_from_sequence_view_box(int imol)"""
    return _coot.remove_sequence_view_from_sequence_view_box(imol)

def change_peptide_carbonyl_by(angle):
    r"""
    change_peptide_carbonyl_by(double angle)


    Parameters
    ----------
    angle : float

    """
    return _coot.change_peptide_carbonyl_by(angle)

def change_peptide_peptide_by(angle):
    r"""
    change_peptide_peptide_by(double angle)


    Parameters
    ----------
    angle : float

    """
    return _coot.change_peptide_peptide_by(angle)

def execute_setup_backbone_torsion_edit(imol, atom_index):
    r"""
    execute_setup_backbone_torsion_edit(int imol, int atom_index)


    Parameters
    ----------
    imol : int
    atom_index : int

    """
    return _coot.execute_setup_backbone_torsion_edit(imol, atom_index)

def setup_backbone_torsion_edit(state):
    r"""
    setup_backbone_torsion_edit(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_backbone_torsion_edit(state)

def set_backbone_torsion_peptide_button_start_pos(ix, iy):
    r"""
    set_backbone_torsion_peptide_button_start_pos(int ix, int iy)


    Parameters
    ----------
    ix : int
    iy : int

    """
    return _coot.set_backbone_torsion_peptide_button_start_pos(ix, iy)

def change_peptide_peptide_by_current_button_pos(ix, iy):
    r"""
    change_peptide_peptide_by_current_button_pos(int ix, int iy)


    Parameters
    ----------
    ix : int
    iy : int

    """
    return _coot.change_peptide_peptide_by_current_button_pos(ix, iy)

def set_backbone_torsion_carbonyl_button_start_pos(ix, iy):
    r"""
    set_backbone_torsion_carbonyl_button_start_pos(int ix, int iy)


    Parameters
    ----------
    ix : int
    iy : int

    """
    return _coot.set_backbone_torsion_carbonyl_button_start_pos(ix, iy)

def change_peptide_carbonyl_by_current_button_pos(ix, iy):
    r"""
    change_peptide_carbonyl_by_current_button_pos(int ix, int iy)


    Parameters
    ----------
    ix : int
    iy : int

    """
    return _coot.change_peptide_carbonyl_by_current_button_pos(ix, iy)

def add_atom_label(imol, chain_id, iresno, atom_id):
    r"""
    add_atom_label(int imol, char const * chain_id, int iresno, char const * atom_id) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    iresno : int
    atom_id : str

    """
    return _coot.add_atom_label(imol, chain_id, iresno, atom_id)

def remove_atom_label(imol, chain_id, iresno, atom_id):
    r"""
    remove_atom_label(int imol, char const * chain_id, int iresno, char const * atom_id) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    iresno : int
    atom_id : str

    """
    return _coot.remove_atom_label(imol, chain_id, iresno, atom_id)

def remove_all_atom_labels():
    r"""remove_all_atom_labels()"""
    return _coot.remove_all_atom_labels()

def set_label_on_recentre_flag(i):
    r"""
    set_label_on_recentre_flag(int i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_label_on_recentre_flag(i)

def centre_atom_label_status():
    r"""centre_atom_label_status() -> int"""
    return _coot.centre_atom_label_status()

def set_brief_atom_labels(istat):
    r"""
    set_brief_atom_labels(int istat)

    use brief atom names for on-screen labels

    call with istat=1 to use brief labels, istat=0 for normal labels

    Parameters
    ----------
    istat : int

    """
    return _coot.set_brief_atom_labels(istat)

def brief_atom_labels_state():
    r"""
    brief_atom_labels_state() -> int

    the brief atom label state

    """
    return _coot.brief_atom_labels_state()

def set_seg_ids_in_atom_labels(istat):
    r"""
    set_seg_ids_in_atom_labels(int istat)

    set if brief atom labels should have seg-ids also

    Parameters
    ----------
    istat : int

    """
    return _coot.set_seg_ids_in_atom_labels(istat)

def rotate_y_scene(nsteps, stepsize):
    r"""
    rotate_y_scene(int nsteps, float stepsize)

    rotate view round y axis stepsize degrees for nstep such steps

    Parameters
    ----------
    nsteps : int
    stepsize : float

    """
    return _coot.rotate_y_scene(nsteps, stepsize)

def rotate_x_scene(nsteps, stepsize):
    r"""
    rotate_x_scene(int nsteps, float stepsize)

    rotate view round x axis stepsize degrees for nstep such steps

    Parameters
    ----------
    nsteps : int
    stepsize : float

    """
    return _coot.rotate_x_scene(nsteps, stepsize)

def rotate_z_scene(nsteps, stepsize):
    r"""
    rotate_z_scene(int nsteps, float stepsize)

    rotate view round z axis stepsize degrees for nstep such steps

    Parameters
    ----------
    nsteps : int
    stepsize : float

    """
    return _coot.rotate_z_scene(nsteps, stepsize)

def spin_zoom_trans(axis, nstep, stepsize, zoom_by, x_rel, y_rel, z_rel):
    r"""
    spin_zoom_trans(int axis, int nstep, float stepsize, float zoom_by, float x_rel, float y_rel, float z_rel)

    Bells and whistles rotation.

    spin, zoom and translate.

    where axis is either x,y or z, stepsize is in degrees, zoom_by and x_rel etc are how much zoom, x,y,z should have changed by after nstep steps.

    Parameters
    ----------
    axis : int
    nstep : int
    stepsize : float
    zoom_by : float
    x_rel : float
    y_rel : float
    z_rel : float

    """
    return _coot.spin_zoom_trans(axis, nstep, stepsize, zoom_by, x_rel, y_rel, z_rel)

def translate_scene_x(nsteps):
    r"""
    translate_scene_x(int nsteps)

    translate rotation centre relative to screen axes for nsteps

    Parameters
    ----------
    nsteps : int

    """
    return _coot.translate_scene_x(nsteps)

def translate_scene_y(nsteps):
    r"""
    translate_scene_y(int nsteps)

    translate rotation centre relative to screen axes for nsteps

    Parameters
    ----------
    nsteps : int

    """
    return _coot.translate_scene_y(nsteps)

def translate_scene_z(nsteps):
    r"""
    translate_scene_z(int nsteps)

    translate rotation centre relative to screen axes for nsteps

    Parameters
    ----------
    nsteps : int

    """
    return _coot.translate_scene_z(nsteps)

def add_view_here(view_name):
    r"""
    add_view_here(char const * view_name) -> int

    return the view number

    Parameters
    ----------
    view_name : str

    """
    return _coot.add_view_here(view_name)

def add_view_raw(rcx, rcy, rcz, quat1, quat2, quat3, quat4, zoom, view_name):
    r"""
    add_view_raw(float rcx, float rcy, float rcz, float quat1, float quat2, float quat3, float quat4, float zoom, char const * view_name) -> int

    return the view number

    Parameters
    ----------
    rcx : float
    rcy : float
    rcz : float
    quat1 : float
    quat2 : float
    quat3 : float
    quat4 : float
    zoom : float
    view_name : str

    """
    return _coot.add_view_raw(rcx, rcy, rcz, quat1, quat2, quat3, quat4, zoom, view_name)

def play_views():
    r"""play_views()"""
    return _coot.play_views()

def remove_this_view():
    r"""remove_this_view()"""
    return _coot.remove_this_view()

def remove_named_view(view_name):
    r"""
    remove_named_view(char const * view_name) -> int

    the view with the given name

    Parameters
    ----------
    view_name : str

    """
    return _coot.remove_named_view(view_name)

def remove_view(view_number):
    r"""
    remove_view(int view_number)

    the given view number

    Parameters
    ----------
    view_number : int

    """
    return _coot.remove_view(view_number)

def go_to_first_view(snap_to_view_flag):
    r"""
    go_to_first_view(int snap_to_view_flag) -> int


    Parameters
    ----------
    snap_to_view_flag : int

    """
    return _coot.go_to_first_view(snap_to_view_flag)

def go_to_view_number(view_number, snap_to_view_flag):
    r"""
    go_to_view_number(int view_number, int snap_to_view_flag) -> int


    Parameters
    ----------
    view_number : int
    snap_to_view_flag : int

    """
    return _coot.go_to_view_number(view_number, snap_to_view_flag)

def add_spin_view(view_name, n_steps, degrees_total):
    r"""
    add_spin_view(char const * view_name, int n_steps, float degrees_total) -> int


    Parameters
    ----------
    view_name : str
    n_steps : int
    degrees_total : float

    """
    return _coot.add_spin_view(view_name, n_steps, degrees_total)

def add_view_description(view_number, description):
    r"""
    add_view_description(int view_number, char const * description)

    Add a view description/annotation to the give view number.

    Parameters
    ----------
    view_number : int
    description : str

    """
    return _coot.add_view_description(view_number, description)

def add_action_view(view_name, action_function):
    r"""
    add_action_view(char const * view_name, char const * action_function) -> int

    add a view (not add to an existing view) that does something (e.g. displays or undisplays a molecule) rather than move the graphics.

    the view number for this (new) view.

    Parameters
    ----------
    view_name : str
    action_function : str

    """
    return _coot.add_action_view(view_name, action_function)

def insert_action_view_after_view(view_number, view_name, action_function):
    r"""
    insert_action_view_after_view(int view_number, char const * view_name, char const * action_function) -> int

    add an action view after the view of the given view number

    the view number for this (new) view.

    Parameters
    ----------
    view_number : int
    view_name : str
    action_function : str

    """
    return _coot.insert_action_view_after_view(view_number, view_name, action_function)

def n_views():
    r"""n_views() -> int"""
    return _coot.n_views()

def save_views(view_file_name):
    r"""
    save_views(char const * view_file_name)

    save views to view_file_name

    Parameters
    ----------
    view_file_name : str

    """
    return _coot.save_views(view_file_name)

def views_play_speed():
    r"""views_play_speed() -> float"""
    return _coot.views_play_speed()

def set_views_play_speed(f):
    r"""
    set_views_play_speed(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_views_play_speed(f)

def view_name_py(view_number):
    r"""
    view_name_py(int view_number) -> PyObject *

    return the name of the given view, if view_number does not specify a view return Python value False

    Parameters
    ----------
    view_number : int

    """
    return _coot.view_name_py(view_number)

def view_description_py(view_number):
    r"""
    view_description_py(int view_number) -> PyObject *


    Parameters
    ----------
    view_number : int

    """
    return _coot.view_description_py(view_number)

def go_to_view_py(view):
    r"""
    go_to_view_py(PyObject * view)


    Parameters
    ----------
    view : object

    """
    return _coot.go_to_view_py(view)

def clear_all_views():
    r"""
    clear_all_views()

    Clear the view list.

    """
    return _coot.clear_all_views()

def set_movie_file_name_prefix(file_name):
    r"""
    set_movie_file_name_prefix(char const * file_name)


    Parameters
    ----------
    file_name : str

    """
    return _coot.set_movie_file_name_prefix(file_name)

def set_movie_frame_number(frame_number):
    r"""
    set_movie_frame_number(int frame_number)


    Parameters
    ----------
    frame_number : int

    """
    return _coot.set_movie_frame_number(frame_number)

def movie_file_name_prefix_py():
    r"""movie_file_name_prefix_py() -> PyObject *"""
    return _coot.movie_file_name_prefix_py()

def movie_frame_number():
    r"""movie_frame_number() -> int"""
    return _coot.movie_frame_number()

def set_make_movie_mode(make_movies_flag):
    r"""
    set_make_movie_mode(int make_movies_flag)


    Parameters
    ----------
    make_movies_flag : int

    """
    return _coot.set_make_movie_mode(make_movies_flag)

def set_background_colour(red, green, blue):
    r"""
    set_background_colour(double red, double green, double blue)

    set the background colour

    red, green and blue are numbers between 0.0 and 1.0

    Parameters
    ----------
    red : float
    green : float
    blue : float

    """
    return _coot.set_background_colour(red, green, blue)

def redraw_background():
    r"""
    redraw_background()

    re draw the background colour when switching between mono and stereo

    """
    return _coot.redraw_background()

def background_is_black_p():
    r"""
    background_is_black_p() -> int

    is the background black (or nearly black)?

    1 if the background is black (or nearly black), else return 0.

    """
    return _coot.background_is_black_p()

def set_ligand_acceptable_fit_fraction(f):
    r"""
    set_ligand_acceptable_fit_fraction(float f)

    set the fraction of atoms which must be in positive density after a ligand fit

    Parameters
    ----------
    f : float

    """
    return _coot.set_ligand_acceptable_fit_fraction(f)

def set_ligand_cluster_sigma_level(f):
    r"""
    set_ligand_cluster_sigma_level(float f)

    set the default sigma level that the map is searched to find potential ligand sites

    Parameters
    ----------
    f : float

    """
    return _coot.set_ligand_cluster_sigma_level(f)

def set_ligand_flexible_ligand_n_samples(i):
    r"""
    set_ligand_flexible_ligand_n_samples(int i)

    set the number of conformation samples

    big ligands require more samples. Default 10.

    Parameters
    ----------
    i : int

    """
    return _coot.set_ligand_flexible_ligand_n_samples(i)

def set_ligand_verbose_reporting(i):
    r"""
    set_ligand_verbose_reporting(int i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_ligand_verbose_reporting(i)

def set_find_ligand_n_top_ligands(n):
    r"""
    set_find_ligand_n_top_ligands(int n)

    search the top n sites for ligands.

    Default 10.

    Parameters
    ----------
    n : int

    """
    return _coot.set_find_ligand_n_top_ligands(n)

def set_find_ligand_do_real_space_refinement(state):
    r"""
    set_find_ligand_do_real_space_refinement(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_find_ligand_do_real_space_refinement(state)

def set_find_ligand_multi_solutions_per_cluster(lim_1, lim_2):
    r"""
    set_find_ligand_multi_solutions_per_cluster(float lim_1, float lim_2)

    allow multiple ligand solutions per cluster.

    The first limit is the fraction of the top scored positions that go on to correlation scoring (closer to 1 means less and faster - default 0.7).

    The second limit is the fraction of the top correlation score that is considered interesting. Limits the number of solutions displayed to user. Default 0.9.

    There is currently no chi-angle set redundancy filtering - I suspect that there should be.

    Nino-mode.

    Parameters
    ----------
    lim_1 : float
    lim_2 : float

    """
    return _coot.set_find_ligand_multi_solutions_per_cluster(lim_1, lim_2)

def set_find_ligand_mask_waters(istate):
    r"""
    set_find_ligand_mask_waters(int istate)

    how shall we treat the waters during ligand fitting?

    pass with istate=1 for waters to mask the map in the same way that protein atoms do.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_find_ligand_mask_waters(istate)

def set_ligand_search_protein_molecule(imol):
    r"""
    set_ligand_search_protein_molecule(int imol)

    set the protein molecule for ligand searching

    Parameters
    ----------
    imol : int

    """
    return _coot.set_ligand_search_protein_molecule(imol)

def set_ligand_search_map_molecule(imol_map):
    r"""
    set_ligand_search_map_molecule(int imol_map)

    set the map molecule for ligand searching

    Parameters
    ----------
    imol_map : int

    """
    return _coot.set_ligand_search_map_molecule(imol_map)

def add_ligand_search_ligand_molecule(imol_ligand):
    r"""
    add_ligand_search_ligand_molecule(int imol_ligand)

    add a rigid ligand molecule to the list of ligands to search for in ligand searching

    Parameters
    ----------
    imol_ligand : int

    """
    return _coot.add_ligand_search_ligand_molecule(imol_ligand)

def add_ligand_search_wiggly_ligand_molecule(imol_ligand):
    r"""
    add_ligand_search_wiggly_ligand_molecule(int imol_ligand)

    add a flexible ligand molecule to the list of ligands to search for in ligand searching

    Parameters
    ----------
    imol_ligand : int

    """
    return _coot.add_ligand_search_wiggly_ligand_molecule(imol_ligand)

def set_find_ligand_here_cluster(state):
    r"""
    set_find_ligand_here_cluster(int state)

    Allow the user a scripting means to find ligand at the rotation centre.

    Parameters
    ----------
    state : int

    """
    return _coot.set_find_ligand_here_cluster(state)

def execute_ligand_search():
    r"""execute_ligand_search()"""
    return _coot.execute_ligand_search()

def execute_ligand_search_py():
    r"""execute_ligand_search_py() -> PyObject *"""
    return _coot.execute_ligand_search_py()

def add_ligand_clear_ligands():
    r"""add_ligand_clear_ligands()"""
    return _coot.add_ligand_clear_ligands()

def ligand_expert():
    r"""
    ligand_expert()

    this sets the flag to have expert option ligand entries in the Ligand Searching dialog

    """
    return _coot.ligand_expert()

def do_find_ligands_dialog():
    r"""
    do_find_ligands_dialog()

    display the find ligands dialog

    if maps, coords and ligands are available, that is.

    """
    return _coot.do_find_ligands_dialog()

def match_ligand_torsions(imol_ligand, imol_ref, chain_id_ref, resno_ref):
    r"""
    match_ligand_torsions(int imol_ligand, int imol_ref, char const * chain_id_ref, int resno_ref)


    Parameters
    ----------
    imol_ligand : int
    imol_ref : int
    chain_id_ref : str
    resno_ref : int

    """
    return _coot.match_ligand_torsions(imol_ligand, imol_ref, chain_id_ref, resno_ref)

def overlap_ligands_py(imol_ligand, imol_ref, chain_id_ref, resno_ref):
    r"""
    overlap_ligands_py(int imol_ligand, int imol_ref, char const * chain_id_ref, int resno_ref) -> PyObject *


    Parameters
    ----------
    imol_ligand : int
    imol_ref : int
    chain_id_ref : str
    resno_ref : int

    """
    return _coot.overlap_ligands_py(imol_ligand, imol_ref, chain_id_ref, resno_ref)

def analyse_ligand_differences_py(imol_ligand, imol_ref, chain_id_ref, resno_ref):
    r"""
    analyse_ligand_differences_py(int imol_ligand, int imol_ref, char const * chain_id_ref, int resno_ref) -> PyObject *


    Parameters
    ----------
    imol_ligand : int
    imol_ref : int
    chain_id_ref : str
    resno_ref : int

    """
    return _coot.analyse_ligand_differences_py(imol_ligand, imol_ref, chain_id_ref, resno_ref)

def compare_ligand_atom_types_py(imol_ligand, imol_ref, chain_id_ref, resno_ref):
    r"""
    compare_ligand_atom_types_py(int imol_ligand, int imol_ref, char const * chain_id_ref, int resno_ref) -> PyObject *


    Parameters
    ----------
    imol_ligand : int
    imol_ref : int
    chain_id_ref : str
    resno_ref : int

    """
    return _coot.compare_ligand_atom_types_py(imol_ligand, imol_ref, chain_id_ref, resno_ref)

def match_ligand_atom_names(imol_ligand, chain_id_ligand, resno_ligand, ins_code_ligand, imol_reference, chain_id_reference, resno_reference, ins_code_reference):
    r"""
    match_ligand_atom_names(int imol_ligand, char const * chain_id_ligand, int resno_ligand, char const * ins_code_ligand, int imol_reference, char const * chain_id_reference, int resno_reference, char const * ins_code_reference)

    Match ligand atom names.

    By using graph matching, make the names of the atoms of the given ligand/residue match those of the reference residue/ligand as closely as possible - where there would be an atom name clash, invent a new atom name.

    Parameters
    ----------
    imol_ligand : int
    chain_id_ligand : str
    resno_ligand : int
    ins_code_ligand : str
    imol_reference : int
    chain_id_reference : str
    resno_reference : int
    ins_code_reference : str

    """
    return _coot.match_ligand_atom_names(imol_ligand, chain_id_ligand, resno_ligand, ins_code_ligand, imol_reference, chain_id_reference, resno_reference, ins_code_reference)

def match_ligand_atom_names_to_comp_id(imol_ligand, chain_id_ligand, resno_ligand, ins_code_ligand, comp_id_ref):
    r"""
    match_ligand_atom_names_to_comp_id(int imol_ligand, char const * chain_id_ligand, int resno_ligand, char const * ins_code_ligand, char const * comp_id_ref)

    Match ligand atom names to a reference ligand type (comp_id)

    By using graph matching, make the names of the atoms of the given ligand/residue match those of the reference ligand from the geometry store as closely as possible. Where there would be an atom name clash, invent a new atom name.

    This doesn't create a new dictionary for the selected ligand - and that's a big problem (see match_residue_and_dictionary).

    Parameters
    ----------
    imol_ligand : int
    chain_id_ligand : str
    resno_ligand : int
    ins_code_ligand : str
    comp_id_ref : str

    """
    return _coot.match_ligand_atom_names_to_comp_id(imol_ligand, chain_id_ligand, resno_ligand, ins_code_ligand, comp_id_ref)

def exchange_ligand(imol_lig, chain_id_lig, resno_lig, ins_code_lig):
    r"""
    exchange_ligand(int imol_lig, char const * chain_id_lig, int resno_lig, char const * ins_code_lig) -> int


    Parameters
    ----------
    imol_lig : int
    chain_id_lig : str
    resno_lig : int
    ins_code_lig : str

    """
    return _coot.exchange_ligand(imol_lig, chain_id_lig, resno_lig, ins_code_lig)

def flip_ligand(imol, chain_id, resno):
    r"""
    flip_ligand(int imol, char const * chain_id, int resno)

    flip the ligand (usually active residue) around its eigen vectors to the next flip number. Immediate replacement (like flip peptide).

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int

    """
    return _coot.flip_ligand(imol, chain_id, resno)

def jed_flip(imol, chain_id, res_no, ins_code, atom_name, alt_conf, invert_selection):
    r"""
    jed_flip(int imol, char const * chain_id, int res_no, char const * ins_code, char const * atom_name, char const * alt_conf, short invert_selection)


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    atom_name : str
    alt_conf : str
    invert_selection : int

    """
    return _coot.jed_flip(imol, chain_id, res_no, ins_code, atom_name, alt_conf, invert_selection)

def show_create_find_waters_dialog():
    r"""
    show_create_find_waters_dialog()

    create a dialog for water fitting

    """
    return _coot.show_create_find_waters_dialog()

def renumber_waters(imol):
    r"""
    renumber_waters(int imol)

    Renumber the waters of molecule number imol with consecutive numbering.

    Parameters
    ----------
    imol : int

    """
    return _coot.renumber_waters(imol)

def execute_find_waters_real(imol_for_map, imol_for_protein, new_waters_mol_flag, rmsd_cut_off):
    r"""
    execute_find_waters_real(int imol_for_map, int imol_for_protein, short new_waters_mol_flag, float rmsd_cut_off)

    find waters

    Parameters
    ----------
    imol_for_map : int
    imol_for_protein : int
    new_waters_mol_flag : int
    rmsd_cut_off : float

    """
    return _coot.execute_find_waters_real(imol_for_map, imol_for_protein, new_waters_mol_flag, rmsd_cut_off)

def find_waters(imol_for_map, imol_for_protein, new_waters_mol_flag, rmsd_cut_off, show_blobs_dialog):
    r"""
    find_waters(int imol_for_map, int imol_for_protein, short new_waters_mol_flag, float rmsd_cut_off, short show_blobs_dialog)


    Parameters
    ----------
    imol_for_map : int
    imol_for_protein : int
    new_waters_mol_flag : int
    rmsd_cut_off : float
    show_blobs_dialog : int

    """
    return _coot.find_waters(imol_for_map, imol_for_protein, new_waters_mol_flag, rmsd_cut_off, show_blobs_dialog)

def move_waters_to_around_protein(imol):
    r"""
    move_waters_to_around_protein(int imol) -> int

    move waters of molecule number imol so that they are around the protein.

    the number of moved waters.

    Parameters
    ----------
    imol : int

    """
    return _coot.move_waters_to_around_protein(imol)

def move_hetgroups_to_around_protein(imol):
    r"""
    move_hetgroups_to_around_protein(int imol)

    move all hetgroups (including waters) of molecule number imol so that they are around the protein.

    Parameters
    ----------
    imol : int

    """
    return _coot.move_hetgroups_to_around_protein(imol)

def max_water_distance(imol):
    r"""
    max_water_distance(int imol) -> float

    return the maximum minimum distance of any water atom to any protein atom - used in validation of move_waters_to_around_protein() funtion.

    Parameters
    ----------
    imol : int

    """
    return _coot.max_water_distance(imol)

def get_text_for_find_waters_sigma_cut_off():
    r"""get_text_for_find_waters_sigma_cut_off() -> char *"""
    return _coot.get_text_for_find_waters_sigma_cut_off()

def set_value_for_find_waters_sigma_cut_off(f):
    r"""
    set_value_for_find_waters_sigma_cut_off(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_value_for_find_waters_sigma_cut_off(f)

def set_water_check_spherical_variance_limit(f):
    r"""
    set_water_check_spherical_variance_limit(float f)

    set the limit of interesting variance, above which waters are listed (otherwise ignored)

    default 0.12.

    Parameters
    ----------
    f : float

    """
    return _coot.set_water_check_spherical_variance_limit(f)

def set_ligand_water_to_protein_distance_limits(f1, f2):
    r"""
    set_ligand_water_to_protein_distance_limits(float f1, float f2)

    set ligand to protein distance limits

    f1 is the minimum distance, f2 is the maximum distance

    Parameters
    ----------
    f1 : float
    f2 : float

    """
    return _coot.set_ligand_water_to_protein_distance_limits(f1, f2)

def set_ligand_water_n_cycles(i):
    r"""
    set_ligand_water_n_cycles(int i)

    set the number of cycles of water searching

    Parameters
    ----------
    i : int

    """
    return _coot.set_ligand_water_n_cycles(i)

def set_write_peaksearched_waters():
    r"""set_write_peaksearched_waters()"""
    return _coot.set_write_peaksearched_waters()

def execute_find_blobs(imol_model, imol_for_map, cut_off, interactive_flag):
    r"""
    execute_find_blobs(int imol_model, int imol_for_map, float cut_off, short interactive_flag)

    find blobs

    Not useful for MCP. For interactive use only.

    Parameters
    ----------
    imol_model : int
    imol_for_map : int
    cut_off : float
    interactive_flag : int

    """
    return _coot.execute_find_blobs(imol_model, imol_for_map, cut_off, interactive_flag)

def split_water(imol, chain_id, res_no, ins_code):
    r"""
    split_water(int imol, char const * chain_id, int res_no, char const * ins_code)

    split the given water and fit to map.

    If refinement map is not defined, don't do anything.

    If there is more than one atom in the specified resiue, don't do anything.

    If the given atom does not have an alt conf of "", don't do anything.

      imol  the index of the molecule   chain_id  the chain id   res_no  the residue number   ins_code  the insertion code of the residue

    Parameters
    ----------
    imol : int
        the index of the molecule
    chain_id : str
        the chain id
    res_no : int
        the residue number
    ins_code : str
        the insertion code of the residue

    """
    return _coot.split_water(imol, chain_id, res_no, ins_code)

def set_default_bond_thickness(t):
    r"""
    set_default_bond_thickness(int t)

    set the default thickness for bonds (e.g. in ~/.coot)

    Parameters
    ----------
    t : int

    """
    return _coot.set_default_bond_thickness(t)

def set_bond_thickness(imol, t):
    r"""
    set_bond_thickness(int imol, float t)

    set the thickness of the bonds in molecule number imol to t pixels

    Parameters
    ----------
    imol : int
    t : float

    """
    return _coot.set_bond_thickness(imol, t)

def set_bond_thickness_intermediate_atoms(t):
    r"""
    set_bond_thickness_intermediate_atoms(float t)

    set the thickness of the bonds of the intermediate atoms to t pixels

    Parameters
    ----------
    t : float

    """
    return _coot.set_bond_thickness_intermediate_atoms(t)

def set_use_variable_bond_thickness(state):
    r"""
    set_use_variable_bond_thickness(short state)

    allow lines that are further away to be thinner

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_variable_bond_thickness(state)

def set_bond_colour_rotation_for_molecule(imol, f):
    r"""
    set_bond_colour_rotation_for_molecule(int imol, float f)

    set bond colour for molecule

    Parameters
    ----------
    imol : int
    f : float

    """
    return _coot.set_bond_colour_rotation_for_molecule(imol, f)

def set_draw_stick_mode_atoms_default(state):
    r"""
    set_draw_stick_mode_atoms_default(short state)

    set default for the drawing of atoms in stick mode (default is on (1))

    Parameters
    ----------
    state : int

    """
    return _coot.set_draw_stick_mode_atoms_default(state)

def get_bond_colour_rotation_for_molecule(imol):
    r"""
    get_bond_colour_rotation_for_molecule(int imol) -> float

    get the bond colour for molecule.

    Return -1 on err (bad molecule number)

    Parameters
    ----------
    imol : int

    """
    return _coot.get_bond_colour_rotation_for_molecule(imol)

def set_unbonded_atom_star_size(f):
    r"""
    set_unbonded_atom_star_size(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_unbonded_atom_star_size(f)

def set_default_representation_type(type):
    r"""
    set_default_representation_type(int type)

    set the default representation type (default 1).

    Parameters
    ----------
    type : int

    """
    return _coot.set_default_representation_type(type)

def get_default_bond_thickness():
    r"""
    get_default_bond_thickness() -> int

    get the default thickness for bonds

    """
    return _coot.get_default_bond_thickness()

def set_draw_zero_occ_markers(status):
    r"""
    set_draw_zero_occ_markers(int status)

    set status of drawing zero occupancy markers.

    default status is 1.

    Parameters
    ----------
    status : int

    """
    return _coot.set_draw_zero_occ_markers(status)

def set_draw_cis_peptide_markups(status):
    r"""
    set_draw_cis_peptide_markups(int status)

    set status of drawing cis-peptide markups

    default status is 1.

    Parameters
    ----------
    status : int

    """
    return _coot.set_draw_cis_peptide_markups(status)

def set_draw_hydrogens(imol, istat):
    r"""
    set_draw_hydrogens(int imol, int istat)

    set the hydrogen drawing state. istat = 0 is hydrogens off, istat = 1: show hydrogens

    Parameters
    ----------
    imol : int
    istat : int

    """
    return _coot.set_draw_hydrogens(imol, istat)

def draw_hydrogens_state(imol):
    r"""
    draw_hydrogens_state(int imol) -> int

    the state of draw hydrogens for molecule number imol.

    return -1 on bad imol.

    Parameters
    ----------
    imol : int

    """
    return _coot.draw_hydrogens_state(imol)

def get_hydrogen_bonds_py(imol, selection_1, selection_2, mcdonald_and_thornton_algoritnm):
    r"""
    get_hydrogen_bonds_py(int imol, char const * selection_1, char const * selection_2, short mcdonald_and_thornton_algoritnm) -> PyObject *


    Parameters
    ----------
    imol : int
    selection_1 : str
    selection_2 : str
    mcdonald_and_thornton_algoritnm : int

    """
    return _coot.get_hydrogen_bonds_py(imol, selection_1, selection_2, mcdonald_and_thornton_algoritnm)

def set_draw_stick_mode_atoms(imol, state):
    r"""
    set_draw_stick_mode_atoms(int imol, short state)

    draw little coloured balls on atoms

    turn off with state = 0

    turn on with state = 1

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_draw_stick_mode_atoms(imol, state)

def set_draw_missing_residues_loops(state):
    r"""
    set_draw_missing_residues_loops(short state)

    set the state for drawing missing resiude loops

    Used, for example, when taking screenshots, we often don't want to see them in such cases. Or maybe there's just too many of them to be useful

      state  the draw state (0 for "off", 1 for "on")

    Parameters
    ----------
    state : int
        the draw state (0 for "off", 1 for "on")

    """
    return _coot.set_draw_missing_residues_loops(state)

def graphics_to_ca_representation(imol):
    r"""
    graphics_to_ca_representation(int imol)

    draw molecule number imol as CAs

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_ca_representation(imol)

def graphics_to_colour_by_chain(imol):
    r"""
    graphics_to_colour_by_chain(int imol)

    draw molecule number imol coloured by chain

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_colour_by_chain(imol)

def graphics_to_ca_plus_ligands_representation(imol):
    r"""
    graphics_to_ca_plus_ligands_representation(int imol)

    draw molecule number imol as CA + ligands

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_ca_plus_ligands_representation(imol)

def graphics_to_ca_plus_ligands_and_sidechains_representation(imol):
    r"""
    graphics_to_ca_plus_ligands_and_sidechains_representation(int imol)

    draw molecule number imol as CA + ligands + sidechains

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_ca_plus_ligands_and_sidechains_representation(imol)

def graphics_to_bonds_no_waters_representation(imol):
    r"""
    graphics_to_bonds_no_waters_representation(int imol)

    draw molecule number imol with no waters

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_bonds_no_waters_representation(imol)

def graphics_to_bonds_representation(mol):
    r"""
    graphics_to_bonds_representation(int mol)

    draw molecule number imol with normal bonds

    Parameters
    ----------
    mol : int

    """
    return _coot.graphics_to_bonds_representation(mol)

def graphics_to_colour_by_molecule(imol):
    r"""
    graphics_to_colour_by_molecule(int imol)

    draw molecule with colour-by-molecule colours

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_colour_by_molecule(imol)

def graphics_to_ca_plus_ligands_sec_struct_representation(imol):
    r"""
    graphics_to_ca_plus_ligands_sec_struct_representation(int imol)

    draw molecule number imol with CA bonds in secondary structure representation and ligands

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_ca_plus_ligands_sec_struct_representation(imol)

def graphics_to_sec_struct_bonds_representation(imol):
    r"""
    graphics_to_sec_struct_bonds_representation(int imol)

    draw molecule number imol with bonds in secondary structure representation

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_sec_struct_bonds_representation(imol)

def graphics_to_rainbow_representation(imol):
    r"""
    graphics_to_rainbow_representation(int imol)

    draw molecule number imol in Jones' Rainbow

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_rainbow_representation(imol)

def graphics_to_b_factor_representation(imol):
    r"""
    graphics_to_b_factor_representation(int imol)

    draw molecule number imol coloured by B-factor

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_b_factor_representation(imol)

def graphics_to_b_factor_cas_representation(imol):
    r"""
    graphics_to_b_factor_cas_representation(int imol)

    draw molecule number imol coloured by B-factor, CA + ligands

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_b_factor_cas_representation(imol)

def graphics_to_occupancy_representation(imol):
    r"""
    graphics_to_occupancy_representation(int imol)

    draw molecule number imol coloured by occupancy

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_occupancy_representation(imol)

def graphics_to_user_defined_atom_colours_representation(imol):
    r"""
    graphics_to_user_defined_atom_colours_representation(int imol)

    draw molecule number imol in CA+Ligands mode coloured by user-defined atom colours

    Parameters
    ----------
    imol : int

    """
    return _coot.graphics_to_user_defined_atom_colours_representation(imol)

def graphics_to_user_defined_atom_colours_all_atoms_representation(imol):
    r"""
    graphics_to_user_defined_atom_colours_all_atoms_representation(int imol)

    draw molecule number imol all atoms coloured by user-defined atom colours

    Use this function after using set_user_defined_atom_colour_by_selection_py() and/or set_user_defined_atom_colour_py(). When atom selection colouring has been created or updated, then calling this function actually forces the regeneration and drawing of the molecule with the new colour scheme.

      imol  the molecule index

    Parameters
    ----------
    imol : int
        the molecule index

    """
    return _coot.graphics_to_user_defined_atom_colours_all_atoms_representation(imol)

def get_graphics_molecule_bond_type(imol):
    r"""
    get_graphics_molecule_bond_type(int imol) -> int

    what is the bond drawing state of molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.get_graphics_molecule_bond_type(imol)

def set_b_factor_bonds_scale_factor(imol, f):
    r"""
    set_b_factor_bonds_scale_factor(int imol, float f) -> int

    scale the colours for colour by b factor representation

    Parameters
    ----------
    imol : int
    f : float

    """
    return _coot.set_b_factor_bonds_scale_factor(imol, f)

def change_model_molecule_representation_mode(up_or_down):
    r"""
    change_model_molecule_representation_mode(int up_or_down)

    change the representation of the model molecule closest to the centre of the screen

    Parameters
    ----------
    up_or_down : int

    """
    return _coot.change_model_molecule_representation_mode(up_or_down)

def set_use_grey_carbons_for_molecule(imol, state):
    r"""
    set_use_grey_carbons_for_molecule(int imol, short state)

    make the carbon atoms for molecule imol be grey

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_use_grey_carbons_for_molecule(imol, state)

def set_grey_carbon_colour(imol, r, g, b):
    r"""
    set_grey_carbon_colour(int imol, float r, float g, float b)

    set the colour for the carbon atoms

    can be not grey if you desire, r, g, b in the range 0 to 1.

    Parameters
    ----------
    imol : int
    r : float
    g : float
    b : float

    """
    return _coot.set_grey_carbon_colour(imol, r, g, b)

def set_draw_moving_atoms_restraints(state):
    r"""
    set_draw_moving_atoms_restraints(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_draw_moving_atoms_restraints(state)

def get_draw_moving_atoms_restraints():
    r"""get_draw_moving_atoms_restraints() -> short"""
    return _coot.get_draw_moving_atoms_restraints()

def make_ball_and_stick(imol, atom_selection_str, bond_thickness, sphere_size, do_spheres_flag):
    r"""
    make_ball_and_stick(int imol, char const * atom_selection_str, float bond_thickness, float sphere_size, int do_spheres_flag) -> int

    make a ball and stick representation of imol given atom selection

    e.g. (make-ball-and-stick 0 "/1" 0.15 0.25 1)

    Parameters
    ----------
    imol : int
    atom_selection_str : str
    bond_thickness : float
    sphere_size : float
    do_spheres_flag : int

    """
    return _coot.make_ball_and_stick(imol, atom_selection_str, bond_thickness, sphere_size, do_spheres_flag)

def clear_ball_and_stick(imol):
    r"""
    clear_ball_and_stick(int imol) -> int

    clear ball and stick representation of molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.clear_ball_and_stick(imol)

def set_model_molecule_representation_style(imol, mode):
    r"""
    set_model_molecule_representation_style(int imol, unsigned int mode)

    set the model molecule representation stye 0 for ball-and-stick/licorice (default) and 1 for ball

    Parameters
    ----------
    imol : int
    mode : int

    """
    return _coot.set_model_molecule_representation_style(imol, mode)

def set_show_molecular_representation(imol, mesh_index, state):
    r"""
    set_show_molecular_representation(int imol, int mesh_index, short state)

    set show a ribbon/mesh for a given molecule

    Parameters
    ----------
    imol : int
    mesh_index : int
    state : int

    """
    return _coot.set_show_molecular_representation(imol, mesh_index, state)

def set_show_additional_representation(imol, representation_number, on_off_flag):
    r"""
    set_show_additional_representation(int imol, int representation_number, int on_off_flag)


    Parameters
    ----------
    imol : int
    representation_number : int
    on_off_flag : int

    """
    return _coot.set_show_additional_representation(imol, representation_number, on_off_flag)

def set_show_all_additional_representations(imol, on_off_flag):
    r"""
    set_show_all_additional_representations(int imol, int on_off_flag)

    display/undisplay all the additional representations for the given molecule

    Parameters
    ----------
    imol : int
    on_off_flag : int

    """
    return _coot.set_show_all_additional_representations(imol, on_off_flag)

def all_additional_representations_off_except(imol, representation_number, ball_and_sticks_off_too_flag):
    r"""
    all_additional_representations_off_except(int imol, int representation_number, short ball_and_sticks_off_too_flag)

    removed from API brief undisplay all the additional representations for the given molecule, except the given representation number (if it is off, leave it off)

    Parameters
    ----------
    imol : int
    representation_number : int
    ball_and_sticks_off_too_flag : int

    """
    return _coot.all_additional_representations_off_except(imol, representation_number, ball_and_sticks_off_too_flag)

def delete_additional_representation(imol, representation_number):
    r"""
    delete_additional_representation(int imol, int representation_number)

    removed from API brief delete a given additional representation

    Parameters
    ----------
    imol : int
    representation_number : int

    """
    return _coot.delete_additional_representation(imol, representation_number)

def additional_representation_by_string(imol, atom_selection, representation_type, bonds_box_type, bond_width, draw_hydrogens_flag):
    r"""
    additional_representation_by_string(int imol, char const * atom_selection, int representation_type, int bonds_box_type, float bond_width, int draw_hydrogens_flag) -> int

    removed from API brief return the index of the additional representation. Return -1 on error

    Parameters
    ----------
    imol : int
    atom_selection : str
    representation_type : int
    bonds_box_type : int
    bond_width : float
    draw_hydrogens_flag : int

    """
    return _coot.additional_representation_by_string(imol, atom_selection, representation_type, bonds_box_type, bond_width, draw_hydrogens_flag)

def additional_representation_by_attributes(imol, chain_id, resno_start, resno_end, ins_code, representation_type, bonds_box_type, bond_width, draw_hydrogens_flag):
    r"""
    additional_representation_by_attributes(int imol, char const * chain_id, int resno_start, int resno_end, char const * ins_code, int representation_type, int bonds_box_type, float bond_width, int draw_hydrogens_flag) -> int

    return the index of the additional representation.

    -1 on error.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno_start : int
    resno_end : int
    ins_code : str
    representation_type : int
    bonds_box_type : int
    bond_width : float
    draw_hydrogens_flag : int

    """
    return _coot.additional_representation_by_attributes(imol, chain_id, resno_start, resno_end, ins_code, representation_type, bonds_box_type, bond_width, draw_hydrogens_flag)

def additional_representation_info_py(imol):
    r"""
    additional_representation_info_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.additional_representation_info_py(imol)

def set_flev_idle_ligand_interactions(state):
    r"""
    set_flev_idle_ligand_interactions(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_flev_idle_ligand_interactions(state)

def toggle_flev_idle_ligand_interactions():
    r"""toggle_flev_idle_ligand_interactions()"""
    return _coot.toggle_flev_idle_ligand_interactions()

def calculate_hydrogen_bonds(imol):
    r"""
    calculate_hydrogen_bonds(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.calculate_hydrogen_bonds(imol)

def set_draw_hydrogen_bonds(state):
    r"""
    set_draw_hydrogen_bonds(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_draw_hydrogen_bonds(state)

def dots(imol, atom_selection_str, dots_object_name, dot_density, sphere_size_scale):
    r"""
    dots(int imol, char const * atom_selection_str, char const * dots_object_name, float dot_density, float sphere_size_scale) -> int

    display dotted surface

    return a generic objects handle (which can be used to remove later)

    Parameters
    ----------
    imol : int
    atom_selection_str : str
    dots_object_name : str
    dot_density : float
    sphere_size_scale : float

    """
    return _coot.dots(imol, atom_selection_str, dots_object_name, dot_density, sphere_size_scale)

def set_dots_colour(imol, r, g, b):
    r"""
    set_dots_colour(int imol, float r, float g, float b)

    set the colour of the surface dots of the imol-th molecule to be the given single colour

    r,g,b are values between 0.0 and 1.0

    Parameters
    ----------
    imol : int
    r : float
    g : float
    b : float

    """
    return _coot.set_dots_colour(imol, r, g, b)

def unset_dots_colour(imol):
    r"""
    unset_dots_colour(int imol)

    no longer set the dots of molecule imol to a single colour

    i.e. go back to element-based colours.

    Parameters
    ----------
    imol : int

    """
    return _coot.unset_dots_colour(imol)

def clear_dots(imol, dots_handle):
    r"""
    clear_dots(int imol, int dots_handle)

    clear dots in imol with dots_handle

    Parameters
    ----------
    imol : int
    dots_handle : int

    """
    return _coot.clear_dots(imol, dots_handle)

def clear_dots_by_name(imol, dots_object_name):
    r"""
    clear_dots_by_name(int imol, char const * dots_object_name)

    clear the first dots object for imol with given name

    Parameters
    ----------
    imol : int
    dots_object_name : str

    """
    return _coot.clear_dots_by_name(imol, dots_object_name)

def n_dots_sets(imol):
    r"""
    n_dots_sets(int imol) -> int

    return the number of dots sets for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.n_dots_sets(imol)

def do_pepflip(state):
    r"""
    do_pepflip(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.do_pepflip(state)

def pepflip(imol, chain_id, resno, inscode, altconf):
    r"""
    pepflip(int imol, char const * chain_id, int resno, char const * inscode, char const * altconf)

    pepflip (flip the peptide) of the given residue

    Rotate the the carbonyl C and O atom of this residue and the N of the next residue around a vector between the two CA atoms by 180 degrees. This is often a useful modelling operation to create a different hypothesis about the orientation of the main-chain atoms - that can then be used for refinement. This can sometimes allow the model to be removed from local minima of backbone conformations.

      imol  is the index of the model molecule   chain_id  is the chain-id   res_no  is the residue number (the residue that has the C and O atoms)   inscode  the insertion code (typically "")   altconf  the altconf (typically "")

    Parameters
    ----------
    imol : int
        is the index of the model molecule
    chain_id : str
        is the chain-id
    resno : int
    inscode : str
        the insertion code (typically "")
    altconf : str
        the altconf (typically "")

    """
    return _coot.pepflip(imol, chain_id, resno, inscode, altconf)

def pepflip_intermediate_atoms():
    r"""pepflip_intermediate_atoms() -> int"""
    return _coot.pepflip_intermediate_atoms()

def pepflip_intermediate_atoms_other_peptide():
    r"""pepflip_intermediate_atoms_other_peptide() -> int"""
    return _coot.pepflip_intermediate_atoms_other_peptide()

def pepflip_using_difference_map_py(imol_coords, imol_difference_map, n_sigma):
    r"""
    pepflip_using_difference_map_py(int imol_coords, int imol_difference_map, float n_sigma) -> PyObject *


    Parameters
    ----------
    imol_coords : int
    imol_difference_map : int
    n_sigma : float

    """
    return _coot.pepflip_using_difference_map_py(imol_coords, imol_difference_map, n_sigma)

def do_rigid_body_refine(state):
    r"""
    do_rigid_body_refine(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.do_rigid_body_refine(state)

def rigid_body_refine_zone(imol, chain_id, reso_start, resno_end):
    r"""
    rigid_body_refine_zone(int imol, char const * chain_id, int reso_start, int resno_end)

    setup rigid body refine zone

    where we set the atom selection holders according to the arguments and then call execute_rigid_body_refine()

    Parameters
    ----------
    imol : int
    chain_id : str
    reso_start : int
    resno_end : int

    """
    return _coot.rigid_body_refine_zone(imol, chain_id, reso_start, resno_end)

def rigid_body_refine_by_atom_selection(imol, atom_selection_string):
    r"""
    rigid_body_refine_by_atom_selection(int imol, char const * atom_selection_string)


    Parameters
    ----------
    imol : int
    atom_selection_string : str

    """
    return _coot.rigid_body_refine_by_atom_selection(imol, atom_selection_string)

def rigid_body_refine_by_residue_ranges_py(imol, residue_ranges):
    r"""
    rigid_body_refine_by_residue_ranges_py(int imol, PyObject * residue_ranges) -> PyObject *

    rigid body refine using residue ranges. residue_ranges is a list of residue ranges. A residue range is [chain_id, resno_start, resno_end].

    Parameters
    ----------
    imol : int
    residue_ranges : object

    """
    return _coot.rigid_body_refine_by_residue_ranges_py(imol, residue_ranges)

def execute_rigid_body_refine(auto_range_flag):
    r"""
    execute_rigid_body_refine(short auto_range_flag)


    Parameters
    ----------
    auto_range_flag : int

    """
    return _coot.execute_rigid_body_refine(auto_range_flag)

def set_rigid_body_fit_acceptable_fit_fraction(f):
    r"""
    set_rigid_body_fit_acceptable_fit_fraction(float f)

    set rigid body fraction of atoms in positive density

      f  in the range 0.0 -> 1.0 (default 0.75)

    Parameters
    ----------
    f : float
        in the range 0.0 -> 1.0 (default 0.75)

    """
    return _coot.set_rigid_body_fit_acceptable_fit_fraction(f)

def toggle_dynamic_map_display_size():
    r"""toggle_dynamic_map_display_size()"""
    return _coot.toggle_dynamic_map_display_size()

def toggle_dynamic_map_sampling():
    r"""toggle_dynamic_map_sampling()"""
    return _coot.toggle_dynamic_map_sampling()

def set_dynamic_map_size_display_on():
    r"""set_dynamic_map_size_display_on()"""
    return _coot.set_dynamic_map_size_display_on()

def set_dynamic_map_size_display_off():
    r"""set_dynamic_map_size_display_off()"""
    return _coot.set_dynamic_map_size_display_off()

def get_dynamic_map_size_display():
    r"""get_dynamic_map_size_display() -> int"""
    return _coot.get_dynamic_map_size_display()

def set_dynamic_map_sampling_on():
    r"""set_dynamic_map_sampling_on()"""
    return _coot.set_dynamic_map_sampling_on()

def set_dynamic_map_sampling_off():
    r"""set_dynamic_map_sampling_off()"""
    return _coot.set_dynamic_map_sampling_off()

def get_dynamic_map_sampling():
    r"""get_dynamic_map_sampling() -> int"""
    return _coot.get_dynamic_map_sampling()

def set_dynamic_map_zoom_offset(i):
    r"""
    set_dynamic_map_zoom_offset(int i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_dynamic_map_zoom_offset(i)

def do_add_terminal_residue(state):
    r"""
    do_add_terminal_residue(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.do_add_terminal_residue(state)

def set_add_terminal_residue_n_phi_psi_trials(n):
    r"""
    set_add_terminal_residue_n_phi_psi_trials(int n)


    Parameters
    ----------
    n : int

    """
    return _coot.set_add_terminal_residue_n_phi_psi_trials(n)

def set_add_terminal_residue_add_other_residue_flag(i):
    r"""
    set_add_terminal_residue_add_other_residue_flag(int i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_add_terminal_residue_add_other_residue_flag(i)

def set_add_terminal_residue_do_rigid_body_refine(v):
    r"""
    set_add_terminal_residue_do_rigid_body_refine(short v)


    Parameters
    ----------
    v : int

    """
    return _coot.set_add_terminal_residue_do_rigid_body_refine(v)

def set_terminal_residue_do_rigid_body_refine(v):
    r"""
    set_terminal_residue_do_rigid_body_refine(short v)


    Parameters
    ----------
    v : int

    """
    return _coot.set_terminal_residue_do_rigid_body_refine(v)

def set_add_terminal_residue_debug_trials(debug_state):
    r"""
    set_add_terminal_residue_debug_trials(short debug_state)


    Parameters
    ----------
    debug_state : int

    """
    return _coot.set_add_terminal_residue_debug_trials(debug_state)

def add_terminal_residue_immediate_addition_state():
    r"""add_terminal_residue_immediate_addition_state() -> int"""
    return _coot.add_terminal_residue_immediate_addition_state()

def set_add_terminal_residue_immediate_addition(i):
    r"""
    set_add_terminal_residue_immediate_addition(int i)

    set immediate addition of terminal residue

    call with i=1 for immediate addtion

    Parameters
    ----------
    i : int

    """
    return _coot.set_add_terminal_residue_immediate_addition(i)

def add_terminal_residue(imol, chain_id, residue_number, residue_type, immediate_add):
    r"""
    add_terminal_residue(int imol, char const * chain_id, int residue_number, char const * residue_type, int immediate_add) -> int

    Add a terminal residue.

    Some text here that should be a detailed-description

      residue_type  can be "auto"   immediate_add  is recommended to be 1. 0 on failure, 1 on success

    Parameters
    ----------
    imol : int
    chain_id : str
    residue_number : int
    residue_type : str
        can be "auto"
    immediate_add : int
        is recommended to be 1.

    """
    return _coot.add_terminal_residue(imol, chain_id, residue_number, residue_type, immediate_add)

def add_residue_by_map_fit(imol, chain_id, residue_number, residue_type, immediate_add):
    r"""
    add_residue_by_map_fit(int imol, char const * chain_id, int residue_number, char const * residue_type, int immediate_add) -> int

    Add a residue to a chain or at the end of a fragment.

    This can be used to fill a gap of one residue or to fill a gap of multiple residues by being called several times. Probably RSR refinement would be useful after each call to this function in such a case.

      imol  the molecule index   chain_id  the chain ID   residue_number  the residue number (of the existing residue to attach to)   residue_type  the type for new residue, can be "auto"   immediate_add  is recommended to be 1 0 on failure, 1 on success

    Parameters
    ----------
    imol : int
        the molecule index
    chain_id : str
        the chain ID
    residue_number : int
        the residue number (of the existing residue to attach to)
    residue_type : str
        the type for new residue, can be "auto"
    immediate_add : int
        is recommended to be 1

    """
    return _coot.add_residue_by_map_fit(imol, chain_id, residue_number, residue_type, immediate_add)

def add_nucleotide(imol, chain_id, res_no):
    r"""
    add_nucleotide(int imol, char const * chain_id, int res_no) -> int

    Add a terminal nucleotide.

    No fitting is done

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int

    """
    return _coot.add_nucleotide(imol, chain_id, res_no)

def add_terminal_residue_using_phi_psi(imol, chain_id, res_no, residue_type, phi, psi):
    r"""
    add_terminal_residue_using_phi_psi(int imol, char const * chain_id, int res_no, char const * residue_type, float phi, float psi) -> int

    Add a terminal residue using given phi and psi angles.

      imol  the molecule index   chain_id  the chain ID   residue_number  the residue number (of the existing residue to attach to   residue_type  can be "auto"   phi  is phi in degrees   psi  is psi in degrees the success status, 0 on failure, 1 on success

    Parameters
    ----------
    imol : int
        the molecule index
    chain_id : str
        the chain ID
    res_no : int
    residue_type : str
        can be "auto"
    phi : float
        is phi in degrees
    psi : float
        is psi in degrees

    """
    return _coot.add_terminal_residue_using_phi_psi(imol, chain_id, res_no, residue_type, phi, psi)

def set_add_terminal_residue_default_residue_type(type):
    r"""
    set_add_terminal_residue_default_residue_type(char const * type)

    set the residue type of an added terminal residue.

    Parameters
    ----------
    type : str

    """
    return _coot.set_add_terminal_residue_default_residue_type(type)

def set_add_terminal_residue_do_post_refine(istat):
    r"""
    set_add_terminal_residue_do_post_refine(short istat)

    set a flag to run refine zone on terminal residues after an addition.

    Parameters
    ----------
    istat : int

    """
    return _coot.set_add_terminal_residue_do_post_refine(istat)

def add_terminal_residue_do_post_refine_state():
    r"""
    add_terminal_residue_do_post_refine_state() -> int

    what is the value of the previous flag?

    """
    return _coot.add_terminal_residue_do_post_refine_state()

def find_terminal_residue_type_py(imol, chain_id, resno):
    r"""
    find_terminal_residue_type_py(int imol, char const * chain_id, int resno) -> PyObject *


    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int

    """
    return _coot.find_terminal_residue_type_py(imol, chain_id, resno)

def add_residue_with_atoms_py(imol, residue_spec, res_name, list_of_atoms):
    r"""
    add_residue_with_atoms_py(int imol, PyObject * residue_spec, std::string const & res_name, PyObject * list_of_atoms) -> int

    add a residue with atoms in scripting

    the number of atoms added

    Parameters
    ----------
    imol : int
    residue_spec : object
    res_name : str
    list_of_atoms : object

    """
    return _coot.add_residue_with_atoms_py(imol, residue_spec, res_name, list_of_atoms)

def delete_atom_by_atom_index(imol, index, do_delete_dialog):
    r"""
    delete_atom_by_atom_index(int imol, int index, short do_delete_dialog)


    Parameters
    ----------
    imol : int
    index : int
    do_delete_dialog : int

    """
    return _coot.delete_atom_by_atom_index(imol, index, do_delete_dialog)

def delete_residue_by_atom_index(imol, index, do_delete_dialog):
    r"""
    delete_residue_by_atom_index(int imol, int index, short do_delete_dialog)


    Parameters
    ----------
    imol : int
    index : int
    do_delete_dialog : int

    """
    return _coot.delete_residue_by_atom_index(imol, index, do_delete_dialog)

def delete_residue_hydrogens_by_atom_index(imol, index, do_delete_dialog):
    r"""
    delete_residue_hydrogens_by_atom_index(int imol, int index, short do_delete_dialog)


    Parameters
    ----------
    imol : int
    index : int
    do_delete_dialog : int

    """
    return _coot.delete_residue_hydrogens_by_atom_index(imol, index, do_delete_dialog)

def delete_residue_range(imol, chain_id, resno_start, end_resno):
    r"""
    delete_residue_range(int imol, char const * chain_id, int resno_start, int end_resno)

    delete residue range

    Parameters
    ----------
    imol : int
    chain_id : str
    resno_start : int
    end_resno : int

    """
    return _coot.delete_residue_range(imol, chain_id, resno_start, end_resno)

def delete_residue(imol, chain_id, res_no, inscode):
    r"""
    delete_residue(int imol, char const * chain_id, int res_no, char const * inscode) -> int

    delete residue

      imol  the molecule index   chain_id  the chain id   res_no  the residue number   inscode  the insertion code 0 on failure to delete, return 1 on residue successfully deleted

    Parameters
    ----------
    imol : int
        the molecule index
    chain_id : str
        the chain id
    res_no : int
        the residue number
    inscode : str
        the insertion code

    """
    return _coot.delete_residue(imol, chain_id, res_no, inscode)

def delete_residue_with_full_spec(imol, imodel, chain_id, resno, inscode, altloc):
    r"""
    delete_residue_with_full_spec(int imol, int imodel, char const * chain_id, int resno, char const * inscode, char const * altloc)

    delete residue with altconf

    Parameters
    ----------
    imol : int
    imodel : int
    chain_id : str
    resno : int
    inscode : str
    altloc : str

    """
    return _coot.delete_residue_with_full_spec(imol, imodel, chain_id, resno, inscode, altloc)

def delete_residues_py(imol, residue_specs_py):
    r"""
    delete_residues_py(int imol, PyObject * residue_specs_py)

    delete residues in the residue spec list

    Parameters
    ----------
    imol : int
    residue_specs_py : object

    """
    return _coot.delete_residues_py(imol, residue_specs_py)

def delete_residue_hydrogens(imol, chain_id, resno, inscode, altloc):
    r"""
    delete_residue_hydrogens(int imol, char const * chain_id, int resno, char const * inscode, char const * altloc)

    delete hydrogen atoms in residue

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    inscode : str
    altloc : str

    """
    return _coot.delete_residue_hydrogens(imol, chain_id, resno, inscode, altloc)

def delete_atom(imol, chain_id, resno, ins_code, at_name, altloc):
    r"""
    delete_atom(int imol, char const * chain_id, int resno, char const * ins_code, char const * at_name, char const * altloc)

    delete atom in residue

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    at_name : str
    altloc : str

    """
    return _coot.delete_atom(imol, chain_id, resno, ins_code, at_name, altloc)

def delete_residue_sidechain(imol, chain_id, resno, ins_code, do_delete_dialog):
    r"""
    delete_residue_sidechain(int imol, char const * chain_id, int resno, char const * ins_code, short do_delete_dialog)

    delete all atoms in residue that are not main chain or CB

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    do_delete_dialog : int

    """
    return _coot.delete_residue_sidechain(imol, chain_id, resno, ins_code, do_delete_dialog)

def delete_hydrogen_atoms(imol):
    r"""
    delete_hydrogen_atoms(int imol) -> int

    delete all hydrogens in molecule,

    number of hydrogens deleted.

    Parameters
    ----------
    imol : int

    """
    return _coot.delete_hydrogen_atoms(imol)

def delete_hydrogens(imol):
    r"""
    delete_hydrogens(int imol) -> int

    delete all hydrogens in molecule,

    number of hydrogens deleted.

    Parameters
    ----------
    imol : int

    """
    return _coot.delete_hydrogens(imol)

def delete_waters(imol):
    r"""
    delete_waters(int imol) -> int

    delete all waters in molecule,

    number of waters deleted.

    Parameters
    ----------
    imol : int

    """
    return _coot.delete_waters(imol)

def post_delete_item_dialog():
    r"""post_delete_item_dialog()"""
    return _coot.post_delete_item_dialog()

def set_delete_atom_mode():
    r"""set_delete_atom_mode()"""
    return _coot.set_delete_atom_mode()

def set_delete_residue_mode():
    r"""set_delete_residue_mode()"""
    return _coot.set_delete_residue_mode()

def set_delete_residue_zone_mode():
    r"""set_delete_residue_zone_mode()"""
    return _coot.set_delete_residue_zone_mode()

def set_delete_residue_hydrogens_mode():
    r"""set_delete_residue_hydrogens_mode()"""
    return _coot.set_delete_residue_hydrogens_mode()

def set_delete_water_mode():
    r"""set_delete_water_mode()"""
    return _coot.set_delete_water_mode()

def set_delete_sidechain_mode():
    r"""set_delete_sidechain_mode()"""
    return _coot.set_delete_sidechain_mode()

def set_delete_sidechain_range_mode():
    r"""set_delete_sidechain_range_mode()"""
    return _coot.set_delete_sidechain_range_mode()

def set_delete_chain_mode():
    r"""set_delete_chain_mode()"""
    return _coot.set_delete_chain_mode()

def delete_item_mode_is_atom_p():
    r"""delete_item_mode_is_atom_p() -> short"""
    return _coot.delete_item_mode_is_atom_p()

def delete_item_mode_is_residue_p():
    r"""delete_item_mode_is_residue_p() -> short"""
    return _coot.delete_item_mode_is_residue_p()

def delete_item_mode_is_water_p():
    r"""delete_item_mode_is_water_p() -> short"""
    return _coot.delete_item_mode_is_water_p()

def delete_item_mode_is_sidechain_p():
    r"""delete_item_mode_is_sidechain_p() -> short"""
    return _coot.delete_item_mode_is_sidechain_p()

def delete_item_mode_is_sidechain_range_p():
    r"""delete_item_mode_is_sidechain_range_p() -> short"""
    return _coot.delete_item_mode_is_sidechain_range_p()

def delete_item_mode_is_chain_p():
    r"""delete_item_mode_is_chain_p() -> short"""
    return _coot.delete_item_mode_is_chain_p()

def clear_pending_delete_item():
    r"""clear_pending_delete_item()"""
    return _coot.clear_pending_delete_item()

def do_rot_trans_setup(state):
    r"""
    do_rot_trans_setup(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.do_rot_trans_setup(state)

def rot_trans_reset_previous():
    r"""rot_trans_reset_previous()"""
    return _coot.rot_trans_reset_previous()

def set_rotate_translate_zone_rotates_about_zone_centre(istate):
    r"""
    set_rotate_translate_zone_rotates_about_zone_centre(int istate)


    Parameters
    ----------
    istate : int

    """
    return _coot.set_rotate_translate_zone_rotates_about_zone_centre(istate)

def set_rot_trans_object_type(rt_type):
    r"""
    set_rot_trans_object_type(short rt_type)


    Parameters
    ----------
    rt_type : int

    """
    return _coot.set_rot_trans_object_type(rt_type)

def get_rot_trans_object_type():
    r"""get_rot_trans_object_type() -> int"""
    return _coot.get_rot_trans_object_type()

def do_cis_trans_conversion_setup(istate):
    r"""
    do_cis_trans_conversion_setup(int istate)


    Parameters
    ----------
    istate : int

    """
    return _coot.do_cis_trans_conversion_setup(istate)

def cis_trans_convert(imol, chain_id, resno, altconf):
    r"""
    cis_trans_convert(int imol, char const * chain_id, int resno, char const * altconf)


    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    altconf : str

    """
    return _coot.cis_trans_convert(imol, chain_id, resno, altconf)

def cis_peptides_py(imol):
    r"""
    cis_peptides_py(int imol) -> PyObject *

    return cis_peptide info for imol.

    Return a Python list object of [residue1, residue2, omega]

    Parameters
    ----------
    imol : int

    """
    return _coot.cis_peptides_py(imol)

def twisted_trans_peptides_py(imol):
    r"""
    twisted_trans_peptides_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.twisted_trans_peptides_py(imol)

def cis_trans_convert_intermediate_atoms():
    r"""
    cis_trans_convert_intermediate_atoms() -> int

    cis-trans convert the active residue of the active atom in the inermediate atoms, and continue with the refinement

    """
    return _coot.cis_trans_convert_intermediate_atoms()

def do_db_main(state):
    r"""
    do_db_main(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.do_db_main(state)

def db_mainchain(imol, chain_id, iresno_start, iresno_end, direction):
    r"""
    db_mainchain(int imol, char const * chain_id, int iresno_start, int iresno_end, char const * direction) -> int

    CA -> mainchain conversion.

    direction is either "forwards" or "backwards"

    See also the function below.

    return the new molecule number

    Parameters
    ----------
    imol : int
    chain_id : str
    iresno_start : int
    iresno_end : int
    direction : str

    """
    return _coot.db_mainchain(imol, chain_id, iresno_start, iresno_end, direction)

def db_mainchains_fragment(imol, chain_id, res_no):
    r"""
    db_mainchains_fragment(int imol, char const * chain_id, int res_no) -> int

    CA-Zone to Mainchain for a fragment based on the given residue.

    Both directions are built. This is the modern interface.

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int

    """
    return _coot.db_mainchains_fragment(imol, chain_id, res_no)

def close_molecule(imol):
    r"""
    close_molecule(int imol)

    close the molecule

    Parameters
    ----------
    imol : int

    """
    return _coot.close_molecule(imol)

def set_rotamer_search_mode(mode):
    r"""
    set_rotamer_search_mode(int mode)

    set the mode of rotamer search, options are (ROTAMERSEARCHAUTOMATIC), (ROTAMERSEARCHLOWRES) (aka. "backrub rotamers"), (ROTAMERSEARCHHIGHRES) (with rigid body fitting)

    Parameters
    ----------
    mode : int

    """
    return _coot.set_rotamer_search_mode(mode)

def rotamer_search_mode_state():
    r"""
    rotamer_search_mode_state() -> int

    \ brief get the mode of rotamer search

    """
    return _coot.rotamer_search_mode_state()

def setup_rotamers(state):
    r"""
    setup_rotamers(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_rotamers(state)

def do_rotamers(atom_index, imol):
    r"""
    do_rotamers(int atom_index, int imol)


    Parameters
    ----------
    atom_index : int
    imol : int

    """
    return _coot.do_rotamers(atom_index, imol)

def show_rotamers_dialog(imol, chain_id, resno, ins_code, altconf):
    r"""
    show_rotamers_dialog(int imol, char const * chain_id, int resno, char const * ins_code, char const * altconf)


    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    altconf : str

    """
    return _coot.show_rotamers_dialog(imol, chain_id, resno, ins_code, altconf)

def set_rotamer_lowest_probability(f):
    r"""
    set_rotamer_lowest_probability(float f)

    For Dunbrack rotamers, set the lowest probability to be considered. Set as a percentage i.e. 1.00 is quite low. For Richardson Rotamers, this has no effect.

    Parameters
    ----------
    f : float

    """
    return _coot.set_rotamer_lowest_probability(f)

def set_rotamer_check_clashes(i):
    r"""
    set_rotamer_check_clashes(int i)

    set a flag: 0 is off, 1 is on

    Parameters
    ----------
    i : int

    """
    return _coot.set_rotamer_check_clashes(i)

def auto_fit_best_rotamer(imol_coords, chain_id, resno, insertion_code, altloc, imol_map, clash_flag, lowest_probability):
    r"""
    auto_fit_best_rotamer(int imol_coords, char const * chain_id, int resno, char const * insertion_code, char const * altloc, int imol_map, int clash_flag, float lowest_probability) -> float

    auto fit by rotamer search.

    return the score, for some not very good reason. clash_flag determines if we use clashes with other residues in the score for this rotamer (or not). It would be cool to call this from a script that went residue by residue along a (newly-built) chain (now available).

    Parameters
    ----------
    imol_coords : int
    chain_id : str
    resno : int
    insertion_code : str
    altloc : str
    imol_map : int
    clash_flag : int
    lowest_probability : float

    """
    return _coot.auto_fit_best_rotamer(imol_coords, chain_id, resno, insertion_code, altloc, imol_map, clash_flag, lowest_probability)

def auto_fit_rotamer_active_residue():
    r"""
    auto_fit_rotamer_active_residue() -> float

    auto-fit the rotamer for the active residue

    """
    return _coot.auto_fit_rotamer_active_residue()

def set_auto_fit_best_rotamer_clash_flag(i):
    r"""
    set_auto_fit_best_rotamer_clash_flag(int i)

    set the clash flag for rotamer search

    And this functions for [pre-setting] the variables for auto_fit_best_rotamer called interactively (using a graphics_info_t function). 0 off, 1 on.

    Parameters
    ----------
    i : int

    """
    return _coot.set_auto_fit_best_rotamer_clash_flag(i)

def rotamer_score(imol, chain_id, res_no, insertion_code, alt_conf):
    r"""
    rotamer_score(int imol, char const * chain_id, int res_no, char const * insertion_code, char const * alt_conf) -> float


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    insertion_code : str
    alt_conf : str

    """
    return _coot.rotamer_score(imol, chain_id, res_no, insertion_code, alt_conf)

def setup_auto_fit_rotamer(state):
    r"""
    setup_auto_fit_rotamer(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_auto_fit_rotamer(state)

def n_rotamers(imol, chain_id, resno, ins_code):
    r"""
    n_rotamers(int imol, char const * chain_id, int resno, char const * ins_code) -> int

    return the number of rotamers for this residue - return -1 on no residue found.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.n_rotamers(imol, chain_id, resno, ins_code)

def set_residue_to_rotamer_number(imol, chain_id, resno, ins_code, alt_conf, rotamer_number):
    r"""
    set_residue_to_rotamer_number(int imol, char const * chain_id, int resno, char const * ins_code, char const * alt_conf, int rotamer_number) -> int

    set the residue specified to the rotamer number specifed.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    alt_conf : str
    rotamer_number : int

    """
    return _coot.set_residue_to_rotamer_number(imol, chain_id, resno, ins_code, alt_conf, rotamer_number)

def set_residue_to_rotamer_name(imol, chain_id, resno, ins_code, alt_conf, rotamer_name):
    r"""
    set_residue_to_rotamer_name(int imol, char const * chain_id, int resno, char const * ins_code, char const * alt_conf, char const * rotamer_name) -> int

    set the residue specified to the rotamer name specified.

    (rotamer names are the Richardson rotamer names.)

    return value is 0 if atoms were not moved (e.g. because rotamer-name was not know)

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    alt_conf : str
    rotamer_name : str

    """
    return _coot.set_residue_to_rotamer_name(imol, chain_id, resno, ins_code, alt_conf, rotamer_name)

def get_rotamer_name_py(imol, chain_id, resno, ins_code):
    r"""
    get_rotamer_name_py(int imol, char const * chain_id, int resno, char const * ins_code) -> PyObject *


    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.get_rotamer_name_py(imol, chain_id, resno, ins_code)

def fill_partial_residues(imol):
    r"""
    fill_partial_residues(int imol)

    fill all the residues of molecule number imol that have missing atoms.

    To be used to remove the effects of chainsaw.

    Parameters
    ----------
    imol : int

    """
    return _coot.fill_partial_residues(imol)

def fill_partial_residue(imol, chain_id, resno, inscode):
    r"""
    fill_partial_residue(int imol, char const * chain_id, int resno, char const * inscode)


    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    inscode : str

    """
    return _coot.fill_partial_residue(imol, chain_id, resno, inscode)

def simple_fill_partial_residues(imol):
    r"""
    simple_fill_partial_residues(int imol)

    Fill amino acid residues.

    do backrub rotamer search for residues, but don't do refinement

    Parameters
    ----------
    imol : int

    """
    return _coot.simple_fill_partial_residues(imol)

def missing_atom_info_py(imol):
    r"""
    missing_atom_info_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.missing_atom_info_py(imol)

def rotamer_graphs_py(imol):
    r"""
    rotamer_graphs_py(int imol) -> PyObject *

    Activate rotamer graph analysis for molecule number imol.

    Return rotamer info - function used in testing.

    Parameters
    ----------
    imol : int

    """
    return _coot.rotamer_graphs_py(imol)

def do_180_degree_side_chain_flip(imol, chain_id, resno, inscode, altconf):
    r"""
    do_180_degree_side_chain_flip(int imol, char const * chain_id, int resno, char const * inscode, char const * altconf)

    rotate 180 degrees around the last chi angle

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    inscode : str
    altconf : str

    """
    return _coot.do_180_degree_side_chain_flip(imol, chain_id, resno, inscode, altconf)

def setup_180_degree_flip(state):
    r"""
    setup_180_degree_flip(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_180_degree_flip(state)

def side_chain_flip_180_intermediate_atoms():
    r"""side_chain_flip_180_intermediate_atoms() -> int"""
    return _coot.side_chain_flip_180_intermediate_atoms()

def setup_mutate(state):
    r"""
    setup_mutate(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_mutate(state)

def setup_mutate_auto_fit(state):
    r"""
    setup_mutate_auto_fit(short state)

    Mutate then fit to map.

    that we have a map define is checked first

    Parameters
    ----------
    state : int

    """
    return _coot.setup_mutate_auto_fit(state)

def do_mutation(type, is_stub_flag):
    r"""
    do_mutation(char const * type, short is_stub_flag)


    Parameters
    ----------
    type : str
    is_stub_flag : int

    """
    return _coot.do_mutation(type, is_stub_flag)

def mutate_active_residue():
    r"""
    mutate_active_residue()

    display a dialog that allows the choice of residue type to which to mutate

    """
    return _coot.mutate_active_residue()

def progressive_residues_in_chain_check(chain_id, imol):
    r"""
    progressive_residues_in_chain_check(char const * chain_id, int imol) -> short


    Parameters
    ----------
    chain_id : str
    imol : int

    """
    return _coot.progressive_residues_in_chain_check(chain_id, imol)

def mutate(imol, chain_id, ires, inscode, target_res_type):
    r"""
    mutate(int imol, char const * chain_id, int ires, char const * inscode, char const * target_res_type) -> int

    mutate a given residue

    target_res_type is a three-letter-code.

    Return 1 on a good mutate.

    Parameters
    ----------
    imol : int
    chain_id : str
    ires : int
    inscode : str
    target_res_type : str

    """
    return _coot.mutate(imol, chain_id, ires, inscode, target_res_type)

def mutate_base(imol, chain_id, res_no, ins_code, res_type):
    r"""
    mutate_base(int imol, char const * chain_id, int res_no, char const * ins_code, char const * res_type) -> int

    mutate a base. return success status, 1 for a good mutate.

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    res_type : str

    """
    return _coot.mutate_base(imol, chain_id, res_no, ins_code, res_type)

def nudge_residue_sequence(imol, chain_id, res_no_range_start, res_no_range_end, nudge_by, nudge_residue_numbers_also):
    r"""
    nudge_residue_sequence(int imol, char const * chain_id, int res_no_range_start, int res_no_range_end, int nudge_by, short nudge_residue_numbers_also) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no_range_start : int
    res_no_range_end : int
    nudge_by : int
    nudge_residue_numbers_also : int

    """
    return _coot.nudge_residue_sequence(imol, chain_id, res_no_range_start, res_no_range_end, nudge_by, nudge_residue_numbers_also)

def set_mutate_auto_fit_do_post_refine(istate):
    r"""
    set_mutate_auto_fit_do_post_refine(short istate)

    Do you want Coot to automatically run a refinement after every mutate and autofit?

    1 for yes, 0 for no.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_mutate_auto_fit_do_post_refine(istate)

def mutate_auto_fit_do_post_refine_state():
    r"""
    mutate_auto_fit_do_post_refine_state() -> int

    what is the value of the previous flag?

    """
    return _coot.mutate_auto_fit_do_post_refine_state()

def set_rotamer_auto_fit_do_post_refine(istate):
    r"""
    set_rotamer_auto_fit_do_post_refine(short istate)

    Do you want Coot to automatically run a refinement after every rotamer autofit?

    1 for yes, 0 for no.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_rotamer_auto_fit_do_post_refine(istate)

def rotamer_auto_fit_do_post_refine_state():
    r"""
    rotamer_auto_fit_do_post_refine_state() -> int

    what is the value of the previous flag?

    """
    return _coot.rotamer_auto_fit_do_post_refine_state()

def mutate_single_residue_by_serial_number(ires_ser, chain_id, imol, target_res_type):
    r"""
    mutate_single_residue_by_serial_number(int ires_ser, char const * chain_id, int imol, char target_res_type) -> int

    an alternate interface to mutation of a singe residue.

    This function doesnt make backups, but mutate() does - CHECKME Hence mutate() is for use as a "one-by-one" type and the following 2 by wrappers that muate either a residue range or a whole chain.

      ires_ser  is the serial number of the residue, not the seqnum   chain_id  is the chain-id   imol  is the index of the model molecule   target_res_type  is the single-letter-code for the target residue Note that the target_res_type is a char, not a string (or a char *). So from the scheme interface you'd use (for example) hash backslash A for ALA.

    1 on success, 0 on failure

    Parameters
    ----------
    ires_ser : int
        is the serial number of the residue, not the seqnum
    chain_id : str
        is the chain-id
    imol : int
        is the index of the model molecule
    target_res_type : char
        is the single-letter-code for the target residue

    """
    return _coot.mutate_single_residue_by_serial_number(ires_ser, chain_id, imol, target_res_type)

def mutate_single_residue_by_seqno(imol, chain_id, ires, inscode, target_res_type):
    r"""
    mutate_single_residue_by_seqno(int imol, char const * chain_id, int ires, char const * inscode, char target_res_type) -> int

    ires is the seqnum of the residue (conventional)

    Parameters
    ----------
    imol : int
    chain_id : str
    ires : int
    inscode : str
    target_res_type : char

    """
    return _coot.mutate_single_residue_by_seqno(imol, chain_id, ires, inscode, target_res_type)

def mutate_and_autofit_residue_range(imol, chain_id, start_res_no, stop_res_no, sequence):
    r"""
    mutate_and_autofit_residue_range(int imol, char const * chain_id, int start_res_no, int stop_res_no, char const * sequence) -> int

    mutate and auto-fit

    (Move this and the above function into cc-interface.hh one day)

    Parameters
    ----------
    imol : int
    chain_id : str
    start_res_no : int
    stop_res_no : int
    sequence : str

    """
    return _coot.mutate_and_autofit_residue_range(imol, chain_id, start_res_no, stop_res_no, sequence)

def do_base_mutation(type):
    r"""
    do_base_mutation(char const * type)


    Parameters
    ----------
    type : str

    """
    return _coot.do_base_mutation(type)

def set_residue_type_chooser_stub_state(istat):
    r"""
    set_residue_type_chooser_stub_state(short istat)

    set a flag saying that the residue chosen by mutate or auto-fit mutate should only be added as a stub (mainchain + CB)

    Parameters
    ----------
    istat : int

    """
    return _coot.set_residue_type_chooser_stub_state(istat)

def handle_residue_type_chooser_entry_chose_type(entry_text, stub_mode):
    r"""
    handle_residue_type_chooser_entry_chose_type(char const * entry_text, short stub_mode)


    Parameters
    ----------
    entry_text : str
    stub_mode : int

    """
    return _coot.handle_residue_type_chooser_entry_chose_type(entry_text, stub_mode)

def alt_conf_split_type_number():
    r"""alt_conf_split_type_number() -> short"""
    return _coot.alt_conf_split_type_number()

def set_add_alt_conf_split_type_number(i):
    r"""
    set_add_alt_conf_split_type_number(short i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_add_alt_conf_split_type_number(i)

def add_alt_conf_py(imol, chain_id, res_no, ins_code, alt_conf, rotamer_number):
    r"""
    add_alt_conf_py(int imol, char const * chain_id, int res_no, char const * ins_code, char const * alt_conf, int rotamer_number) -> PyObject *

    add an alternative conformer to a residue. Add it in conformation rotamer number rotamer_number.

    Return the new alt_conf chain_id on sucess, python False on fail

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    alt_conf : str
    rotamer_number : int

    """
    return _coot.add_alt_conf_py(imol, chain_id, res_no, ins_code, alt_conf, rotamer_number)

def unset_add_alt_conf_dialog():
    r"""unset_add_alt_conf_dialog()"""
    return _coot.unset_add_alt_conf_dialog()

def unset_add_alt_conf_define():
    r"""unset_add_alt_conf_define()"""
    return _coot.unset_add_alt_conf_define()

def altconf():
    r"""altconf()"""
    return _coot.altconf()

def set_add_alt_conf_new_atoms_occupancy(f):
    r"""
    set_add_alt_conf_new_atoms_occupancy(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_add_alt_conf_new_atoms_occupancy(f)

def get_add_alt_conf_new_atoms_occupancy():
    r"""get_add_alt_conf_new_atoms_occupancy() -> float"""
    return _coot.get_add_alt_conf_new_atoms_occupancy()

def set_show_alt_conf_intermediate_atoms(i):
    r"""
    set_show_alt_conf_intermediate_atoms(int i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_show_alt_conf_intermediate_atoms(i)

def show_alt_conf_intermediate_atoms_state():
    r"""show_alt_conf_intermediate_atoms_state() -> int"""
    return _coot.show_alt_conf_intermediate_atoms_state()

def zero_occupancy_residue_range(imol, chain_id, ires1, ires2):
    r"""
    zero_occupancy_residue_range(int imol, char const * chain_id, int ires1, int ires2)


    Parameters
    ----------
    imol : int
    chain_id : str
    ires1 : int
    ires2 : int

    """
    return _coot.zero_occupancy_residue_range(imol, chain_id, ires1, ires2)

def fill_occupancy_residue_range(imol, chain_id, ires1, ires2):
    r"""
    fill_occupancy_residue_range(int imol, char const * chain_id, int ires1, int ires2)


    Parameters
    ----------
    imol : int
    chain_id : str
    ires1 : int
    ires2 : int

    """
    return _coot.fill_occupancy_residue_range(imol, chain_id, ires1, ires2)

def set_occupancy_residue_range(imol, chain_id, ires1, ires2, occ):
    r"""
    set_occupancy_residue_range(int imol, char const * chain_id, int ires1, int ires2, float occ)


    Parameters
    ----------
    imol : int
    chain_id : str
    ires1 : int
    ires2 : int
    occ : float

    """
    return _coot.set_occupancy_residue_range(imol, chain_id, ires1, ires2, occ)

def set_b_factor_residue_range(imol, chain_id, ires1, ires2, bval):
    r"""
    set_b_factor_residue_range(int imol, char const * chain_id, int ires1, int ires2, float bval)


    Parameters
    ----------
    imol : int
    chain_id : str
    ires1 : int
    ires2 : int
    bval : float

    """
    return _coot.set_b_factor_residue_range(imol, chain_id, ires1, ires2, bval)

def reset_b_factor_residue_range(imol, chain_id, ires1, ires2):
    r"""
    reset_b_factor_residue_range(int imol, char const * chain_id, int ires1, int ires2)


    Parameters
    ----------
    imol : int
    chain_id : str
    ires1 : int
    ires2 : int

    """
    return _coot.reset_b_factor_residue_range(imol, chain_id, ires1, ires2)

def place_atom_at_pointer():
    r"""place_atom_at_pointer()"""
    return _coot.place_atom_at_pointer()

def place_atom_at_pointer_by_window():
    r"""place_atom_at_pointer_by_window()"""
    return _coot.place_atom_at_pointer_by_window()

def place_typed_atom_at_pointer(type):
    r"""
    place_typed_atom_at_pointer(char const * type)


    Parameters
    ----------
    type : str

    """
    return _coot.place_typed_atom_at_pointer(type)

def set_pointer_atom_is_dummy(i):
    r"""
    set_pointer_atom_is_dummy(int i)


    Parameters
    ----------
    i : int

    """
    return _coot.set_pointer_atom_is_dummy(i)

def display_where_is_pointer():
    r"""display_where_is_pointer()"""
    return _coot.display_where_is_pointer()

def create_pointer_atom_molecule_maybe():
    r"""
    create_pointer_atom_molecule_maybe() -> int

    Return the current pointer atom molecule, create a pointer atom molecule if necessary (i.e. when the user has not set it).

    """
    return _coot.create_pointer_atom_molecule_maybe()

def pointer_atom_molecule():
    r"""
    pointer_atom_molecule() -> int

    Return the current pointer atom molecule.

    """
    return _coot.pointer_atom_molecule()

def set_pointer_atom_molecule(imol):
    r"""
    set_pointer_atom_molecule(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.set_pointer_atom_molecule(imol)

def set_baton_mode(i):
    r"""
    set_baton_mode(short i)

    toggle so that mouse movement moves the baton not rotates the view.

    Parameters
    ----------
    i : int

    """
    return _coot.set_baton_mode(i)

def try_set_draw_baton(i):
    r"""
    try_set_draw_baton(short i) -> int

    draw the baton or not

    Parameters
    ----------
    i : int

    """
    return _coot.try_set_draw_baton(i)

def accept_baton_position():
    r"""
    accept_baton_position()

    accept the baton tip position

    a prime candidate for a key binding

    """
    return _coot.accept_baton_position()

def baton_tip_try_another():
    r"""
    baton_tip_try_another()

    move the baton tip position - another prime candidate for a key binding

    """
    return _coot.baton_tip_try_another()

def baton_tip_previous():
    r"""
    baton_tip_previous()

    move the baton tip to the previous position

    """
    return _coot.baton_tip_previous()

def shorten_baton():
    r"""
    shorten_baton()

    shorten the baton length

    """
    return _coot.shorten_baton()

def lengthen_baton():
    r"""
    lengthen_baton()

    lengthen the baton

    """
    return _coot.lengthen_baton()

def baton_build_delete_last_residue():
    r"""
    baton_build_delete_last_residue()

    delete the most recently build CA position

    """
    return _coot.baton_build_delete_last_residue()

def set_baton_build_params(istart_resno, chain_id, direction):
    r"""
    set_baton_build_params(int istart_resno, char const * chain_id, char const * direction)

    set the parameters for the start of a new baton-built fragment. direction can either be "forwards" or "backwards"

    Parameters
    ----------
    istart_resno : int
    chain_id : str
    direction : str

    """
    return _coot.set_baton_build_params(istart_resno, chain_id, direction)

def reverse_direction_of_fragment(imol, chain_id, resno):
    r"""
    reverse_direction_of_fragment(int imol, char const * chain_id, int resno)

    Reverse the direction of a the fragment of the clicked on atom/residue.

    A fragment is a consecutive range of residues - where there is a gap in the numbering, that marks breaks between fragments in a chain. There also needs to be a distance break - if the CA of the next/previous residue is more than 5A away, that also marks a break. Throw away all atoms in fragment other than CAs.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int

    """
    return _coot.reverse_direction_of_fragment(imol, chain_id, resno)

def setup_reverse_direction(i):
    r"""
    setup_reverse_direction(short i)


    Parameters
    ----------
    i : int

    """
    return _coot.setup_reverse_direction(i)

def add_OXT_to_residue(imol, chain_id, reso, insertion_code):
    r"""
    add_OXT_to_residue(int imol, char const * chain_id, int reso, char const * insertion_code) -> short


    Parameters
    ----------
    imol : int
    chain_id : str
    reso : int
    insertion_code : str

    """
    return _coot.add_OXT_to_residue(imol, chain_id, reso, insertion_code)

def set_draw_crosshairs(i):
    r"""
    set_draw_crosshairs(short i)

    draw the distance crosshairs, 0 for off, 1 for on.

    Parameters
    ----------
    i : int

    """
    return _coot.set_draw_crosshairs(i)

def draw_crosshairs_state():
    r"""draw_crosshairs_state() -> short"""
    return _coot.draw_crosshairs_state()

def setup_edit_chi_angles(state):
    r"""
    setup_edit_chi_angles(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_edit_chi_angles(state)

def rotate_chi(am):
    r"""
    rotate_chi(float am)


    Parameters
    ----------
    am : float

    """
    return _coot.rotate_chi(am)

def set_find_hydrogen_torsions(state):
    r"""
    set_find_hydrogen_torsions(short state)

    show torsions that rotate hydrogens in the torsion angle manipulation dialog. Note that this may be needed if, in the dictionary cif file torsion which have as a 4th atom both a hydrogen and a heavier atom bonding to the 3rd atom, but list the 4th atom as a hydrogen (not a heavier atom).

    Parameters
    ----------
    state : int

    """
    return _coot.set_find_hydrogen_torsions(state)

def set_graphics_edit_current_chi(ichi):
    r"""
    set_graphics_edit_current_chi(int ichi)


    Parameters
    ----------
    ichi : int

    """
    return _coot.set_graphics_edit_current_chi(ichi)

def unset_moving_atom_move_chis():
    r"""unset_moving_atom_move_chis()"""
    return _coot.unset_moving_atom_move_chis()

def set_moving_atom_move_chis():
    r"""set_moving_atom_move_chis()"""
    return _coot.set_moving_atom_move_chis()

def edit_chi_angles(imol, chain_id, resno, ins_code, altconf):
    r"""
    edit_chi_angles(int imol, char const * chain_id, int resno, char const * ins_code, char const * altconf) -> int

    display the edit chi angles gui for the given residue

    return a status of 0 if it failed to fined the residue, return a value of 1 if it worked.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    altconf : str

    """
    return _coot.edit_chi_angles(imol, chain_id, resno, ins_code, altconf)

def set_show_chi_angle_bond(imode):
    r"""
    set_show_chi_angle_bond(int imode) -> int


    Parameters
    ----------
    imode : int

    """
    return _coot.set_show_chi_angle_bond(imode)

def set_edit_chi_angles_reverse_fragment_state(istate):
    r"""
    set_edit_chi_angles_reverse_fragment_state(short istate)


    Parameters
    ----------
    istate : int

    """
    return _coot.set_edit_chi_angles_reverse_fragment_state(istate)

def setup_torsion_general(state):
    r"""
    setup_torsion_general(short state)

    beloved torsion general at last makes an entrance onto the Coot scene...

    Parameters
    ----------
    state : int

    """
    return _coot.setup_torsion_general(state)

def toggle_torsion_general_reverse():
    r"""toggle_torsion_general_reverse()"""
    return _coot.toggle_torsion_general_reverse()

def setup_residue_partial_alt_locs(state):
    r"""
    setup_residue_partial_alt_locs(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_residue_partial_alt_locs(state)

def backrub_rotamer(imol, chain_id, res_no, ins_code, alt_conf):
    r"""
    backrub_rotamer(int imol, char const * chain_id, int res_no, char const * ins_code, char const * alt_conf) -> int

    Do a back-rub rotamer search (with autoaccept).

    the success status, 0 for fail, 1 for successful fit.

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    alt_conf : str

    """
    return _coot.backrub_rotamer(imol, chain_id, res_no, ins_code, alt_conf)

def backrub_rotamer_intermediate_atoms():
    r"""
    backrub_rotamer_intermediate_atoms() -> int

    apply rotamer backrub to the active atom of the intermediate atoms

    """
    return _coot.backrub_rotamer_intermediate_atoms()

def mask_map_by_molecule(map_mol_no, coord_mol_no, invert_flag):
    r"""
    mask_map_by_molecule(int map_mol_no, int coord_mol_no, short invert_flag) -> int

    generate a new map that has been masked by some coordinates

    (mask-map-by-molecule map-no mol-no invert?) creates and displays a masked map, cuts down density where the coordinates are (invert is 0). If invert? is 1, cut the density down where there are no atoms atoms.

    Parameters
    ----------
    map_mol_no : int
    coord_mol_no : int
    invert_flag : int

    """
    return _coot.mask_map_by_molecule(map_mol_no, coord_mol_no, invert_flag)

def mask_map_by_atom_selection(map_mol_no, coords_mol_no, mmdb_atom_selection, invert_flag):
    r"""
    mask_map_by_atom_selection(int map_mol_no, int coords_mol_no, char const * mmdb_atom_selection, short invert_flag) -> int

    mask map by atom selection

    Parameters
    ----------
    map_mol_no : int
    coords_mol_no : int
    mmdb_atom_selection : str
    invert_flag : int

    """
    return _coot.mask_map_by_atom_selection(map_mol_no, coords_mol_no, mmdb_atom_selection, invert_flag)

def make_masked_maps_split_by_chain(imol, imol_map):
    r"""
    make_masked_maps_split_by_chain(int imol, int imol_map) -> int

    make chain masked maps

    needs to return a list of values

    Parameters
    ----------
    imol : int
    imol_map : int

    """
    return _coot.make_masked_maps_split_by_chain(imol, imol_map)

def set_map_mask_atom_radius(rad):
    r"""
    set_map_mask_atom_radius(float rad)

    set the atom radius for map masking

    Parameters
    ----------
    rad : float

    """
    return _coot.set_map_mask_atom_radius(rad)

def map_mask_atom_radius():
    r"""
    map_mask_atom_radius() -> float

    get the atom radius for map masking

    """
    return _coot.map_mask_atom_radius()

def set_check_waters_b_factor_limit(f):
    r"""
    set_check_waters_b_factor_limit(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_check_waters_b_factor_limit(f)

def set_check_waters_map_sigma_limit(f):
    r"""
    set_check_waters_map_sigma_limit(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_check_waters_map_sigma_limit(f)

def set_check_waters_min_dist_limit(f):
    r"""
    set_check_waters_min_dist_limit(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_check_waters_min_dist_limit(f)

def set_check_waters_max_dist_limit(f):
    r"""
    set_check_waters_max_dist_limit(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_check_waters_max_dist_limit(f)

def delete_checked_waters_baddies(imol, b_factor_lim, map_sigma_lim, min_dist, max_dist, part_occ_contact_flag, zero_occ_flag, logical_operator_and_or_flag):
    r"""
    delete_checked_waters_baddies(int imol, float b_factor_lim, float map_sigma_lim, float min_dist, float max_dist, short part_occ_contact_flag, short zero_occ_flag, short logical_operator_and_or_flag)

    Delete waters that are fail to meet the given criteria.

    Parameters
    ----------
    imol : int
    b_factor_lim : float
    map_sigma_lim : float
    min_dist : float
    max_dist : float
    part_occ_contact_flag : int
    zero_occ_flag : int
    logical_operator_and_or_flag : int

    """
    return _coot.delete_checked_waters_baddies(imol, b_factor_lim, map_sigma_lim, min_dist, max_dist, part_occ_contact_flag, zero_occ_flag, logical_operator_and_or_flag)

def check_waters_by_difference_map(imol_waters, imol_diff_map, interactive_flag):
    r"""
    check_waters_by_difference_map(int imol_waters, int imol_diff_map, int interactive_flag)


    Parameters
    ----------
    imol_waters : int
    imol_diff_map : int
    interactive_flag : int

    """
    return _coot.check_waters_by_difference_map(imol_waters, imol_diff_map, interactive_flag)

def check_waters_by_difference_map_sigma_level_state():
    r"""check_waters_by_difference_map_sigma_level_state() -> float"""
    return _coot.check_waters_by_difference_map_sigma_level_state()

def set_check_waters_by_difference_map_sigma_level(f):
    r"""
    set_check_waters_by_difference_map_sigma_level(float f)


    Parameters
    ----------
    f : float

    """
    return _coot.set_check_waters_by_difference_map_sigma_level(f)

def highly_coordinated_waters_py(imol, coordination_number, dist_max):
    r"""
    highly_coordinated_waters_py(int imol, int coordination_number, float dist_max) -> PyObject *

    return a list first of waters, second metals that are coordinated with at least coordination_number of other atoms at distances less than or equal to dist_max. Return Python false on not able to make a list, otherwise a list of atoms and neighours. can return Python False if imol is not a valid molecule.

    Parameters
    ----------
    imol : int
    coordination_number : int
    dist_max : float

    """
    return _coot.highly_coordinated_waters_py(imol, coordination_number, dist_max)

def metal_coordination_py(imol, dist_max):
    r"""
    metal_coordination_py(int imol, float dist_max) -> PyObject *


    Parameters
    ----------
    imol : int
    dist_max : float

    """
    return _coot.metal_coordination_py(imol, dist_max)

def clear_lsq_matches():
    r"""clear_lsq_matches()"""
    return _coot.clear_lsq_matches()

def add_lsq_match(reference_resno_start, reference_resno_end, chain_id_reference, moving_resno_start, moving_resno_end, chain_id_moving, match_type):
    r"""
    add_lsq_match(int reference_resno_start, int reference_resno_end, char const * chain_id_reference, int moving_resno_start, int moving_resno_end, char const * chain_id_moving, int match_type)


    Parameters
    ----------
    reference_resno_start : int
    reference_resno_end : int
    chain_id_reference : str
    moving_resno_start : int
    moving_resno_end : int
    chain_id_moving : str
    match_type : int

    """
    return _coot.add_lsq_match(reference_resno_start, reference_resno_end, chain_id_reference, moving_resno_start, moving_resno_end, chain_id_moving, match_type)

def add_lsq_atom_pair_py(atom_spec_ref, atom_spec_moving):
    r"""
    add_lsq_atom_pair_py(PyObject * atom_spec_ref, PyObject * atom_spec_moving)


    Parameters
    ----------
    atom_spec_ref : object
    atom_spec_moving : object

    """
    return _coot.add_lsq_atom_pair_py(atom_spec_ref, atom_spec_moving)

def apply_lsq_matches_py(imol_reference, imol_moving):
    r"""
    apply_lsq_matches_py(int imol_reference, int imol_moving) -> PyObject *


    Parameters
    ----------
    imol_reference : int
    imol_moving : int

    """
    return _coot.apply_lsq_matches_py(imol_reference, imol_moving)

def get_lsq_matrix_py(imol_reference, imol_moving):
    r"""
    get_lsq_matrix_py(int imol_reference, int imol_moving) -> PyObject *


    Parameters
    ----------
    imol_reference : int
    imol_moving : int

    """
    return _coot.get_lsq_matrix_py(imol_reference, imol_moving)

def apply_lsq_matches_simple(imol_reference, imol_moving):
    r"""
    apply_lsq_matches_simple(int imol_reference, int imol_moving) -> int


    Parameters
    ----------
    imol_reference : int
    imol_moving : int

    """
    return _coot.apply_lsq_matches_simple(imol_reference, imol_moving)

def setup_lsq_deviation(state):
    r"""
    setup_lsq_deviation(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_lsq_deviation(state)

def setup_lsq_plane_define(state):
    r"""
    setup_lsq_plane_define(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_lsq_plane_define(state)

def unset_lsq_plane_dialog():
    r"""unset_lsq_plane_dialog()"""
    return _coot.unset_lsq_plane_dialog()

def remove_last_lsq_plane_atom():
    r"""remove_last_lsq_plane_atom()"""
    return _coot.remove_last_lsq_plane_atom()

def trim_molecule_by_map(imol_coords, imol_map, map_level, delete_or_zero_occ_flag):
    r"""
    trim_molecule_by_map(int imol_coords, int imol_map, float map_level, int delete_or_zero_occ_flag)

    cut off (delete or give zero occupancy) atoms in the given molecule if they are below the given map (absolute) level.

    Parameters
    ----------
    imol_coords : int
    imol_map : int
    map_level : float
    delete_or_zero_occ_flag : int

    """
    return _coot.trim_molecule_by_map(imol_coords, imol_map, map_level, delete_or_zero_occ_flag)

def trim_molecule_by_b_factor(imol, limit, keep_higher):
    r"""
    trim_molecule_by_b_factor(int imol, float limit, short keep_higher)

    trim the molecule by the value in the B-factor column.

    If an atom in a residue has a "B-factor" above (or below, if keep_higher is true) limit, then the whole residue is deleted

    Parameters
    ----------
    imol : int
    limit : float
    keep_higher : int

    """
    return _coot.trim_molecule_by_b_factor(imol, limit, keep_higher)

def pLDDT_to_b_factor(imol):
    r"""
    pLDDT_to_b_factor(int imol)

    convert the value in the B-factor column (typically pLDDT for AlphaFold models) to a temperature factor

    Parameters
    ----------
    imol : int

    """
    return _coot.pLDDT_to_b_factor(imol)

def raster3d(rd3_filename):
    r"""
    raster3d(char const * rd3_filename)

    create a r3d file for the current view

    Parameters
    ----------
    rd3_filename : str

    """
    return _coot.raster3d(rd3_filename)

def povray(filename):
    r"""
    povray(char const * filename)


    Parameters
    ----------
    filename : str

    """
    return _coot.povray(filename)

def renderman(rib_filename):
    r"""
    renderman(char const * rib_filename)


    Parameters
    ----------
    rib_filename : str

    """
    return _coot.renderman(rib_filename)

def make_image_raster3d(filename):
    r"""
    make_image_raster3d(char const * filename)


    Parameters
    ----------
    filename : str

    """
    return _coot.make_image_raster3d(filename)

def make_image_povray(filename):
    r"""
    make_image_povray(char const * filename)


    Parameters
    ----------
    filename : str

    """
    return _coot.make_image_povray(filename)

def make_image_raster3d_py(filename):
    r"""
    make_image_raster3d_py(char const * filename)


    Parameters
    ----------
    filename : str

    """
    return _coot.make_image_raster3d_py(filename)

def make_image_povray_py(filename):
    r"""
    make_image_povray_py(char const * filename)


    Parameters
    ----------
    filename : str

    """
    return _coot.make_image_povray_py(filename)

def set_raster3d_bond_thickness(f):
    r"""
    set_raster3d_bond_thickness(float f)

    set the bond thickness for the Raster3D representation

    Parameters
    ----------
    f : float

    """
    return _coot.set_raster3d_bond_thickness(f)

def set_raster3d_atom_radius(f):
    r"""
    set_raster3d_atom_radius(float f)

    set the atom radius for the Raster3D representation

    Parameters
    ----------
    f : float

    """
    return _coot.set_raster3d_atom_radius(f)

def set_raster3d_density_thickness(f):
    r"""
    set_raster3d_density_thickness(float f)

    set the density line thickness for the Raster3D representation

    Parameters
    ----------
    f : float

    """
    return _coot.set_raster3d_density_thickness(f)

def set_renderer_show_atoms(istate):
    r"""
    set_renderer_show_atoms(int istate)

    set the flag to show atoms for the Raster3D representation

    Parameters
    ----------
    istate : int

    """
    return _coot.set_renderer_show_atoms(istate)

def set_raster3d_bone_thickness(f):
    r"""
    set_raster3d_bone_thickness(float f)

    set the bone (skeleton) thickness for the Raster3D representation

    Parameters
    ----------
    f : float

    """
    return _coot.set_raster3d_bone_thickness(f)

def set_raster3d_shadows_enabled(state):
    r"""
    set_raster3d_shadows_enabled(int state)

    turn off shadows for raster3d output - give argument 0 to turn off

    Parameters
    ----------
    state : int

    """
    return _coot.set_raster3d_shadows_enabled(state)

def set_raster3d_water_sphere(istate):
    r"""
    set_raster3d_water_sphere(int istate)

    set the flag to show waters as spheres for the Raster3D representation. 1 show as spheres, 0 the usual stars.

    Parameters
    ----------
    istate : int

    """
    return _coot.set_raster3d_water_sphere(istate)

def set_raster3d_font_size(size_in):
    r"""
    set_raster3d_font_size(char const * size_in)

    set the font size (as a string) for raster3d

    Parameters
    ----------
    size_in : str

    """
    return _coot.set_raster3d_font_size(size_in)

def raster_screen_shot():
    r"""
    raster_screen_shot()

    run raster3d and display the resulting image.

    """
    return _coot.raster_screen_shot()

def raster_screen_shot_py():
    r"""raster_screen_shot_py()"""
    return _coot.raster_screen_shot_py()

def citation_notice_off():
    r"""citation_notice_off()"""
    return _coot.citation_notice_off()

def superpose(imol1, imol2, move_imol2_flag):
    r"""
    superpose(int imol1, int imol2, short move_imol2_flag)

    simple interface to superposition.

      imol1  the reference model index   imol2  the index of the superposed molecule Superpose all residues of imol2 onto imol1. imol1 is reference, we can either move imol2 or copy it to generate a new molecule depending on the vaule of move_imol2_flag (1 for copy 0 for move).

    Parameters
    ----------
    imol1 : int
        the reference model index
    imol2 : int
        the index of the superposed molecule
    move_imol2_flag : int

    """
    return _coot.superpose(imol1, imol2, move_imol2_flag)

def superpose_with_chain_selection(imol1, imol2, chain_imol1, chain_imol2, chain_used_flag_imol1, chain_used_flag_imol2, move_imol2_copy_flag):
    r"""
    superpose_with_chain_selection(int imol1, int imol2, char const * chain_imol1, char const * chain_imol2, int chain_used_flag_imol1, int chain_used_flag_imol2, short move_imol2_copy_flag)

    chain-based interface to superposition.

      imol1  the reference model index   imol2  the index of the superposed molecule   chain_imol1  the chain_id of imol1   chain_imol2  the chain_id of imol2   chain_used_flag_imol1  should the chain-id be used for imol1 (1 for yes, 0 for no)   chain_used_flag_imol2  should the chain-id be used for imol2 (1 for yes, 0 for no)   move_imol2_coppy_flag  flag to control if imol2 is copied (1) or moved (0) Superpose the given chains of imol2 onto imol1. imol1 is reference, we can either move imol2 or copy it to generate a new molecule depending on the vaule of move_imol2_flag (1 for move 0 for copy).

    Parameters
    ----------
    imol1 : int
        the reference model index
    imol2 : int
        the index of the superposed molecule
    chain_imol1 : str
        the chain_id of imol1
    chain_imol2 : str
        the chain_id of imol2
    chain_used_flag_imol1 : int
        should the chain-id be used for imol1 (1 for yes, 0 for no)
    chain_used_flag_imol2 : int
        should the chain-id be used for imol2 (1 for yes, 0 for no)
    move_imol2_copy_flag : int

    """
    return _coot.superpose_with_chain_selection(imol1, imol2, chain_imol1, chain_imol2, chain_used_flag_imol1, chain_used_flag_imol2, move_imol2_copy_flag)

def superpose_with_atom_selection(imol1, imol2, mmdb_atom_sel_str_1, mmdb_atom_sel_str_2, move_imol2_copy_flag):
    r"""
    superpose_with_atom_selection(int imol1, int imol2, char const * mmdb_atom_sel_str_1, char const * mmdb_atom_sel_str_2, short move_imol2_copy_flag) -> int

    detailed interface to superposition.

    Superpose the given atom selection (specified by the mmdb atom selection strings) of imol2 onto imol1. imol1 is reference, we can either move imol2 or copy it to generate a new molecule depending on the vaule of move_imol2_flag (1 for move 0 for copy).

    the index of the superposed molecule - which could either be a new molecule (if move_imol2_flag was 1) or the imol2 or -1 (signifying failure to do the SSM superposition).   imol1  the reference model index   imol2  the index of the superposed molecule   mmdb_atom_sel_str_1  the mmdb-format atom selection for imol1   mmdb_atom_sel_str_2  the mmdb-format atom selection for imol2   move_imol2_coppy_flag  flag to control if imol2 is copied (1) or moved (0)

    Parameters
    ----------
    imol1 : int
        the reference model index
    imol2 : int
        the index of the superposed molecule
    mmdb_atom_sel_str_1 : str
        the mmdb-format atom selection for imol1
    mmdb_atom_sel_str_2 : str
        the mmdb-format atom selection for imol2
    move_imol2_copy_flag : int

    """
    return _coot.superpose_with_atom_selection(imol1, imol2, mmdb_atom_sel_str_1, mmdb_atom_sel_str_2, move_imol2_copy_flag)

def set_draw_ncs_ghosts(imol, istate):
    r"""
    set_draw_ncs_ghosts(int imol, int istate)

    set drawing state of NCS ghosts for molecule number imol

    Parameters
    ----------
    imol : int
    istate : int

    """
    return _coot.set_draw_ncs_ghosts(imol, istate)

def draw_ncs_ghosts_state(imol):
    r"""
    draw_ncs_ghosts_state(int imol) -> int

    return the drawing state of NCS ghosts for molecule number imol. Return -1 on imol is a bad molecule or no ghosts.

    Parameters
    ----------
    imol : int

    """
    return _coot.draw_ncs_ghosts_state(imol)

def set_ncs_ghost_bond_thickness(imol, f):
    r"""
    set_ncs_ghost_bond_thickness(int imol, float f)

    set bond thickness of NCS ghosts for molecule number imol

    Parameters
    ----------
    imol : int
    f : float

    """
    return _coot.set_ncs_ghost_bond_thickness(imol, f)

def ncs_update_ghosts(imol):
    r"""
    ncs_update_ghosts(int imol)

    update ghosts for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.ncs_update_ghosts(imol)

def make_dynamically_transformed_ncs_maps(imol_model, imol_map, overwrite_maps_of_same_name_flag):
    r"""
    make_dynamically_transformed_ncs_maps(int imol_model, int imol_map, int overwrite_maps_of_same_name_flag) -> int

    make NCS map

    Parameters
    ----------
    imol_model : int
    imol_map : int
    overwrite_maps_of_same_name_flag : int

    """
    return _coot.make_dynamically_transformed_ncs_maps(imol_model, imol_map, overwrite_maps_of_same_name_flag)

def make_ncs_ghosts_maybe(imol):
    r"""
    make_ncs_ghosts_maybe(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.make_ncs_ghosts_maybe(imol)

def add_ncs_matrix(imol, this_chain_id, target_chain_id, m11, m12, m13, m21, m22, m23, m31, m32, m33, t1, t2, t3):
    r"""
    add_ncs_matrix(int imol, char const * this_chain_id, char const * target_chain_id, float m11, float m12, float m13, float m21, float m22, float m23, float m31, float m32, float m33, float t1, float t2, float t3)

    Add NCS matrix.

    Parameters
    ----------
    imol : int
    this_chain_id : str
    target_chain_id : str
    m11 : float
    m12 : float
    m13 : float
    m21 : float
    m22 : float
    m23 : float
    m31 : float
    m32 : float
    m33 : float
    t1 : float
    t2 : float
    t3 : float

    """
    return _coot.add_ncs_matrix(imol, this_chain_id, target_chain_id, m11, m12, m13, m21, m22, m23, m31, m32, m33, t1, t2, t3)

def clear_ncs_ghost_matrices(imol):
    r"""
    clear_ncs_ghost_matrices(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.clear_ncs_ghost_matrices(imol)

def add_strict_ncs_matrix(imol, this_chain_id, target_chain_id, m11, m12, m13, m21, m22, m23, m31, m32, m33, t1, t2, t3):
    r"""
    add_strict_ncs_matrix(int imol, char const * this_chain_id, char const * target_chain_id, float m11, float m12, float m13, float m21, float m22, float m23, float m31, float m32, float m33, float t1, float t2, float t3) -> int

    add an NCS matrix for strict NCS molecule representation

    for CNS strict NCS usage: expand like normal symmetry does

    Parameters
    ----------
    imol : int
    this_chain_id : str
    target_chain_id : str
    m11 : float
    m12 : float
    m13 : float
    m21 : float
    m22 : float
    m23 : float
    m31 : float
    m32 : float
    m33 : float
    t1 : float
    t2 : float
    t3 : float

    """
    return _coot.add_strict_ncs_matrix(imol, this_chain_id, target_chain_id, m11, m12, m13, m21, m22, m23, m31, m32, m33, t1, t2, t3)

def add_strict_ncs_from_mtrix_from_self_file(imol):
    r"""
    add_strict_ncs_from_mtrix_from_self_file(int imol) -> int


    Parameters
    ----------
    imol : int

    """
    return _coot.add_strict_ncs_from_mtrix_from_self_file(imol)

def show_strict_ncs_state(imol):
    r"""
    show_strict_ncs_state(int imol) -> int

    return the state of NCS ghost molecules for molecule number imol

    Parameters
    ----------
    imol : int

    """
    return _coot.show_strict_ncs_state(imol)

def set_show_strict_ncs(imol, state):
    r"""
    set_show_strict_ncs(int imol, int state)

    set display state of NCS ghost molecules for molecule number imol

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_show_strict_ncs(imol, state)

def set_ncs_homology_level(flev):
    r"""
    set_ncs_homology_level(float flev)

    At what level of homology should we say that we can't see homology for NCS calculation? (default 0.8)

    Parameters
    ----------
    flev : float

    """
    return _coot.set_ncs_homology_level(flev)

def copy_chain(imol, from_chain, to_chain):
    r"""
    copy_chain(int imol, char const * from_chain, char const * to_chain)

    Copy single NCS chain.

    Parameters
    ----------
    imol : int
    from_chain : str
    to_chain : str

    """
    return _coot.copy_chain(imol, from_chain, to_chain)

def copy_from_ncs_master_to_others(imol, chain_id):
    r"""
    copy_from_ncs_master_to_others(int imol, char const * chain_id)

    Copy chain from master to all related NCS chains.

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.copy_from_ncs_master_to_others(imol, chain_id)

def copy_residue_range_from_ncs_master_to_others(imol, master_chain_id, residue_range_start, residue_range_end):
    r"""
    copy_residue_range_from_ncs_master_to_others(int imol, char const * master_chain_id, int residue_range_start, int residue_range_end)

    Copy residue range to all related NCS chains.

    If the target residues do not exist in the peer chains, then create them.

    Parameters
    ----------
    imol : int
    master_chain_id : str
    residue_range_start : int
    residue_range_end : int

    """
    return _coot.copy_residue_range_from_ncs_master_to_others(imol, master_chain_id, residue_range_start, residue_range_end)

def copy_from_ncs_master_to_specific_other_chains_py(imol, chain_id, other_chain_id_list_py):
    r"""
    copy_from_ncs_master_to_specific_other_chains_py(int imol, char const * chain_id, PyObject * other_chain_id_list_py)

    Copy chain from master to specified other NCS chains.

    Parameters
    ----------
    imol : int
    chain_id : str
    other_chain_id_list_py : object

    """
    return _coot.copy_from_ncs_master_to_specific_other_chains_py(imol, chain_id, other_chain_id_list_py)

def ncs_master_chains_py(imol):
    r"""
    ncs_master_chains_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.ncs_master_chains_py(imol)

def copy_residue_range_from_ncs_master_to_chains_py(imol, master_chain_id, residue_range_start, residue_range_end, chain_id_list):
    r"""
    copy_residue_range_from_ncs_master_to_chains_py(int imol, char const * master_chain_id, int residue_range_start, int residue_range_end, PyObject * chain_id_list)


    Parameters
    ----------
    imol : int
    master_chain_id : str
    residue_range_start : int
    residue_range_end : int
    chain_id_list : object

    """
    return _coot.copy_residue_range_from_ncs_master_to_chains_py(imol, master_chain_id, residue_range_start, residue_range_end, chain_id_list)

def copy_from_ncs_master_to_chains_py(imol, master_chain_id, chain_id_list):
    r"""
    copy_from_ncs_master_to_chains_py(int imol, char const * master_chain_id, PyObject * chain_id_list)


    Parameters
    ----------
    imol : int
    master_chain_id : str
    chain_id_list : object

    """
    return _coot.copy_from_ncs_master_to_chains_py(imol, master_chain_id, chain_id_list)

def ncs_control_change_ncs_master_to_chain(imol, ichain):
    r"""
    ncs_control_change_ncs_master_to_chain(int imol, int ichain)

    change the NCS master chain (by number)

    Parameters
    ----------
    imol : int
    ichain : int

    """
    return _coot.ncs_control_change_ncs_master_to_chain(imol, ichain)

def ncs_control_change_ncs_master_to_chain_id(imol, chain_id):
    r"""
    ncs_control_change_ncs_master_to_chain_id(int imol, char const * chain_id)

    change the NCS master chain (by chain_id)

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.ncs_control_change_ncs_master_to_chain_id(imol, chain_id)

def ncs_control_display_chain(imol, ichain, state):
    r"""
    ncs_control_display_chain(int imol, int ichain, int state)

    display the NCS master chain

    Parameters
    ----------
    imol : int
    ichain : int
    state : int

    """
    return _coot.ncs_control_display_chain(imol, ichain, state)

def set_ncs_matrix_type(flag):
    r"""
    set_ncs_matrix_type(int flag)


    Parameters
    ----------
    flag : int

    """
    return _coot.set_ncs_matrix_type(flag)

def get_ncs_matrix_state():
    r"""get_ncs_matrix_state() -> int"""
    return _coot.get_ncs_matrix_state()

def ncs_chain_differences_py(imol, master_chain_id):
    r"""
    ncs_chain_differences_py(int imol, char const * master_chain_id) -> PyObject *


    Parameters
    ----------
    imol : int
    master_chain_id : str

    """
    return _coot.ncs_chain_differences_py(imol, master_chain_id)

def ncs_chain_ids_py(imol):
    r"""
    ncs_chain_ids_py(int imol) -> PyObject *

    Return the ncs chains id for the given molecule.

    return something like: [["A", "B"]] or [["A", "C", "E"], ["B", "D", "F"]]. The master chain goes in first.

    If imol does not have NCS ghosts, return python False.

    Parameters
    ----------
    imol : int

    """
    return _coot.ncs_chain_ids_py(imol)

def ncs_ghosts_py(imol):
    r"""
    ncs_ghosts_py(int imol) -> PyObject *

    Get the NCS ghosts description.

    False on bad imol or a list of ghosts on good imol. Can include NCS rtops if they are available, else the rtops are False

    Parameters
    ----------
    imol : int

    """
    return _coot.ncs_ghosts_py(imol)
FIND_SECSTRUC_NORMAL = _coot.FIND_SECSTRUC_NORMAL

FIND_SECSTRUC_STRICT = _coot.FIND_SECSTRUC_STRICT

FIND_SECSTRUC_HI_RES = _coot.FIND_SECSTRUC_HI_RES

FIND_SECSTRUC_LO_RES = _coot.FIND_SECSTRUC_LO_RES


def place_helix_here():
    r"""
    place_helix_here() -> int

    add a helix

    Add a helix somewhere close to this point in the map, try to fit the orientation. Add to a molecule called "Helix", create it if needed. Create another moecule called "Reverse Helix" if the helix orientation isn't completely unequivocal.

    the index of the new molecule.

    """
    return _coot.place_helix_here()

def place_strand_here(n_residues, n_sample_strands):
    r"""
    place_strand_here(int n_residues, int n_sample_strands) -> int

    add a strands

    Add a strand close to this point in the map, try to fit the orientation. Add to a molecule called "Strand", create it if needed. n_residues is the estimated number of residues in the strand.

    n_sample_strands is the number of strands from the database tested to fit into this strand density. 8 is a suggested number. 20 for a more rigourous search, but it will be slower.

    the index of the new molecule.

    Parameters
    ----------
    n_residues : int
    n_sample_strands : int

    """
    return _coot.place_strand_here(n_residues, n_sample_strands)

def set_place_helix_here_fudge_factor(ff):
    r"""
    set_place_helix_here_fudge_factor(float ff)


    Parameters
    ----------
    ff : float

    """
    return _coot.set_place_helix_here_fudge_factor(ff)

def place_strand_here_dialog():
    r"""
    place_strand_here_dialog()

    show the strand placement gui.

    Choose the python version in there, if needed. Call scripting function, display it in place, don't return a widget.

    """
    return _coot.place_strand_here_dialog()

def find_helices():
    r"""
    find_helices() -> int

    autobuild helices

    Find secondary structure in the current map. Add to a molecule called "Helices", create it if needed.

    the index of the new molecule.

    """
    return _coot.find_helices()

def find_strands():
    r"""
    find_strands() -> int

    autobuild strands

    Find secondary structure in the current map. Add to a molecule called "Strands", create it if needed.

    the index of the new molecule.

    """
    return _coot.find_strands()

def find_secondary_structure(use_helix, helix_length, helix_target, use_strand, strand_length, strand_target):
    r"""
    find_secondary_structure(short use_helix, int helix_length, int helix_target, short use_strand, int strand_length, int strand_target) -> int

    autobuild secondary structure

    Find secondary structure in the current map. Add to a molecule called "SecStruc", create it if needed.

    the index of the new molecule.

    Parameters
    ----------
    use_helix : int
    helix_length : int
    helix_target : int
    use_strand : int
    strand_length : int
    strand_target : int

    """
    return _coot.find_secondary_structure(use_helix, helix_length, helix_target, use_strand, strand_length, strand_target)

def find_secondary_structure_local(use_helix, helix_length, helix_target, use_strand, strand_length, strand_target, radius):
    r"""
    find_secondary_structure_local(short use_helix, int helix_length, int helix_target, short use_strand, int strand_length, int strand_target, float radius) -> int

    autobuild secondary structure

    Find secondary structure local to current view in the current map. Add to a molecule called "SecStruc", create it if needed.

    the index of the new molecule.

    Parameters
    ----------
    use_helix : int
    helix_length : int
    helix_target : int
    use_strand : int
    strand_length : int
    strand_target : int
    radius : float

    """
    return _coot.find_secondary_structure_local(use_helix, helix_length, helix_target, use_strand, strand_length, strand_target, radius)

def find_nucleic_acids_local(radius):
    r"""
    find_nucleic_acids_local(float radius) -> int

    autobuild nucleic acid chains

    Find secondary structure local to current view in the current map. Add to a molecule called "NuclAcid", create it if needed.

    the index of the new molecule.

    Parameters
    ----------
    radius : float

    """
    return _coot.find_nucleic_acids_local(radius)

def new_molecule_by_residue_type_selection(imol, residue_type):
    r"""
    new_molecule_by_residue_type_selection(int imol, char const * residue_type) -> int

    create a new molecule that consists of only the residue of type residue_type in molecule number imol

    the new molecule number, -1 means an error.

    Parameters
    ----------
    imol : int
    residue_type : str

    """
    return _coot.new_molecule_by_residue_type_selection(imol, residue_type)

def new_molecule_by_atom_selection(imol, atom_selection):
    r"""
    new_molecule_by_atom_selection(int imol, char const * atom_selection) -> int

    create a new molecule that consists of only the atoms specified by the mmdb atoms selection string in molecule number imol

    the new molecule number, -1 means an error.

    Parameters
    ----------
    imol : int
    atom_selection : str

    """
    return _coot.new_molecule_by_atom_selection(imol, atom_selection)

def new_molecule_by_sphere_selection(imol, x, y, z, r, allow_partial_residues):
    r"""
    new_molecule_by_sphere_selection(int imol, float x, float y, float z, float r, short allow_partial_residues) -> int

    create a new molecule that consists of only the atoms within the given radius (r) of the given position.

    the new molecule number, -1 means an error.

    Parameters
    ----------
    imol : int
    x : float
    y : float
    z : float
    r : float
    allow_partial_residues : int

    """
    return _coot.new_molecule_by_sphere_selection(imol, x, y, z, r, allow_partial_residues)

def new_molecule_by_residue_specs_py(imol, residue_spec_list_py):
    r"""
    new_molecule_by_residue_specs_py(int imol, PyObject * residue_spec_list_py) -> int

    create a new molecule that consists of only the atoms of the specified list of residues

    the new molecule number, -1 means an error.

    Parameters
    ----------
    imol : int
    residue_spec_list_py : object

    """
    return _coot.new_molecule_by_residue_specs_py(imol, residue_spec_list_py)

def set_axis_orientation_matrix(m11, m12, m13, m21, m22, m23, m31, m32, m33):
    r"""
    set_axis_orientation_matrix(float m11, float m12, float m13, float m21, float m22, float m23, float m31, float m32, float m33)


    Parameters
    ----------
    m11 : float
    m12 : float
    m13 : float
    m21 : float
    m22 : float
    m23 : float
    m31 : float
    m32 : float
    m33 : float

    """
    return _coot.set_axis_orientation_matrix(m11, m12, m13, m21, m22, m23, m31, m32, m33)

def set_axis_orientation_matrix_usage(state):
    r"""
    set_axis_orientation_matrix_usage(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_axis_orientation_matrix_usage(state)

def ideal_nucleic_acid(RNA_or_DNA, form, single_stranged_flag, sequence):
    r"""
    ideal_nucleic_acid(char const * RNA_or_DNA, char const * form, short single_stranged_flag, char const * sequence) -> int

    create a molecule of idea nucleotides

    use the given sequence (single letter code)

    RNA_or_DNA is either "RNA" or "DNA"

    form is either "A" or "B"

    the new molecule number or -1 if a problem

    Parameters
    ----------
    RNA_or_DNA : str
    form : str
    single_stranged_flag : int
    sequence : str

    """
    return _coot.ideal_nucleic_acid(RNA_or_DNA, form, single_stranged_flag, sequence)

def pucker_info_py(imol, residue_spec, do_pukka_pucker_check):
    r"""
    pucker_info_py(int imol, PyObject * residue_spec, int do_pukka_pucker_check) -> PyObject *

    return False if residue not found, otherwise [[phosphate_distance, puckered_atom, out_of_plane_distance, plane_distortion], chain_id, resno, ins_code]

    (where plane_distortion is for the other 4 atoms in the plane (I think)).

    and if there is no following residue, then the phosphate distance cannot be calculated, so the (inner) list is null (not filled).

    Parameters
    ----------
    imol : int
    residue_spec : object
    do_pukka_pucker_check : int

    """
    return _coot.pucker_info_py(imol, residue_spec, do_pukka_pucker_check)

def watson_crick_pair(imol, chain_id, resno):
    r"""
    watson_crick_pair(int imol, char const * chain_id, int resno) -> int

    Return a molecule that contains a residue that is the WC pair partner of the clicked/picked/selected residue.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int

    """
    return _coot.watson_crick_pair(imol, chain_id, resno)

def watson_crick_pair_for_residue_range(imol, chain_id, resno_start, resno_end):
    r"""
    watson_crick_pair_for_residue_range(int imol, char const * chain_id, int resno_start, int resno_end) -> int

    add base pairs for the given residue range, modify molecule imol by creating a new chain

    Parameters
    ----------
    imol : int
    chain_id : str
    resno_start : int
    resno_end : int

    """
    return _coot.watson_crick_pair_for_residue_range(imol, chain_id, resno_start, resno_end)

def setup_base_pairing(state):
    r"""
    setup_base_pairing(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.setup_base_pairing(state)

def print_sequence_chain(imol, chain_id):
    r"""
    print_sequence_chain(int imol, char const * chain_id)

    Print the sequence to the console of the given molecule.

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.print_sequence_chain(imol, chain_id)

def print_sequence_chain_general(imol, chain_id, pir_format, file_output, file_name):
    r"""
    print_sequence_chain_general(int imol, char const * chain_id, short pir_format, short file_output, char const * file_name)

    optionally write the sequence to the file for the given molecule, optionally in PIR format

    Parameters
    ----------
    imol : int
    chain_id : str
    pir_format : int
    file_output : int
    file_name : str

    """
    return _coot.print_sequence_chain_general(imol, chain_id, pir_format, file_output, file_name)

def assign_fasta_sequence(imol, chain_id_in, seq):
    r"""
    assign_fasta_sequence(int imol, char const * chain_id_in, char const * seq)

    Assign a FASTA sequence to a given chain in the molecule.

    Parameters
    ----------
    imol : int
    chain_id_in : str
    seq : str

    """
    return _coot.assign_fasta_sequence(imol, chain_id_in, seq)

def assign_pir_sequence(imol, chain_id_in, seq):
    r"""
    assign_pir_sequence(int imol, char const * chain_id_in, char const * seq)

    Assign a PIR sequence to a given chain in the molecule. If the chain of the molecule already had a chain assigned to it, then this will overwrite that old assignment with the new one.

    Parameters
    ----------
    imol : int
    chain_id_in : str
    seq : str

    """
    return _coot.assign_pir_sequence(imol, chain_id_in, seq)

def assign_sequence(imol_model, imol_map, chain_id):
    r"""
    assign_sequence(int imol_model, int imol_map, char const * chain_id)


    Parameters
    ----------
    imol_model : int
    imol_map : int
    chain_id : str

    """
    return _coot.assign_sequence(imol_model, imol_map, chain_id)

def assign_sequence_from_file(imol, file):
    r"""
    assign_sequence_from_file(int imol, char const * file)

    Assign a sequence to a given molecule from (whatever) sequence file by alignment.

    Parameters
    ----------
    imol : int
    file : str

    """
    return _coot.assign_sequence_from_file(imol, file)

def assign_sequence_from_string(imol, chain_id_in, seq):
    r"""
    assign_sequence_from_string(int imol, char const * chain_id_in, char const * seq)

    Assign a sequence to a given molecule from a simple string.

    Parameters
    ----------
    imol : int
    chain_id_in : str
    seq : str

    """
    return _coot.assign_sequence_from_string(imol, chain_id_in, seq)

def delete_all_sequences_from_molecule(imol):
    r"""
    delete_all_sequences_from_molecule(int imol)

    Delete all the sequences from a given molecule.

    Parameters
    ----------
    imol : int

    """
    return _coot.delete_all_sequences_from_molecule(imol)

def delete_sequence_by_chain_id(imol, chain_id_in):
    r"""
    delete_sequence_by_chain_id(int imol, char const * chain_id_in)

    Delete the sequence for a given chain_id from a given molecule.

    Parameters
    ----------
    imol : int
    chain_id_in : str

    """
    return _coot.delete_sequence_by_chain_id(imol, chain_id_in)

def associate_sequence_from_file(imol, file_name):
    r"""
    associate_sequence_from_file(int imol, char const * file_name)

    Associate the sequence to the molecule - to be used later for sequence assignment (.c.f assign_pir_sequence)

    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.associate_sequence_from_file(imol, file_name)

def sequence_info_py(imol):
    r"""
    sequence_info_py(int imol) -> PyObject *

    return the sequence info that has been assigned to molecule number imol. return as a list of dotted pairs [[chain-id, seq]]. To be used in constructing the cootaneer gui. Return False when no sequence has been assigned.

    Parameters
    ----------
    imol : int

    """
    return _coot.sequence_info_py(imol)

def alignment_mismatches_py(imol):
    r"""
    alignment_mismatches_py(int imol) -> PyObject *

    do a internal alignment of all the assigned sequences, return a list of mismatches that need to be made to model number imol to match the input sequence.

    Return a list of mutations deletions insetions. Return False on failure to align (e.g. not assigned sequence) and the empty list on no alignment mismatches.

    Parameters
    ----------
    imol : int

    """
    return _coot.alignment_mismatches_py(imol)

def do_surface(imol, istate):
    r"""
    do_surface(int imol, int istate)

    draw surface of molecule number imol

    if state = 1 draw the surface (normal representation goes away)

    if state = 0 don't draw surface

    Parameters
    ----------
    imol : int
    istate : int

    """
    return _coot.do_surface(imol, istate)

def molecule_is_drawn_as_surface_int(imol):
    r"""
    molecule_is_drawn_as_surface_int(int imol) -> int


    Parameters
    ----------
    imol : int

    """
    return _coot.molecule_is_drawn_as_surface_int(imol)

def do_clipped_surface_py(imol, residue_specs):
    r"""
    do_clipped_surface_py(int imol, PyObject * residue_specs)

    draw the surface of the imolth molecule clipped to the residues given by residue_specs

    Parameters
    ----------
    imol : int
    residue_specs : object

    """
    return _coot.do_clipped_surface_py(imol, residue_specs)

def make_molecular_surface(imol, selection_string):
    r"""
    make_molecular_surface(int imol, char const * selection_string)

    make molecular surface for given atom selection

    per-chain functions can be added later

    Parameters
    ----------
    imol : int
    selection_string : str

    """
    return _coot.make_molecular_surface(imol, selection_string)

def make_electrostatic_surface(imol, selection_string):
    r"""
    make_electrostatic_surface(int imol, char const * selection_string)

    make electrostatics surface for given atom selection

    per-chain functions can be added later

    Parameters
    ----------
    imol : int
    selection_string : str

    """
    return _coot.make_electrostatic_surface(imol, selection_string)

def set_electrostatic_surface_charge_range(v):
    r"""
    set_electrostatic_surface_charge_range(float v)


    Parameters
    ----------
    v : float

    """
    return _coot.set_electrostatic_surface_charge_range(v)

def get_electrostatic_surface_charge_range():
    r"""get_electrostatic_surface_charge_range() -> float"""
    return _coot.get_electrostatic_surface_charge_range()

def set_transparent_electrostatic_surface(imol, opacity):
    r"""
    set_transparent_electrostatic_surface(int imol, float opacity)

    simple on/off screendoor transparency at the moment, an opacity > 0.0 will turn on screendoor transparency (stippling).

    Parameters
    ----------
    imol : int
    opacity : float

    """
    return _coot.set_transparent_electrostatic_surface(imol, opacity)

def get_electrostatic_surface_opacity(imol):
    r"""
    get_electrostatic_surface_opacity(int imol) -> float

    return 1.0 for non transparent and 0.5 if screendoor transparency has been turned on.

    Parameters
    ----------
    imol : int

    """
    return _coot.get_electrostatic_surface_opacity(imol)

def fffear_search(imol_model, imol_map):
    r"""
    fffear_search(int imol_model, int imol_map) -> int

    fffear search model in molecule number imol_model in map number imol_map

    Parameters
    ----------
    imol_model : int
    imol_map : int

    """
    return _coot.fffear_search(imol_model, imol_map)

def set_fffear_angular_resolution(f):
    r"""
    set_fffear_angular_resolution(float f)

    set and return the fffear angular resolution in degrees

    Parameters
    ----------
    f : float

    """
    return _coot.set_fffear_angular_resolution(f)

def fffear_angular_resolution():
    r"""
    fffear_angular_resolution() -> float

    return the fffear angular resolution in degrees

    """
    return _coot.fffear_angular_resolution()

def make_socket_listener_maybe():
    r"""
    make_socket_listener_maybe()

    try to make socket listener

    """
    return _coot.make_socket_listener_maybe()

def set_coot_listener_socket_state_internal(sock_state):
    r"""
    set_coot_listener_socket_state_internal(int sock_state)


    Parameters
    ----------
    sock_state : int

    """
    return _coot.set_coot_listener_socket_state_internal(sock_state)

def set_socket_string_waiting(s):
    r"""
    set_socket_string_waiting(char const * s)

    feed the main thread a scheme script to evaluate

    Parameters
    ----------
    s : str

    """
    return _coot.set_socket_string_waiting(s)

def set_socket_python_string_waiting(s):
    r"""
    set_socket_python_string_waiting(char const * s)

    feed the main thread a python script to evaluate

    Parameters
    ----------
    s : str

    """
    return _coot.set_socket_python_string_waiting(s)

def set_remote_control_port(port_number):
    r"""
    set_remote_control_port(int port_number)


    Parameters
    ----------
    port_number : int

    """
    return _coot.set_remote_control_port(port_number)

def get_remote_control_port_number():
    r"""get_remote_control_port_number() -> int"""
    return _coot.get_remote_control_port_number()

def set_tip_of_the_day_flag(state):
    r"""
    set_tip_of_the_day_flag(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_tip_of_the_day_flag(state)

def set_display_lists_for_maps(i):
    r"""
    set_display_lists_for_maps(int i)

    Should display lists be used for maps? It may speed things up if these are turned on (or off) - depends on graphics card and drivers. Pass 1 for on, 0 for off.

    Parameters
    ----------
    i : int

    """
    return _coot.set_display_lists_for_maps(i)

def display_lists_for_maps_state():
    r"""
    display_lists_for_maps_state() -> int

    return the state of display_lists_for_maps.

    """
    return _coot.display_lists_for_maps_state()

def update_maps():
    r"""update_maps()"""
    return _coot.update_maps()

def browser_url(url):
    r"""
    browser_url(char const * url)

    try to open given url in Web browser

    Parameters
    ----------
    url : str

    """
    return _coot.browser_url(url)

def set_browser_interface(browser):
    r"""
    set_browser_interface(char const * browser)

    set command to open the web browser,

    examples are "open" or "mozilla"

    Parameters
    ----------
    browser : str

    """
    return _coot.set_browser_interface(browser)

def handle_online_coot_search_request(entry_text):
    r"""
    handle_online_coot_search_request(char const * entry_text)

    the search interface

    find words, construct a url and open it.

    Parameters
    ----------
    entry_text : str

    """
    return _coot.handle_online_coot_search_request(entry_text)

def handle_read_draw_probe_dots(dots_file):
    r"""
    handle_read_draw_probe_dots(char const * dots_file)

    pass a filename that contains molprobity's probe output in XtalView format

    Parameters
    ----------
    dots_file : str

    """
    return _coot.handle_read_draw_probe_dots(dots_file)

def handle_read_draw_probe_dots_unformatted(dots_file, imol, show_clash_gui_flag):
    r"""
    handle_read_draw_probe_dots_unformatted(char const * dots_file, int imol, int show_clash_gui_flag)

    pass a filename that contains molprobity's probe output in unformatted format

    Parameters
    ----------
    dots_file : str
    imol : int
    show_clash_gui_flag : int

    """
    return _coot.handle_read_draw_probe_dots_unformatted(dots_file, imol, show_clash_gui_flag)

def set_do_probe_dots_on_rotamers_and_chis(state):
    r"""
    set_do_probe_dots_on_rotamers_and_chis(short state)

    shall we run molprobity for on edit chi angles intermediate atoms?

    Parameters
    ----------
    state : int

    """
    return _coot.set_do_probe_dots_on_rotamers_and_chis(state)

def do_probe_dots_on_rotamers_and_chis_state():
    r"""
    do_probe_dots_on_rotamers_and_chis_state() -> short

    return the state of if run molprobity for on edit chi angles intermediate atoms?

    """
    return _coot.do_probe_dots_on_rotamers_and_chis_state()

def set_do_probe_dots_post_refine(state):
    r"""
    set_do_probe_dots_post_refine(short state)

    shall we run molprobity after a refinement has happened?

    Parameters
    ----------
    state : int

    """
    return _coot.set_do_probe_dots_post_refine(state)

def do_probe_dots_post_refine_state():
    r"""
    do_probe_dots_post_refine_state() -> short

    show the state of shall we run molprobity after a refinement has happened?

    """
    return _coot.do_probe_dots_post_refine_state()

def set_do_coot_probe_dots_during_refine(state):
    r"""
    set_do_coot_probe_dots_during_refine(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_do_coot_probe_dots_during_refine(state)

def get_do_coot_probe_dots_during_refine():
    r"""get_do_coot_probe_dots_during_refine() -> short"""
    return _coot.get_do_coot_probe_dots_during_refine()

def unmangle_hydrogen_name(pdb_hydrogen_name):
    r"""
    unmangle_hydrogen_name(char const * pdb_hydrogen_name) -> char *

    make an attempt to convert pdb hydrogen name to the name used in Coot (and the refmac dictionary, perhaps).

    Parameters
    ----------
    pdb_hydrogen_name : str

    """
    return _coot.unmangle_hydrogen_name(pdb_hydrogen_name)

def set_interactive_probe_dots_molprobity_radius(r):
    r"""
    set_interactive_probe_dots_molprobity_radius(float r)

    set the radius over which we can run interactive probe, bigger is better but slower.

    default is 6.0

    Parameters
    ----------
    r : float

    """
    return _coot.set_interactive_probe_dots_molprobity_radius(r)

def interactive_probe_dots_molprobity_radius():
    r"""
    interactive_probe_dots_molprobity_radius() -> float

    return the radius over which we can run interactive probe.

    """
    return _coot.interactive_probe_dots_molprobity_radius()

def user_mods_py(file_name):
    r"""
    user_mods_py(char const * file_name) -> PyObject *

    return the parsed user mod fields from the PDB file file_name (output by reduce most likely)

    Parameters
    ----------
    file_name : str

    """
    return _coot.user_mods_py(file_name)

def sharpen(imol, b_factor):
    r"""
    sharpen(int imol, float b_factor)

    Sharpen map imol by b_factor (note (of course) that positive numbers blur the map).

    Parameters
    ----------
    imol : int
    b_factor : float

    """
    return _coot.sharpen(imol, b_factor)

def sharpen_with_gompertz_scaling(imol, b_factor, try_gompertz, gompertz_factor):
    r"""
    sharpen_with_gompertz_scaling(int imol, float b_factor, short try_gompertz, float gompertz_factor)


    Parameters
    ----------
    imol : int
    b_factor : float
    try_gompertz : int
    gompertz_factor : float

    """
    return _coot.sharpen_with_gompertz_scaling(imol, b_factor, try_gompertz, gompertz_factor)

def set_map_sharpening_scale_limit(f):
    r"""
    set_map_sharpening_scale_limit(float f)

    set the limit of the b-factor map sharpening slider (default 30)

    Parameters
    ----------
    f : float

    """
    return _coot.set_map_sharpening_scale_limit(f)

def optimal_B_kurtosis(imol):
    r"""
    optimal_B_kurtosis(int imol) -> float


    Parameters
    ----------
    imol : int

    """
    return _coot.optimal_B_kurtosis(imol)

def drag_intermediate_atom_py(atom_spec, position):
    r"""
    drag_intermediate_atom_py(PyObject * atom_spec, PyObject * position) -> PyObject *


    Parameters
    ----------
    atom_spec : object
    position : object

    """
    return _coot.drag_intermediate_atom_py(atom_spec, position)

def add_target_position_restraint_for_intermediate_atom_py(atom_spec, position):
    r"""
    add_target_position_restraint_for_intermediate_atom_py(PyObject * atom_spec, PyObject * position) -> PyObject *

    add a target position for an intermediate atom and refine

    Parameters
    ----------
    atom_spec : object
    position : object

    """
    return _coot.add_target_position_restraint_for_intermediate_atom_py(atom_spec, position)

def add_target_position_restraints_for_intermediate_atoms_py(atom_spec_position_list):
    r"""
    add_target_position_restraints_for_intermediate_atoms_py(PyObject * atom_spec_position_list) -> PyObject *


    Parameters
    ----------
    atom_spec_position_list : object

    """
    return _coot.add_target_position_restraints_for_intermediate_atoms_py(atom_spec_position_list)

def mark_atom_as_fixed_py(imol, atom_spec, state):
    r"""
    mark_atom_as_fixed_py(int imol, PyObject * atom_spec, int state) -> PyObject *


    Parameters
    ----------
    imol : int
    atom_spec : object
    state : int

    """
    return _coot.mark_atom_as_fixed_py(imol, atom_spec, state)

def mark_multiple_atoms_as_fixed_py(imol, atom_spec_list, state):
    r"""
    mark_multiple_atoms_as_fixed_py(int imol, PyObject * atom_spec_list, int state) -> int


    Parameters
    ----------
    imol : int
    atom_spec_list : object
    state : int

    """
    return _coot.mark_multiple_atoms_as_fixed_py(imol, atom_spec_list, state)

def setup_fixed_atom_pick(ipick, is_unpick):
    r"""
    setup_fixed_atom_pick(short ipick, short is_unpick)


    Parameters
    ----------
    ipick : int
    is_unpick : int

    """
    return _coot.setup_fixed_atom_pick(ipick, is_unpick)

def clear_all_fixed_atoms(imol):
    r"""
    clear_all_fixed_atoms(int imol)

    clear all fixed atoms

    Parameters
    ----------
    imol : int

    """
    return _coot.clear_all_fixed_atoms(imol)

def clear_fixed_atoms_all():
    r"""clear_fixed_atoms_all()"""
    return _coot.clear_fixed_atoms_all()

def set_debug_atom_picking(istate):
    r"""
    set_debug_atom_picking(int istate)


    Parameters
    ----------
    istate : int

    """
    return _coot.set_debug_atom_picking(istate)

def show_partial_charge_info(imol, chain_id, resno, ins_code):
    r"""
    show_partial_charge_info(int imol, char const * chain_id, int resno, char const * ins_code)

    show the partial charges for the residue of the given specs (charges are read from the dictionary)

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.show_partial_charge_info(imol, chain_id, resno, ins_code)

def scale_cell(imol_map, fac_u, fac_v, fac_w):
    r"""
    scale_cell(int imol_map, float fac_u, float fac_v, float fac_w) -> int

    Scale the cell, for use with EM maps, where the cell needs to be adjusted. Use like: (scale-cell 2 1.012 1.012 1.012). Return error status, 1 means it worked, 0 means it did not work.

    Parameters
    ----------
    imol_map : int
    fac_u : float
    fac_v : float
    fac_w : float

    """
    return _coot.scale_cell(imol_map, fac_u, fac_v, fac_w)

def segment_map(imol_map, low_level):
    r"""
    segment_map(int imol_map, float low_level)


    Parameters
    ----------
    imol_map : int
    low_level : float

    """
    return _coot.segment_map(imol_map, low_level)

def segment_map_multi_scale(imol_map, low_level, b_factor_inc, n_rounds):
    r"""
    segment_map_multi_scale(int imol_map, float low_level, float b_factor_inc, int n_rounds)


    Parameters
    ----------
    imol_map : int
    low_level : float
    b_factor_inc : float
    n_rounds : int

    """
    return _coot.segment_map_multi_scale(imol_map, low_level, b_factor_inc, n_rounds)

def map_histogram(imol_map):
    r"""
    map_histogram(int imol_map)

    make a map histogram

    Parameters
    ----------
    imol_map : int

    """
    return _coot.map_histogram(imol_map)

def set_ignore_pseudo_zeros_for_map_stats(state):
    r"""
    set_ignore_pseudo_zeros_for_map_stats(short state)

    ignore pseudo-zeros when calculationg maps stats (default 1 = true)

    Parameters
    ----------
    state : int

    """
    return _coot.set_ignore_pseudo_zeros_for_map_stats(state)

def ccp4i_projects_py():
    r"""
    ccp4i_projects_py() -> PyObject *

    return a list of pairs of strings, the project names and the directory. Include aliases.

    """
    return _coot.ccp4i_projects_py()

def set_add_ccp4i_projects_to_file_dialogs(state):
    r"""
    set_add_ccp4i_projects_to_file_dialogs(short state)

    allow the user to not add ccp4i directories to the file choosers

    use state=0 to turn it off

    Parameters
    ----------
    state : int

    """
    return _coot.set_add_ccp4i_projects_to_file_dialogs(state)

def write_ccp4mg_picture_description(filename):
    r"""
    write_ccp4mg_picture_description(char const * filename)

    write a ccp4mg picture description file

    Parameters
    ----------
    filename : str

    """
    return _coot.write_ccp4mg_picture_description(filename)

def delete_dipole(imol, dipole_number):
    r"""
    delete_dipole(int imol, int dipole_number)


    Parameters
    ----------
    imol : int
    dipole_number : int

    """
    return _coot.delete_dipole(imol, dipole_number)

def add_dipole_py(imol, chain_id, res_no, ins_code):
    r"""
    add_dipole_py(int imol, char const * chain_id, int res_no, char const * ins_code) -> PyObject *

    generate a dipole from all atoms in the given residues.

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str

    """
    return _coot.add_dipole_py(imol, chain_id, res_no, ins_code)

def add_dipole_for_residues_py(imol, residue_specs):
    r"""
    add_dipole_for_residues_py(int imol, PyObject * residue_specs) -> PyObject *

    add a dipole given a set of residues. Return a dipole description.

    Parameters
    ----------
    imol : int
    residue_specs : object

    """
    return _coot.add_dipole_for_residues_py(imol, residue_specs)

def make_and_draw_patterson(mtz_file_name, f_col, sigf_col):
    r"""
    make_and_draw_patterson(char const * mtz_file_name, char const * f_col, char const * sigf_col) -> int

    Make a patterson molecule.

    a new molecule number or -1 on failure

    Parameters
    ----------
    mtz_file_name : str
    f_col : str
    sigf_col : str

    """
    return _coot.make_and_draw_patterson(mtz_file_name, f_col, sigf_col)

def make_and_draw_patterson_using_intensities(mtz_file_name, i_col, sigi_col):
    r"""
    make_and_draw_patterson_using_intensities(char const * mtz_file_name, char const * i_col, char const * sigi_col) -> int

    Make a patterson molecule.

    a new molecule number or -1 on failure

    Parameters
    ----------
    mtz_file_name : str
    i_col : str
    sigi_col : str

    """
    return _coot.make_and_draw_patterson_using_intensities(mtz_file_name, i_col, sigi_col)

def laplacian(imol):
    r"""
    laplacian(int imol) -> int

    Create the "Laplacian" (-ve second derivative) of the given map.

    Parameters
    ----------
    imol : int

    """
    return _coot.laplacian(imol)

def get_pkgdatadir_py():
    r"""get_pkgdatadir_py() -> PyObject *"""
    return _coot.get_pkgdatadir_py()

def do_smiles_gui():
    r"""
    do_smiles_gui()

    display the SMILES string dialog

    """
    return _coot.do_smiles_gui()

def do_tw():
    r"""do_tw()"""
    return _coot.do_tw()

def set_button_label_for_external_refinement(button_label):
    r"""
    set_button_label_for_external_refinement(char const * button_label)

    set the button label of the external Refinement program

    Parameters
    ----------
    button_label : str

    """
    return _coot.set_button_label_for_external_refinement(button_label)

def place_text(text, x, y, z, size):
    r"""
    place_text(char const * text, float x, float y, float z, int size) -> int

    Put text at x,y,z.

    a text handle size variable is currently ignored.

    Parameters
    ----------
    text : str
    x : float
    y : float
    z : float
    size : int

    """
    return _coot.place_text(text, x, y, z, size)

def remove_text(text_handle):
    r"""
    remove_text(int text_handle)

    Remove "3d" text item.

    Parameters
    ----------
    text_handle : int

    """
    return _coot.remove_text(text_handle)

def edit_text(text_handle, new_text):
    r"""
    edit_text(int text_handle, char const * new_text)


    Parameters
    ----------
    text_handle : int
    new_text : str

    """
    return _coot.edit_text(text_handle, new_text)

def text_index_near_position(x, y, z, r):
    r"""
    text_index_near_position(float x, float y, float z, float r) -> int

    return the closest text that is with r A of the given position. If no text item is close, then return -1

    Parameters
    ----------
    x : float
    y : float
    z : float
    r : float

    """
    return _coot.text_index_near_position(x, y, z, r)

def pisa_interaction(imol_1, imol_2):
    r"""
    pisa_interaction(int imol_1, int imol_2) -> int

    return the molecule number of the interacting residues. Return -1 if no new model was created. Old, not very useful.

    Parameters
    ----------
    imol_1 : int
    imol_2 : int

    """
    return _coot.pisa_interaction(imol_1, imol_2)

def handle_pisa_interfaces_py(interfaces_description_py):
    r"""
    handle_pisa_interfaces_py(PyObject * interfaces_description_py) -> PyObject *

    the scripting interface, called from parsing the PISA XML interface description

    An interface_description_scm is a record detailing the interface. A record contains the bsa, asa, and 2 molecule records. Molecule records contain list of residue records. The interface (dots) is be made from these lists of residue records. Note of course that imol_2 (or 1) can be a symmetry copy of (part of) mol_1 (or 2).

    Return the dot indexes (currently -1)

    Parameters
    ----------
    interfaces_description_py : object

    """
    return _coot.handle_pisa_interfaces_py(interfaces_description_py)

def add_pisa_interface_bond_py(imol_1, imol_2, pisa_bond_py, interface_number):
    r"""
    add_pisa_interface_bond_py(int imol_1, int imol_2, PyObject * pisa_bond_py, int interface_number)


    Parameters
    ----------
    imol_1 : int
    imol_2 : int
    pisa_bond_py : object
    interface_number : int

    """
    return _coot.add_pisa_interface_bond_py(imol_1, imol_2, pisa_bond_py, interface_number)

def pisa_clear_interfaces():
    r"""pisa_clear_interfaces()"""
    return _coot.pisa_clear_interfaces()

def fit_to_map_by_random_jiggle(imol, chain_id, resno, ins_code, n_trials, jiggle_scale_factor):
    r"""
    fit_to_map_by_random_jiggle(int imol, char const * chain_id, int resno, char const * ins_code, int n_trials, float jiggle_scale_factor) -> float

    jiggle fit to the current refinment map. return < -100 if not possible, else return the new best fit for this residue.

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    n_trials : int
    jiggle_scale_factor : float

    """
    return _coot.fit_to_map_by_random_jiggle(imol, chain_id, resno, ins_code, n_trials, jiggle_scale_factor)

def fit_molecule_to_map_by_random_jiggle(imol, n_trials, jiggle_scale_factor):
    r"""
    fit_molecule_to_map_by_random_jiggle(int imol, int n_trials, float jiggle_scale_factor) -> float

    jiggle fit the molecule to the current refinment map. return < -100 if not possible, else return the new best fit for this molecule.

    Parameters
    ----------
    imol : int
    n_trials : int
    jiggle_scale_factor : float

    """
    return _coot.fit_molecule_to_map_by_random_jiggle(imol, n_trials, jiggle_scale_factor)

def fit_molecule_to_map_by_random_jiggle_and_blur(imol, n_trials, jiggle_scale_factor, map_blur_factor):
    r"""
    fit_molecule_to_map_by_random_jiggle_and_blur(int imol, int n_trials, float jiggle_scale_factor, float map_blur_factor) -> float

    jiggle fit the molecule to the current refinment map. return < -100 if not possible, else return the new best fit for this molecule - create a map that is blurred by the given factor for fitting

    Parameters
    ----------
    imol : int
    n_trials : int
    jiggle_scale_factor : float
    map_blur_factor : float

    """
    return _coot.fit_molecule_to_map_by_random_jiggle_and_blur(imol, n_trials, jiggle_scale_factor, map_blur_factor)

def fit_chain_to_map_by_random_jiggle(imol, chain_id, n_trials, jiggle_scale_factor):
    r"""
    fit_chain_to_map_by_random_jiggle(int imol, char const * chain_id, int n_trials, float jiggle_scale_factor) -> float

    jiggle fit the chain to the current refinment map. return < -100 if not possible, else return the new best fit for this chain.

    Parameters
    ----------
    imol : int
    chain_id : str
    n_trials : int
    jiggle_scale_factor : float

    """
    return _coot.fit_chain_to_map_by_random_jiggle(imol, chain_id, n_trials, jiggle_scale_factor)

def fit_chain_to_map_by_random_jiggle_and_blur(imol, chain_id, n_trials, jiggle_scale_factor, map_blur_factor):
    r"""
    fit_chain_to_map_by_random_jiggle_and_blur(int imol, char const * chain_id, int n_trials, float jiggle_scale_factor, float map_blur_factor) -> float

    jiggle fit the chain to the current refinment map

    Use a map that is blurred by the give factor for fitting. < -100 if not possible, else return the new best fit for this chain.

    Parameters
    ----------
    imol : int
    chain_id : str
    n_trials : int
    jiggle_scale_factor : float
    map_blur_factor : float

    """
    return _coot.fit_chain_to_map_by_random_jiggle_and_blur(imol, chain_id, n_trials, jiggle_scale_factor, map_blur_factor)

def matching_compound_names_from_sbase_py(compound_name_fragment):
    r"""
    matching_compound_names_from_sbase_py(char const * compound_name_fragment) -> PyObject *

    return a list of compoundIDs of in SBase of which the given string is a substring of the compound name

    Parameters
    ----------
    compound_name_fragment : str

    """
    return _coot.matching_compound_names_from_sbase_py(compound_name_fragment)

def get_ccp4srs_monomer_and_dictionary(comp_id):
    r"""
    get_ccp4srs_monomer_and_dictionary(char const * comp_id) -> int

    return the new molecule number of the monomer.

    The monomer will have chainid "A" and residue number 1.

    Return -1 on failure to get monomer.

    Parameters
    ----------
    comp_id : str

    """
    return _coot.get_ccp4srs_monomer_and_dictionary(comp_id)

def get_sbase_monomer(comp_id):
    r"""
    get_sbase_monomer(char const * comp_id) -> int

    same as above but using old name for back-compatibility

    Parameters
    ----------
    comp_id : str

    """
    return _coot.get_sbase_monomer(comp_id)

def add_linked_residue(imol, chain_id, resno, ins_code, new_residue_comp_id, link_type, n_trials):
    r"""
    add_linked_residue(int imol, char const * chain_id, int resno, char const * ins_code, char const * new_residue_comp_id, char const * link_type, int n_trials) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    new_residue_comp_id : str
    link_type : str
    n_trials : int

    """
    return _coot.add_linked_residue(imol, chain_id, resno, ins_code, new_residue_comp_id, link_type, n_trials)

def add_linked_residue_py(imol, chain_id, resno, ins_code, new_residue_comp_id, link_type, mode):
    r"""
    add_linked_residue_py(int imol, char const * chain_id, int resno, char const * ins_code, char const * new_residue_comp_id, char const * link_type, int mode) -> PyObject *


    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    new_residue_comp_id : str
    link_type : str
    mode : int

    """
    return _coot.add_linked_residue_py(imol, chain_id, resno, ins_code, new_residue_comp_id, link_type, mode)

def set_add_linked_residue_do_fit_and_refine(state):
    r"""
    set_add_linked_residue_do_fit_and_refine(int state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_add_linked_residue_do_fit_and_refine(state)

def fle_view(imol, chain_id, res_no, ins_code, dist_max):
    r"""
    fle_view(int imol, char const * chain_id, int res_no, char const * ins_code, float dist_max)


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    dist_max : float

    """
    return _coot.fle_view(imol, chain_id, res_no, ins_code, dist_max)

def fle_view_with_rdkit(imol, chain_id, res_no, ins_code, residues_near_radius):
    r"""
    fle_view_with_rdkit(int imol, char const * chain_id, int res_no, char const * ins_code, float residues_near_radius)


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    residues_near_radius : float

    """
    return _coot.fle_view_with_rdkit(imol, chain_id, res_no, ins_code, residues_near_radius)

def fle_view_with_rdkit_to_png(imol, chain_id, res_no, ins_code, residues_near_radius, png_file_name):
    r"""
    fle_view_with_rdkit_to_png(int imol, char const * chain_id, int res_no, char const * ins_code, float residues_near_radius, char const * png_file_name)


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    residues_near_radius : float
    png_file_name : str

    """
    return _coot.fle_view_with_rdkit_to_png(imol, chain_id, res_no, ins_code, residues_near_radius, png_file_name)

def fle_view_with_rdkit_to_svg(imol, chain_id, res_no, ins_code, residues_near_radius, svg_file_name):
    r"""
    fle_view_with_rdkit_to_svg(int imol, char const * chain_id, int res_no, char const * ins_code, float residues_near_radius, char const * svg_file_name)


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    residues_near_radius : float
    svg_file_name : str

    """
    return _coot.fle_view_with_rdkit_to_svg(imol, chain_id, res_no, ins_code, residues_near_radius, svg_file_name)

def fle_view_with_rdkit_internal(imol, chain_id, res_no, ins_code, residues_near_radius, file_format, file_name):
    r"""
    fle_view_with_rdkit_internal(int imol, char const * chain_id, int res_no, char const * ins_code, float residues_near_radius, char const * file_format, char const * file_name)


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    residues_near_radius : float
    file_format : str
    file_name : str

    """
    return _coot.fle_view_with_rdkit_internal(imol, chain_id, res_no, ins_code, residues_near_radius, file_format, file_name)

def fle_view_set_water_dist_max(dist_max):
    r"""
    fle_view_set_water_dist_max(float dist_max)

    set the maximum considered distance to water

    default 3.25 A.

    Parameters
    ----------
    dist_max : float

    """
    return _coot.fle_view_set_water_dist_max(dist_max)

def fle_view_set_h_bond_dist_max(h_bond_dist_max):
    r"""
    fle_view_set_h_bond_dist_max(float h_bond_dist_max)

    set the maximum considered hydrogen bond distance

    default 3.9 A.

    Parameters
    ----------
    h_bond_dist_max : float

    """
    return _coot.fle_view_set_h_bond_dist_max(h_bond_dist_max)

def sprout_hydrogens(imol, chain_id, res_no, ins_code):
    r"""
    sprout_hydrogens(int imol, char const * chain_id, int res_no, char const * ins_code) -> int

    Add hydrogens to specificied residue.

    success status. use RDKit for enterprise version

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str

    """
    return _coot.sprout_hydrogens(imol, chain_id, res_no, ins_code)

def lsq_improve(imol_ref, ref_selection, imol_moving, moving_selection, n_res, dist_crit):
    r"""
    lsq_improve(int imol_ref, char const * ref_selection, int imol_moving, char const * moving_selection, int n_res, float dist_crit)

    an slightly-modified implementation of the "lsq_improve" algorithm of Kleywegt and Jones (1997).

    Note that if a residue selection is specified in the residue selection(s), then the first residue of the given range must exist in the molecule (if not, then mmdb will not select any atoms from that molecule).

    Kleywegt and Jones set n_res to 4 and dist_crit to 6.0.

    Parameters
    ----------
    imol_ref : int
    ref_selection : str
    imol_moving : int
    moving_selection : str
    n_res : int
    dist_crit : float

    """
    return _coot.lsq_improve(imol_ref, ref_selection, imol_moving, moving_selection, n_res, dist_crit)

def toolbar_multi_refine_stop():
    r"""toolbar_multi_refine_stop()"""
    return _coot.toolbar_multi_refine_stop()

def toolbar_multi_refine_continue():
    r"""toolbar_multi_refine_continue()"""
    return _coot.toolbar_multi_refine_continue()

def toolbar_multi_refine_cancel():
    r"""toolbar_multi_refine_cancel()"""
    return _coot.toolbar_multi_refine_cancel()

def set_visible_toolbar_multi_refine_stop_button(state):
    r"""
    set_visible_toolbar_multi_refine_stop_button(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_visible_toolbar_multi_refine_stop_button(state)

def set_visible_toolbar_multi_refine_continue_button(state):
    r"""
    set_visible_toolbar_multi_refine_continue_button(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_visible_toolbar_multi_refine_continue_button(state)

def set_visible_toolbar_multi_refine_cancel_button(state):
    r"""
    set_visible_toolbar_multi_refine_cancel_button(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_visible_toolbar_multi_refine_cancel_button(state)

def toolbar_multi_refine_button_set_sensitive(button_type, state):
    r"""
    toolbar_multi_refine_button_set_sensitive(char const * button_type, short state)


    Parameters
    ----------
    button_type : str
    state : int

    """
    return _coot.toolbar_multi_refine_button_set_sensitive(button_type, state)

def load_tutorial_model_and_data():
    r"""
    load_tutorial_model_and_data()

    load tutorial model and data

    Loads an example dataset - the sample is an RNase structure (model and maps) and is used for learning and testing.

    This is the standard Coot tutorial dataset for practicing model building and validation.

    """
    return _coot.load_tutorial_model_and_data()

def single_model_view_model_number(imol, imodel):
    r"""
    single_model_view_model_number(int imol, int imodel)

    put molecule number imol to display only model number imodel

    Parameters
    ----------
    imol : int
    imodel : int

    """
    return _coot.single_model_view_model_number(imol, imodel)

def single_model_view_this_model_number(imol):
    r"""
    single_model_view_this_model_number(int imol) -> int

    the current model number being displayed

    return 0 on non-multimodel-molecule.

    Parameters
    ----------
    imol : int

    """
    return _coot.single_model_view_this_model_number(imol)

def single_model_view_next_model_number(imol):
    r"""
    single_model_view_next_model_number(int imol) -> int

    change the representation to the next model number to be displayed

    return 0 on non-multimodel-molecule.

    Parameters
    ----------
    imol : int

    """
    return _coot.single_model_view_next_model_number(imol)

def single_model_view_prev_model_number(imol):
    r"""
    single_model_view_prev_model_number(int imol) -> int

    change the representation to the previous model number to be displayed

    return 0 on non-multimodel-molecule.

    Parameters
    ----------
    imol : int

    """
    return _coot.single_model_view_prev_model_number(imol)

def run_update_self_maybe():
    r"""run_update_self_maybe()"""
    return _coot.run_update_self_maybe()

def show_go_to_residue_keyboarding_mode_window():
    r"""show_go_to_residue_keyboarding_mode_window()"""
    return _coot.show_go_to_residue_keyboarding_mode_window()

def handle_go_to_residue_keyboarding_mode(text):
    r"""
    handle_go_to_residue_keyboarding_mode(char const * text)


    Parameters
    ----------
    text : str

    """
    return _coot.handle_go_to_residue_keyboarding_mode(text)

def set_show_graphics_ligand_view(state):
    r"""
    set_show_graphics_ligand_view(int state)

    set the graphics ligand view state

    (default is 1 (on)).

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_graphics_ligand_view(state)

def fetch_and_superpose_alphafold_models_using_active_molecule():
    r"""fetch_and_superpose_alphafold_models_using_active_molecule()"""
    return _coot.fetch_and_superpose_alphafold_models_using_active_molecule()

def start_ligand_builder_gui():
    r"""
    start_ligand_builder_gui()

    display the ligand builder dialog

    """
    return _coot.start_ligand_builder_gui()

def all_molecule_rotamer_score_py(imol):
    r"""
    all_molecule_rotamer_score_py(int imol) -> PyObject *

    Compute rotamer score for an entire molecule and return result as a Python object.

    This wrapper computes the rotamer score information for molecule number imol and returns a Python list containing the numeric score and the number of rotamer-bearing residues.

    Parameters
    ----------

    Return value
    ------------
    Returns a NEW reference to a Python object. Two possible outcomes:
    - Success: a Python list of length 2 (PyList), with elements: 0 : float — overall rotamer score (PyFloat) 1 : int — number of rotamer residues considered (PyLong)
    - Failure / invalid model index: Py_False (Python False). The implementation INCREFs Py_False before returning, so the caller receives a new reference in the failure case as well.

    Reference counting
    ------------------
    The returned PyObject* is a new reference. The caller is responsible for DECREFing it when finished.

    Notes
    -----
    - Callers should detect the failure case by testing with PyBool_Check (Py_False).
    - Ensure the Python GIL is held when calling this function from non-Python threads.

    """
    return _coot.all_molecule_rotamer_score_py(imol)

def all_molecule_ramachandran_score_py(imol):
    r"""
    all_molecule_ramachandran_score_py(int imol) -> PyObject *

    Compute overall and per-residue Ramachandran statistics for a molecule and return the results as a Python object.

    This wrapper gathers the Ramachandran score information computed for molecule number imol and returns a Python list with six elements describing the overall scores and per-residue details.

    Parameters
    ----------

    Return value
    ------------
    a NEW reference to a Python object. Two possible outcomes:
    - Success: a Python list of length 6 (PyList), with elements: 0 : float — overall Ramachandran score (PyFloat) 1 : int — number of residues considered (PyLong) 2 : float — Ramachandran score restricted to non-secondary-structure residues (PyFloat) 3 : int — number of residues used for the non-secondary-structure score (PyLong) 4 : int — number of zero-score residues (PyLong) 5 : list — info_by_residue: a list with one entry per residue (length == number of residues). Each entry is either:  a list of four items: [ phi_psi_list, residue_spec_py, residue_score, res_names_list ]  phi_psi_list: list of two floats [phi, psi] residue_spec_py: Python representation of the residue spec (see residue_spec_to_py) residue_score: float (PyFloat) res_names_list: list of three strings [prev_res_name, this_res_name, next_res_name] the integer -1 as a placeholder if per-residue info could not be computed for that index.
      - a list of four items: [ phi_psi_list, residue_spec_py, residue_score, res_names_list ]  phi_psi_list: list of two floats [phi, psi] residue_spec_py: Python representation of the residue spec (see residue_spec_to_py) residue_score: float (PyFloat) res_names_list: list of three strings [prev_res_name, this_res_name, next_res_name]
        - phi_psi_list: list of two floats [phi, psi]
        - residue_spec_py: Python representation of the residue spec (see residue_spec_to_py)
        - residue_score: float (PyFloat)
        - res_names_list: list of three strings [prev_res_name, this_res_name, next_res_name]
      - the integer -1 as a placeholder if per-residue info could not be computed for that index.
      - phi_psi_list: list of two floats [phi, psi]
      - residue_spec_py: Python representation of the residue spec (see residue_spec_to_py)
      - residue_score: float (PyFloat)
      - res_names_list: list of three strings [prev_res_name, this_res_name, next_res_name]
    - Failure / invalid model index: Py_False (Python False). The implementation INCREFs Py_False before returning, so the caller receives a new reference in this case as well.

    Reference counting
    ------------------
    The returned PyObject* is a new reference. The caller is responsible for DECREFing it when finished.

    Notes
    -----
    - Callers should check the return with PyBool_Check to detect the failure case (Py_False).
    - Some per-residue entries may be -1 (an integer) if residue data was unavailable.
    - The function must be called with appropriate GIL handling if invoked from non-Python threads.

    """
    return _coot.all_molecule_ramachandran_score_py(imol)

def all_molecule_ramachandran_region_py(imol):
    r"""
    all_molecule_ramachandran_region_py(int imol) -> PyObject *

    Return the Ramachandran region annotation for a molecule as a Python list.

    This wrapper returns per-residue region information computed for molecule imol . It queries the internal Ramachandran scoring machinery and returns a Python list of (residue_spec, region_int) pairs for residues that lie in the computed region.

    Parameters
    ----------

    Return value
    ------------
    Returns a NEW reference to a Python object. There are two possible outcomes:
    - Success: a Python list (PyList) of length N > 0, where each element is a 2-tuple: ( residue_spec_py, region_code )  residue_spec_py: Python representation of the residue spec (as produced by residue_spec_to_py). region_code: integer (PyLong) — the integer label associated with that residue's Ramachandran region (as provided by the underlying rama score/region computation).
      - residue_spec_py: Python representation of the residue spec (as produced by residue_spec_to_py).
      - region_code: integer (PyLong) — the integer label associated with that residue's Ramachandran region (as provided by the underlying rama score/region computation).
    - Failure / no region entries / invalid model index: Py_False (Python False). The implementation INCREFs Py_False before returning, so the caller receives a new reference in this case as well.

    Reference counting
    ------------------
    The returned PyObject* is a new reference. The caller is responsible for DECREFing it when finished.

    Notes
    -----
    - Callers should detect the failure/empty case by testing with PyBool_Check (Py_False).
    - The exact meaning of the integer region_code is defined by the internal Ramachandran scoring code; consult the implementation or documentation for interpretation of region codes.
    - Ensure the Python GIL is held when calling this function from non-Python threads.

    """
    return _coot.all_molecule_ramachandran_region_py(imol)

def globularize(imol):
    r"""
    globularize(int imol)

    globularize the molecule.

    This is not guaranteed to generate the correct biological entity, but will bring together molecules (chains/domains) that are dispersed throughout the unit cell.

      imol  the molecule index.

    Parameters
    ----------
    imol : int
        the molecule index.

    """
    return _coot.globularize(imol)

def user_defined_click_py(n_clicks, func):
    r"""
    user_defined_click_py(int n_clicks, PyObject * func)


    Parameters
    ----------
    n_clicks : int
    func : object

    """
    return _coot.user_defined_click_py(n_clicks, func)

def preferences():
    r"""preferences()"""
    return _coot.preferences()

def show_preferences():
    r"""show_preferences()"""
    return _coot.show_preferences()

def clear_preferences():
    r"""clear_preferences()"""
    return _coot.clear_preferences()

def set_mark_cis_peptides_as_bad(istate):
    r"""set_mark_cis_peptides_as_bad(int istate)"""
    return _coot.set_mark_cis_peptides_as_bad(istate)

def show_mark_cis_peptides_as_bad_state():
    r"""show_mark_cis_peptides_as_bad_state() -> int"""
    return _coot.show_mark_cis_peptides_as_bad_state()

def update_preference_gui():
    r"""update_preference_gui()"""
    return _coot.update_preference_gui()

def make_preferences_internal():
    r"""make_preferences_internal()"""
    return _coot.make_preferences_internal()

def make_preferences_internal_default():
    r"""make_preferences_internal_default()"""
    return _coot.make_preferences_internal_default()

def reset_preferences():
    r"""reset_preferences()"""
    return _coot.reset_preferences()

def save_preferences():
    r"""save_preferences()"""
    return _coot.save_preferences()

def preferences_internal_change_value_int(preference_type, ivalue):
    r"""preferences_internal_change_value_int(int preference_type, int ivalue)"""
    return _coot.preferences_internal_change_value_int(preference_type, ivalue)

def preferences_internal_change_value_int2(preference_type, ivalue1, ivalue2):
    r"""preferences_internal_change_value_int2(int preference_type, int ivalue1, int ivalue2)"""
    return _coot.preferences_internal_change_value_int2(preference_type, ivalue1, ivalue2)

def preferences_internal_change_value_float(preference_type, fvalue):
    r"""preferences_internal_change_value_float(int preference_type, float fvalue)"""
    return _coot.preferences_internal_change_value_float(preference_type, fvalue)

def preferences_internal_change_value_float3(preference_type, fvalue1, fvalue2, fvalue3):
    r"""preferences_internal_change_value_float3(int preference_type, float fvalue1, float fvalue2, float fvalue3)"""
    return _coot.preferences_internal_change_value_float3(preference_type, fvalue1, fvalue2, fvalue3)

def show_model_toolbar_icon(pos):
    r"""show_model_toolbar_icon(int pos)"""
    return _coot.show_model_toolbar_icon(pos)

def hide_model_toolbar_icon(pos):
    r"""hide_model_toolbar_icon(int pos)"""
    return _coot.hide_model_toolbar_icon(pos)

def show_main_toolbar_icon(pos):
    r"""show_main_toolbar_icon(int pos)"""
    return _coot.show_main_toolbar_icon(pos)

def hide_main_toolbar_icon(pos):
    r"""hide_main_toolbar_icon(int pos)"""
    return _coot.hide_main_toolbar_icon(pos)

def preferences_internal_font_own_colour_flag():
    r"""preferences_internal_font_own_colour_flag() -> int"""
    return _coot.preferences_internal_font_own_colour_flag()

def add_initial_position_restraints(imol, residue_specs, weight):
    r"""add_initial_position_restraints(int imol, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & residue_specs, double weight)"""
    return _coot.add_initial_position_restraints(imol, residue_specs, weight)

def remove_initial_position_restraints(imol, residue_specs):
    r"""remove_initial_position_restraints(int imol, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & residue_specs)"""
    return _coot.remove_initial_position_restraints(imol, residue_specs)

def use_unimodal_ring_torsion_restraints(res_name):
    r"""use_unimodal_ring_torsion_restraints(std::string const & res_name)"""
    return _coot.use_unimodal_ring_torsion_restraints(res_name)

def use_unimodal_ring_torsion_restraints_for_residue(res_name, torsions_info_list):
    r"""use_unimodal_ring_torsion_restraints_for_residue(std::string const & res_name, PyObject * torsions_info_list)"""
    return _coot.use_unimodal_ring_torsion_restraints_for_residue(res_name, torsions_info_list)

def set_refinement_geman_mcclure_alpha(alpha):
    r"""set_refinement_geman_mcclure_alpha(float alpha)"""
    return _coot.set_refinement_geman_mcclure_alpha(alpha)

def get_refinement_geman_mcclure_alpha():
    r"""get_refinement_geman_mcclure_alpha() -> float"""
    return _coot.get_refinement_geman_mcclure_alpha()

def set_refinement_lennard_jones_epsilon(epsilon):
    r"""set_refinement_lennard_jones_epsilon(float epsilon)"""
    return _coot.set_refinement_lennard_jones_epsilon(epsilon)

def set_log_cosh_target_distance_scale_factor(sf):
    r"""set_log_cosh_target_distance_scale_factor(float sf)"""
    return _coot.set_log_cosh_target_distance_scale_factor(sf)

def crankshaft_peptide_rotation_optimization_py(imol, residue_spec_py):
    r"""crankshaft_peptide_rotation_optimization_py(int imol, PyObject * residue_spec_py)"""
    return _coot.crankshaft_peptide_rotation_optimization_py(imol, residue_spec_py)

def convert_dictionary_planes_to_improper_dihedrals():
    r"""convert_dictionary_planes_to_improper_dihedrals()"""
    return _coot.convert_dictionary_planes_to_improper_dihedrals()

def make_ncs_maps(imol_model, imol_map):
    r"""make_ncs_maps(int imol_model, int imol_map) -> IntVector"""
    return _coot.make_ncs_maps(imol_model, imol_map)

def add_molecular_representation_py(imol, atom_selection_py, ColorScheme_py, style_py, secondary_structure_usage_type):
    r"""
    add_molecular_representation_py(int imol, PyObject * atom_selection_py, PyObject * ColorScheme_py, PyObject * style_py, int secondary_structure_usage_type) -> int

    add a molecular representation, e.g. Ribbon diagram or surface

    e.g. 0, "//C", "RampChainsScheme", "Ribbon"

      imol  the molecule index   atom_selection_py  the atom-selection in mmdb-style CID   ColorScheme_py  colour-scheme-name, e.g. "colorRampChainsScheme" or "Chain" or "colorBySecondaryScheme"   style_py  the representation style, e.g. "Ribbon" or "MolecularSurface" -1 on failure, the representation index on success

    Parameters
    ----------
    imol : int
        the molecule index
    atom_selection_py : object
        the atom-selection in mmdb-style CID
    ColorScheme_py : object
        colour-scheme-name, e.g. "colorRampChainsScheme" or "Chain" or "colorBySecondaryScheme"
    style_py : object
        the representation style, e.g. "Ribbon" or "MolecularSurface"
    secondary_structure_usage_type : int

    """
    return _coot.add_molecular_representation_py(imol, atom_selection_py, ColorScheme_py, style_py, secondary_structure_usage_type)

def add_ribbon_representation_with_user_defined_colours(imol, name, secondary_structure_usage_type):
    r"""
    add_ribbon_representation_with_user_defined_colours(int imol, std::string const & name, int secondary_structure_usage_type) -> int

    add ribbon representation with user-defined colours

    not dependent on scm or python

      imol  the molecule index   name  the name to appear in the display control widget will be -1 - the return value currently has no meaning.

    Parameters
    ----------
    imol : int
        the molecule index
    name : str
        the name to appear in the display control widget
    secondary_structure_usage_type : int

    """
    return _coot.add_ribbon_representation_with_user_defined_colours(imol, name, secondary_structure_usage_type)

def remove_molecular_representation(imol, rep_no):
    r"""
    remove_molecular_representation(int imol, int rep_no)

    remove molecular representation

      imol  the molecule index   rep_no  the representation-index

    Parameters
    ----------
    imol : int
        the molecule index
    rep_no : int
        the representation-index

    """
    return _coot.remove_molecular_representation(imol, rep_no)
class alias_path_t(object):
    r"""Proxy of C++ coot::alias_path_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    index = property(_coot.alias_path_t_index_get, _coot.alias_path_t_index_set, doc=r"""index : int""")
    s = property(_coot.alias_path_t_s_get, _coot.alias_path_t_s_set, doc=r"""s : std::string""")
    flag = property(_coot.alias_path_t_flag_get, _coot.alias_path_t_flag_set, doc=r"""flag : bool""")

    def __init__(self, index_in, s_in, flag_in):
        r"""__init__(alias_path_t self, int index_in, std::string const & s_in, bool flag_in) -> alias_path_t"""
        _coot.alias_path_t_swiginit(self, _coot.new_alias_path_t(index_in, s_in, flag_in))
    __swig_destroy__ = _coot.delete_alias_path_t

# Register alias_path_t in _coot:
_coot.alias_path_t_swigregister(alias_path_t)
class pisa_interface_bond_info_t(object):
    r"""Proxy of C++ coot::pisa_interface_bond_info_t class."""

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

    def __init__(self):
        r"""__init__(pisa_interface_bond_info_t self) -> pisa_interface_bond_info_t"""
        _coot.pisa_interface_bond_info_t_swiginit(self, _coot.new_pisa_interface_bond_info_t())
    n_h_bonds = property(_coot.pisa_interface_bond_info_t_n_h_bonds_get, _coot.pisa_interface_bond_info_t_n_h_bonds_set, doc=r"""n_h_bonds : int""")
    n_salt_bridges = property(_coot.pisa_interface_bond_info_t_n_salt_bridges_get, _coot.pisa_interface_bond_info_t_n_salt_bridges_set, doc=r"""n_salt_bridges : int""")
    n_cov_bonds = property(_coot.pisa_interface_bond_info_t_n_cov_bonds_get, _coot.pisa_interface_bond_info_t_n_cov_bonds_set, doc=r"""n_cov_bonds : int""")
    n_ss_bonds = property(_coot.pisa_interface_bond_info_t_n_ss_bonds_get, _coot.pisa_interface_bond_info_t_n_ss_bonds_set, doc=r"""n_ss_bonds : int""")
    __swig_destroy__ = _coot.delete_pisa_interface_bond_info_t

# Register pisa_interface_bond_info_t in _coot:
_coot.pisa_interface_bond_info_t_swigregister(pisa_interface_bond_info_t)

def get_pisa_interface_bond_info_py(bonds_info_py):
    r"""get_pisa_interface_bond_info_py(PyObject * bonds_info_py) -> pisa_interface_bond_info_t"""
    return _coot.get_pisa_interface_bond_info_py(bonds_info_py)

def git_commit():
    r"""
    git_commit() -> std::string

    Get the Git commit hash of the Coot build.

    Returns the Git commit identifier for the version of Coot currently running. Useful for bug reports and version tracking.

    String containing the Git commit hash (e.g., "a3f2c1d") Example: std::string commit = git_commit (); std::cout << "Coot version: commit " << commit << std::endl;

    """
    return _coot.git_commit()

def filtered_by_glob(pre_directory, data_type):
    r"""
    filtered_by_glob(std::string const & pre_directory, int data_type) -> vector_string

    Filter files by glob pattern.

    Returns a list of files in the specified directory that match the given glob pattern, useful for file selection dialogs.

      pre_directory  Directory path to search   data_type  Type of data to filter (specific values TBD) Vector of filename strings matching the criteria

    Parameters
    ----------
    pre_directory : str
        Directory path to search
    data_type : int
        Type of data to filter (specific values TBD)

    """
    return _coot.filtered_by_glob(pre_directory, data_type)

def string_member(search, list):
    r"""
    string_member(std::string const & search, vector_string list) -> short

    Check if a string exists in a vector.

    Searches for an exact match of the search string in the provided list.

      search  String to search for   list  Vector of strings to search within 1 if found, 0 if not found Example: std::vector<std::string> chains = { "A" , "B" , "C" }; if ( string_member ( "B" , chains)) { std::cout << "Chain B exists" << std::endl; }

    Parameters
    ----------
    search : str
        String to search for
    list : list
        Vector of strings to search within

    """
    return _coot.string_member(search, list)

def compare_strings(a, b):
    r"""
    compare_strings(std::string const & a, std::string const & b) -> bool

    Compare two strings.

    Performs string comparison for sorting purposes.

      a  First string   b  Second string true if a < b in lexicographic order Useful as a comparator function for std::sort

    Parameters
    ----------
    a : str
        First string
    b : str
        Second string

    """
    return _coot.compare_strings(a, b)

def add_cablam_markup(imol, cablam_file_name):
    r"""
    add_cablam_markup(int imol, std::string const & cablam_file_name) -> std::vector< std::pair< coot::residue_spec_t,double >,std::allocator< std::pair< coot::residue_spec_t,double > > >


    Parameters
    ----------
    imol : int
    cablam_file_name : str

    """
    return _coot.add_cablam_markup(imol, cablam_file_name)

def add_cablam_markup_py(imol, cablam_log_file_name):
    r"""
    add_cablam_markup_py(int imol, std::string const & cablam_log_file_name) -> PyObject *

    Add CaBLAM validation markup (Python interface)

    Reads CaBLAM output and adds colored markup to the model showing backbone validation results.

      imol  Model molecule number   cablam_log_file_name  Path to CaBLAM output file PyObject* - List of tuples [(residue_spec, score), ...] where residue_spec is [chain_id, resno, ins_code] and score is the CaBLAM validation score Example usage: # Read CaBLAM results and add markup results = add_cablam_markup_py (1, "cablam_results.txt" ) # Find worst CaBLAM outliers outliers = [r for r in results if r[1] < 0.5] print(f "Found {len(outliers)} CaBLAM outliers" ) for (chain, resno, ins), score in outliers: print(f " {chain} {resno}: score = {score:.3f}" )

    Parameters
    ----------
    imol : int
        Model molecule number
    cablam_log_file_name : str
        Path to CaBLAM output file

    """
    return _coot.add_cablam_markup_py(imol, cablam_log_file_name)

def print_key_bindings():
    r"""print_key_bindings()"""
    return _coot.print_key_bindings()

def set_rotation_centre(*args):
    r"""
    set_rotation_centre(float x, float y, float z)
    set_rotation_centre(clipper::Coord_orth const & pos)

    set the rotation centre

    Parameters
    ----------
    x : float
    y : float
    z : float

    """
    return _coot.set_rotation_centre(*args)

def goto_next_atom_maybe_py(chain_id, resno, ins_code, atom_name):
    r"""
    goto_next_atom_maybe_py(char const * chain_id, int resno, char const * ins_code, char const * atom_name) -> PyObject *

    Navigate to the next atom in the sequence (Python interface)

    Given the current atom position, return the specification for the next atom in the sequence. Useful for iterating through atoms programmatically.

      chain_id  Current chain identifier   resno  Current residue number   ins_code  Current insertion code (use "" if none)   atom_name  Current atom name PyObject* - List [chain_id, resno, ins_code, atom_name] for next atom Example usage: # Navigate forward through atoms current = [ "A" , 42, "" , "CA" ] next_atom = goto_next_atom_maybe_py (*current) print(f "Next atom: {next_atom}" )

    Parameters
    ----------
    chain_id : str
        Current chain identifier
    resno : int
        Current residue number
    ins_code : str
        Current insertion code (use "" if none)
    atom_name : str
        Current atom name

    """
    return _coot.goto_next_atom_maybe_py(chain_id, resno, ins_code, atom_name)

def goto_prev_atom_maybe_py(chain_id, resno, ins_code, atom_name):
    r"""
    goto_prev_atom_maybe_py(char const * chain_id, int resno, char const * ins_code, char const * atom_name) -> PyObject *

    Navigate to the previous atom in the sequence (Python interface)

    Given the current atom position, return the specification for the previous atom. Useful for iterating backwards through atoms programmatically.

      chain_id  Current chain identifier   resno  Current residue number   ins_code  Current insertion code (use "" if none)   atom_name  Current atom name PyObject* - List [chain_id, resno, ins_code, atom_name] for previous atom

    Parameters
    ----------
    chain_id : str
        Current chain identifier
    resno : int
        Current residue number
    ins_code : str
        Current insertion code (use "" if none)
    atom_name : str
        Current atom name

    """
    return _coot.goto_prev_atom_maybe_py(chain_id, resno, ins_code, atom_name)

def set_go_to_atom_from_spec(atom_spec):
    r"""
    set_go_to_atom_from_spec(atom_spec_t atom_spec) -> int


    Parameters
    ----------
    atom_spec : atom_spec

    """
    return _coot.set_go_to_atom_from_spec(atom_spec)

def set_go_to_atom_from_res_spec(spec):
    r"""
    set_go_to_atom_from_res_spec(residue_spec_t spec) -> int


    Parameters
    ----------
    spec : residue_spec

    """
    return _coot.set_go_to_atom_from_res_spec(spec)

def set_go_to_atom_from_res_spec_py(residue_spec):
    r"""
    set_go_to_atom_from_res_spec_py(PyObject * residue_spec) -> int


    Parameters
    ----------
    residue_spec : object

    """
    return _coot.set_go_to_atom_from_res_spec_py(residue_spec)

def set_go_to_atom_from_atom_spec_py(residue_spec):
    r"""
    set_go_to_atom_from_atom_spec_py(PyObject * residue_spec) -> int


    Parameters
    ----------
    residue_spec : object

    """
    return _coot.set_go_to_atom_from_atom_spec_py(residue_spec)

def active_atom_spec():
    r"""active_atom_spec() -> std::pair< bool,std::pair< int,coot::atom_spec_t > >"""
    return _coot.active_atom_spec()

def active_atom_spec_py():
    r"""
    active_atom_spec_py() -> PyObject *

    Get the currently active atom (Python interface)

    Returns the atom specification for the atom at the current rotation center.

    PyObject* - Tuple (found, (molecule_number, atom_spec)) where:  found: Boolean indicating if an atom exists at center molecule_number: Integer molecule ID atom_spec: List [chain_id, resno, ins_code, atom_name, alt_conf] Example usage: found, (imol, atom_spec) = active_atom_spec_py () if found: chain, resno, ins, atom, alt = atom_spec print(f "Active: {chain} {resno} {atom} in molecule {imol}" ) else : print( "No active atom" )

    """
    return _coot.active_atom_spec_py()

def get_symmetry_py(imol):
    r"""
    get_symmetry_py(int imol) -> PyObject *

    return the symmetry of the imolth molecule

    Return as a list of strings the symmetry operators of the given molecule. If imol is a not a valid molecule, return an empty list.* / a python object as a list (or some other python container)

    Parameters
    ----------
    imol : int

    """
    return _coot.get_symmetry_py(imol)

def clashes_with_symmetry(imol, chain_id, res_no, ins_code, clash_dist):
    r"""
    clashes_with_symmetry(int imol, char const * chain_id, int res_no, char const * ins_code, float clash_dist) -> int

    return 1 if this residue clashes with the symmetry-related atoms of the same molecule.

      imol  the molecule index   chain_id  the chain id   res_no  the residue number   ins_code  the insertion code   clash_dist  the clash distance cut-off - typically 3.6 Angstroms 0 means that it did not clash, -1 means that the residue or molecule could not be found or that there was no cell and symmetry.

    Parameters
    ----------
    imol : int
        the molecule index
    chain_id : str
        the chain id
    res_no : int
        the residue number
    ins_code : str
        the insertion code
    clash_dist : float
        the clash distance cut-off - typically 3.6 Angstroms

    """
    return _coot.clashes_with_symmetry(imol, chain_id, res_no, ins_code, clash_dist)

def add_molecular_symmetry(imol, r_00, r_01, r_02, r_10, r_11, r_12, r_20, r_21, r_22, about_origin_x, about_origin_y, about_origin_z):
    r"""
    add_molecular_symmetry(int imol, double r_00, double r_01, double r_02, double r_10, double r_11, double r_12, double r_20, double r_21, double r_22, double about_origin_x, double about_origin_y, double about_origin_z)

    Add molecular symmetry

    You will need to know how to expand your point group molecular symmetry to a set of 3x3 matrices. Call this function for every matrix.   imol  the molecule index

    Parameters
    ----------
    imol : int
        the molecule index
    r_00 : float
    r_01 : float
    r_02 : float
    r_10 : float
    r_11 : float
    r_12 : float
    r_20 : float
    r_21 : float
    r_22 : float
    about_origin_x : float
    about_origin_y : float
    about_origin_z : float

    """
    return _coot.add_molecular_symmetry(imol, r_00, r_01, r_02, r_10, r_11, r_12, r_20, r_21, r_22, about_origin_x, about_origin_y, about_origin_z)

def add_molecular_symmetry_from_mtrix_from_file(imol, file_name):
    r"""
    add_molecular_symmetry_from_mtrix_from_file(int imol, std::string const & file_name) -> int

    Add molecular symmetry from MTRIX records from file

    Often molecular symmetry is descibed using MTRIX card in a PDB file header. Use this function to extract and apply such molecular symmmetry

    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.add_molecular_symmetry_from_mtrix_from_file(imol, file_name)

def add_molecular_symmetry_from_mtrix_from_self_file(imol):
    r"""
    add_molecular_symmetry_from_mtrix_from_self_file(int imol) -> int

    Add molecular symmetry

    This is a convenience function for the above - where you don't need to specify the PDB file name.

      imol  the molecule index 1 on success and 0 on failure

    Parameters
    ----------
    imol : int
        the molecule index

    """
    return _coot.add_molecular_symmetry_from_mtrix_from_self_file(imol)

def auto_read_make_and_draw_maps(filename):
    r"""
    auto_read_make_and_draw_maps(char const * filename) -> IntVector

    read MTZ file filename and from it try to make maps

    Useful for reading the output of refmac. The default labels (FWT/PHWT and DELFWT/PHDELFWT) can be changed using ...[something]

    a list of molecule numbers for the new maps

    Parameters
    ----------
    filename : str

    """
    return _coot.auto_read_make_and_draw_maps(filename)

def auto_read_make_and_draw_maps_from_mtz(file_name):
    r"""
    auto_read_make_and_draw_maps_from_mtz(std::string const & file_name) -> IntVector

    set the flag to do a difference map (too) on auto-read MTZ

    Parameters
    ----------
    file_name : str

    """
    return _coot.auto_read_make_and_draw_maps_from_mtz(file_name)

def auto_read_make_and_draw_maps_from_cns(file_name):
    r"""
    auto_read_make_and_draw_maps_from_cns(std::string const & file_name) -> IntVector


    Parameters
    ----------
    file_name : str

    """
    return _coot.auto_read_make_and_draw_maps_from_cns(file_name)

def valid_labels(mtz_file_name, f_col, phi_col, weight_col, use_weights_flag):
    r"""
    valid_labels(std::string const & mtz_file_name, std::string const & f_col, std::string const & phi_col, std::string const & weight_col, bool use_weights_flag) -> int

    does the mtz file have the columms that we want it to have?

      mtz_file_name  the mtz file name   f_col  desired f_col   phi_col  desired phi_col   weight_col  desired weight col   mtz_file_name  use_weights_flag specifies if the weight_col flay should be used/is interesting

    Parameters
    ----------
    mtz_file_name : str
        use_weights_flag specifies if the weight_col flay should be used/is interesting
    f_col : str
        desired f_col
    phi_col : str
        desired phi_col
    weight_col : str
        desired weight col
    use_weights_flag : bool

    """
    return _coot.valid_labels(mtz_file_name, f_col, phi_col, weight_col, use_weights_flag)

def sharpen_blur_map(imol_map, b_factor):
    r"""
    sharpen_blur_map(int imol_map, float b_factor) -> int

    make a sharpened or blurred map

    blurred maps are generated by using a positive value of b_factor.

      imol  the molecule index   b_factor  is the B-factor to blur by (positive numbers blur) the index of the map created by applying a b-factor to the given map. Return -1 on failure.

    Parameters
    ----------
    imol_map : int
    b_factor : float
        is the B-factor to blur by (positive numbers blur)

    """
    return _coot.sharpen_blur_map(imol_map, b_factor)

def sharpen_blur_map_with_resampling(imol_map, b_factor, resample_factor):
    r"""
    sharpen_blur_map_with_resampling(int imol_map, float b_factor, float resample_factor) -> int

    make a sharpened or blurred map with resampling

    resampling factor might typically be 1.3

    blurred maps are generated by using a positive value of b_factor.

      imol  the molecule index   b_factor  is the B-factor to blur by (positive numbers blur) the index of the map created by applying a b-factor to the given map. Return -1 on failure.

    Parameters
    ----------
    imol_map : int
    b_factor : float
        is the B-factor to blur by (positive numbers blur)
    resample_factor : float

    """
    return _coot.sharpen_blur_map_with_resampling(imol_map, b_factor, resample_factor)

def sharpen_blur_map_with_resampling_threaded_version(imol_map, b_factor, resample_factor):
    r"""
    sharpen_blur_map_with_resampling_threaded_version(int imol_map, float b_factor, float resample_factor)


    Parameters
    ----------
    imol_map : int
    b_factor : float
    resample_factor : float

    """
    return _coot.sharpen_blur_map_with_resampling_threaded_version(imol_map, b_factor, resample_factor)

def multi_sharpen_blur_map_py(imol_map, b_factors_list):
    r"""
    multi_sharpen_blur_map_py(int imol_map, PyObject * b_factors_list)

    make many sharpened or blurred maps

    blurred maps are generated by using a positive value of b_factor.

      imol  the molecule index   b_factor_lisst  is a list of B-factor to blur by (positive numbers blur)

    Parameters
    ----------
    imol_map : int
    b_factors_list : object

    """
    return _coot.multi_sharpen_blur_map_py(imol_map, b_factors_list)

def amplitude_vs_resolution_py(mol_map):
    r"""
    amplitude_vs_resolution_py(int mol_map) -> PyObject *

    amplitude vs resolution data for graph

      imol  the molecule index a list of list of lists, for each item in the list the resolution is the 0th element (in reciprocal Angstroms squared) and the count is the element index 1 and the amplitude is in element index 2.

    Parameters
    ----------
    mol_map : int

    """
    return _coot.amplitude_vs_resolution_py(mol_map)

def flip_hand(imol_map):
    r"""
    flip_hand(int imol_map) -> int

    Flip the hand of the map.

    in case it was accidentally generated on the wrong one. the molecule number of the flipped map.

    Parameters
    ----------
    imol_map : int

    """
    return _coot.flip_hand(imol_map)

def analyse_map_point_density_change_py(map_number_list, imol_map_mask):
    r"""
    analyse_map_point_density_change_py(PyObject * map_number_list, int imol_map_mask) -> int

    I don't know what this does

    Looks interesting though   map_number_list  a list of map numbers   imol_map_mask  the molecule index for the mask 0 on failure, 1 on success

    Parameters
    ----------
    map_number_list : object
        a list of map numbers
    imol_map_mask : int
        the molecule index for the mask

    """
    return _coot.analyse_map_point_density_change_py(map_number_list, imol_map_mask)

def go_to_map_molecule_centre(imol_map):
    r"""
    go_to_map_molecule_centre(int imol_map)

    Go to the centre of the molecule - for Cryo-EM Molecules.

    and recontour at a sensible value.

      imol  the molecule index

    Parameters
    ----------
    imol_map : int

    """
    return _coot.go_to_map_molecule_centre(imol_map)

def b_factor_from_map(imol_map):
    r"""
    b_factor_from_map(int imol_map) -> float

    b-factor from map

    calculate structure factors and use the amplitudes to estimate the B-factor of the data using a wilson plot using a low resolution limit of 4.5A. -1 when given a bad map or there were no data beyond 4.5A

    Parameters
    ----------
    imol_map : int

    """
    return _coot.b_factor_from_map(imol_map)

def map_colour_components_py(imol):
    r"""
    map_colour_components_py(int imol) -> PyObject *

    return the colour triple of the imolth map

    e.g.: [0.4, 0.6, 0.8]. If invalid imol return Py_False.

      imol  the molecule index the colour triple of the imolth map

    Parameters
    ----------
    imol : int
        the molecule index

    """
    return _coot.map_colour_components_py(imol)

def read_ccp4_map(filename, is_diff_map_flag):
    r"""
    read_ccp4_map(std::string const & filename, int is_diff_map_flag) -> int

    read a CCP4 map or a CNS map (despite the name)

      filename  is the file name   is_diff_map_flag  is either 0 or 1 denoting if this is a difference map the molecule index of the new map. Return -1 on failure

    Parameters
    ----------
    filename : str
        is the file name
    is_diff_map_flag : int
        is either 0 or 1 denoting if this is a difference map

    """
    return _coot.read_ccp4_map(filename, is_diff_map_flag)

def handle_read_ccp4_map(filename, is_diff_map_flag):
    r"""
    handle_read_ccp4_map(std::string const & filename, int is_diff_map_flag) -> int

    same function as above - old name for the function. Deleted from the API at some stage

      filename  is the file name   is_diff_map_flag  is either 0 or 1 denoting if this is a difference map the molecule index of the new map. Return -1 on failure

    Parameters
    ----------
    filename : str
        is the file name
    is_diff_map_flag : int
        is either 0 or 1 denoting if this is a difference map

    """
    return _coot.handle_read_ccp4_map(filename, is_diff_map_flag)

def handle_read_emdb_data(dir_name):
    r"""
    handle_read_emdb_data(std::string const & dir_name) -> int

    this reads a EMDB bundle - I don't think they exist any more

    Parameters
    ----------
    dir_name : str

    """
    return _coot.handle_read_emdb_data(dir_name)

def show_map_partition_by_chain_dialog():
    r"""show_map_partition_by_chain_dialog()"""
    return _coot.show_map_partition_by_chain_dialog()

def map_partition_by_chain(imol_map, imol_model):
    r"""
    map_partition_by_chain(int imol_map, int imol_model) -> IntVector

    Use the function for scriptng.

    Parameters
    ----------
    imol_map : int
    imol_model : int

    """
    return _coot.map_partition_by_chain(imol_map, imol_model)

def map_partition_by_chain_threaded(imol_map, imol_model):
    r"""
    map_partition_by_chain_threaded(int imol_map, int imol_model)

    Use the function for use in the GUI (non-blocking, no results returned)

    Parameters
    ----------
    imol_map : int
    imol_model : int

    """
    return _coot.map_partition_by_chain_threaded(imol_map, imol_model)

def set_use_vertex_gradients_for_map_normals(imol, state):
    r"""
    set_use_vertex_gradients_for_map_normals(int imol, int state)

    use (or not) vertex gradients for the specified map

    vertex gradients make the map look smoother but are slower to calculate

      imol  the molecule index   state  0 for no, 1 for yes

    Parameters
    ----------
    imol : int
        the molecule index
    state : int
        0 for no, 1 for yes

    """
    return _coot.set_use_vertex_gradients_for_map_normals(imol, state)

def use_vertex_gradients_for_map_normals_for_latest_map():
    r"""
    use_vertex_gradients_for_map_normals_for_latest_map()

    the map should be displayed and not a difference map

    """
    return _coot.use_vertex_gradients_for_map_normals_for_latest_map()

def set_use_vertex_gradients_for_map_normals_for_latest_map():
    r"""
    set_use_vertex_gradients_for_map_normals_for_latest_map()

    alias for the above (more canonical naming)

    """
    return _coot.set_use_vertex_gradients_for_map_normals_for_latest_map()

def colour_map_by_other_map(imol_map, imol_map_used_for_colouring):
    r"""
    colour_map_by_other_map(int imol_map, int imol_map_used_for_colouring)

    colour map by other map

    maybe we need to spefify_other things like the colour table.   imol_map  the molecule index   imol_map_used_for_colouring  is the other map index

    Parameters
    ----------
    imol_map : int
        the molecule index
    imol_map_used_for_colouring : int
        is the other map index

    """
    return _coot.colour_map_by_other_map(imol_map, imol_map_used_for_colouring)

def colour_map_by_other_map_py(imol_map, imol_map_used_for_colouring, table_bin_start, table_bin_size, colour_table_list):
    r"""
    colour_map_by_other_map_py(int imol_map, int imol_map_used_for_colouring, float table_bin_start, float table_bin_size, PyObject * colour_table_list)

    the colour_table should be a list of colours

    So, if the map has 4 entries covering the range from 0 to 1, then the table_bin_size would be 0.25 and the colour_table list would have 4 entries covering the range 0->0.25, 0.25->0.5, 0.5->0.75, 0.75->1.0

    Parameters
    ----------
    imol_map : int
    imol_map_used_for_colouring : int
    table_bin_start : float
    table_bin_size : float
    colour_table_list : object

    """
    return _coot.colour_map_by_other_map_py(imol_map, imol_map_used_for_colouring, table_bin_start, table_bin_size, colour_table_list)

def export_molecule_as_x3d(imol):
    r"""
    export_molecule_as_x3d(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.export_molecule_as_x3d(imol)

def export_molecule_as_obj(imol, file_name):
    r"""
    export_molecule_as_obj(int imol, std::string const & file_name) -> bool


    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.export_molecule_as_obj(imol, file_name)

def export_molecule_as_gltf(imol, file_name):
    r"""
    export_molecule_as_gltf(int imol, std::string const & file_name) -> bool


    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.export_molecule_as_gltf(imol, file_name)

def colour_map_by_other_map_turn_off(imol_map):
    r"""
    colour_map_by_other_map_turn_off(int imol_map)

    turn of colour map by other map

    Parameters
    ----------
    imol_map : int

    """
    return _coot.colour_map_by_other_map_turn_off(imol_map)

def add_density_map_cap():
    r"""
    add_density_map_cap()

    Add map caps.

    """
    return _coot.add_density_map_cap()

def recolour_mesh_by_map(imol_model, imol_map, scale, offset):
    r"""
    recolour_mesh_by_map(int imol_model, int imol_map, float scale, float offset)

    colour meshes (e.g. Ribbon diagrams) by map

    scale might be 2 and offset 1 (for example)

    Parameters
    ----------
    imol_model : int
    imol_map : int
    scale : float
    offset : float

    """
    return _coot.recolour_mesh_by_map(imol_model, imol_map, scale, offset)

def multi_residue_torsion_fit(imol, specs, n_trials):
    r"""
    multi_residue_torsion_fit(int imol, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & specs, int n_trials)


    Parameters
    ----------
    imol : int
    specs : list
    n_trials : int

    """
    return _coot.multi_residue_torsion_fit(imol, specs, n_trials)

def multi_residue_torsion_fit_py(imol, residues_specs_py, n_trials):
    r"""
    multi_residue_torsion_fit_py(int imol, PyObject * residues_specs_py, int n_trials) -> PyObject *

    fit residues

    (note: fit to the current-refinement map)

    Parameters
    ----------
    imol : int
    residues_specs_py : object
    n_trials : int

    """
    return _coot.multi_residue_torsion_fit_py(imol, residues_specs_py, n_trials)

def import_bild(file_name):
    r"""
    import_bild(std::string const & file_name)


    Parameters
    ----------
    file_name : str

    """
    return _coot.import_bild(file_name)

def servalcat_fofc(imol_model, imol_fofc_map, half_map_1, half_map_2, resolution):
    r"""
    servalcat_fofc(int imol_model, int imol_fofc_map, std::string const & half_map_1, std::string const & half_map_2, float resolution)


    Parameters
    ----------
    imol_model : int
    imol_fofc_map : int
    half_map_1 : str
    half_map_2 : str
    resolution : float

    """
    return _coot.servalcat_fofc(imol_model, imol_fofc_map, half_map_1, half_map_2, resolution)

def servalcat_refine(imol_model, half_map_1, half_map_2, mask_map, resolution):
    r"""
    servalcat_refine(int imol_model, std::string const & half_map_1, std::string const & half_map_2, std::string const & mask_map, float resolution)

    resolution in A.

    Parameters
    ----------
    imol_model : int
    half_map_1 : str
    half_map_2 : str
    mask_map : str
    resolution : float

    """
    return _coot.servalcat_refine(imol_model, half_map_1, half_map_2, mask_map, resolution)

def run_acedrg_link_generation(acedrg_link_command):
    r"""
    run_acedrg_link_generation(std::string const & acedrg_link_command)

    run acedrg link

    Parameters
    ----------
    acedrg_link_command : str

    """
    return _coot.run_acedrg_link_generation(acedrg_link_command)

def add_toolbar_subprocess_button(button_label, subprocess_command, arg_list, on_completion_function, on_completion_args):
    r"""
    add_toolbar_subprocess_button(std::string const & button_label, std::string const & subprocess_command, PyObject * arg_list, PyObject * on_completion_function, PyObject * on_completion_args)

    run generic process - doesn't work at the moment - on_completion_args is wrongly interpretted.

    Parameters
    ----------
    button_label : str
    subprocess_command : str
    arg_list : object
    on_completion_function : object
    on_completion_args : object

    """
    return _coot.add_toolbar_subprocess_button(button_label, subprocess_command, arg_list, on_completion_function, on_completion_args)

def add_an_atom(element):
    r"""
    add_an_atom(std::string const & element)


    Parameters
    ----------
    element : str

    """
    return _coot.add_an_atom(element)

def nudge_the_temperature_factors_py(imol, residue_spec_py, amount):
    r"""
    nudge_the_temperature_factors_py(int imol, PyObject * residue_spec_py, float amount)


    Parameters
    ----------
    imol : int
    residue_spec_py : object
    amount : float

    """
    return _coot.nudge_the_temperature_factors_py(imol, residue_spec_py, amount)

def merge_fragments(imol):
    r"""
    merge_fragments(int imol) -> int

    each fragment is presumed to be in its own chain.

    Parameters
    ----------
    imol : int

    """
    return _coot.merge_fragments(imol)

def delete_chain(imol, chain_id):
    r"""
    delete_chain(int imol, std::string const & chain_id)

    delete the chain

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.delete_chain(imol, chain_id)

def delete_sidechains_for_chain(imol, chain_id):
    r"""
    delete_sidechains_for_chain(int imol, std::string const & chain_id)

    delete the side chains in the chain

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.delete_sidechains_for_chain(imol, chain_id)

def execute_refmac_real(pdb_in_filename, pdb_out_filename, mtz_in_filename, mtz_out_filename, cif_lib_filename, fobs_col_name, sigfobs_col_name, r_free_col_name, have_sensible_free_r_flag, make_molecules_flag, refmac_count_string, swap_map_colours_post_refmac_flag, imol_refmac_map, diff_map_flag, phase_combine_flag, phib_string, fom_string, ccp4i_project_dir):
    r"""
    execute_refmac_real(std::string pdb_in_filename, std::string pdb_out_filename, std::string mtz_in_filename, std::string mtz_out_filename, std::string cif_lib_filename, std::string fobs_col_name, std::string sigfobs_col_name, std::string r_free_col_name, short have_sensible_free_r_flag, short make_molecules_flag, std::string refmac_count_string, int swap_map_colours_post_refmac_flag, int imol_refmac_map, int diff_map_flag, int phase_combine_flag, std::string phib_string, std::string fom_string, std::string ccp4i_project_dir)

    if swap_map_colours_post_refmac_flag is not 1 thenn imol_refmac_map is ignored.

    Parameters
    ----------
    pdb_in_filename : str
    pdb_out_filename : str
    mtz_in_filename : str
    mtz_out_filename : str
    cif_lib_filename : str
    fobs_col_name : str
    sigfobs_col_name : str
    r_free_col_name : str
    have_sensible_free_r_flag : int
    make_molecules_flag : int
    refmac_count_string : str
    swap_map_colours_post_refmac_flag : int
    imol_refmac_map : int
    diff_map_flag : int
    phase_combine_flag : int
    phib_string : str
    fom_string : str
    ccp4i_project_dir : str

    """
    return _coot.execute_refmac_real(pdb_in_filename, pdb_out_filename, mtz_in_filename, mtz_out_filename, cif_lib_filename, fobs_col_name, sigfobs_col_name, r_free_col_name, have_sensible_free_r_flag, make_molecules_flag, refmac_count_string, swap_map_colours_post_refmac_flag, imol_refmac_map, diff_map_flag, phase_combine_flag, phib_string, fom_string, ccp4i_project_dir)

def refmac_name(imol):
    r"""
    refmac_name(int imol) -> std::string

    the name for refmac

    a stub name used in the construction of filename for refmac output

    Parameters
    ----------
    imol : int

    """
    return _coot.refmac_name(imol)
class str_mtime(object):
    r"""Proxy of C++ coot::str_mtime class."""

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

    def __init__(self, *args):
        r"""
        __init__(str_mtime self, std::string file_in, time_t mtime_in) -> str_mtime
        __init__(str_mtime self) -> str_mtime
        """
        _coot.str_mtime_swiginit(self, _coot.new_str_mtime(*args))
    mtime = property(_coot.str_mtime_mtime_get, _coot.str_mtime_mtime_set, doc=r"""mtime : time_t""")
    file = property(_coot.str_mtime_file_get, _coot.str_mtime_file_set, doc=r"""file : std::string""")
    __swig_destroy__ = _coot.delete_str_mtime

# Register str_mtime in _coot:
_coot.str_mtime_swigregister(str_mtime)
class file_attribs_info_t(object):
    r"""Proxy of C++ coot::file_attribs_info_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    directory_prefix = property(_coot.file_attribs_info_t_directory_prefix_get, _coot.file_attribs_info_t_directory_prefix_set, doc=r"""directory_prefix : std::string""")
    file_mtimes = property(_coot.file_attribs_info_t_file_mtimes_get, _coot.file_attribs_info_t_file_mtimes_set, doc=r"""file_mtimes : std::vector<(coot::str_mtime,std::allocator<(coot::str_mtime)>)>""")

    def __init__(self):
        r"""__init__(file_attribs_info_t self) -> file_attribs_info_t"""
        _coot.file_attribs_info_t_swiginit(self, _coot.new_file_attribs_info_t())
    __swig_destroy__ = _coot.delete_file_attribs_info_t

# Register file_attribs_info_t in _coot:
_coot.file_attribs_info_t_swigregister(file_attribs_info_t)

def compare_mtimes(a, b):
    r"""
    compare_mtimes(str_mtime a, str_mtime b) -> bool


    Parameters
    ----------
    a : 
    b : 

    """
    return _coot.compare_mtimes(a, b)

def parse_ccp4i_defs(filename):
    r"""
    parse_ccp4i_defs(std::string const & filename) -> vector_pair_string_string


    Parameters
    ----------
    filename : str

    """
    return _coot.parse_ccp4i_defs(filename)

def ccp4_project_directory(ccp4_project_name):
    r"""
    ccp4_project_directory(std::string const & ccp4_project_name) -> std::string


    Parameters
    ----------
    ccp4_project_name : str

    """
    return _coot.ccp4_project_directory(ccp4_project_name)

def add_to_history(ls):
    r"""
    add_to_history(vector_string ls)


    Parameters
    ----------
    ls : list

    """
    return _coot.add_to_history(ls)

def add_to_history_simple(cmd):
    r"""
    add_to_history_simple(std::string const & cmd)


    Parameters
    ----------
    cmd : str

    """
    return _coot.add_to_history_simple(cmd)

def add_to_history_typed(command, args):
    r"""
    add_to_history_typed(std::string const & command, std::vector< coot::command_arg_t,std::allocator< coot::command_arg_t > > const & args)


    Parameters
    ----------
    command : str
    args : list

    """
    return _coot.add_to_history_typed(command, args)

def single_quote(s):
    r"""
    single_quote(std::string const & s) -> std::string


    Parameters
    ----------
    s : str

    """
    return _coot.single_quote(s)

def pythonize_command_name(s):
    r"""
    pythonize_command_name(std::string const & s) -> std::string


    Parameters
    ----------
    s : str

    """
    return _coot.pythonize_command_name(s)

def schemize_command_name(s):
    r"""
    schemize_command_name(std::string const & s) -> std::string


    Parameters
    ----------
    s : str

    """
    return _coot.schemize_command_name(s)

def languagize_command(command_parts):
    r"""
    languagize_command(vector_string command_parts) -> std::string


    Parameters
    ----------
    command_parts : list

    """
    return _coot.languagize_command(command_parts)

def add_to_database(command_strings):
    r"""
    add_to_database(vector_string command_strings)


    Parameters
    ----------
    command_strings : list

    """
    return _coot.add_to_database(command_strings)

def merge_molecules_by_vector(add_molecules, imol):
    r"""
    merge_molecules_by_vector(IntVector add_molecules, int imol) -> std::pair< int,std::vector< merge_molecule_results_info_t,std::allocator< merge_molecule_results_info_t > > >


    Parameters
    ----------
    add_molecules : list
    imol : int

    """
    return _coot.merge_molecules_by_vector(add_molecules, imol)

def handle_cif_dictionary(filename):
    r"""
    handle_cif_dictionary(std::string const & filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.handle_cif_dictionary(filename)

def read_cif_dictionary(filename):
    r"""
    read_cif_dictionary(std::string const & filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.read_cif_dictionary(filename)

def handle_cif_dictionary_for_molecule(filename, imol_enc, new_molecule_from_dictionary_cif_checkbutton_state):
    r"""
    handle_cif_dictionary_for_molecule(std::string const & filename, int imol_enc, short new_molecule_from_dictionary_cif_checkbutton_state) -> int


    Parameters
    ----------
    filename : str
    imol_enc : int
    new_molecule_from_dictionary_cif_checkbutton_state : int

    """
    return _coot.handle_cif_dictionary_for_molecule(filename, imol_enc, new_molecule_from_dictionary_cif_checkbutton_state)

def dictionary_entries():
    r"""
    dictionary_entries() -> vector_string

    dictionary entries

    """
    return _coot.dictionary_entries()

def debug_dictionary():
    r"""
    debug_dictionary()

    debug dictionary information

    """
    return _coot.debug_dictionary()

def get_types_in_molecule(imol):
    r"""
    get_types_in_molecule(int imol) -> vector_string

    get types in molecule

      imol  the molecule index a vector of residue types

    Parameters
    ----------
    imol : int
        the molecule index

    """
    return _coot.get_types_in_molecule(imol)

def SMILES_for_comp_id(comp_id):
    r"""
    SMILES_for_comp_id(std::string const & comp_id) -> std::string

    Get the SMILES for the given residue type

      comp_id  is the residue type the SMILES string

    Parameters
    ----------
    comp_id : str
        is the residue type

    """
    return _coot.SMILES_for_comp_id(comp_id)

def dictionaries_read_py():
    r"""dictionaries_read_py() -> PyObject *"""
    return _coot.dictionaries_read_py()

def cif_file_for_comp_id_py(comp_id):
    r"""
    cif_file_for_comp_id_py(std::string const & comp_id) -> PyObject *


    Parameters
    ----------
    comp_id : str

    """
    return _coot.cif_file_for_comp_id_py(comp_id)

def dictionary_entries_py():
    r"""dictionary_entries_py() -> PyObject *"""
    return _coot.dictionary_entries_py()

def SMILES_for_comp_id_py(comp_id):
    r"""
    SMILES_for_comp_id_py(std::string const & comp_id) -> PyObject *

    Get the SMILES for the given residue type.

      comp_id  is the residue type the SMILES string or False on failure to find the residue type or SMILES string

    Parameters
    ----------
    comp_id : str
        is the residue type

    """
    return _coot.SMILES_for_comp_id_py(comp_id)

def monomer_restraints_py(monomer_type):
    r"""
    monomer_restraints_py(std::string monomer_type) -> PyObject *


    Parameters
    ----------
    monomer_type : str

    """
    return _coot.monomer_restraints_py(monomer_type)

def monomer_restraints_for_molecule_py(monomer_type, imol):
    r"""
    monomer_restraints_for_molecule_py(std::string monomer_type, int imol) -> PyObject *


    Parameters
    ----------
    monomer_type : str
    imol : int

    """
    return _coot.monomer_restraints_for_molecule_py(monomer_type, imol)

def set_monomer_restraints_py(monomer_type, restraints):
    r"""
    set_monomer_restraints_py(char const * monomer_type, PyObject * restraints) -> PyObject *


    Parameters
    ----------
    monomer_type : str
    restraints : object

    """
    return _coot.set_monomer_restraints_py(monomer_type, restraints)

def show_restraints_editor(monomer_type):
    r"""
    show_restraints_editor(std::string monomer_type)

    show restraints editor

    Parameters
    ----------
    monomer_type : str

    """
    return _coot.show_restraints_editor(monomer_type)

def show_restraints_editor_by_index(menu_item_index):
    r"""
    show_restraints_editor_by_index(int menu_item_index)


    Parameters
    ----------
    menu_item_index : int

    """
    return _coot.show_restraints_editor_by_index(menu_item_index)

def write_restraints_cif_dictionary(monomer_type, file_name):
    r"""
    write_restraints_cif_dictionary(std::string monomer_type, std::string file_name)

    write cif restraints for monomer

    Parameters
    ----------
    monomer_type : str
    file_name : str

    """
    return _coot.write_restraints_cif_dictionary(monomer_type, file_name)

def list_nomenclature_errors_py(imol):
    r"""
    list_nomenclature_errors_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.list_nomenclature_errors_py(imol)

def show_fix_nomenclature_errors_gui(imol, nomenclature_errors):
    r"""
    show_fix_nomenclature_errors_gui(int imol, std::vector< std::pair< std::string,coot::residue_spec_t >,std::allocator< std::pair< std::string,coot::residue_spec_t > > > const & nomenclature_errors)


    Parameters
    ----------
    imol : int
    nomenclature_errors : list

    """
    return _coot.show_fix_nomenclature_errors_gui(imol, nomenclature_errors)

def dipole_to_py(dp):
    r"""
    dipole_to_py(std::pair< coot::dipole,int > dp) -> PyObject *


    Parameters
    ----------
    dp : std::pair< coot::dipole, int >

    """
    return _coot.dipole_to_py(dp)

def coot_has_guile():
    r"""coot_has_guile() -> PyObject *"""
    return _coot.coot_has_guile()

def coot_can_do_lidia_p():
    r"""coot_can_do_lidia_p() -> bool"""
    return _coot.coot_can_do_lidia_p()

def run_scheme_command(scheme_command):
    r"""
    run_scheme_command(char const * scheme_command) -> PyObject *


    Parameters
    ----------
    scheme_command : str

    """
    return _coot.run_scheme_command(scheme_command)

def pyrun_simple_string(python_command):
    r"""
    pyrun_simple_string(char const * python_command) -> int


    Parameters
    ----------
    python_command : str

    """
    return _coot.pyrun_simple_string(python_command)

def residue_spec_to_py(res):
    r"""
    residue_spec_to_py(residue_spec_t res) -> PyObject *


    Parameters
    ----------
    res : residue_spec

    """
    return _coot.residue_spec_to_py(res)

def residue_spec_make_triple_py(residue_spec_py):
    r"""
    residue_spec_make_triple_py(PyObject * residue_spec_py) -> PyObject *


    Parameters
    ----------
    residue_spec_py : object

    """
    return _coot.residue_spec_make_triple_py(residue_spec_py)

def residue_spec_from_py(residue_in):
    r"""
    residue_spec_from_py(PyObject * residue_in) -> residue_spec_t


    Parameters
    ----------
    residue_in : object

    """
    return _coot.residue_spec_from_py(residue_in)

def get_residue_by_type(imol, residue_type):
    r"""
    get_residue_by_type(int imol, std::string const & residue_type) -> residue_spec_t


    Parameters
    ----------
    imol : int
    residue_type : str

    """
    return _coot.get_residue_by_type(imol, residue_type)

def get_residue_specs_in_mol(imol, residue_type):
    r"""
    get_residue_specs_in_mol(int imol, std::string const & residue_type) -> std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > >


    Parameters
    ----------
    imol : int
    residue_type : str

    """
    return _coot.get_residue_specs_in_mol(imol, residue_type)

def get_residue_specs_in_mol_py(imol, residue_type):
    r"""
    get_residue_specs_in_mol_py(int imol, std::string const & residue_type) -> PyObject *


    Parameters
    ----------
    imol : int
    residue_type : str

    """
    return _coot.get_residue_specs_in_mol_py(imol, residue_type)

def get_residue_by_type_py(imol, residue_type):
    r"""
    get_residue_by_type_py(int imol, std::string const & residue_type) -> PyObject *

    get residue by type

    Find the first residue of the given type in the molecule

      imol  the molecule index   residue_type  the residue type requested a residue spec or Python False.

    Parameters
    ----------
    imol : int
        the molecule index
    residue_type : str
        the residue type requested

    """
    return _coot.get_residue_by_type_py(imol, residue_type)

def get_residue_name_py(imol, residue_spec_py):
    r"""
    get_residue_name_py(int imol, PyObject * residue_spec_py) -> std::string

    get the residue name of the specified residue

      imol  the molecule index   residue_spec_py  the residue spec the residue name or blank on failure

    Parameters
    ----------
    imol : int
        the molecule index
    residue_spec_py : object
        the residue spec

    """
    return _coot.get_residue_name_py(imol, residue_spec_py)

def get_residue_name(imol, res_spec):
    r"""
    get_residue_name(int imol, residue_spec_t res_spec) -> std::string

    as above, but for use by callback

    Parameters
    ----------
    imol : int
    res_spec : residue_spec

    """
    return _coot.get_residue_name(imol, res_spec)

def is_N_terminus(imol, res_spec):
    r"""
    is_N_terminus(int imol, residue_spec_t res_spec) -> bool

    use by callback

    Parameters
    ----------
    imol : int
    res_spec : residue_spec

    """
    return _coot.is_N_terminus(imol, res_spec)

def is_C_terminus(imol, res_spec):
    r"""
    is_C_terminus(int imol, residue_spec_t res_spec) -> bool

    use by callback

    Parameters
    ----------
    imol : int
    res_spec : residue_spec

    """
    return _coot.is_C_terminus(imol, res_spec)

def resname_from_serial_number(imol, chain_id, serial_num):
    r"""
    resname_from_serial_number(int imol, char const * chain_id, int serial_num) -> std::string

    return the rename from a residue serial number

    blank ("") on failure.

    Parameters
    ----------
    imol : int
    chain_id : str
    serial_num : int

    """
    return _coot.resname_from_serial_number(imol, chain_id, serial_num)

def residue_name(imol, chain_id, resno, ins_code):
    r"""
    residue_name(int imol, std::string const & chain_id, int resno, std::string const & ins_code) -> std::string

    return the residue name of the specified residue

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.residue_name(imol, chain_id, resno, ins_code)

def serial_number_from_residue_specs(imol, chain_id, res_no, ins_code):
    r"""
    serial_number_from_residue_specs(int imol, std::string const & chain_id, int res_no, std::string const & ins_code) -> int

    return the serial number of the specified residue

    -1 on failure to find the residue

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str

    """
    return _coot.serial_number_from_residue_specs(imol, chain_id, res_no, ins_code)

def hydrogenate_region(radius):
    r"""
    hydrogenate_region(float radius)

    find the active residue, find the near residues (within radius) create a new molecule, run reduce on that, import hydrogens from the result and apply them to the molecule of the active residue.

    Parameters
    ----------
    radius : float

    """
    return _coot.hydrogenate_region(radius)

def add_hydrogens_from_file(imol, pdb_with_Hs_file_name):
    r"""
    add_hydrogens_from_file(int imol, std::string pdb_with_Hs_file_name)

    Add hydrogens to imol from the given pdb file.

    Parameters
    ----------
    imol : int
    pdb_with_Hs_file_name : str

    """
    return _coot.add_hydrogens_from_file(imol, pdb_with_Hs_file_name)

def add_hydrogen_atoms_to_residue(imol, chain_id, res_no, ins_code):
    r"""
    add_hydrogen_atoms_to_residue(int imol, std::string chain_id, int res_no, std::string ins_code)

    add hydrogen atoms to the specified residue

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str

    """
    return _coot.add_hydrogen_atoms_to_residue(imol, chain_id, res_no, ins_code)

def add_hydrogen_atoms_to_residue_py(imol, residue_spec_py):
    r"""
    add_hydrogen_atoms_to_residue_py(int imol, PyObject * residue_spec_py)

    add hydrogen atoms to the specified residue

    Parameters
    ----------
    imol : int
    residue_spec_py : object

    """
    return _coot.add_hydrogen_atoms_to_residue_py(imol, residue_spec_py)

def atom_info_string_py(imol, chain_id, resno, ins_code, atname, altconf):
    r"""
    atom_info_string_py(int imol, char const * chain_id, int resno, char const * ins_code, char const * atname, char const * altconf) -> PyObject *

    output atom info in a python list for use in scripting:

    in this format [occ, temp_factor, element, x, y, z]. Return empty list if atom not found. * /

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    atname : str
    altconf : str

    """
    return _coot.atom_info_string_py(imol, chain_id, resno, ins_code, atname, altconf)

def molecule_to_pdb_string_py(imol):
    r"""
    molecule_to_pdb_string_py(int imol) -> PyObject *

    Return the molecule as a PDB string.

    Parameters
    ----------
    imol : int

    """
    return _coot.molecule_to_pdb_string_py(imol)

def residue_info_py(imol, chain_id, resno, ins_code):
    r"""
    residue_info_py(int imol, char const * chain_id, int resno, char const * ins_code) -> PyObject *

    Get detailed atom information for a residue (Python interface)

    Returns per-atom information including coordinates, occupancy, B-factor, and element for all atoms in the specified residue. Useful for inspecting residue completeness and identifying missing atoms.

      imol  Model molecule index   chain_id  Chain identifier (e.g., "A")   resno  Residue number   ins_code  Insertion code (use "" if none) PyObject* - A list of atom information, one entry per atom: [ [[atom_name, alt_conf], [occupancy, b_factor, element, seg_id], [x, y, z], atom_index], ... ]  atom_name (str): Atom name (e.g., " CA ", " SG ") alt_conf (str): Alternate conformation identifier ("" if none) occupancy (float): Atom occupancy (0.0-1.0) b_factor (float or list of [b_iso, B11, B22, B33, B12, B13, B23]): Temperature factor element (str): Element symbol (e.g., " C", " N", " S") x , y , z (float): Cartesian coordinates in Ångstroms atom_index (int): Internal atom index Example usage: # Check if a CYS residue has all expected atoms atoms = coot.residue_info_py(0, "A" , 72, "" ) atom_names = [a[0][0].strip() for a in atoms] print(f "Atoms present: {atom_names}" ) expected_cys = [ 'N' , 'CA' , 'CB' , 'SG' , 'C' , 'O' ] missing = [a for a in expected_cys if a not in atom_names] if missing: print(f "Missing atoms: {missing}" ) # Get B-factors for all atoms for atom in atoms: name = atom[0][0].strip() b_factor = atom[1][1] print(f "{name}: B={b_factor:.2f}" )

    Parameters
    ----------
    imol : int
        Model molecule index
    chain_id : str
        Chain identifier (e.g., "A")
    resno : int
        Residue number
    ins_code : str
        Insertion code (use "" if none)

    """
    return _coot.residue_info_py(imol, chain_id, resno, ins_code)

def residue_name_py(imol, chain_id, resno, ins_code):
    r"""
    residue_name_py(int imol, char const * chain_id, int resno, char const * ins_code) -> PyObject *

    get the residue name

      imol  Model molecule index   chain_id  Chain identifier (e.g., "A")   resno  Residue number   ins_code  Insertion code (use "" if none) residue name string or blank string on failure

    Parameters
    ----------
    imol : int
        Model molecule index
    chain_id : str
        Chain identifier (e.g., "A")
    resno : int
        Residue number
    ins_code : str
        Insertion code (use "" if none)

    """
    return _coot.residue_name_py(imol, chain_id, resno, ins_code)

def residue_centre_from_spec_py(imol, spec_py):
    r"""
    residue_centre_from_spec_py(int imol, PyObject * spec_py) -> PyObject *


    Parameters
    ----------
    imol : int
    spec_py : object

    """
    return _coot.residue_centre_from_spec_py(imol, spec_py)

def chain_fragments_py(imol, screen_output_also):
    r"""
    chain_fragments_py(int imol, short screen_output_also) -> PyObject *


    Parameters
    ----------
    imol : int
    screen_output_also : int

    """
    return _coot.chain_fragments_py(imol, screen_output_also)

def set_b_factor_residues_py(imol, residue_specs_b_value_tuple_list_py):
    r"""
    set_b_factor_residues_py(int imol, PyObject * residue_specs_b_value_tuple_list_py)


    Parameters
    ----------
    imol : int
    residue_specs_b_value_tuple_list_py : object

    """
    return _coot.set_b_factor_residues_py(imol, residue_specs_b_value_tuple_list_py)

def clear_and_update_molecule_py(molecule_number, molecule_expression):
    r"""
    clear_and_update_molecule_py(int molecule_number, PyObject * molecule_expression) -> int


    Parameters
    ----------
    molecule_number : int
    molecule_expression : object

    """
    return _coot.clear_and_update_molecule_py(molecule_number, molecule_expression)

def add_molecule_py(molecule_expression, name):
    r"""
    add_molecule_py(PyObject * molecule_expression, char const * name) -> int


    Parameters
    ----------
    molecule_expression : object
    name : str

    """
    return _coot.add_molecule_py(molecule_expression, name)

def active_residue_py():
    r"""
    active_residue_py() -> PyObject *

    Return a list of [imol, chain-id, resno, ins-code, atom-name, alt-conf] for atom that is closest to the screen centre. If there are multiple models with the same coordinates at the screen centre, return the attributes of the atom in the highest number molecule number.

    return False if no active residue

    """
    return _coot.active_residue_py()

def closest_atom_simple_py():
    r"""
    closest_atom_simple_py() -> PyObject *

    return the spec of the closest displayed atom

    a list of [imol, chain-id, resno, ins-code, atom-name, alt-conf, [x, y, z]] for atom that is closest to the screen centre in the given molecule (unlike active-residue, potential CA substition is not performed). If there is no atom, or if imol is not a valid model molecule, return False.

    """
    return _coot.closest_atom_simple_py()

def closest_atom_py(imol):
    r"""
    closest_atom_py(int imol) -> PyObject *

    return closest atom in imolth molecule

      imol  is the molecule index a list of [imol, chain-id, resno, ins-code, atom-name, alt-conf, [x, y, z]] for the atom that is closest to the screen centre in the given molecule (unlike active-residue, no account is taken of the displayed state of the imol molecule). If there is no atom, or if imol is not a valid model molecule, return False.

    Parameters
    ----------
    imol : int
        is the molecule index

    """
    return _coot.closest_atom_py(imol)

def closest_atom_raw_py():
    r"""
    closest_atom_raw_py() -> PyObject *

    return the specs of the closest atom to the centre of the screen

    a list of (list imol chain-id resno ins-code atom-name alt-conf (list x y z)) for atom that is closest to the screen for displayed molecules. If there is no atom, return scheme false. Don't choose the CA of the residue if there is a CA in the residue of the closest atom

    """
    return _coot.closest_atom_raw_py()

def residues_near_residue_py(imol, residue_spec_in, radius):
    r"""
    residues_near_residue_py(int imol, PyObject * residue_spec_in, float radius) -> PyObject *

    get the residues near a specified residue

    This is useful to select the residues for "Sphere" refinement.

      imol  is the molecule index   residue_in  is a residue spec [chain_id, res_no, insertion_code]   radius  is the cut-off distance atoms of the surrounding residues if they are to be included in the residue selection. a list of residue specs for residues that have atoms that are closer than radius Angstroems to any atom in the residue specified by residue_in.

    Parameters
    ----------
    imol : int
        is the molecule index
    residue_spec_in : object
    radius : float
        is the cut-off distance atoms of the surrounding residues if they are to be included in the residue selection.

    """
    return _coot.residues_near_residue_py(imol, residue_spec_in, radius)

def residues_near_residues_py(imol, residues_specs_in, radius):
    r"""
    residues_near_residues_py(int imol, PyObject * residues_specs_in, float radius) -> PyObject *

    get the residues near a specified list of residues

      imol  is the molecule index   residues_in  is a list of residue specs each of which is [chain_id, res_no, insertion_code]   radius  is the cut-off distance atoms of the surrounding residues if they are to be included in the residue selection. a list of residue specs for residues that have atoms that are closer than radius Angstroems to any atom in the residue specified by the input residue spec list.

    Parameters
    ----------
    imol : int
        is the molecule index
    residues_specs_in : object
    radius : float
        is the cut-off distance atoms of the surrounding residues if they are to be included in the residue selection.

    """
    return _coot.residues_near_residues_py(imol, residues_specs_in, radius)

def residues_near_position_py(imol, pos_in, radius):
    r"""
    residues_near_position_py(int imol, PyObject * pos_in, float radius) -> PyObject *

    Return residue specs for residues that have atoms that are closer than radius Angstroems to the given position.

    Parameters
    ----------
    imol : int
    pos_in : object
    radius : float

    """
    return _coot.residues_near_position_py(imol, pos_in, radius)

def label_closest_atoms_in_neighbour_residues_py(imol, residue_spec_py, radius):
    r"""
    label_closest_atoms_in_neighbour_residues_py(int imol, PyObject * residue_spec_py, float radius)

    label the closest atoms in the residues that neighbour residue_spec

    Parameters
    ----------
    imol : int
    residue_spec_py : object
    radius : float

    """
    return _coot.label_closest_atoms_in_neighbour_residues_py(imol, residue_spec_py, radius)

def get_bonds_representation(imol):
    r"""
    get_bonds_representation(int imol) -> PyObject *

    return a Python object for the bonds

    Parameters
    ----------
    imol : int

    """
    return _coot.get_bonds_representation(imol)

def set_new_non_drawn_bonds(imol, cid):
    r"""
    set_new_non_drawn_bonds(int imol, std::string const & cid)

    replace any current non-drawn bonds with these - and regen bonds

    Parameters
    ----------
    imol : int
    cid : str

    """
    return _coot.set_new_non_drawn_bonds(imol, cid)

def add_to_non_drawn_bonds(imol, cid):
    r"""
    add_to_non_drawn_bonds(int imol, std::string const & cid)

    add to non-drawn bonds - and regen bonds

    Parameters
    ----------
    imol : int
    cid : str

    """
    return _coot.add_to_non_drawn_bonds(imol, cid)

def clear_non_drawn_bonds(imol):
    r"""
    clear_non_drawn_bonds(int imol)

    clear the non-drawn bonds - force regen bonds to restore all

    Parameters
    ----------
    imol : int

    """
    return _coot.clear_non_drawn_bonds(imol)

def get_dictionary_radii():
    r"""
    get_dictionary_radii() -> PyObject *

    return a Python object for the radii of the atoms in the dictionary

    """
    return _coot.get_dictionary_radii()

def get_environment_distances_representation_py(imol, residue_spec_py):
    r"""
    get_environment_distances_representation_py(int imol, PyObject * residue_spec_py) -> PyObject *

    return a Python object for the representation of bump and hydrogen bonds oft

    Parameters
    ----------
    imol : int
    residue_spec_py : object

    """
    return _coot.get_environment_distances_representation_py(imol, residue_spec_py)

def get_intermediate_atoms_bonds_representation():
    r"""
    get_intermediate_atoms_bonds_representation() -> PyObject *

    return a Python object for the intermediate atoms bonds

    """
    return _coot.get_intermediate_atoms_bonds_representation()

def get_continue_updating_refinement_atoms_state():
    r"""
    get_continue_updating_refinement_atoms_state() -> int

    return the continue-updating-refinement-atoms state

    """
    return _coot.get_continue_updating_refinement_atoms_state()

def atom_info_as_text_for_statusbar(*args):
    r"""
    atom_info_as_text_for_statusbar(int atom_index, int imol) -> std::string
    atom_info_as_text_for_statusbar(int atom_index, int imol, std::pair< symm_trans_t,Cell_Translation > const & sts) -> std::string


    Parameters
    ----------
    atom_index : int
    imol : int
    sts : const std::pair< symm_trans_t, Cell_Translation > &

    """
    return _coot.atom_info_as_text_for_statusbar(*args)

def all_residues_with_serial_numbers_py(imol):
    r"""
    all_residues_with_serial_numbers_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.all_residues_with_serial_numbers_py(imol)

def mtz_file_name(imol):
    r"""
    mtz_file_name(int imol) -> std::string

    presumes that imol_Refinement_Map has been set

    Parameters
    ----------
    imol : int

    """
    return _coot.mtz_file_name(imol)

def refine_zone_with_full_residue_spec_py(imol, chain_id, resno1, inscode_1, resno2, inscode_2, altconf):
    r"""
    refine_zone_with_full_residue_spec_py(int imol, char const * chain_id, int resno1, char const * inscode_1, int resno2, char const * inscode_2, char const * altconf) -> PyObject *


    Parameters
    ----------
    imol : int
    chain_id : str
    resno1 : int
    inscode_1 : str
    resno2 : int
    inscode_2 : str
    altconf : str

    """
    return _coot.refine_zone_with_full_residue_spec_py(imol, chain_id, resno1, inscode_1, resno2, inscode_2, altconf)

def set_draw_moving_atoms_rota_markup(state):
    r"""
    set_draw_moving_atoms_rota_markup(short state)

    set display of rotamer markup during interactive real space refinement

    Parameters
    ----------
    state : int

    """
    return _coot.set_draw_moving_atoms_rota_markup(state)

def set_draw_moving_atoms_rama_markup(state):
    r"""
    set_draw_moving_atoms_rama_markup(short state)

    set display of ramachandran markup during interactive real space refinement

    Parameters
    ----------
    state : int

    """
    return _coot.set_draw_moving_atoms_rama_markup(state)

def set_show_intermediate_atoms_rota_markup(state):
    r"""
    set_show_intermediate_atoms_rota_markup(short state)

    the old names for the above functions:

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_intermediate_atoms_rota_markup(state)

def set_show_intermediate_atoms_rama_markup(state):
    r"""
    set_show_intermediate_atoms_rama_markup(short state)

    the old names for the above functions:

    Parameters
    ----------
    state : int

    """
    return _coot.set_show_intermediate_atoms_rama_markup(state)

def get_draw_moving_atoms_rota_markup_state():
    r"""
    get_draw_moving_atoms_rota_markup_state() -> int

    the geters for the rota markup

    """
    return _coot.get_draw_moving_atoms_rota_markup_state()

def get_draw_moving_atoms_rama_markup_state():
    r"""
    get_draw_moving_atoms_rama_markup_state() -> int

    the geters for the rama markup

    """
    return _coot.get_draw_moving_atoms_rama_markup_state()

def get_show_intermediate_atoms_rota_markup():
    r"""
    get_show_intermediate_atoms_rota_markup() -> int

    the old names for the above functions:

    """
    return _coot.get_show_intermediate_atoms_rota_markup()

def get_show_intermediate_atoms_rama_markup():
    r"""
    get_show_intermediate_atoms_rama_markup() -> int

    the old names for the above functions:

    """
    return _coot.get_show_intermediate_atoms_rama_markup()

def set_cryo_em_refinement(mode):
    r"""
    set_cryo_em_refinement(bool mode)


    Parameters
    ----------
    mode : bool

    """
    return _coot.set_cryo_em_refinement(mode)

def get_cryo_em_refinement():
    r"""get_cryo_em_refinement() -> bool"""
    return _coot.get_cryo_em_refinement()

def accept_moving_atoms_py():
    r"""
    accept_moving_atoms_py() -> PyObject *

    Accept refined/regularized atoms into the main molecule (Python interface)

    Accept moving atoms

    When scripting refinement with set_refinement_immediate_replacement(1), call this function after refinement operations to ensure atoms are committed. While immediate replacement mode should handle this automatically, calling accept_moving_atoms_py() ensures reliable synchronization.

    PyObject* with one of:  Py_False if no restraints were found (nothing to accept) A Python list [info_text, progress, lights] on success:  info_text (str): Usually empty string progress (int): GSL minimization status  0 = GSL_SUCCESS (converged) -2 = GSL_CONTINUE 27 = GSL_ENOPROG (no progress) lights (list): Refinement statistics as [[name, label, value], ...]  name (str): Restraint type (e.g., "Bonds", "Angles", "Trans_peptide", "Planes", "Non-bonded", "Chirals") label (str): Formatted string (e.g., "Bonds: 0.625") value (float): Distortion value (lower is better) Example usage: coot.set_refinement_immediate_replacement(1) coot.refine_residues_py(0, [[ "A" , 42, "" ]]) result = coot.accept_moving_atoms_py() if result: info, progress, lights = result for name, label, value in lights: print(f "{name}: {value:.3f}" )

    """
    return _coot.accept_moving_atoms_py()

def register_post_intermediate_atoms_moved_hook(function_name):
    r"""
    register_post_intermediate_atoms_moved_hook(PyObject * function_name)


    Parameters
    ----------
    function_name : object

    """
    return _coot.register_post_intermediate_atoms_moved_hook(function_name)

def set_regenerate_bonds_needs_make_bonds_type_checked(state):
    r"""
    set_regenerate_bonds_needs_make_bonds_type_checked(bool state)


    Parameters
    ----------
    state : bool

    """
    return _coot.set_regenerate_bonds_needs_make_bonds_type_checked(state)

def get_regenerate_bonds_needs_make_bonds_type_checked_state():
    r"""get_regenerate_bonds_needs_make_bonds_type_checked_state() -> bool"""
    return _coot.get_regenerate_bonds_needs_make_bonds_type_checked_state()

def rigid_body_fit_with_residue_ranges(imol, ranges):
    r"""
    rigid_body_fit_with_residue_ranges(int imol, std::vector< coot::high_res_residue_range_t,std::allocator< coot::high_res_residue_range_t > > const & ranges) -> int

    return 0 on fail to refine (no sensible place to put atoms) and 1 on fitting happened.

    Parameters
    ----------
    imol : int
    ranges : list

    """
    return _coot.rigid_body_fit_with_residue_ranges(imol, ranges)

def morph_fit_all(imol, transformation_averaging_radius):
    r"""
    morph_fit_all(int imol, float transformation_averaging_radius) -> int


    Parameters
    ----------
    imol : int
    transformation_averaging_radius : float

    """
    return _coot.morph_fit_all(imol, transformation_averaging_radius)

def morph_fit_chain(imol, chain_id, transformation_averaging_radius):
    r"""
    morph_fit_chain(int imol, std::string chain_id, float transformation_averaging_radius) -> int

    Morph the given chain.

    Parameters
    ----------
    imol : int
    chain_id : str
    transformation_averaging_radius : float

    """
    return _coot.morph_fit_chain(imol, chain_id, transformation_averaging_radius)

def morph_fit_residues_py(imol, residue_specs, transformation_averaging_radius):
    r"""
    morph_fit_residues_py(int imol, PyObject * residue_specs, float transformation_averaging_radius) -> int


    Parameters
    ----------
    imol : int
    residue_specs : object
    transformation_averaging_radius : float

    """
    return _coot.morph_fit_residues_py(imol, residue_specs, transformation_averaging_radius)

def morph_fit_residues(imol, residue_specs, transformation_averaging_radius):
    r"""
    morph_fit_residues(int imol, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & residue_specs, float transformation_averaging_radius) -> int

    morph the given residues.

    Parameters
    ----------
    imol : int
    residue_specs : list
    transformation_averaging_radius : float

    """
    return _coot.morph_fit_residues(imol, residue_specs, transformation_averaging_radius)

def morph_fit_by_secondary_structure_elements(imol, chain_id):
    r"""
    morph_fit_by_secondary_structure_elements(int imol, std::string const & chain_id) -> int

    morph transformation are based primarily on rigid body refinement of the secondary structure elements.

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.morph_fit_by_secondary_structure_elements(imol, chain_id)

def check_waters_baddies(imol, b_factor_lim, map_sigma_lim, min_dist, max_dist, part_occ_contact_flag, zero_occ_flag, logical_operator_and_or_flag):
    r"""
    check_waters_baddies(int imol, float b_factor_lim, float map_sigma_lim, float min_dist, float max_dist, short part_occ_contact_flag, short zero_occ_flag, short logical_operator_and_or_flag) -> vector_atom_spec


    Parameters
    ----------
    imol : int
    b_factor_lim : float
    map_sigma_lim : float
    min_dist : float
    max_dist : float
    part_occ_contact_flag : int
    zero_occ_flag : int
    logical_operator_and_or_flag : int

    """
    return _coot.check_waters_baddies(imol, b_factor_lim, map_sigma_lim, min_dist, max_dist, part_occ_contact_flag, zero_occ_flag, logical_operator_and_or_flag)

def find_blobs(imol_model, imol_map, cut_off_density_level):
    r"""
    find_blobs(int imol_model, int imol_map, float cut_off_density_level) -> std::vector< std::pair< clipper::Coord_orth,double >,std::allocator< std::pair< clipper::Coord_orth,double > > >


    Parameters
    ----------
    imol_model : int
    imol_map : int
    cut_off_density_level : float

    """
    return _coot.find_blobs(imol_model, imol_map, cut_off_density_level)

def find_blobs_py(imol_model, imol_map, cut_off_sigma_density_level):
    r"""
    find_blobs_py(int imol_model, int imol_map, float cut_off_sigma_density_level) -> PyObject *

    Find regions of unmodeled electron density ("blobs") in a map.

    Identifies regions of significant electron density that are not explained by the current atomic model. This is essential for discovering missing features such as waters, ligands, alternative conformations, metal ions, or missing residues during structure validation and refinement.

    The function masks out density already explained by the model atoms, then searches for contiguous regions of density above the specified sigma threshold. Each blob is characterized by its center position and an integrated volume/score representing the strength of the feature.

      imol_model  The model molecule index. Density explained by atoms in this model will be masked out (excluded) from the search. Must be a valid model molecule.   imol_map  The map molecule index to search for unmodeled density. This is typically a difference map (mFo-DFc) for most sensitive detection, but can also be a regular map (2mFo-DFc). Must be a valid map molecule.   cut_off_sigma  The sigma threshold for blob detection (in units of map sigma). Typical values:  3.5σ: Standard threshold for significant features in difference maps 2.5σ: More sensitive, finds weaker features (more false positives) 4.5σ: Conservative, only strong features (fewer false positives) 1.0σ: For regular maps (2mFo-DFc), lower threshold appropriate PyObject* - Returns a Python list of blobs, or Py_False on error. Return format (on success): [ [[x1, y1, z1], volume1], # First blob: [position_list, score] [[x2, y2, z2], volume2], # Second blob ... ]

    Each blob is represented as a 2-element list:  Element 0: Position as [x, y, z] list (coordinates in Ångströms, orthogonal space) Element 1: Volume/score as float (integrated density strength)

    Return value (on error):  Py_False if imol_model is not a valid model molecule Py_False if imol_map is not a valid map molecule

    Parameters
    ----------
    imol_model : int
        The model molecule index. Density explained by atoms in this model will be masked out (excluded) from the search. Must be a valid model molecule.
    imol_map : int
        The map molecule index to search for unmodeled density. This is typically a difference map (mFo-DFc) for most sensitive detection, but can also be a regular map (2mFo-DFc). Must be a valid map molecule.
    cut_off_sigma_density_level : float

    """
    return _coot.find_blobs_py(imol_model, imol_map, cut_off_sigma_density_level)

def b_factor_distribution_graph(imol):
    r"""
    b_factor_distribution_graph(int imol)

    B-factor distribution histogram.

    Parameters
    ----------
    imol : int

    """
    return _coot.b_factor_distribution_graph(imol)

def water_chain_from_shelx_ins_py(imol):
    r"""
    water_chain_from_shelx_ins_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.water_chain_from_shelx_ins_py(imol)

def water_chain_py(imol):
    r"""
    water_chain_py(int imol) -> PyObject *

    return the chain id of the water chain. Raw interface

    Parameters
    ----------
    imol : int

    """
    return _coot.water_chain_py(imol)

def add_status_bar_text(s):
    r"""
    add_status_bar_text(std::string const & s)

    Put text s into the status bar.

    use this to put info for the user in the statusbar (less intrusive than popup).

    Parameters
    ----------
    s : str

    """
    return _coot.add_status_bar_text(s)

def set_logging_level(level):
    r"""
    set_logging_level(std::string const & level)

    set the logging level

      level  is either "LOW" or "HIGH" or "DEBUGGING"

    Parameters
    ----------
    level : str
        is either "LOW" or "HIGH" or "DEBUGGING"

    """
    return _coot.set_logging_level(level)

def print_glyco_tree(imol, chain_id, resno, ins_code):
    r"""
    print_glyco_tree(int imol, std::string const & chain_id, int resno, std::string const & ins_code)

    print the glycosylation tree that contains the specified residue

    Parameters
    ----------
    imol : int
    chain_id : str
    resno : int
    ins_code : str

    """
    return _coot.print_glyco_tree(imol, chain_id, resno, ins_code)

def make_variance_map(map_molecule_number_vec):
    r"""
    make_variance_map(IntVector map_molecule_number_vec) -> int


    Parameters
    ----------
    map_molecule_number_vec : list

    """
    return _coot.make_variance_map(map_molecule_number_vec)

def make_variance_map_py(map_molecule_number_list):
    r"""
    make_variance_map_py(PyObject * map_molecule_number_list) -> int


    Parameters
    ----------
    map_molecule_number_list : object

    """
    return _coot.make_variance_map_py(map_molecule_number_list)

def spin_search_by_atom_vectors(imol_map, imol, chain_id, resno, ins_code, direction_atoms_list, moving_atoms_list):
    r"""
    spin_search_by_atom_vectors(int imol_map, int imol, std::string const & chain_id, int resno, std::string const & ins_code, pair_string_string direction_atoms_list, vector_string moving_atoms_list)


    Parameters
    ----------
    imol_map : int
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    direction_atoms_list : const std::pair< std::string, std::string > &
    moving_atoms_list : list

    """
    return _coot.spin_search_by_atom_vectors(imol_map, imol, chain_id, resno, ins_code, direction_atoms_list, moving_atoms_list)

def spin_search_py(imol_map, imol, chain_id, resno, ins_code, direction_atoms_list, moving_atoms_list):
    r"""
    spin_search_py(int imol_map, int imol, char const * chain_id, int resno, char const * ins_code, PyObject * direction_atoms_list, PyObject * moving_atoms_list)

    for the given residue, spin the atoms in moving_atom_list...

    around the bond defined by direction_atoms_list looking for the best fit to density of imom_map map of the first atom in moving_atom_list. Works (only) with atoms in altconf ""

    Parameters
    ----------
    imol_map : int
    imol : int
    chain_id : str
    resno : int
    ins_code : str
    direction_atoms_list : object
    moving_atoms_list : object

    """
    return _coot.spin_search_py(imol_map, imol, chain_id, resno, ins_code, direction_atoms_list, moving_atoms_list)

def spin_N_py(imol, residue_spec, angle):
    r"""
    spin_N_py(int imol, PyObject * residue_spec, float angle)

    Spin N and CB (and the rest of the side chain if extant)

    Sometime on N-terminal addition, then N ends up pointing the wrong way. The allows us to (more or less) interchange the positions of the CB and the N. angle is in degrees.

      imol  is the index of the model molecule   residue_spec  is the specifier for the residue   angle  is the rotation angle, in degrees, typically 120.

    Parameters
    ----------
    imol : int
        is the index of the model molecule
    residue_spec : object
        is the specifier for the residue
    angle : float
        is the rotation angle, in degrees, typically 120.

    """
    return _coot.spin_N_py(imol, residue_spec, angle)

def CG_spin_search_py(imol_model, imol_map):
    r"""
    CG_spin_search_py(int imol_model, int imol_map) -> PyObject *

    Spin search the density based on possible positions of CG of a side-chain

      imol_model  is the index of the model molecule   imol_map  is the index of the map molecule either False (in the case of a failure) or a list of pairs of residue specifers and score - for each spinnable residue in the model.

    Parameters
    ----------
    imol_model : int
        is the index of the model molecule
    imol_map : int
        is the index of the map molecule

    """
    return _coot.CG_spin_search_py(imol_model, imol_map)

def monomer_lib_3_letter_codes_matching(search_string, allow_minimal_descriptions_flag):
    r"""
    monomer_lib_3_letter_codes_matching(std::string const & search_string, short allow_minimal_descriptions_flag) -> vector_pair_string_string


    Parameters
    ----------
    search_string : str
    allow_minimal_descriptions_flag : int

    """
    return _coot.monomer_lib_3_letter_codes_matching(search_string, allow_minimal_descriptions_flag)

def mutate_residue_range(imol, chain_id, res_no_start, res_no_end, target_sequence):
    r"""
    mutate_residue_range(int imol, std::string const & chain_id, int res_no_start, int res_no_end, std::string const & target_sequence) -> int


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no_start : int
    res_no_end : int
    target_sequence : str

    """
    return _coot.mutate_residue_range(imol, chain_id, res_no_start, res_no_end, target_sequence)

def mutate_internal(ires, chain_id, imol, target_res_type):
    r"""
    mutate_internal(int ires, char const * chain_id, int imol, std::string const & target_res_type) -> int


    Parameters
    ----------
    ires : int
    chain_id : str
    imol : int
    target_res_type : str

    """
    return _coot.mutate_internal(ires, chain_id, imol, target_res_type)

def mutate_active_residue_to_single_letter_code(slc):
    r"""
    mutate_active_residue_to_single_letter_code(std::string const & slc)

    mutate active residue to single letter code slc

    Parameters
    ----------
    slc : str

    """
    return _coot.mutate_active_residue_to_single_letter_code(slc)

def show_keyboard_mutate_frame():
    r"""
    show_keyboard_mutate_frame()

    show keyboard mutate frame

    """
    return _coot.show_keyboard_mutate_frame()

def mutate_by_overlap(imol, chain_id, res_no, new_type):
    r"""
    mutate_by_overlap(int imol, std::string const & chain_id, int res_no, std::string const & new_type) -> int

    mutate by overlap

    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    new_type : str

    """
    return _coot.mutate_by_overlap(imol, chain_id, res_no, new_type)

def overlap_ligands_internal(imol_ligand, imol_ref, chain_id_ref, resno_ref, apply_rtop_flag):
    r"""
    overlap_ligands_internal(int imol_ligand, int imol_ref, char const * chain_id_ref, int resno_ref, bool apply_rtop_flag) -> coot::graph_match_info_t


    Parameters
    ----------
    imol_ligand : int
    imol_ref : int
    chain_id_ref : str
    resno_ref : int
    apply_rtop_flag : bool

    """
    return _coot.overlap_ligands_internal(imol_ligand, imol_ref, chain_id_ref, resno_ref, apply_rtop_flag)

def do_smiles_to_simple_3d_overlay_frame():
    r"""
    do_smiles_to_simple_3d_overlay_frame()

    display the SMILES entry. This is the simple version - no dictionary is generated.

    """
    return _coot.do_smiles_to_simple_3d_overlay_frame()

def get_residues_in_chain_py(imol, chain_id):
    r"""
    get_residues_in_chain_py(int imol, std::string const & chain_id) -> PyObject *

    get residues in the specified chain

      imol  the molecule index   chain_id  the specified chain-id a python list of residue specs for the residues in the given chain

    Parameters
    ----------
    imol : int
        the molecule index
    chain_id : str
        the specified chain-id

    """
    return _coot.get_residues_in_chain_py(imol, chain_id)

def residue_exists_py(imol, residue_spec_py):
    r"""
    residue_exists_py(int imol, PyObject * residue_spec_py) -> int

    does the specfied residue exist?

      imol  the molecule index   spec  is the residue spec to test for existance 0 for no, 1 for yes, -1 for error

    Parameters
    ----------
    imol : int
        the molecule index
    residue_spec_py : object

    """
    return _coot.residue_exists_py(imol, residue_spec_py)

def ligand_search_make_conformers_py():
    r"""ligand_search_make_conformers_py() -> PyObject *"""
    return _coot.ligand_search_make_conformers_py()

def get_rdkit_mol_base64_from_molecule(imol, residue_spec):
    r"""
    get_rdkit_mol_base64_from_molecule(int imol, PyObject * residue_spec) -> std::string

    get an rdkit molecule as a pickled string

      imol  the index of the molecule   residue  spec the residue specifier, e..g ['A', 11, ""] pickled string. Return empty string on failure.

    Parameters
    ----------
    imol : int
        the index of the molecule
    residue_spec : object

    """
    return _coot.get_rdkit_mol_base64_from_molecule(imol, residue_spec)

def molecule_from_rdkit_mol_base64(rdkit_mol, atom_name_list, comp_id):
    r"""
    molecule_from_rdkit_mol_base64(std::string const & rdkit_mol, PyObject * atom_name_list, std::string const & comp_id) -> int

    and back the other way - import an RDKit mol in base64-encoded binary format

    the index of the new molecule - or -1 on failure

    Parameters
    ----------
    rdkit_mol : str
    atom_name_list : object
    comp_id : str

    """
    return _coot.molecule_from_rdkit_mol_base64(rdkit_mol, atom_name_list, comp_id)

def restraints_from_rdkit_mol_base64(rdkit_mol_binary_base64, atom_name_list_py, comp_id):
    r"""
    restraints_from_rdkit_mol_base64(std::string const & rdkit_mol_binary_base64, PyObject * atom_name_list_py, std::string const & comp_id) -> int


    Parameters
    ----------
    rdkit_mol_binary_base64 : str
    atom_name_list_py : object
    comp_id : str

    """
    return _coot.restraints_from_rdkit_mol_base64(rdkit_mol_binary_base64, atom_name_list_py, comp_id)

def ligand_search_make_conformers_internal():
    r"""ligand_search_make_conformers_internal() -> IntVector"""
    return _coot.ligand_search_make_conformers_internal()

def add_animated_ligand_interaction(imol, lb):
    r"""
    add_animated_ligand_interaction(int imol, pli::fle_ligand_bond_t const & lb)


    Parameters
    ----------
    imol : int
    lb : const pli::fle_ligand_bond_t &

    """
    return _coot.add_animated_ligand_interaction(imol, lb)

def cootaneer_internal(imol_map, imol_model, atom_spec):
    r"""
    cootaneer_internal(int imol_map, int imol_model, atom_spec_t atom_spec) -> int


    Parameters
    ----------
    imol_map : int
    imol_model : int
    atom_spec : atom_spec

    """
    return _coot.cootaneer_internal(imol_map, imol_model, atom_spec)

def cootaneer_py(imol_map, imol_model, atom_in_fragment_atom_spec):
    r"""
    cootaneer_py(int imol_map, int imol_model, PyObject * atom_in_fragment_atom_spec) -> int

    cootaneer (i.e. assign sidechains onto mainchain model)

    atom_in_fragment_atom_spec is any atom spec in the fragment that should be assigned with sidechains.

    the success status (0 is fail).

    Parameters
    ----------
    imol_map : int
    imol_model : int
    atom_in_fragment_atom_spec : object

    """
    return _coot.cootaneer_py(imol_map, imol_model, atom_in_fragment_atom_spec)

def sequence_from_map(imol, chain_id, resno_start, resno_end, imol_map):
    r"""
    sequence_from_map(int imol, std::string const & chain_id, int resno_start, int resno_end, int imol_map) -> std::string


    Parameters
    ----------
    imol : int
    chain_id : str
    resno_start : int
    resno_end : int
    imol_map : int

    """
    return _coot.sequence_from_map(imol, chain_id, resno_start, resno_end, imol_map)

def apply_sequence_to_fragment(imol, chain_id, resno_start, resno_end, imol_map, file_name_for_sequences):
    r"""
    apply_sequence_to_fragment(int imol, std::string const & chain_id, int resno_start, int resno_end, int imol_map, std::string const & file_name_for_sequences)


    Parameters
    ----------
    imol : int
    chain_id : str
    resno_start : int
    resno_end : int
    imol_map : int
    file_name_for_sequences : str

    """
    return _coot.apply_sequence_to_fragment(imol, chain_id, resno_start, resno_end, imol_map, file_name_for_sequences)

def assign_sequence_to_active_fragment():
    r"""assign_sequence_to_active_fragment()"""
    return _coot.assign_sequence_to_active_fragment()

def is_interesting_dots_object_next_p(vs):
    r"""
    is_interesting_dots_object_next_p(vector_string vs) -> std::pair< short,std::string >


    Parameters
    ----------
    vs : list

    """
    return _coot.is_interesting_dots_object_next_p(vs)

def generic_string_vector_to_list_internal_py(v):
    r"""
    generic_string_vector_to_list_internal_py(vector_string v) -> PyObject *


    Parameters
    ----------
    v : list

    """
    return _coot.generic_string_vector_to_list_internal_py(v)

def generic_int_vector_to_list_internal_py(v):
    r"""
    generic_int_vector_to_list_internal_py(IntVector v) -> PyObject *


    Parameters
    ----------
    v : list

    """
    return _coot.generic_int_vector_to_list_internal_py(v)

def generic_list_to_string_vector_internal_py(l):
    r"""
    generic_list_to_string_vector_internal_py(PyObject * l) -> vector_string


    Parameters
    ----------
    l : object

    """
    return _coot.generic_list_to_string_vector_internal_py(l)

def rtop_to_python(rtop):
    r"""
    rtop_to_python(clipper::RTop_orth const & rtop) -> PyObject *


    Parameters
    ----------
    rtop : const clipper::RTop_orth &

    """
    return _coot.rtop_to_python(rtop)

def inverse_rtop_py(rtop_py):
    r"""
    inverse_rtop_py(PyObject * rtop_py) -> PyObject *


    Parameters
    ----------
    rtop_py : object

    """
    return _coot.inverse_rtop_py(rtop_py)

def atom_spec_from_python_expression(expr):
    r"""
    atom_spec_from_python_expression(PyObject * expr) -> atom_spec_t


    Parameters
    ----------
    expr : object

    """
    return _coot.atom_spec_from_python_expression(expr)

def atom_spec_to_py(spec):
    r"""
    atom_spec_to_py(atom_spec_t spec) -> PyObject *


    Parameters
    ----------
    spec : atom_spec

    """
    return _coot.atom_spec_to_py(spec)

def set_display_control_button_state(imol, button_type, state):
    r"""
    set_display_control_button_state(int imol, std::string const & button_type, int state)


    Parameters
    ----------
    imol : int
    button_type : str
    state : int

    """
    return _coot.set_display_control_button_state(imol, button_type, state)

def fullscreen():
    r"""fullscreen()"""
    return _coot.fullscreen()

def unfullscreen():
    r"""unfullscreen()"""
    return _coot.unfullscreen()

def set_use_trackpad(state):
    r"""
    set_use_trackpad(short state)

    Use left-mouse for view rotation.

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_trackpad(state)

def set_use_primary_mouse_button_for_view_rotation(state):
    r"""
    set_use_primary_mouse_button_for_view_rotation(short state)

    this is an alias for the above

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_primary_mouse_button_for_view_rotation(state)

def get_coords_for_accession_code(code):
    r"""
    get_coords_for_accession_code(std::string const & code)

    if possible, read in the new coords getting coords via web.

    (no return value because get-url-str does not return one).

    Parameters
    ----------
    code : str

    """
    return _coot.get_coords_for_accession_code(code)

def coot_get_url_as_string_internal(url):
    r"""
    coot_get_url_as_string_internal(char const * url) -> std::string


    Parameters
    ----------
    url : str

    """
    return _coot.coot_get_url_as_string_internal(url)

def stop_curl_download(file_name):
    r"""
    stop_curl_download(char const * file_name)


    Parameters
    ----------
    file_name : str

    """
    return _coot.stop_curl_download(file_name)

def get_drug_mdl_via_wikipedia_and_drugbank(drugname):
    r"""
    get_drug_mdl_via_wikipedia_and_drugbank(std::string drugname) -> std::string


    Parameters
    ----------
    drugname : str

    """
    return _coot.get_drug_mdl_via_wikipedia_and_drugbank(drugname)

def fetch_and_superpose_alphafold_models(imol):
    r"""
    fetch_and_superpose_alphafold_models(int imol)

    fetch and superpose AlphaFold models corresponding to model

    model must have Uniprot DBREF info in the header.

    Parameters
    ----------
    imol : int

    """
    return _coot.fetch_and_superpose_alphafold_models(imol)

def fetch_alphafold_model_for_uniprot_id(uniprot_id):
    r"""
    fetch_alphafold_model_for_uniprot_id(std::string const & uniprot_id) -> int

    return the model number

    Parameters
    ----------
    uniprot_id : str

    """
    return _coot.fetch_alphafold_model_for_uniprot_id(uniprot_id)

def fetch_emdb_map(emd_accession_code):
    r"""
    fetch_emdb_map(std::string const & emd_accession_code)

    Loads up map from emdb.

    This is an asynchronous function and wil trigger a download subthread and return immediately.

      emd_accession_code  the EMDB accession code

    Parameters
    ----------
    emd_accession_code : str
        the EMDB accession code

    """
    return _coot.fetch_emdb_map(emd_accession_code)

def fetch_cod_entry(cod_entry_id):
    r"""
    fetch_cod_entry(std::string const & cod_entry_id) -> int

    return the COD entry, return a molecule index

    Parameters
    ----------
    cod_entry_id : str

    """
    return _coot.fetch_cod_entry(cod_entry_id)

def orient_view(imol, central_residue_spec, neighbour_residue_spec):
    r"""
    orient_view(int imol, residue_spec_t central_residue_spec, residue_spec_t neighbour_residue_spec)


    Parameters
    ----------
    imol : int
    central_residue_spec : residue_spec
    neighbour_residue_spec : residue_spec

    """
    return _coot.orient_view(imol, central_residue_spec, neighbour_residue_spec)

def topological_equivalence_chiral_centres(residue_type):
    r"""
    topological_equivalence_chiral_centres(std::string const & residue_type) -> vector_string


    Parameters
    ----------
    residue_type : str

    """
    return _coot.topological_equivalence_chiral_centres(residue_type)

def screendump_tga(file_name):
    r"""
    screendump_tga(std::string const & file_name)


    Parameters
    ----------
    file_name : str

    """
    return _coot.screendump_tga(file_name)

def set_framebuffer_scale_factor(sf):
    r"""
    set_framebuffer_scale_factor(unsigned int sf)


    Parameters
    ----------
    sf : int

    """
    return _coot.set_framebuffer_scale_factor(sf)

def set_use_perspective_projection(state):
    r"""
    set_use_perspective_projection(short state)

    set use perspective mode

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_perspective_projection(state)

def use_perspective_projection_state():
    r"""
    use_perspective_projection_state() -> int

    query if perspective mode is being used

    """
    return _coot.use_perspective_projection_state()

def set_perspective_fov(degrees):
    r"""
    set_perspective_fov(float degrees)

    set the perspective fov. Default 20 degrees.

    Parameters
    ----------
    degrees : float

    """
    return _coot.set_perspective_fov(degrees)

def set_use_ambient_occlusion(state):
    r"""
    set_use_ambient_occlusion(short state)

    set use ambient occlusion

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_ambient_occlusion(state)

def use_ambient_occlusion_state():
    r"""
    use_ambient_occlusion_state() -> int

    query use ambient occlusion

    """
    return _coot.use_ambient_occlusion_state()

def set_use_depth_blur(state):
    r"""
    set_use_depth_blur(short state)

    set use depth blur

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_depth_blur(state)

def use_depth_blur_state():
    r"""
    use_depth_blur_state() -> int

    query use depth blur

    """
    return _coot.use_depth_blur_state()

def set_use_fog(state):
    r"""
    set_use_fog(short state)

    set use fog

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_fog(state)

def use_fog_state():
    r"""
    use_fog_state() -> int

    query use fog

    """
    return _coot.use_fog_state()

def set_use_outline(state):
    r"""
    set_use_outline(short state)

    set use ourline

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_outline(state)

def use_outline_state():
    r"""
    use_outline_state() -> int

    query use outline

    """
    return _coot.use_outline_state()

def set_map_shininess(imol, shininess):
    r"""
    set_map_shininess(int imol, float shininess)

    set the map shininess

    Parameters
    ----------
    imol : int
    shininess : float

    """
    return _coot.set_map_shininess(imol, shininess)

def set_map_specular_strength(imol, specular_strength):
    r"""
    set_map_specular_strength(int imol, float specular_strength)

    set the map specular strength

    Parameters
    ----------
    imol : int
    specular_strength : float

    """
    return _coot.set_map_specular_strength(imol, specular_strength)

def set_draw_normals(state):
    r"""
    set_draw_normals(short state)


    Parameters
    ----------
    state : int

    """
    return _coot.set_draw_normals(state)

def draw_normals_state():
    r"""draw_normals_state() -> int"""
    return _coot.draw_normals_state()

def set_draw_mesh(imol, mesh_index, state):
    r"""
    set_draw_mesh(int imol, int mesh_index, short state)


    Parameters
    ----------
    imol : int
    mesh_index : int
    state : int

    """
    return _coot.set_draw_mesh(imol, mesh_index, state)

def draw_mesh_state(imol, mesh_index):
    r"""
    draw_mesh_state(int imol, int mesh_index) -> int

    return -1 on unable to lookup mesh

    Parameters
    ----------
    imol : int
    mesh_index : int

    """
    return _coot.draw_mesh_state(imol, mesh_index)

def set_map_material_specular(imol, specular_strength, shininess):
    r"""
    set_map_material_specular(int imol, float specular_strength, float shininess)


    Parameters
    ----------
    imol : int
    specular_strength : float
    shininess : float

    """
    return _coot.set_map_material_specular(imol, specular_strength, shininess)

def set_model_material_specular(imol, specular_strength, shininess):
    r"""
    set_model_material_specular(int imol, float specular_strength, float shininess)


    Parameters
    ----------
    imol : int
    specular_strength : float
    shininess : float

    """
    return _coot.set_model_material_specular(imol, specular_strength, shininess)

def set_model_material_ambient(imol, r, g, b, alpha):
    r"""
    set_model_material_ambient(int imol, float r, float g, float b, float alpha)

    set the ambient

    Parameters
    ----------
    imol : int
    r : float
    g : float
    b : float
    alpha : float

    """
    return _coot.set_model_material_ambient(imol, r, g, b, alpha)

def set_model_material_diffuse(imol, r, g, b, alpha):
    r"""
    set_model_material_diffuse(int imol, float r, float g, float b, float alpha)


    Parameters
    ----------
    imol : int
    r : float
    g : float
    b : float
    alpha : float

    """
    return _coot.set_model_material_diffuse(imol, r, g, b, alpha)

def set_model_goodselliness(pastelization_factor):
    r"""
    set_model_goodselliness(float pastelization_factor)

    set the goodselliness (pastelization_factor) 0.3 is about right, but "the right value" depends on the renderer, may be some personal choice.

    Parameters
    ----------
    pastelization_factor : float

    """
    return _coot.set_model_goodselliness(pastelization_factor)

def set_map_fresnel_settings(imol, state, bias, scale, power):
    r"""
    set_map_fresnel_settings(int imol, short state, float bias, float scale, float power)


    Parameters
    ----------
    imol : int
    state : int
    bias : float
    scale : float
    power : float

    """
    return _coot.set_map_fresnel_settings(imol, state, bias, scale, power)

def reload_map_shader():
    r"""reload_map_shader()"""
    return _coot.reload_map_shader()

def reload_model_shader():
    r"""reload_model_shader()"""
    return _coot.reload_model_shader()

def set_atom_radius_scale_factor(imol, scale_factor):
    r"""
    set_atom_radius_scale_factor(int imol, float scale_factor)


    Parameters
    ----------
    imol : int
    scale_factor : float

    """
    return _coot.set_atom_radius_scale_factor(imol, scale_factor)

def set_use_fancy_lighting(state):
    r"""
    set_use_fancy_lighting(short state)

    set use fancy rendering lighting

    Turn on framebuffer effects

      state  where 1 mean turn on and 0 means turn off.

    Parameters
    ----------
    state : int
        where 1 mean turn on and 0 means turn off.

    """
    return _coot.set_use_fancy_lighting(state)

def set_use_simple_lines_for_model_molecules(state):
    r"""
    set_use_simple_lines_for_model_molecules(short state)

    set use simple lines for model molecule

      state  where 1 mean turn on and 0 means turn off.

    Parameters
    ----------
    state : int
        where 1 mean turn on and 0 means turn off.

    """
    return _coot.set_use_simple_lines_for_model_molecules(state)

def set_fresnel_colour(imol, red, green, blue, opacity):
    r"""
    set_fresnel_colour(int imol, float red, float green, float blue, float opacity)

      state  where 1 mean turn on and 0 means turn off.

    Parameters
    ----------
    imol : int
    red : float
    green : float
    blue : float
    opacity : float

    """
    return _coot.set_fresnel_colour(imol, red, green, blue, opacity)

def set_focus_blur_z_depth(z):
    r"""
    set_focus_blur_z_depth(float z)


    Parameters
    ----------
    z : float

    """
    return _coot.set_focus_blur_z_depth(z)

def set_focus_blur_strength(st):
    r"""
    set_focus_blur_strength(float st)

    set focus blur strength

    Parameters
    ----------
    st : float

    """
    return _coot.set_focus_blur_strength(st)

def set_shadow_strength(s):
    r"""
    set_shadow_strength(float s)

    set shadow stren

      s  is the shadow strength between 0 and 1.

    Parameters
    ----------
    s : float
        is the shadow strength between 0 and 1.

    """
    return _coot.set_shadow_strength(s)

def set_shadow_resolution(reso_multiplier):
    r"""
    set_shadow_resolution(int reso_multiplier)

    set the shadow resolution (1,2,3,4)

    Parameters
    ----------
    reso_multiplier : int

    """
    return _coot.set_shadow_resolution(reso_multiplier)

def set_shadow_box_size(size):
    r"""
    set_shadow_box_size(float size)

    set shadow box size - default 66;

    Parameters
    ----------
    size : float

    """
    return _coot.set_shadow_box_size(size)

def set_ssao_kernel_n_samples(n_samples):
    r"""
    set_ssao_kernel_n_samples(unsigned int n_samples)

    set SSAO kernel n samples

    Parameters
    ----------
    n_samples : int

    """
    return _coot.set_ssao_kernel_n_samples(n_samples)

def set_ssao_strength(strength):
    r"""
    set_ssao_strength(float strength)

    set SSAO strength

    screen-space ambient occlusionn

      strength  is the SSAO strength between 0 and 1.

    Parameters
    ----------
    strength : float
        is the SSAO strength between 0 and 1.

    """
    return _coot.set_ssao_strength(strength)

def set_ssao_radius(radius):
    r"""
    set_ssao_radius(float radius)

    set SSAO radius

    screen-space ambient occlusionn Doesn't do much. Not worth adjusting

      radius  is the SSAO radius.

    Parameters
    ----------
    radius : float
        is the SSAO radius.

    """
    return _coot.set_ssao_radius(radius)

def set_ssao_bias(bias):
    r"""
    set_ssao_bias(float bias)

    set SSAO bias

    screen-space ambient occlusionn Doesn't do much. Not worth adjusting

    Parameters
    ----------
    bias : float

    """
    return _coot.set_ssao_bias(bias)

def set_ssao_blur_size(blur_size):
    r"""
    set_ssao_blur_size(unsigned int blur_size)

    set SSAO blur size (0, 1, or 2)

    Parameters
    ----------
    blur_size : int

    """
    return _coot.set_ssao_blur_size(blur_size)

def set_shadow_softness(softness):
    r"""
    set_shadow_softness(unsigned int softness)

    set the shadow softness (1, 2 or 3)

    Parameters
    ----------
    softness : int

    """
    return _coot.set_shadow_softness(softness)

def set_shadow_texture_resolution_multiplier(m):
    r"""
    set_shadow_texture_resolution_multiplier(unsigned int m)

    set the shadow softness (1, 2 or 3)

    Parameters
    ----------
    m : int

    """
    return _coot.set_shadow_texture_resolution_multiplier(m)

def set_effects_shader_output_type(type):
    r"""
    set_effects_shader_output_type(unsigned int type)

    adjust the effects shader output type (for debugging effects)

    Parameters
    ----------
    type : int

    """
    return _coot.set_effects_shader_output_type(type)

def set_effects_shader_brightness(f):
    r"""
    set_effects_shader_brightness(float f)

    adjust the effects shader brightness

    Parameters
    ----------
    f : float

    """
    return _coot.set_effects_shader_brightness(f)

def set_effects_shader_gamma(f):
    r"""
    set_effects_shader_gamma(float f)

    adjust the effects shader gamma

    Parameters
    ----------
    f : float

    """
    return _coot.set_effects_shader_gamma(f)

def set_bond_smoothness_factor(fac):
    r"""
    set_bond_smoothness_factor(unsigned int fac)

    set bond smoothness (default 1 (not smooth))

    Use fac 3 for screenshots

      fac  (1: course, 2: smooth, 3: fine)

    Parameters
    ----------
    fac : int
        (1: course, 2: smooth, 3: fine)

    """
    return _coot.set_bond_smoothness_factor(fac)

def toggle_bond_smoothness_factor():
    r"""
    toggle_bond_smoothness_factor()

    increase bond smoothness

    and if it's currently at 3, reset back to 1

    """
    return _coot.toggle_bond_smoothness_factor()

def set_draw_gl_ramachandran_plot_during_refinement(state):
    r"""
    set_draw_gl_ramachandran_plot_during_refinement(short state)

    set the draw state of the Ramachandran plot display during Real Space Refinement

    Parameters
    ----------
    state : int

    """
    return _coot.set_draw_gl_ramachandran_plot_during_refinement(state)

def set_fps_timing_scale_factor(f):
    r"""
    set_fps_timing_scale_factor(float f)

    set the FPS timing scale factor - default 0.0025

    Parameters
    ----------
    f : float

    """
    return _coot.set_fps_timing_scale_factor(f)

def set_draw_background_image(state):
    r"""
    set_draw_background_image(bool state)

    draw background image

    Parameters
    ----------
    state : bool

    """
    return _coot.set_draw_background_image(state)

def read_test_gltf_models():
    r"""read_test_gltf_models()"""
    return _coot.read_test_gltf_models()

def load_gltf_model(gltf_file_name):
    r"""
    load_gltf_model(std::string const & gltf_file_name) -> int

    load a gltf model

    If the gltf files does not exist, an empty model will be created

      gltf_file_name  is the name of the gltf file to load the model index of the loaded model.

    Parameters
    ----------
    gltf_file_name : str
        is the name of the gltf file to load

    """
    return _coot.load_gltf_model(gltf_file_name)

def set_model_animation_parameters(model_index, amplitude, wave_numer, freq):
    r"""
    set_model_animation_parameters(unsigned int model_index, float amplitude, float wave_numer, float freq)

    set the model animation parameters

    Parameters
    ----------
    model_index : int
    amplitude : float
    wave_numer : float
    freq : float

    """
    return _coot.set_model_animation_parameters(model_index, amplitude, wave_numer, freq)

def set_model_animation_state(model_index, state):
    r"""
    set_model_animation_state(unsigned int model_index, bool state)

    enable/disable the model animation (on or off)

    Parameters
    ----------
    model_index : int
    state : bool

    """
    return _coot.set_model_animation_state(model_index, state)

def scale_model(model_index, scale_factor):
    r"""
    scale_model(unsigned int model_index, float scale_factor)

    load a gltf model

    Parameters
    ----------
    model_index : int
    scale_factor : float

    """
    return _coot.scale_model(model_index, scale_factor)

def reset_framebuffers():
    r"""
    reset_framebuffers()

    reset the frame buffers

    """
    return _coot.reset_framebuffers()

def score_rotamers(imol, chain_id, res_no, ins_code, alt_conf, imol_map, clash_flag, lowest_probability):
    r"""
    score_rotamers(int imol, char const * chain_id, int res_no, char const * ins_code, char const * alt_conf, int imol_map, int clash_flag, float lowest_probability) -> std::vector< coot::named_rotamer_score,std::allocator< coot::named_rotamer_score > >


    Parameters
    ----------
    imol : int
    chain_id : str
    res_no : int
    ins_code : str
    alt_conf : str
    imol_map : int
    clash_flag : int
    lowest_probability : float

    """
    return _coot.score_rotamers(imol, chain_id, res_no, ins_code, alt_conf, imol_map, clash_flag, lowest_probability)

def score_rotamers_py(imol, chain_id, res_no, ins_code, alt_conf, imol_map, clash_flag, lowest_probability):
    r"""
    score_rotamers_py(int imol, char const * chain_id, int res_no, char const * ins_code, char const * alt_conf, int imol_map, int clash_flag, float lowest_probability) -> PyObject *

    Score all rotamers for a residue (Python interface)

    USEFUL FOR FIXING BAD ROTAMERS

    Evaluates all possible rotamer conformations and returns them with scores. This is the function to call before using auto_fit_best_rotamer.

      imol  Model molecule number   chain_id  Chain identifier   res_no  Residue number   ins_code  Insertion code (use "" if none)   alt_conf  Alternate conformation (use "" for default)   imol_map  Map molecule for density scoring (use -1 to ignore density)   clash_flag  1 to check for clashes with other atoms, 0 to skip   lowest_probability  Filter: only return rotamers above this probability PyObject* - List of rotamer dictionaries, each containing:  'name': Rotamer name (e.g., "mt-85") 'probability': Rotamer library probability (0.0-1.0) 'density_score': Fit to density (if map provided) 'richardson_name': Rotamer name in Richardson notation Empty list if no suitable rotamers found. Rotamers are ranked by combined probability and density fit Use clash_flag=1 to avoid rotamers that clash with nearby atoms Example usage: # Score rotamers for LEU 42, considering density and clashes rotamers = score_rotamers_py ( imol=1, chain_id= "A" , res_no=42, ins_code= "" , alt_conf= "" , imol_map=2, # Use map 2 for density scoring clash_flag=1, # Check for clashes lowest_probability=0.01 # Only show rotamers >1% probability ) print(f "Found {len(rotamers)} possible rotamers" ) for rot in rotamers: print(f "{rot['name']}: " f "prob={rot['probability']:.1%}, " f "fit={rot['density_score']:.3f}" ) # The best rotamer is typically first in the list if rotamers: best = rotamers[0] print(f "Best rotamer: {best['name']}" )

    Parameters
    ----------
    imol : int
        Model molecule number
    chain_id : str
        Chain identifier
    res_no : int
        Residue number
    ins_code : str
        Insertion code (use "" if none)
    alt_conf : str
        Alternate conformation (use "" for default)
    imol_map : int
        Map molecule for density scoring (use -1 to ignore density)
    clash_flag : int
        1 to check for clashes with other atoms, 0 to skip
    lowest_probability : float
        Filter: only return rotamers above this probability

    """
    return _coot.score_rotamers_py(imol, chain_id, res_no, ins_code, alt_conf, imol_map, clash_flag, lowest_probability)

def protein_db_loops(imol_coords, residue_specs, imol_map, nfrags, preserve_residue_names):
    r"""
    protein_db_loops(int imol_coords, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & residue_specs, int imol_map, int nfrags, bool preserve_residue_names) -> std::pair< std::pair< int,int >,std::vector< int,std::allocator< int > > >

    Cowtan's protein_db loops.

    Parameters
    ----------
    imol_coords : int
    residue_specs : list
    imol_map : int
    nfrags : int
    preserve_residue_names : bool

    """
    return _coot.protein_db_loops(imol_coords, residue_specs, imol_map, nfrags, preserve_residue_names)

def protein_db_loop_specs_to_atom_selection_string(specs):
    r"""
    protein_db_loop_specs_to_atom_selection_string(std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & specs) -> std::string


    Parameters
    ----------
    specs : list

    """
    return _coot.protein_db_loop_specs_to_atom_selection_string(specs)

def protein_db_loops_py(imol_coords, residues_specs, imol_map, nfrags, preserve_residue_names):
    r"""
    protein_db_loops_py(int imol_coords, PyObject * residues_specs, int imol_map, int nfrags, bool preserve_residue_names) -> PyObject *

    Cowtan's protein_db loops.

    return in the first pair, the imol of the new molecule generated from an atom selection of the imol_coords for the residue selection of the loop and the molecule number of the consolidated solutions (displayed in purple). and the second of the outer pair, there is vector of molecule indices for each of the candidate loops.

    Use this to create hypotheses about where the atoms of the missing residues could be. Often the top/first solution is the best one. This fragment will then need to be patched back into molecule imol_coords using copy_fragment().

    return -1 in the first of the pair on failure

    Parameters
    ----------
    imol_coords : int
    residues_specs : object
    imol_map : int
    nfrags : int
    preserve_residue_names : bool

    """
    return _coot.protein_db_loops_py(imol_coords, residues_specs, imol_map, nfrags, preserve_residue_names)

def hole(imol, start_x, start_y, start_z, end_x, end_y, end_z, colour_map_multiplier, colour_map_offset, n_runs, show_probe_radius_graph_flag, export_surface_dots_file_name):
    r"""
    hole(int imol, float start_x, float start_y, float start_z, float end_x, float end_y, float end_z, float colour_map_multiplier, float colour_map_offset, int n_runs, bool show_probe_radius_graph_flag, std::string export_surface_dots_file_name)

    starting point and end point, colour map multiplier and shall the probe radius graph be shown (dummy value currently).

    if export_dots_file_name string length is zero, then don't try to export the surface dots.

    Parameters
    ----------
    imol : int
    start_x : float
    start_y : float
    start_z : float
    end_x : float
    end_y : float
    end_z : float
    colour_map_multiplier : float
    colour_map_offset : float
    n_runs : int
    show_probe_radius_graph_flag : bool
    export_surface_dots_file_name : str

    """
    return _coot.hole(imol, start_x, start_y, start_z, end_x, end_y, end_z, colour_map_multiplier, colour_map_offset, n_runs, show_probe_radius_graph_flag, export_surface_dots_file_name)

def gaussian_surface(imol):
    r"""
    gaussian_surface(int imol) -> int

    The surface is separated into chains to make Generid Display Objects There is no colour, contour, grid or sigma or material control yet for Gaussian surfaces.

    there should be one day...

    Parameters
    ----------
    imol : int

    """
    return _coot.gaussian_surface(imol)

def set_gaussian_surface_sigma(s):
    r"""
    set_gaussian_surface_sigma(float s)

    set the sigma for gaussian surface (default 4.0)

    Parameters
    ----------
    s : float

    """
    return _coot.set_gaussian_surface_sigma(s)

def set_gaussian_surface_contour_level(s):
    r"""
    set_gaussian_surface_contour_level(float s)

    set the contour_level for gaussian surface (default 4.4)

    Parameters
    ----------
    s : float

    """
    return _coot.set_gaussian_surface_contour_level(s)

def set_gaussian_surface_box_radius(s):
    r"""
    set_gaussian_surface_box_radius(float s)

    set the box_radius for gaussian surface (defautl 5)

    Parameters
    ----------
    s : float

    """
    return _coot.set_gaussian_surface_box_radius(s)

def set_gaussian_surface_grid_scale(s):
    r"""
    set_gaussian_surface_grid_scale(float s)

    set the grid_scale for gaussian surface (default 0.7)

    Parameters
    ----------
    s : float

    """
    return _coot.set_gaussian_surface_grid_scale(s)

def set_gaussian_surface_fft_b_factor(f):
    r"""
    set_gaussian_surface_fft_b_factor(float f)

    set the fft B-factor for gaussian surface. Use 0 for no B-factor (default 100)

    Parameters
    ----------
    f : float

    """
    return _coot.set_gaussian_surface_fft_b_factor(f)

def set_gaussian_surface_chain_colour_mode(mode):
    r"""
    set_gaussian_surface_chain_colour_mode(short mode)

    set the chain colour mode for Gaussian surfaces mode = 1 means each chain has its own colour mode = 2 means the chain colour is determined from NCS/molecular symmetry (so that, in this mode, chains with the same sequence have the same colour

    Parameters
    ----------
    mode : int

    """
    return _coot.set_gaussian_surface_chain_colour_mode(mode)

def set_gaussian_surface_opacity(imol, opacity):
    r"""
    set_gaussian_surface_opacity(int imol, float opacity)

    set the opacity for a given molecule's gaussian_surface

      imol  the molecule index   opacity  between 0. and 1.0

    Parameters
    ----------
    imol : int
        the molecule index
    opacity : float
        between 0. and 1.0

    """
    return _coot.set_gaussian_surface_opacity(imol, opacity)

def show_gaussian_surface_overlay():
    r"""show_gaussian_surface_overlay()"""
    return _coot.show_gaussian_surface_overlay()

def make_acedrg_dictionary_via_CCD_dictionary(imol, spec):
    r"""
    make_acedrg_dictionary_via_CCD_dictionary(int imol, residue_spec_t spec)


    Parameters
    ----------
    imol : int
    spec : residue_spec

    """
    return _coot.make_acedrg_dictionary_via_CCD_dictionary(imol, spec)

def make_link(imol, spec_1, spec_2, link_name, length):
    r"""
    make_link(int imol, atom_spec_t spec_1, atom_spec_t spec_2, std::string const & link_name, float length)

    make a link between the specified atoms

    Parameters
    ----------
    imol : int
    spec_1 : atom_spec
    spec_2 : atom_spec
    link_name : str
    length : float

    """
    return _coot.make_link(imol, spec_1, spec_2, link_name, length)

def make_link_py(imol, spec_1, spec_2, link_name, length):
    r"""
    make_link_py(int imol, PyObject * spec_1, PyObject * spec_2, std::string const & link_name, float length)


    Parameters
    ----------
    imol : int
    spec_1 : object
    spec_2 : object
    link_name : str
    length : float

    """
    return _coot.make_link_py(imol, spec_1, spec_2, link_name, length)

def link_info_py(imol):
    r"""
    link_info_py(int imol) -> PyObject *


    Parameters
    ----------
    imol : int

    """
    return _coot.link_info_py(imol)

def show_acedrg_link_interface_overlay():
    r"""show_acedrg_link_interface_overlay()"""
    return _coot.show_acedrg_link_interface_overlay()

def handle_drag_and_drop_string(uri):
    r"""
    handle_drag_and_drop_string(std::string const & uri) -> int

    handle the string that get when a file or URL is dropped.

    Parameters
    ----------
    uri : str

    """
    return _coot.handle_drag_and_drop_string(uri)

def undisplay_all_maps_except(imol_map):
    r"""
    undisplay_all_maps_except(int imol_map)

    undisplay all maps except the given one

    Parameters
    ----------
    imol_map : int

    """
    return _coot.undisplay_all_maps_except(imol_map)

def map_contours(imol, contour_level):
    r"""
    map_contours(int imol, float contour_level) -> PyObject *

    return a list of pairs of vertices for the lines

    Parameters
    ----------
    imol : int
    contour_level : float

    """
    return _coot.map_contours(imol, contour_level)

def map_contours_as_triangles(imol, contour_level):
    r"""
    map_contours_as_triangles(int imol, float contour_level) -> PyObject *

    return two lists: a list of vertices and a list of index-triples for connection

    Parameters
    ----------
    imol : int
    contour_level : float

    """
    return _coot.map_contours_as_triangles(imol, contour_level)

def set_radial_map_colouring_enabled(imol, state):
    r"""
    set_radial_map_colouring_enabled(int imol, int state)

    enable radial map colouring

    Parameters
    ----------
    imol : int
    state : int

    """
    return _coot.set_radial_map_colouring_enabled(imol, state)

def set_radial_map_colouring_centre(imol, x, y, z):
    r"""
    set_radial_map_colouring_centre(int imol, float x, float y, float z)

    radial map colouring centre

    Parameters
    ----------
    imol : int
    x : float
    y : float
    z : float

    """
    return _coot.set_radial_map_colouring_centre(imol, x, y, z)

def set_radial_map_colouring_min_radius(imol, r):
    r"""
    set_radial_map_colouring_min_radius(int imol, float r)

    radial map colouring min

    Parameters
    ----------
    imol : int
    r : float

    """
    return _coot.set_radial_map_colouring_min_radius(imol, r)

def set_radial_map_colouring_max_radius(imol, r):
    r"""
    set_radial_map_colouring_max_radius(int imol, float r)

    radial map colouring max

    Parameters
    ----------
    imol : int
    r : float

    """
    return _coot.set_radial_map_colouring_max_radius(imol, r)

def set_radial_map_colouring_invert(imol, invert_state):
    r"""
    set_radial_map_colouring_invert(int imol, int invert_state)

    radial map colouring inverted colour map

    Parameters
    ----------
    imol : int
    invert_state : int

    """
    return _coot.set_radial_map_colouring_invert(imol, invert_state)

def set_radial_map_colouring_saturation(imol, saturation):
    r"""
    set_radial_map_colouring_saturation(int imol, float saturation)

    radial map colouring saturation

    saturation is a number between 0 and 1, typically 0.5

    Parameters
    ----------
    imol : int
    saturation : float

    """
    return _coot.set_radial_map_colouring_saturation(imol, saturation)

def set_map_correlation_atom_radius(r):
    r"""
    set_map_correlation_atom_radius(float r)

    The atom radius is not passed as a parameter to correlation.

    Parameters
    ----------
    r : float

    """
    return _coot.set_map_correlation_atom_radius(r)

def map_to_model_correlation_py(imol, residue_specs, neighb_residue_specs, atom_mask_mode, imol_map):
    r"""
    map_to_model_correlation_py(int imol, PyObject * residue_specs, PyObject * neighb_residue_specs, unsigned short atom_mask_mode, int imol_map) -> PyObject *

    Calculate map-to-model correlation (Python interface)

    Python wrapper for map_to_model_correlation. Evaluates the fit of specific residues to the electron density map.

      imol  Model molecule number   residue_specs  Python list of residue specs [[chain_id, resno, ins_code], ...]   neighb_residue_specs  Python list of neighboring residue specs to exclude   atom_mask_mode  Controls which atoms to include (see atom_mask_mode values above)   imol_map  Map molecule number PyObject* - correlation coefficient as a Python float Use atom_mask_mode=2 to evaluate side-chain fit specifically Example usage: # Evaluate side-chain fit for residues 40-44 residue_specs = [[ 'A' , res_no, '' ] for res_no in range(40, 45)] correlation = map_to_model_correlation_py ( imol=1, residue_specs=residue_specs, neighb_residue_specs=[], atom_mask_mode=2, # Side-chain atoms only imol_map=2 ) print(f "Side-chain correlation: {correlation}" )

    Parameters
    ----------
    imol : int
        Model molecule number
    residue_specs : object
        Python list of residue specs [[chain_id, resno, ins_code], ...]
    neighb_residue_specs : object
        Python list of neighboring residue specs to exclude
    atom_mask_mode : unsigned short int
        Controls which atoms to include (see atom_mask_mode values above)
    imol_map : int
        Map molecule number

    """
    return _coot.map_to_model_correlation_py(imol, residue_specs, neighb_residue_specs, atom_mask_mode, imol_map)

def map_to_model_correlation_stats_py(imol, residue_specs, neighb_residue_specs, atom_mask_mode, imol_map):
    r"""
    map_to_model_correlation_stats_py(int imol, PyObject * residue_specs, PyObject * neighb_residue_specs, unsigned short atom_mask_mode, int imol_map) -> PyObject *

    Get map-to-model correlation statistics (Python interface)

    Returns detailed statistics about the correlation between model and map, including mean, standard deviation, and range.

      imol  Model molecule number   residue_specs  Python list of residue specs   neighb_residue_specs  Python list of neighboring residue specs   atom_mask_mode  Controls which atoms to include   imol_map  Map molecule number PyObject* - Dictionary with statistics:  'mean': Mean correlation 'std_dev': Standard deviation 'min': Minimum correlation 'max': Maximum correlation Example usage: stats = map_to_model_correlation_stats_py (1, residues, [], 0, 2) print(f "Mean: {stats['mean']:.3f}" ) print(f "Std Dev: {stats['std_dev']:.3f}" ) print(f "Range: {stats['min']:.3f} to {stats['max']:.3f}" )

    Parameters
    ----------
    imol : int
        Model molecule number
    residue_specs : object
        Python list of residue specs
    neighb_residue_specs : object
        Python list of neighboring residue specs
    atom_mask_mode : unsigned short int
        Controls which atoms to include
    imol_map : int
        Map molecule number

    """
    return _coot.map_to_model_correlation_stats_py(imol, residue_specs, neighb_residue_specs, atom_mask_mode, imol_map)

def map_to_model_correlation_stats_per_residue_range_py(imol, chain_id, imol_map, n_residue_per_residue_range, exclude_mainchain_NOC_flag):
    r"""
    map_to_model_correlation_stats_per_residue_range_py(int imol, std::string const & chain_id, int imol_map, unsigned int n_residue_per_residue_range, short exclude_mainchain_NOC_flag) -> PyObject *

    Get density statistics per residue range (Python interface)

    PRIMARY FUNCTION FOR FINDING POORLY-FITTED RESIDUES

    This is the main function to use when asked "Which side chain is worst fitting to density?" It analyzes correlation statistics for all residues in a chain and returns comprehensive data for both all-atom and side-chain-only analysis.

      imol  Model molecule number   chain_id  Chain identifier (e.g., "A", "B")   imol_map  Map molecule number   n_residue_per_residue_range  Number of residues per analysis window:  Use 1 for per-residue statistics (most common) Use 3 for smoothed statistics over 3-residue windows   exclude_backbone_NOC_flag  Whether to exclude backbone N, O, C atoms:  0: Include all atoms (for overall fit assessment) 1: Exclude N, O, C (for side-chain-focused analysis) PyObject* - List of two lists (first is all_atom_stats, second is sidechain_stats): Each list contains a residue_spec [chain_id, res_no, ins_code] and correlation_stats containing:  n_points: Number of grid points correlation: Correlation coefficient If the residue does not have a side-chain then the number of grid points is 0 and the correlation is nan.

    This function analyzes the ENTIRE chain at once, making it very efficient Returns both all-atom and side-chain statistics in one call Use the side-chain statistics to identify problem side chains specifically Example usage - Find worst-fitting side chain: # Get correlation statistics for all residues in chain A all_atom_stats, sidechain_stats = map_to_model_correlation_stats_per_residue_range_py ( imol=1, # Model molecule chain_id= "A" , # Chain A imol_map=2, # Map molecule n_residue_per_residue_range=1, # Per-residue (not averaged) exclude_NOC_flag=0 # Include all atoms ) # Find worst-fitting side chain worst_residue = min(sidechain_stats.items(), key= lambda x: x[1][1]) chain_id, resno, ins_code = worst_residue[0] correlation = worst_residue[1][1] print(f "Worst side chain: {chain_id} {resno}, correlation = {correlation:.3f}" ) # Center on worst residue set_go_to_atom_chain_residue_atom_name (chain_id, resno, 'CA' )

    Example usage - Compare main-chain vs side-chain fit: all_atom, sidechain = map_to_model_correlation_stats_per_residue_range_py ( 1, "A" , 2, 1, 0 ) for residue_spec in all_atom.keys(): all_corr = all_atom[residue_spec][ 'correlation' ] side_corr = sidechain[residue_spec][ 'correlation' ] if all_corr > 0.7 and side_corr < 0.5: print(f "Residue {residue_spec}: Good backbone, poor sidechain" )

    Parameters
    ----------
    imol : int
        Model molecule number
    chain_id : str
        Chain identifier (e.g., "A", "B")
    imol_map : int
        Map molecule number
    n_residue_per_residue_range : int
        Number of residues per analysis window:  Use 1 for per-residue statistics (most common) Use 3 for smoothed statistics over 3-residue windows
    exclude_mainchain_NOC_flag : int

    """
    return _coot.map_to_model_correlation_stats_per_residue_range_py(imol, chain_id, imol_map, n_residue_per_residue_range, exclude_mainchain_NOC_flag)

def map_to_model_correlation(imol, residue_specs, neigh_residue_specs, atom_mask_mode, imol_map):
    r"""
    map_to_model_correlation(int imol, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & residue_specs, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & neigh_residue_specs, unsigned short atom_mask_mode, int imol_map) -> float

    Calculate the correlation between a map and model for specific residues.

    This function calculates the map-to-model correlation for specified residues, excluding grid points that overlap with neighboring residues.

      imol  Model molecule number   residue_specs  Vector of residue specifications to evaluate   neigh_residue_specs  Vector of neighboring residues whose grid points should be excluded   atom_mask_mode  Controls which atoms are included in the calculation:  0: All atoms 1: Main-chain atoms if standard amino acid, else all atoms 2: Side-chain atoms if standard amino acid, else all atoms 3: Side-chain atoms excluding CB if standard amino acid, else all atoms 4: Main-chain atoms if standard amino acid, else nothing 5: Side-chain atoms if standard amino acid, else nothing 10: Atom radius dependent on B-factor   imol_map  Map molecule number to correlate against Correlation coefficient (float) between model and map Use this after refinement to evaluate if the fit improved Example: std::vector<coot::residue_spec_t> residues = {{chain_id, 40, "" }, {chain_id, 41, "" }}; std::vector<coot::residue_spec_t> neighbors; float corr = map_to_model_correlation (1, residues, neighbors, 2, 2);

    atom-mask-mode is as follows:

    Parameters
    ----------
    imol : int
        Model molecule number
    residue_specs : list
        Vector of residue specifications to evaluate
    neigh_residue_specs : list
        Vector of neighboring residues whose grid points should be excluded
    atom_mask_mode : unsigned short int
        Controls which atoms are included in the calculation:  0: All atoms 1: Main-chain atoms if standard amino acid, else all atoms 2: Side-chain atoms if standard amino acid, else all atoms 3: Side-chain atoms excluding CB if standard amino acid, else all atoms 4: Main-chain atoms if standard amino acid, else nothing 5: Side-chain atoms if standard amino acid, else nothing 10: Atom radius dependent on B-factor
    imol_map : int
        Map molecule number to correlate against

    """
    return _coot.map_to_model_correlation(imol, residue_specs, neigh_residue_specs, atom_mask_mode, imol_map)

def map_to_model_correlation_stats(imol, residue_specs, neigh_residue_specs, atom_mask_mode, imol_map):
    r"""
    map_to_model_correlation_stats(int imol, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & residue_specs, std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > > const & neigh_residue_specs, unsigned short atom_mask_mode, int imol_map) -> coot::util::density_correlation_stats_info_t

    Get detailed statistics for map-to-model correlation.

    Returns comprehensive statistics including mean, standard deviation, minimum, and maximum correlation values for the specified residues.

      imol  Model molecule number   residue_specs  Vector of residue specifications to evaluate   neigh_residue_specs  Vector of neighboring residues to exclude from grid   atom_mask_mode  Controls which atoms are included (see atom_mask_mode values)   imol_map  Map molecule number coot::util::density_correlation_stats_info_t containing:  mean correlation standard deviation minimum correlation maximum correlation number of residues evaluated Useful for getting overall quality metrics for a region Example: auto stats = map_to_model_correlation_stats (1, residues, neighbors, 0, 2); std::cout << "Mean correlation: " << stats.mean << std::endl; std::cout << "Std dev: " << stats.std_dev << std::endl;

    Parameters
    ----------
    imol : int
        Model molecule number
    residue_specs : list
        Vector of residue specifications to evaluate
    neigh_residue_specs : list
        Vector of neighboring residues to exclude from grid
    atom_mask_mode : unsigned short int
        Controls which atoms are included (see atom_mask_mode values)
    imol_map : int
        Map molecule number

    """
    return _coot.map_to_model_correlation_stats(imol, residue_specs, neigh_residue_specs, atom_mask_mode, imol_map)

def map_to_model_correlation_per_residue_py(imol, residue_specs, atom_mask_mode, imol_map):
    r"""
    map_to_model_correlation_per_residue_py(int imol, PyObject * residue_specs, unsigned short atom_mask_mode, int imol_map) -> PyObject *

    Get map-to-model correlation per residue (Python interface)

    Returns correlation values individually for each specified residue. Essential for identifying which specific residues have poor density fit.

      imol  Model molecule number   residue_specs  Python list of residue specs   atom_mask_mode  Controls which atoms to include   imol_map  Map molecule number PyObject* - List of tuples: [(residue_spec, correlation), ...] Sort the results to find worst-fitting residues Example usage: # Get all residues in chain A residues = get_residues_in_chain_py (1, "A" ) # Get per-residue correlations correlations = map_to_model_correlation_per_residue_py ( imol=1, residue_specs=residues, atom_mask_mode=0, # All atoms imol_map=2 ) # Find worst 10 residues worst_10 = sorted(correlations, key= lambda x: x[1])[:10] for spec, corr in worst_10: print(f "Residue {spec}: correlation = {corr:.3f}" )

    Parameters
    ----------
    imol : int
        Model molecule number
    residue_specs : object
        Python list of residue specs
    atom_mask_mode : unsigned short int
        Controls which atoms to include
    imol_map : int
        Map molecule number

    """
    return _coot.map_to_model_correlation_per_residue_py(imol, residue_specs, atom_mask_mode, imol_map)

def qq_plot_map_and_model_py(imol, residue_specs_py, neigh_residue_specs_py, atom_mask_mode, imol_map):
    r"""
    qq_plot_map_and_model_py(int imol, PyObject * residue_specs_py, PyObject * neigh_residue_specs_py, unsigned short atom_mask_mode, int imol_map) -> PyObject *


    Parameters
    ----------
    imol : int
    residue_specs_py : object
    neigh_residue_specs_py : object
    atom_mask_mode : unsigned short int
    imol_map : int

    """
    return _coot.qq_plot_map_and_model_py(imol, residue_specs_py, neigh_residue_specs_py, atom_mask_mode, imol_map)

def density_score_residue_py(imol, residue_spec, imol_map):
    r"""
    density_score_residue_py(int imol, PyObject * residue_spec, int imol_map) -> float

    Calculate density score for a residue (Python interface)

    Computes how well a residue fits into the electron density map. This is a simpler alternative to the more comprehensive map_to_model_correlation functions.

      imol  Model molecule number   residue_spec  Python list [chain_id, resno, ins_code]   imol_map  Map molecule number Float score - higher values indicate better fit to density For comprehensive density validation, use map_to_model_correlation_stats_per_residue_range_py() instead Example usage: # Score a single residue score = density_score_residue_py (1, [ "A" , 42, "" ], 2) print(f "Density fit score: {score:.3f}" ) # Find residues with poor density fit for resno in range(1, 100): score = density_score_residue_py (1, [ "A" , resno, "" ], 2) if score < 0.5: print(f "Poor fit: A {resno}, score = {score:.3f}" )

    Parameters
    ----------
    imol : int
        Model molecule number
    residue_spec : object
        Python list [chain_id, resno, ins_code]
    imol_map : int
        Map molecule number

    """
    return _coot.density_score_residue_py(imol, residue_spec, imol_map)

def density_score_residue(imol, chain_id, res_no, ins_code, imol_map):
    r"""
    density_score_residue(int imol, char const * chain_id, int res_no, char const * ins_code, int imol_map) -> float

    Simple density score for given residue (C++ interface)

    Calculates a basic density fit score for the specified residue. This function provides a quick assessment of how well atoms fit density.

      imol  Model molecule number   chain_id  Chain identifier   res_no  Residue number   ins_code  Insertion code (use "" if none)   imol_map  Map molecule number to score against Float score indicating density fit quality (higher is better) This is a simplified scoring function. For detailed validation including correlation statistics, use map_to_model_correlation functions instead. Example: float score = density_score_residue (1, "A" , 42, "" , 2); if (score < 0.5) { std::cout << "Residue A 42 has poor density fit: " << score << std::endl; }

    Parameters
    ----------
    imol : int
        Model molecule number
    chain_id : str
        Chain identifier
    res_no : int
        Residue number
    ins_code : str
        Insertion code (use "" if none)
    imol_map : int
        Map molecule number to score against

    """
    return _coot.density_score_residue(imol, chain_id, res_no, ins_code, imol_map)

def map_mean_py(imol):
    r"""
    map_mean_py(int imol) -> PyObject *

    Get the mean value of a map (Python interface)

    Returns the mean (average) density value for all grid points in the map.

      imol  Map molecule number PyObject* - Float mean value, or False if imol is not a valid map Example usage: mean = map_mean_py (2) if mean is not False : print(f "Map mean: {mean}" )

    Parameters
    ----------
    imol : int
        Map molecule number

    """
    return _coot.map_mean_py(imol)

def map_sigma_py(imol):
    r"""
    map_sigma_py(int imol) -> PyObject *

    Get the standard deviation (sigma) of a map (Python interface)

    Returns the standard deviation of density values. This is the "sigma" value used when you set contouring to "1.5 sigma".

      imol  Map molecule number PyObject* - Float sigma value, or False if invalid map Example usage: sigma = map_sigma_py (2) if sigma is not False : print(f "1.5 sigma contour level: {1.5 * sigma}" )

    Parameters
    ----------
    imol : int
        Map molecule number

    """
    return _coot.map_sigma_py(imol)

def map_statistics_py(imol):
    r"""
    map_statistics_py(int imol) -> PyObject *

    Get comprehensive map statistics (Python interface)

    Returns detailed statistical information about the map distribution.

      imol  Map molecule number PyObject* - List [mean, std_dev, skew, kurtosis] or False if invalid  mean: Average density value std_dev: Standard deviation (sigma) skew: Asymmetry of the distribution kurtosis: "Tailedness" of the distribution Normal distributions have skew≈0 and kurtosis≈3 Large deviations may indicate data problems Example usage: stats = map_statistics_py (2) if stats is not False : mean, sigma, skew, kurtosis = stats print(f "Map statistics:" ) print(f " Mean: {mean:.3f}" ) print(f " Sigma: {sigma:.3f}" ) print(f " Skew: {skew:.3f}" ) print(f " Kurtosis: {kurtosis:.3f}" ) if abs(skew) > 1.0: print( " Warning: Unusual skew detected" )

    Parameters
    ----------
    imol : int
        Map molecule number

    """
    return _coot.map_statistics_py(imol)

def get_sequence_as_fasta_for_chain(imol, chain_id):
    r"""
    get_sequence_as_fasta_for_chain(int imol, std::string const & chain_id) -> std::string

    get the sequence for chain_id in imol

    Parameters
    ----------
    imol : int
    chain_id : str

    """
    return _coot.get_sequence_as_fasta_for_chain(imol, chain_id)

def write_sequence(imol, file_name):
    r"""
    write_sequence(int imol, std::string const & file_name)

    write the sequence for imol as fasta

    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.write_sequence(imol, file_name)

def res_tracer(imol_map, pir_file_name):
    r"""
    res_tracer(int imol_map, std::string const & pir_file_name)

    trace the given map and try to apply the sequence in the given pir file

    Parameters
    ----------
    imol_map : int
    pir_file_name : str

    """
    return _coot.res_tracer(imol_map, pir_file_name)

def register_interesting_positions_list_py(pos_list):
    r"""
    register_interesting_positions_list_py(PyObject * pos_list)


    Parameters
    ----------
    pos_list : object

    """
    return _coot.register_interesting_positions_list_py(pos_list)

def molecule_atom_overlaps_py(imol, n_max_pairs):
    r"""
    molecule_atom_overlaps_py(int imol, int n_max_pairs) -> PyObject *

    get the atom overlaps for the molecule

      imol  the molecule index   n_max_pairs  the maximum number of atom pairs to return. Typically this should be 20 or 30. Use -1 (with caution!) to get all of the (poteentially thousands) of atom overlaps. a list of dictionaries with contact information. The list is sorted by largest overlap first. Return False on failure.

    Parameters
    ----------
    imol : int
        the molecule index
    n_max_pairs : int
        the maximum number of atom pairs to return. Typically this should be 20 or 30. Use -1 (with caution!) to get all of the (poteentially thousands) of atom overlaps.

    """
    return _coot.molecule_atom_overlaps_py(imol, n_max_pairs)

def align_to_closest_chain(target_seq, match_fraction):
    r"""
    align_to_closest_chain(std::string target_seq, float match_fraction) -> std::pair< int,std::string >

    align sequence to closest chain (compare across all chains in all molecules).

    Typically match_fraction is 0.95 or so.

    Return the molecule number and chain id if successful, return -1 as the molecule number if not.

    Parameters
    ----------
    target_seq : str
    match_fraction : float

    """
    return _coot.align_to_closest_chain(target_seq, match_fraction)

def align_to_closest_chain_py(target_seq, match_fraction):
    r"""
    align_to_closest_chain_py(std::string target_seq, float match_fraction) -> PyObject *


    Parameters
    ----------
    target_seq : str
    match_fraction : float

    """
    return _coot.align_to_closest_chain_py(target_seq, match_fraction)

def resolve_clashing_sidechains_by_deletion(imol):
    r"""
    resolve_clashing_sidechains_by_deletion(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.resolve_clashing_sidechains_by_deletion(imol)

def resolve_clashing_sidechains_by_rebuilding(imol):
    r"""
    resolve_clashing_sidechains_by_rebuilding(int imol)


    Parameters
    ----------
    imol : int

    """
    return _coot.resolve_clashing_sidechains_by_rebuilding(imol)

def simple_text_dialog(dialog_title, text, geom_x, geom_y):
    r"""
    simple_text_dialog(std::string const & dialog_title, std::string const & text, int geom_x, int geom_y)

    make a simple text dialog.

    Parameters
    ----------
    dialog_title : str
    text : str
    geom_x : int
    geom_y : int

    """
    return _coot.simple_text_dialog(dialog_title, text, geom_x, geom_y)

def graphics_to_phenix_geo_representation(*args):
    r"""
    graphics_to_phenix_geo_representation(int imol, int mode, phenix_geometry g)
    graphics_to_phenix_geo_representation(int imol, int mode, std::string const & geo_file_name)

    phenix GEO bonds representation, read GEO info from file

      imol  the molecule index   mode  current unused, so use 0   geo_file_name  is the file name of the phenix_geo file

    Parameters
    ----------
    imol : int
        the molecule index
    mode : int
        current unused, so use 0
    geo_file_name : str
        is the file name of the phenix_geo file

    """
    return _coot.graphics_to_phenix_geo_representation(*args)

def validate_using_phenix_geo_bonds(imol, geo_file_name):
    r"""
    validate_using_phenix_geo_bonds(int imol, std::string const & geo_file_name)

    validate using phenix geo bonds

    Typically this would be called shortly after graphics_to_phenix_geo_representation()

      imol  the molecule index   geo_file_name  is the file name of the phenix_geo file

    Parameters
    ----------
    imol : int
        the molecule index
    geo_file_name : str
        is the file name of the phenix_geo file

    """
    return _coot.validate_using_phenix_geo_bonds(imol, geo_file_name)

def set_python_draw_function(command_string):
    r"""
    set_python_draw_function(std::string const & command_string)

    client/server functions

    Parameters
    ----------
    command_string : str

    """
    return _coot.set_python_draw_function(command_string)

def pathology_data(mtz_file_name, fp_col, sigfp_col):
    r"""
    pathology_data(std::string const & mtz_file_name, std::string const & fp_col, std::string const & sigfp_col) -> PyObject *


    Parameters
    ----------
    mtz_file_name : str
    fp_col : str
    sigfp_col : str

    """
    return _coot.pathology_data(mtz_file_name, fp_col, sigfp_col)

def encode_ints(i1, i2):
    r"""
    encode_ints(int i1, int i2) -> int

    encoding of ints

    Parameters
    ----------
    i1 : int
    i2 : int

    """
    return _coot.encode_ints(i1, i2)

def decode_ints(i):
    r"""
    decode_ints(int i) -> std::pair< int,int >


    Parameters
    ----------
    i : int

    """
    return _coot.decode_ints(i)

def store_keyed_user_name(key, user_name, passwd):
    r"""
    store_keyed_user_name(std::string key, std::string user_name, std::string passwd)

    store username and password for the database.

    Parameters
    ----------
    key : str
    user_name : str
    passwd : str

    """
    return _coot.store_keyed_user_name(key, user_name, passwd)

def py_to_residue_specs(s):
    r"""
    py_to_residue_specs(PyObject * s) -> std::vector< coot::residue_spec_t,std::allocator< coot::residue_spec_t > >


    Parameters
    ----------
    s : object

    """
    return _coot.py_to_residue_specs(s)

def key_sym_code_py(po):
    r"""
    key_sym_code_py(PyObject * po) -> int


    Parameters
    ----------
    po : object

    """
    return _coot.key_sym_code_py(po)

def py_symop_strings_to_space_group(symop_string_list):
    r"""
    py_symop_strings_to_space_group(PyObject * symop_string_list) -> clipper::Spacegroup


    Parameters
    ----------
    symop_string_list : object

    """
    return _coot.py_symop_strings_to_space_group(symop_string_list)

def set_use_sounds(state):
    r"""
    set_use_sounds(bool state)

    enable or diable sounds (coot needs to have been compiled with sounds of course)

    Parameters
    ----------
    state : bool

    """
    return _coot.set_use_sounds(state)

def curmudgeon_mode():
    r"""
    curmudgeon_mode()

    turn off sounds and particles and textures

    """
    return _coot.curmudgeon_mode()

def halloween():
    r"""
    halloween()

    easter egg 2023

    """
    return _coot.halloween()

def display_svg_from_file_in_a_dialog(file_name):
    r"""
    display_svg_from_file_in_a_dialog(std::string const & file_name)


    Parameters
    ----------
    file_name : str

    """
    return _coot.display_svg_from_file_in_a_dialog(file_name)

def display_svg_from_string_in_a_dialog(string, title):
    r"""
    display_svg_from_string_in_a_dialog(std::string const & string, std::string const & title)


    Parameters
    ----------
    string : str
    title : str

    """
    return _coot.display_svg_from_string_in_a_dialog(string, title)

def display_pae_from_file_in_a_dialog(imol, file_name):
    r"""
    display_pae_from_file_in_a_dialog(int imol, std::string const & file_name)


    Parameters
    ----------
    imol : int
    file_name : str

    """
    return _coot.display_pae_from_file_in_a_dialog(imol, file_name)

def read_interesting_places_json_file(file_name):
    r"""
    read_interesting_places_json_file(std::string const & file_name)


    Parameters
    ----------
    file_name : str

    """
    return _coot.read_interesting_places_json_file(file_name)

def setup_tomo_slider(imol):
    r"""
    setup_tomo_slider(int imol) -> int

    return the section index (the middle section currently)

    Parameters
    ----------
    imol : int

    """
    return _coot.setup_tomo_slider(imol)

def tomo_section_view(imol, axis_id):
    r"""
    tomo_section_view(int imol, int axis_id)


    Parameters
    ----------
    imol : int
    axis_id : int

    """
    return _coot.tomo_section_view(imol, axis_id)

def set_tomo_section_view_section(imol, section_index):
    r"""
    set_tomo_section_view_section(int imol, int section_index)


    Parameters
    ----------
    imol : int
    section_index : int

    """
    return _coot.set_tomo_section_view_section(imol, section_index)

def set_tomo_picker_mode_is_active(state):
    r"""
    set_tomo_picker_mode_is_active(short state)

    set tomo picker is active

    Parameters
    ----------
    state : int

    """
    return _coot.set_tomo_picker_mode_is_active(state)

def tomo_map_analysis(imol_map, spot_positions):
    r"""
    tomo_map_analysis(int imol_map, PyObject * spot_positions)


    Parameters
    ----------
    imol_map : int
    spot_positions : object

    """
    return _coot.tomo_map_analysis(imol_map, spot_positions)

def tomo_map_analysis_2(imol_map, spot_positions):
    r"""
    tomo_map_analysis_2(int imol_map, PyObject * spot_positions)


    Parameters
    ----------
    imol_map : int
    spot_positions : object

    """
    return _coot.tomo_map_analysis_2(imol_map, spot_positions)

def reverse_map(imol_map):
    r"""
    reverse_map(int imol_map)

    negative becomes positive and positive becomes negative. Apply an offset so that most of the map is above zero.

    Parameters
    ----------
    imol_map : int

    """
    return _coot.reverse_map(imol_map)

def read_positron_metadata(z_data, table):
    r"""
    read_positron_metadata(std::string const & z_data, std::string const & table)


    Parameters
    ----------
    z_data : str
    table : str

    """
    return _coot.read_positron_metadata(z_data, table)

def positron_pathway(map_molecule_list_py, pathway_points_py):
    r"""
    positron_pathway(PyObject * map_molecule_list_py, PyObject * pathway_points_py) -> PyObject *


    Parameters
    ----------
    map_molecule_list_py : object
    pathway_points_py : object

    """
    return _coot.positron_pathway(map_molecule_list_py, pathway_points_py)

def positron_plot_py(fn_z_csv, fn_s_csv, base_map_index_list):
    r"""
    positron_plot_py(std::string const & fn_z_csv, std::string const & fn_s_csv, PyObject * base_map_index_list)


    Parameters
    ----------
    fn_z_csv : str
    fn_s_csv : str
    base_map_index_list : object

    """
    return _coot.positron_plot_py(fn_z_csv, fn_s_csv, base_map_index_list)

def global_phasing_screen(imol, screen_dict):
    r"""
    global_phasing_screen(int imol, PyObject * screen_dict) -> PyObject *


    Parameters
    ----------
    imol : int
    screen_dict : object

    """
    return _coot.global_phasing_screen(imol, screen_dict)

def handle_read_draw_molecule_with_recentre(filename, recentre_on_read_pdb_flag):
    r"""
    handle_read_draw_molecule_with_recentre(std::string const & filename, int recentre_on_read_pdb_flag) -> int

    read coordinates from filename with option to not recentre.

    set recentre_on_read_pdb_flag to 0 if you don't want the view to recentre on the new coordinates.

    Parameters
    ----------
    filename : str
    recentre_on_read_pdb_flag : int

    """
    return _coot.handle_read_draw_molecule_with_recentre(filename, recentre_on_read_pdb_flag)

def handle_read_draw_molecule_and_move_molecule_here(filename):
    r"""
    handle_read_draw_molecule_and_move_molecule_here(std::string const & filename) -> int

    read coordinates from filename and recentre the new molecule at the screen rotation centre.

    Parameters
    ----------
    filename : str

    """
    return _coot.handle_read_draw_molecule_and_move_molecule_here(filename)

def read_pdb(filename):
    r"""
    read_pdb(std::string const & filename) -> int

    read coordinates from filename

    Parameters
    ----------
    filename : str

    """
    return _coot.read_pdb(filename)

def read_coordinates(filename):
    r"""
    read_coordinates(std::string const & filename) -> int

    read coordinates from filename

      filename  is the file name of the coordinates the new molecule index. Return -1 on failure

    Parameters
    ----------
    filename : str
        is the file name of the coordinates

    """
    return _coot.read_coordinates(filename)

def read_coordinates_as_string(file_as_string, molecule_name):
    r"""
    read_coordinates_as_string(std::string const & file_as_string, std::string const & molecule_name) -> int

    read coordinates from a string

      file_as_string  a string which is the contents of a file the new molecule index. Return -1 on failure

    Parameters
    ----------
    file_as_string : str
        a string which is the contents of a file
    molecule_name : str

    """
    return _coot.read_coordinates_as_string(file_as_string, molecule_name)

def read_amber_trajectory(imol_coords, trajectory_file_name, start_frame, end_frame, stride):
    r"""
    read_amber_trajectory(int imol_coords, std::string const & trajectory_file_name, int start_frame, int end_frame, int stride) -> int

    read an Amber NetCDF trajectory file

    Reads trajectory frames and creates a multi-model molecule. Requires NetCDF support to be compiled in ( with-netcdf at configure time).

      imol_coords  is the model molecule index providing the topology (atom names, residues)   trajectory_file_name  is the path to the Amber NetCDF trajectory file (.nc)   start_frame  is the first frame to read (0-indexed), -1 for first frame   end_frame  is the last frame to read (0-indexed), -1 for last frame   stride  read every nth frame (1 = all frames) the new molecule index. Return -1 on failure

    Parameters
    ----------
    imol_coords : int
        is the model molecule index providing the topology (atom names, residues)
    trajectory_file_name : str
        is the path to the Amber NetCDF trajectory file (.nc)
    start_frame : int
        is the first frame to read (0-indexed), -1 for first frame
    end_frame : int
        is the last frame to read (0-indexed), -1 for last frame
    stride : int
        read every nth frame (1 = all frames)

    """
    return _coot.read_amber_trajectory(imol_coords, trajectory_file_name, start_frame, end_frame, stride)

def handle_read_draw_molecule(filename):
    r"""
    handle_read_draw_molecule(std::string const & filename) -> int

    a synonym for read-pdb. Read the coordinates from filename (can be pdb, cif or shelx format)

    Parameters
    ----------
    filename : str

    """
    return _coot.handle_read_draw_molecule(filename)

def set_use_gemmi_as_model_molecule_parser(state):
    r"""
    set_use_gemmi_as_model_molecule_parser(int state)

    set (or unset) GEMMI as the molecule parser. Currently by passing an int.

    Parameters
    ----------
    state : int

    """
    return _coot.set_use_gemmi_as_model_molecule_parser(state)

def read_shelx_ins_file(filename, recentre_flag):
    r"""
    read_shelx_ins_file(std::string const & filename, short recentre_flag) -> int

    read a SHELXL .ins file

    Parameters
    ----------
    filename : str
    recentre_flag : int

    """
    return _coot.read_shelx_ins_file(filename, recentre_flag)

def write_shelx_ins_file(imol, filename):
    r"""
    write_shelx_ins_file(int imol, char const * filename) -> int

    write a SHELXL .ins file for molecule number imol

    Parameters
    ----------
    imol : int
    filename : str

    """
    return _coot.write_shelx_ins_file(imol, filename)

def handle_shelx_fcf_file_internal(filename):
    r"""
    handle_shelx_fcf_file_internal(char const * filename) -> int


    Parameters
    ----------
    filename : str

    """
    return _coot.handle_shelx_fcf_file_internal(filename)

def is_shelx_molecule(imol):
    r"""
    is_shelx_molecule(int imol) -> int


    Parameters
    ----------
    imol : int

    """
    return _coot.is_shelx_molecule(imol)

def chain_id_for_shelxl_residue_number_py(imol, resno):
    r"""
    chain_id_for_shelxl_residue_number_py(int imol, int resno) -> PyObject *

    the chain id for the given residue. Return Py_False if can't do it/fail.

    Parameters
    ----------
    imol : int
    resno : int

    """
    return _coot.chain_id_for_shelxl_residue_number_py(imol, resno)

def add_shelx_string_to_molecule(imol, string):
    r"""
    add_shelx_string_to_molecule(int imol, char const * string)


    Parameters
    ----------
    imol : int
    string : str

    """
    return _coot.add_shelx_string_to_molecule(imol, string)

def make_directory_maybe(dir):
    r"""make_directory_maybe(std::string const & dir) -> int"""
    return _coot.make_directory_maybe(dir)

def text_png_as_string(text_info_dict):
    r"""text_png_as_string(PyObject * text_info_dict) -> std::string"""
    return _coot.text_png_as_string(text_info_dict)

def safe_scheme_command(scheme_command):
    r"""safe_scheme_command(std::string const & scheme_command)"""
    return _coot.safe_scheme_command(scheme_command)

def safe_python_command(python_command):
    r"""safe_python_command(std::string const & python_command)"""
    return _coot.safe_python_command(python_command)

def safe_python_command_by_char_star(python_command):
    r"""safe_python_command_by_char_star(char const * python_command)"""
    return _coot.safe_python_command_by_char_star(python_command)

def py_clean_internal(obj):
    r"""py_clean_internal(PyObject * obj) -> PyObject *"""
    return _coot.py_clean_internal(obj)

def safe_python_command_with_return(python_cmd):
    r"""safe_python_command_with_return(std::string const & python_cmd) -> PyObject *"""
    return _coot.safe_python_command_with_return(python_cmd)

def safe_python_command_test(cmd):
    r"""safe_python_command_test(char const * cmd) -> PyObject *"""
    return _coot.safe_python_command_test(cmd)

def safe_python_command_with_unsafe_thread(cmd):
    r"""safe_python_command_with_unsafe_thread(char const * cmd)"""
    return _coot.safe_python_command_with_unsafe_thread(cmd)

def run_generic_script(cmd_strings):
    r"""run_generic_script(vector_string cmd_strings)"""
    return _coot.run_generic_script(cmd_strings)

def add_key_binding_gtk4_py(key, ctrl_key_flag, func, description):
    r"""add_key_binding_gtk4_py(PyObject * key, int ctrl_key_flag, PyObject * func, std::string const & description)"""
    return _coot.add_key_binding_gtk4_py(key, ctrl_key_flag, func, description)

def set_light_position_py(light_id, x, y, z):
    r"""set_light_position_py(int light_id, float x, float y, float z)"""
    return _coot.set_light_position_py(light_id, x, y, z)

def reload_shaders():
    r"""reload_shaders()"""
    return _coot.reload_shaders()

def reload_shader(shader_name):
    r"""reload_shader(std::string const & shader_name)"""
    return _coot.reload_shader(shader_name)

def display_python(o):
    r"""display_python(PyObject * o) -> PyObject *"""
    return _coot.display_python(o)

def make_atom_spec_py(spec):
    r"""make_atom_spec_py(PyObject * spec) -> std::pair< bool,coot::atom_spec_t >"""
    return _coot.make_atom_spec_py(spec)

def make_residue_spec_py(spec):
    r"""make_residue_spec_py(PyObject * spec) -> std::pair< bool,coot::residue_spec_t >"""
    return _coot.make_residue_spec_py(spec)

def get_monomer_molecule_by_network_and_dict_gen(text):
    r"""get_monomer_molecule_by_network_and_dict_gen(std::string const & text) -> int"""
    return _coot.get_monomer_molecule_by_network_and_dict_gen(text)

def new_molecule_sans_biggest_ligand_py(imol):
    r"""new_molecule_sans_biggest_ligand_py(int imol) -> PyObject *"""
    return _coot.new_molecule_sans_biggest_ligand_py(imol)

def gui_ligand_metrics_py(ligand_spec, ligand_metrics, percentile_limit):
    r"""gui_ligand_metrics_py(PyObject * ligand_spec, PyObject * ligand_metrics, double percentile_limit)"""
    return _coot.gui_ligand_metrics_py(ligand_spec, ligand_metrics, percentile_limit)

def residues_distortions_py(imol, residue_spec_list):
    r"""residues_distortions_py(int imol, PyObject * residue_spec_list) -> PyObject *"""
    return _coot.residues_distortions_py(imol, residue_spec_list)

def get_intermediate_atoms_distortions_py():
    r"""get_intermediate_atoms_distortions_py() -> PyObject *"""
    return _coot.get_intermediate_atoms_distortions_py()

def probe_clash_score(dots_file_name):
    r"""probe_clash_score(std::string const & dots_file_name) -> probe_clash_score_t"""
    return _coot.probe_clash_score(dots_file_name)

def ligand_atom_overlaps_py(imol, ligand_spec, neighb_radius):
    r"""ligand_atom_overlaps_py(int imol, PyObject * ligand_spec, double neighb_radius) -> PyObject *"""
    return _coot.ligand_atom_overlaps_py(imol, ligand_spec, neighb_radius)

def residues_torsions_match_py(imol_1, res_1, imol_2, res_2, tolerance):
    r"""residues_torsions_match_py(int imol_1, PyObject * res_1, int imol_2, PyObject * res_2, float tolerance) -> bool"""
    return _coot.residues_torsions_match_py(imol_1, res_1, imol_2, res_2, tolerance)

def kolmogorov_smirnov_py(l1, l2):
    r"""kolmogorov_smirnov_py(PyObject * l1, PyObject * l2) -> double"""
    return _coot.kolmogorov_smirnov_py(l1, l2)

def kolmogorov_smirnov_vs_normal_py(l1, mean, std_dev):
    r"""kolmogorov_smirnov_vs_normal_py(PyObject * l1, double mean, double std_dev) -> double"""
    return _coot.kolmogorov_smirnov_vs_normal_py(l1, mean, std_dev)

def kullback_liebler_py(l1, l2):
    r"""kullback_liebler_py(PyObject * l1, PyObject * l2) -> PyObject *"""
    return _coot.kullback_liebler_py(l1, l2)

def print_residue_distortions(imol, chain_id, res_no, ins_code):
    r"""print_residue_distortions(int imol, std::string chain_id, int res_no, std::string ins_code) -> double"""
    return _coot.print_residue_distortions(imol, chain_id, res_no, ins_code)

def display_residue_distortions(imol, chain_id, res_no, ins_code):
    r"""display_residue_distortions(int imol, std::string chain_id, int res_no, std::string ins_code)"""
    return _coot.display_residue_distortions(imol, chain_id, res_no, ins_code)

def display_residue_hydrogen_bond_atom_status_using_dictionary(imol, chain_id, res_no, ins_code):
    r"""display_residue_hydrogen_bond_atom_status_using_dictionary(int imol, std::string chain_id, int res_no, std::string ins_code)"""
    return _coot.display_residue_hydrogen_bond_atom_status_using_dictionary(imol, chain_id, res_no, ins_code)

def write_dictionary_from_residue(imol, chain_id, res_no, ins_code, cif_file_name):
    r"""write_dictionary_from_residue(int imol, std::string chain_id, int res_no, std::string ins_code, std::string cif_file_name)"""
    return _coot.write_dictionary_from_residue(imol, chain_id, res_no, ins_code, cif_file_name)

def add_dictionary_from_residue(imol, chain_id, res_no, ins_code):
    r"""add_dictionary_from_residue(int imol, std::string chain_id, int res_no, std::string ins_code)"""
    return _coot.add_dictionary_from_residue(imol, chain_id, res_no, ins_code)

def invert_chiral_centre(imol, chain_id, res_no, ins_code, atom_name):
    r"""invert_chiral_centre(int imol, std::string chain_id, int res_no, std::string ins_code, std::string atom_name)"""
    return _coot.invert_chiral_centre(imol, chain_id, res_no, ins_code, atom_name)

def match_residue_and_dictionary(imol, chain_id, res_no, ins_code, cif_dict_in, cif_dict_out, cif_dict_comp_id, reference_comp_id, output_comp_id, output_compound_name):
    r"""match_residue_and_dictionary(int imol, std::string chain_id, int res_no, std::string ins_code, std::string cif_dict_in, std::string cif_dict_out, std::string cif_dict_comp_id, std::string reference_comp_id, std::string output_comp_id, std::string output_compound_name) -> int"""
    return _coot.match_residue_and_dictionary(imol, chain_id, res_no, ins_code, cif_dict_in, cif_dict_out, cif_dict_comp_id, reference_comp_id, output_comp_id, output_compound_name)

def match_this_residue_and_dictionary(imol, chain_id, res_no, ins_code, cif_dict_out, reference_comp_id, output_comp_id):
    r"""match_this_residue_and_dictionary(int imol, std::string chain_id, int res_no, std::string ins_code, std::string cif_dict_out, std::string reference_comp_id, std::string output_comp_id) -> int"""
    return _coot.match_this_residue_and_dictionary(imol, chain_id, res_no, ins_code, cif_dict_out, reference_comp_id, output_comp_id)

def comprised_of_organic_set_p(rn):
    r"""comprised_of_organic_set_p(std::string const & rn) -> bool"""
    return _coot.comprised_of_organic_set_p(rn)

def coot_all_atom_contact_dots(imol):
    r"""coot_all_atom_contact_dots(int imol)"""
    return _coot.coot_all_atom_contact_dots(imol)

def coot_all_atom_contact_dots_active_molecule():
    r"""coot_all_atom_contact_dots_active_molecule()"""
    return _coot.coot_all_atom_contact_dots_active_molecule()

def set_all_atom_contact_dots_ignore_water(state):
    r"""set_all_atom_contact_dots_ignore_water(short state)"""
    return _coot.set_all_atom_contact_dots_ignore_water(state)

def set_all_atom_contact_dots_do_vdw_surface(state):
    r"""set_all_atom_contact_dots_do_vdw_surface(short state)"""
    return _coot.set_all_atom_contact_dots_do_vdw_surface(state)

def coot_contact_dots_for_ligand_py(imol, ligand_spec):
    r"""coot_contact_dots_for_ligand_py(int imol, PyObject * ligand_spec)"""
    return _coot.coot_contact_dots_for_ligand_py(imol, ligand_spec)

def switch_HIS_protonation_py(imol, residue_spec):
    r"""switch_HIS_protonation_py(int imol, PyObject * residue_spec)"""
    return _coot.switch_HIS_protonation_py(imol, residue_spec)

def coot_add_hydrogen_atoms(imol):
    r"""coot_add_hydrogen_atoms(int imol)"""
    return _coot.coot_add_hydrogen_atoms(imol)

def add_hydrogen_atoms(imol):
    r"""add_hydrogen_atoms(int imol)"""
    return _coot.add_hydrogen_atoms(imol)

def coot_reduce(imol):
    r"""coot_reduce(int imol)"""
    return _coot.coot_reduce(imol)

def set_contact_dots_density(density):
    r"""set_contact_dots_density(float density)"""
    return _coot.set_contact_dots_density(density)

def set_contact_dot_sphere_n_subdivisions(n_subdivisions):
    r"""set_contact_dot_sphere_n_subdivisions(unsigned int n_subdivisions)"""
    return _coot.set_contact_dot_sphere_n_subdivisions(n_subdivisions)

def get_ligand_percentile(metric_name, metric_value, reverse_order):
    r"""get_ligand_percentile(std::string metric_name, double metric_value, short reverse_order) -> double"""
    return _coot.get_ligand_percentile(metric_name, metric_value, reverse_order)

def linked_residues_py(residue_centre, imol, close_dist_max):
    r"""linked_residues_py(PyObject * residue_centre, int imol, float close_dist_max) -> PyObject *"""
    return _coot.linked_residues_py(residue_centre, imol, close_dist_max)

def enhanced_ligand_coot_p():
    r"""enhanced_ligand_coot_p() -> bool"""
    return _coot.enhanced_ligand_coot_p()

def jed_flip_intermediate_atoms():
    r"""jed_flip_intermediate_atoms() -> int"""
    return _coot.jed_flip_intermediate_atoms()

def reverse_jed_flip_intermediate_atoms():
    r"""reverse_jed_flip_intermediate_atoms() -> int"""
    return _coot.reverse_jed_flip_intermediate_atoms()

def get_ligand_distortion_summary_info_py(imol, residue_spec):
    r"""get_ligand_distortion_summary_info_py(int imol, PyObject * residue_spec) -> PyObject *"""
    return _coot.get_ligand_distortion_summary_info_py(imol, residue_spec)

def gsl_sf_erf_scm(v):
    r"""gsl_sf_erf_scm(double v) -> double"""
    return _coot.gsl_sf_erf_scm(v)

def mogul_markup(imol, chain_id, res_no, ins_code, mogul_out_file_name):
    r"""mogul_markup(int imol, char const * chain_id, int res_no, char const * ins_code, char const * mogul_out_file_name)"""
    return _coot.mogul_markup(imol, chain_id, res_no, ins_code, mogul_out_file_name)

def update_restraints_using_mogul(imol, chain_id, res_no, ins_code, residue_type, mogul_out_file_name):
    r"""update_restraints_using_mogul(int imol, char const * chain_id, int res_no, char const * ins_code, char const * residue_type, char const * mogul_out_file_name) -> int"""
    return _coot.update_restraints_using_mogul(imol, chain_id, res_no, ins_code, residue_type, mogul_out_file_name)

def set_mogul_max_badness(b):
    r"""set_mogul_max_badness(float b)"""
    return _coot.set_mogul_max_badness(b)

def get_mogul_max_badness():
    r"""get_mogul_max_badness() -> float"""
    return _coot.get_mogul_max_badness()

def mogul_results_py(mogul_out_file_name):
    r"""mogul_results_py(char const * mogul_out_file_name) -> PyObject *"""
    return _coot.mogul_results_py(mogul_out_file_name)
class sequence_to_chain_results_t(object):
    r"""Proxy of C++ sequence_to_chain_results_t class."""

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

    def __init__(self):
        r"""__init__(sequence_to_chain_results_t self) -> sequence_to_chain_results_t"""
        _coot.sequence_to_chain_results_t_swiginit(self, _coot.new_sequence_to_chain_results_t())
    matches = property(_coot.sequence_to_chain_results_t_matches_get, _coot.sequence_to_chain_results_t_matches_set, doc=r"""matches : bool""")
    match_fraction = property(_coot.sequence_to_chain_results_t_match_fraction_get, _coot.sequence_to_chain_results_t_match_fraction_set, doc=r"""match_fraction : double""")
    __swig_destroy__ = _coot.delete_sequence_to_chain_results_t

# Register sequence_to_chain_results_t in _coot:
_coot.sequence_to_chain_results_t_swigregister(sequence_to_chain_results_t)

def sequence_comparison_to_chains(imol, sequence):
    r"""sequence_comparison_to_chains(int imol, std::string sequence) -> std::vector< coot::chain_mutation_info_container_t,std::allocator< coot::chain_mutation_info_container_t > >"""
    return _coot.sequence_comparison_to_chains(imol, sequence)

def assign_sequence_to_best_matching_chain(sequence):
    r"""assign_sequence_to_best_matching_chain(std::string sequence) -> bool"""
    return _coot.assign_sequence_to_best_matching_chain(sequence)

def assign_sequences_to_best_matching_chain_from_fasta(fasta_file_name):
    r"""assign_sequences_to_best_matching_chain_from_fasta(std::string fasta_file_name) -> bool"""
    return _coot.assign_sequences_to_best_matching_chain_from_fasta(fasta_file_name)

def apply_fasta_multi_to_fragment(imol, chain_id, resno_start, resno_end, imol_map, fam):
    r"""apply_fasta_multi_to_fragment(int imol, std::string const & chain_id, int resno_start, int resno_end, int imol_map, coot::fasta_multi const & fam)"""
    return _coot.apply_fasta_multi_to_fragment(imol, chain_id, resno_start, resno_end, imol_map, fam)

def get_refmac_refinement_method():
    r"""get_refmac_refinement_method() -> int"""
    return _coot.get_refmac_refinement_method()

def set_refmac_refinement_method(method):
    r"""set_refmac_refinement_method(int method)"""
    return _coot.set_refmac_refinement_method(method)

def refmac_imol_coords():
    r"""refmac_imol_coords() -> int"""
    return _coot.refmac_imol_coords()

def crankshaft_peptide_rotation_optimization_intermediate_atoms():
    r"""crankshaft_peptide_rotation_optimization_intermediate_atoms() -> int"""
    return _coot.crankshaft_peptide_rotation_optimization_intermediate_atoms()

def curlew():
    r"""curlew()"""
    return _coot.curlew()

def new_generic_object_number(obj_name):
    r"""new_generic_object_number(std::string const & obj_name) -> int"""
    return _coot.new_generic_object_number(obj_name)

def new_generic_object_number_for_molecule(obj_name, imol):
    r"""new_generic_object_number_for_molecule(std::string const & obj_name, int imol) -> int"""
    return _coot.new_generic_object_number_for_molecule(obj_name, imol)

def to_generic_object_add_line(object_number, colour, line_width, to_x1, to_y1, to_z1, to_x2, to_y2, to_z2):
    r"""to_generic_object_add_line(int object_number, char const * colour, int line_width, float to_x1, float to_y1, float to_z1, float to_x2, float to_y2, float to_z2)"""
    return _coot.to_generic_object_add_line(object_number, colour, line_width, to_x1, to_y1, to_z1, to_x2, to_y2, to_z2)

def to_generic_object_add_lines(object_number, line_info_list_py):
    r"""to_generic_object_add_lines(int object_number, PyObject * line_info_list_py)"""
    return _coot.to_generic_object_add_lines(object_number, line_info_list_py)

def to_generic_object_add_cylinder(object_number, colour, line_radius, n_slices, from_x, from_y, from_z, to_x, to_y, to_z, cap_start, cap_end):
    r"""to_generic_object_add_cylinder(int object_number, char const * colour, float line_radius, int n_slices, float from_x, float from_y, float from_z, float to_x, float to_y, float to_z, bool cap_start, bool cap_end)"""
    return _coot.to_generic_object_add_cylinder(object_number, colour, line_radius, n_slices, from_x, from_y, from_z, to_x, to_y, to_z, cap_start, cap_end)

def to_generic_object_add_dashed_line(object_number, colour, line_width, dash_density, from_x1, from_y1, from_z1, to_x2, to_y2, to_z2):
    r"""to_generic_object_add_dashed_line(int object_number, char const * colour, int line_width, float dash_density, float from_x1, float from_y1, float from_z1, float to_x2, float to_y2, float to_z2)"""
    return _coot.to_generic_object_add_dashed_line(object_number, colour, line_width, dash_density, from_x1, from_y1, from_z1, to_x2, to_y2, to_z2)

def to_generic_object_add_point(object_number, colour, point_width, from_x1, from_y1, from_z1):
    r"""to_generic_object_add_point(int object_number, char const * colour, int point_width, float from_x1, float from_y1, float from_z1)"""
    return _coot.to_generic_object_add_point(object_number, colour, point_width, from_x1, from_y1, from_z1)

def to_generic_object_add_points(object_number, point_info_list_py):
    r"""to_generic_object_add_points(int object_number, PyObject * point_info_list_py)"""
    return _coot.to_generic_object_add_points(object_number, point_info_list_py)

def from_generic_object_remove_last_item(object_number):
    r"""from_generic_object_remove_last_item(int object_number)"""
    return _coot.from_generic_object_remove_last_item(object_number)

def to_generic_object_add_arc(object_number, colour, radius, radius_inner, angle_delta, start_point_x, start_point_y, start_point_z, start_dir_x, start_dir_y, start_dir_z, normal_x1, normal_y1, normal_z1):
    r"""to_generic_object_add_arc(int object_number, char const * colour, float radius, float radius_inner, float angle_delta, float start_point_x, float start_point_y, float start_point_z, float start_dir_x, float start_dir_y, float start_dir_z, float normal_x1, float normal_y1, float normal_z1)"""
    return _coot.to_generic_object_add_arc(object_number, colour, radius, radius_inner, angle_delta, start_point_x, start_point_y, start_point_z, start_dir_x, start_dir_y, start_dir_z, normal_x1, normal_y1, normal_z1)

def to_generic_object_add_torus(object_number, colour_name, radius, radius_inner, centre_point_x, centre_point_y, centre_point_z, normal_x, normal_y, normal_z):
    r"""to_generic_object_add_torus(int object_number, char const * colour_name, float radius, float radius_inner, float centre_point_x, float centre_point_y, float centre_point_z, float normal_x, float normal_y, float normal_z)"""
    return _coot.to_generic_object_add_torus(object_number, colour_name, radius, radius_inner, centre_point_x, centre_point_y, centre_point_z, normal_x, normal_y, normal_z)

def to_generic_object_add_arrow(object_number, colour_name, stem_radius, from_x1, from_y1, from_z1, to_x2, to_y2, to_z2):
    r"""to_generic_object_add_arrow(int object_number, char const * colour_name, float stem_radius, float from_x1, float from_y1, float from_z1, float to_x2, float to_y2, float to_z2)"""
    return _coot.to_generic_object_add_arrow(object_number, colour_name, stem_radius, from_x1, from_y1, from_z1, to_x2, to_y2, to_z2)

def to_generic_object_add_dodecahedron(object_number, colour, radius, x, y, z):
    r"""to_generic_object_add_dodecahedron(int object_number, char const * colour, float radius, float x, float y, float z)"""
    return _coot.to_generic_object_add_dodecahedron(object_number, colour, radius, x, y, z)

def to_generic_object_add_pentakis_dodecahedron(object_number, colour, stellation_factor, radius_factor, x, y, z):
    r"""to_generic_object_add_pentakis_dodecahedron(int object_number, char const * colour, float stellation_factor, float radius_factor, float x, float y, float z)"""
    return _coot.to_generic_object_add_pentakis_dodecahedron(object_number, colour, stellation_factor, radius_factor, x, y, z)

def to_generic_object_add_mesh(object_number, mesh_py):
    r"""to_generic_object_add_mesh(int object_number, PyObject * mesh_py)"""
    return _coot.to_generic_object_add_mesh(object_number, mesh_py)

def to_generic_object_attach_translation_gizmo(object_number):
    r"""to_generic_object_attach_translation_gizmo(int object_number)"""
    return _coot.to_generic_object_attach_translation_gizmo(object_number)

def generic_object_mesh_calculate_normals(object_number):
    r"""generic_object_mesh_calculate_normals(int object_number)"""
    return _coot.generic_object_mesh_calculate_normals(object_number)

def to_generic_object_add_display_list_handle(object_number, display_list_id):
    r"""to_generic_object_add_display_list_handle(int object_number, int display_list_id)"""
    return _coot.to_generic_object_add_display_list_handle(object_number, display_list_id)

def set_display_generic_object(object_number, istate):
    r"""set_display_generic_object(int object_number, short istate)"""
    return _coot.set_display_generic_object(object_number, istate)

def set_display_generic_object_simple(object_number, istate):
    r"""set_display_generic_object_simple(int object_number, short istate)"""
    return _coot.set_display_generic_object_simple(object_number, istate)

def generic_object_is_displayed_p(object_number):
    r"""generic_object_is_displayed_p(int object_number) -> int"""
    return _coot.generic_object_is_displayed_p(object_number)

def generic_object_index(name):
    r"""generic_object_index(std::string const & name) -> int"""
    return _coot.generic_object_index(name)

def generic_object_name_py(obj_number):
    r"""generic_object_name_py(unsigned int obj_number) -> PyObject *"""
    return _coot.generic_object_name_py(obj_number)

def get_generic_object_py(obj_number):
    r"""get_generic_object_py(unsigned int obj_number) -> PyObject *"""
    return _coot.get_generic_object_py(obj_number)

def number_of_generic_objects():
    r"""number_of_generic_objects() -> int"""
    return _coot.number_of_generic_objects()

def generic_object_info():
    r"""generic_object_info()"""
    return _coot.generic_object_info()

def get_generic_object_info(obj_number):
    r"""get_generic_object_info(int obj_number) -> PyObject *"""
    return _coot.get_generic_object_info(obj_number)

def generic_object_has_objects_p(obj_no):
    r"""generic_object_has_objects_p(int obj_no) -> short"""
    return _coot.generic_object_has_objects_p(obj_no)

def close_generic_object(object_number):
    r"""close_generic_object(int object_number)"""
    return _coot.close_generic_object(object_number)

def is_closed_generic_object_p(object_number):
    r"""is_closed_generic_object_p(int object_number) -> short"""
    return _coot.is_closed_generic_object_p(object_number)

def generic_object_clear(object_number):
    r"""generic_object_clear(int object_number)"""
    return _coot.generic_object_clear(object_number)

def attach_generic_object_to_molecule(obj_number, imol):
    r"""attach_generic_object_to_molecule(int obj_number, int imol)"""
    return _coot.attach_generic_object_to_molecule(obj_number, imol)
class mtz_to_map_info_t(object):
    r"""Proxy of C++ coot::mtz_to_map_info_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mtz_file_name = property(_coot.mtz_to_map_info_t_mtz_file_name_get, _coot.mtz_to_map_info_t_mtz_file_name_set, doc=r"""
    mtz_file_name : std::string

    presumes that imol_Refinement_Map has been set

    Parameters
    ----------
    imol : int

    """)
    f_col = property(_coot.mtz_to_map_info_t_f_col_get, _coot.mtz_to_map_info_t_f_col_set, doc=r"""f_col : std::string""")
    phi_col = property(_coot.mtz_to_map_info_t_phi_col_get, _coot.mtz_to_map_info_t_phi_col_set, doc=r"""phi_col : std::string""")
    w_col = property(_coot.mtz_to_map_info_t_w_col_get, _coot.mtz_to_map_info_t_w_col_set, doc=r"""w_col : std::string""")
    id = property(_coot.mtz_to_map_info_t_id_get, _coot.mtz_to_map_info_t_id_set, doc=r"""id : std::string""")
    use_weights = property(_coot.mtz_to_map_info_t_use_weights_get, _coot.mtz_to_map_info_t_use_weights_set, doc=r"""use_weights : bool""")
    is_difference_map = property(_coot.mtz_to_map_info_t_is_difference_map_get, _coot.mtz_to_map_info_t_is_difference_map_set, doc=r"""is_difference_map : bool""")

    def __init__(self):
        r"""__init__(mtz_to_map_info_t self) -> mtz_to_map_info_t"""
        _coot.mtz_to_map_info_t_swiginit(self, _coot.new_mtz_to_map_info_t())
    __swig_destroy__ = _coot.delete_mtz_to_map_info_t

# Register mtz_to_map_info_t in _coot:
_coot.mtz_to_map_info_t_swigregister(mtz_to_map_info_t)
class mtz_type_label(object):
    r"""Proxy of C++ coot::mtz_type_label class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    column_type = property(_coot.mtz_type_label_column_type_get, _coot.mtz_type_label_column_type_set, doc=r"""column_type : char""")
    column_label = property(_coot.mtz_type_label_column_label_get, _coot.mtz_type_label_column_label_set, doc=r"""column_label : std::string""")
    column_position = property(_coot.mtz_type_label_column_position_get, _coot.mtz_type_label_column_position_set, doc=r"""column_position : int""")

    def __init__(self, *args):
        r"""
        __init__(mtz_type_label self, std::string const & column_label_in, char column_type_in, int column_position_in) -> mtz_type_label
        __init__(mtz_type_label self) -> mtz_type_label
        """
        _coot.mtz_type_label_swiginit(self, _coot.new_mtz_type_label(*args))
    __swig_destroy__ = _coot.delete_mtz_type_label

# Register mtz_type_label in _coot:
_coot.mtz_type_label_swigregister(mtz_type_label)
class mtz_column_types_info_t(object):
    r"""Proxy of C++ coot::mtz_column_types_info_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mtz_filename = property(_coot.mtz_column_types_info_t_mtz_filename_get, _coot.mtz_column_types_info_t_mtz_filename_set, doc=r"""mtz_filename : std::string""")
    read_success = property(_coot.mtz_column_types_info_t_read_success_get, _coot.mtz_column_types_info_t_read_success_set, doc=r"""read_success : short""")
    f_cols = property(_coot.mtz_column_types_info_t_f_cols_get, _coot.mtz_column_types_info_t_f_cols_set, doc=r"""f_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    sigf_cols = property(_coot.mtz_column_types_info_t_sigf_cols_get, _coot.mtz_column_types_info_t_sigf_cols_set, doc=r"""sigf_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    d_cols = property(_coot.mtz_column_types_info_t_d_cols_get, _coot.mtz_column_types_info_t_d_cols_set, doc=r"""d_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    sigd_cols = property(_coot.mtz_column_types_info_t_sigd_cols_get, _coot.mtz_column_types_info_t_sigd_cols_set, doc=r"""sigd_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    phi_cols = property(_coot.mtz_column_types_info_t_phi_cols_get, _coot.mtz_column_types_info_t_phi_cols_set, doc=r"""phi_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    weight_cols = property(_coot.mtz_column_types_info_t_weight_cols_get, _coot.mtz_column_types_info_t_weight_cols_set, doc=r"""weight_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    r_free_cols = property(_coot.mtz_column_types_info_t_r_free_cols_get, _coot.mtz_column_types_info_t_r_free_cols_set, doc=r"""r_free_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    hl_cols = property(_coot.mtz_column_types_info_t_hl_cols_get, _coot.mtz_column_types_info_t_hl_cols_set, doc=r"""hl_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    fpm_cols = property(_coot.mtz_column_types_info_t_fpm_cols_get, _coot.mtz_column_types_info_t_fpm_cols_set, doc=r"""fpm_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    sigfpm_cols = property(_coot.mtz_column_types_info_t_sigfpm_cols_get, _coot.mtz_column_types_info_t_sigfpm_cols_set, doc=r"""sigfpm_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    i_cols = property(_coot.mtz_column_types_info_t_i_cols_get, _coot.mtz_column_types_info_t_i_cols_set, doc=r"""i_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    ipm_cols = property(_coot.mtz_column_types_info_t_ipm_cols_get, _coot.mtz_column_types_info_t_ipm_cols_set, doc=r"""ipm_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    sigipm_cols = property(_coot.mtz_column_types_info_t_sigipm_cols_get, _coot.mtz_column_types_info_t_sigipm_cols_set, doc=r"""sigipm_cols : std::vector<(coot::mtz_type_label,std::allocator<(coot::mtz_type_label)>)>""")
    selected_f_col = property(_coot.mtz_column_types_info_t_selected_f_col_get, _coot.mtz_column_types_info_t_selected_f_col_set, doc=r"""selected_f_col : int""")
    selected_phi_col = property(_coot.mtz_column_types_info_t_selected_phi_col_get, _coot.mtz_column_types_info_t_selected_phi_col_set, doc=r"""selected_phi_col : int""")
    selected_weight_col = property(_coot.mtz_column_types_info_t_selected_weight_col_get, _coot.mtz_column_types_info_t_selected_weight_col_set, doc=r"""selected_weight_col : int""")
    selected_refmac_fobs_col = property(_coot.mtz_column_types_info_t_selected_refmac_fobs_col_get, _coot.mtz_column_types_info_t_selected_refmac_fobs_col_set, doc=r"""selected_refmac_fobs_col : int""")
    selected_refmac_sigfobs_col = property(_coot.mtz_column_types_info_t_selected_refmac_sigfobs_col_get, _coot.mtz_column_types_info_t_selected_refmac_sigfobs_col_set, doc=r"""selected_refmac_sigfobs_col : int""")
    selected_refmac_r_free_col = property(_coot.mtz_column_types_info_t_selected_refmac_r_free_col_get, _coot.mtz_column_types_info_t_selected_refmac_r_free_col_set, doc=r"""selected_refmac_r_free_col : int""")
    selected_refmac_phi_col = property(_coot.mtz_column_types_info_t_selected_refmac_phi_col_get, _coot.mtz_column_types_info_t_selected_refmac_phi_col_set, doc=r"""selected_refmac_phi_col : int""")
    selected_refmac_fom_col = property(_coot.mtz_column_types_info_t_selected_refmac_fom_col_get, _coot.mtz_column_types_info_t_selected_refmac_fom_col_set, doc=r"""selected_refmac_fom_col : int""")
    selected_refmac_hla_col = property(_coot.mtz_column_types_info_t_selected_refmac_hla_col_get, _coot.mtz_column_types_info_t_selected_refmac_hla_col_set, doc=r"""selected_refmac_hla_col : int""")
    selected_refmac_hlb_col = property(_coot.mtz_column_types_info_t_selected_refmac_hlb_col_get, _coot.mtz_column_types_info_t_selected_refmac_hlb_col_set, doc=r"""selected_refmac_hlb_col : int""")
    selected_refmac_hlc_col = property(_coot.mtz_column_types_info_t_selected_refmac_hlc_col_get, _coot.mtz_column_types_info_t_selected_refmac_hlc_col_set, doc=r"""selected_refmac_hlc_col : int""")
    selected_refmac_hld_col = property(_coot.mtz_column_types_info_t_selected_refmac_hld_col_get, _coot.mtz_column_types_info_t_selected_refmac_hld_col_set, doc=r"""selected_refmac_hld_col : int""")
    selected_refmac_fp_col = property(_coot.mtz_column_types_info_t_selected_refmac_fp_col_get, _coot.mtz_column_types_info_t_selected_refmac_fp_col_set, doc=r"""selected_refmac_fp_col : int""")
    selected_refmac_sigfp_col = property(_coot.mtz_column_types_info_t_selected_refmac_sigfp_col_get, _coot.mtz_column_types_info_t_selected_refmac_sigfp_col_set, doc=r"""selected_refmac_sigfp_col : int""")
    selected_refmac_fm_col = property(_coot.mtz_column_types_info_t_selected_refmac_fm_col_get, _coot.mtz_column_types_info_t_selected_refmac_fm_col_set, doc=r"""selected_refmac_fm_col : int""")
    selected_refmac_sigfm_col = property(_coot.mtz_column_types_info_t_selected_refmac_sigfm_col_get, _coot.mtz_column_types_info_t_selected_refmac_sigfm_col_set, doc=r"""selected_refmac_sigfm_col : int""")
    selected_refmac_iobs_col = property(_coot.mtz_column_types_info_t_selected_refmac_iobs_col_get, _coot.mtz_column_types_info_t_selected_refmac_iobs_col_set, doc=r"""selected_refmac_iobs_col : int""")
    selected_refmac_sigiobs_col = property(_coot.mtz_column_types_info_t_selected_refmac_sigiobs_col_get, _coot.mtz_column_types_info_t_selected_refmac_sigiobs_col_set, doc=r"""selected_refmac_sigiobs_col : int""")
    selected_refmac_ip_col = property(_coot.mtz_column_types_info_t_selected_refmac_ip_col_get, _coot.mtz_column_types_info_t_selected_refmac_ip_col_set, doc=r"""selected_refmac_ip_col : int""")
    selected_refmac_sigip_col = property(_coot.mtz_column_types_info_t_selected_refmac_sigip_col_get, _coot.mtz_column_types_info_t_selected_refmac_sigip_col_set, doc=r"""selected_refmac_sigip_col : int""")
    selected_refmac_im_col = property(_coot.mtz_column_types_info_t_selected_refmac_im_col_get, _coot.mtz_column_types_info_t_selected_refmac_im_col_set, doc=r"""selected_refmac_im_col : int""")
    selected_refmac_sigim_col = property(_coot.mtz_column_types_info_t_selected_refmac_sigim_col_get, _coot.mtz_column_types_info_t_selected_refmac_sigim_col_set, doc=r"""selected_refmac_sigim_col : int""")
    use_weights = property(_coot.mtz_column_types_info_t_use_weights_get, _coot.mtz_column_types_info_t_use_weights_set, doc=r"""use_weights : int""")

    def get_prefered_label_idx(self, cols, prefered_suffix):
        r"""get_prefered_label_idx(mtz_column_types_info_t self, vector_mtz_type_label cols, std::string const & prefered_suffix) -> int"""
        return _coot.mtz_column_types_info_t_get_prefered_label_idx(self, cols, prefered_suffix)

    def get_prefered_f_col_idx(self):
        r"""get_prefered_f_col_idx(mtz_column_types_info_t self) -> int"""
        return _coot.mtz_column_types_info_t_get_prefered_f_col_idx(self)

    def get_prefered_phi_col_idx(self):
        r"""get_prefered_phi_col_idx(mtz_column_types_info_t self) -> int"""
        return _coot.mtz_column_types_info_t_get_prefered_phi_col_idx(self)

    def __init__(self):
        r"""__init__(mtz_column_types_info_t self) -> mtz_column_types_info_t"""
        _coot.mtz_column_types_info_t_swiginit(self, _coot.new_mtz_column_types_info_t())
    __swig_destroy__ = _coot.delete_mtz_column_types_info_t

# Register mtz_column_types_info_t in _coot:
_coot.mtz_column_types_info_t_swigregister(mtz_column_types_info_t)

def get_mtz_columns(filename):
    r"""get_mtz_columns(std::string const & filename) -> mtz_column_types_info_t"""
    return _coot.get_mtz_columns(filename)

def get_f_cols(mtz_file_name):
    r"""get_f_cols(std::string const & mtz_file_name) -> vector_string"""
    return _coot.get_f_cols(mtz_file_name)

def get_sigf_cols(mtz_file_name):
    r"""get_sigf_cols(std::string const & mtz_file_name) -> vector_string"""
    return _coot.get_sigf_cols(mtz_file_name)

def get_r_free_cols(mtz_file_name):
    r"""get_r_free_cols(std::string const & mtz_file_name) -> vector_string"""
    return _coot.get_r_free_cols(mtz_file_name)

def get_phi_cols(mtz_file_name):
    r"""get_phi_cols(std::string const & mtz_file_name) -> vector_string"""
    return _coot.get_phi_cols(mtz_file_name)

def get_weight_cols(mtz_file_name):
    r"""get_weight_cols(std::string const & mtz_file_name) -> vector_string"""
    return _coot.get_weight_cols(mtz_file_name)

def get_d_cols(mtz_file_name):
    r"""get_d_cols(std::string const & mtz_file_name) -> vector_string"""
    return _coot.get_d_cols(mtz_file_name)

def my_combo_box_text_add_items(combobox, labels, active_label_index):
    r"""my_combo_box_text_add_items(GtkComboBox * combobox, vector_mtz_type_label labels, int active_label_index)"""
    return _coot.my_combo_box_text_add_items(combobox, labels, active_label_index)
DELETED = _coot.DELETED

MUTATED = _coot.MUTATED

MOVINGATOMS = _coot.MOVINGATOMS


def network_get_accession_code_entity(pdb_accession_code, mode):
    r"""
    network_get_accession_code_entity(std::string const & pdb_accession_code, int mode)

    download and read the model (and data) for the given PDB accession code from PDBe

    This is an asynchronous function and will return immediately and invoke a download subthread. Check later so see if a molecule has loaded.

      pdb_accession_code  is the PDB accession code to fetch   mode  1 means fetch the "mtz" (to make the map) and 0 means fetch the coordinates model (.pdb or .cif file)

    Parameters
    ----------
    pdb_accession_code : str
        is the PDB accession code to fetch
    mode : int
        1 means fetch the "mtz" (to make the map) and 0 means fetch the coordinates model (.pdb or .cif file)

    """
    return _coot.network_get_accession_code_entity(pdb_accession_code, mode)

def fetch_pdb_redo(code):
    r"""
    fetch_pdb_redo(std::string const & code) -> int

    fetch structure from PDB_REDO

    This is not an asynchronous function.

      pdb_accession_code  is the PDB accession code to fetch the molecule index of the coordinates molecule or -1 on failure

    Parameters
    ----------
    code : str

    """
    return _coot.fetch_pdb_redo(code)
ROTAMERSEARCHAUTOMATIC = _coot.ROTAMERSEARCHAUTOMATIC

ROTAMERSEARCHHIGHRES = _coot.ROTAMERSEARCHHIGHRES

ROTAMERSEARCHLOWRES = _coot.ROTAMERSEARCHLOWRES


def residue_to_sdf_file(imol, chain_id, res_no, ins_code, sdf_file_name, kekulize):
    r"""residue_to_sdf_file(int imol, char const * chain_id, int res_no, char const * ins_code, char const * sdf_file_name, bool kekulize) -> bool"""
    return _coot.residue_to_sdf_file(imol, chain_id, res_no, ins_code, sdf_file_name, kekulize)

def residue_to_mdl_file_for_mogul(imol, chain_id, res_no, ins_code, mdl_file_name):
    r"""residue_to_mdl_file_for_mogul(int imol, char const * chain_id, int res_no, char const * ins_code, char const * mdl_file_name) -> bool"""
    return _coot.residue_to_mdl_file_for_mogul(imol, chain_id, res_no, ins_code, mdl_file_name)

def show_feats(imol, chain_id, resno, ins_code):
    r"""show_feats(int imol, char const * chain_id, int resno, char const * ins_code) -> bool"""
    return _coot.show_feats(imol, chain_id, resno, ins_code)
class atom_spec_t(object):
    r"""Proxy of C++ coot::atom_spec_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    chain_id = property(_coot.atom_spec_t_chain_id_get, _coot.atom_spec_t_chain_id_set, doc=r"""chain_id : std::string""")
    res_no = property(_coot.atom_spec_t_res_no_get, _coot.atom_spec_t_res_no_set, doc=r"""res_no : int""")
    ins_code = property(_coot.atom_spec_t_ins_code_get, _coot.atom_spec_t_ins_code_set, doc=r"""ins_code : std::string""")
    atom_name = property(_coot.atom_spec_t_atom_name_get, _coot.atom_spec_t_atom_name_set, doc=r"""atom_name : std::string""")
    alt_conf = property(_coot.atom_spec_t_alt_conf_get, _coot.atom_spec_t_alt_conf_set, doc=r"""alt_conf : std::string""")
    int_user_data = property(_coot.atom_spec_t_int_user_data_get, _coot.atom_spec_t_int_user_data_set, doc=r"""int_user_data : int""")
    float_user_data = property(_coot.atom_spec_t_float_user_data_get, _coot.atom_spec_t_float_user_data_set, doc=r"""float_user_data : float""")
    string_user_data = property(_coot.atom_spec_t_string_user_data_get, _coot.atom_spec_t_string_user_data_set, doc=r"""string_user_data : std::string""")
    model_number = property(_coot.atom_spec_t_model_number_get, _coot.atom_spec_t_model_number_set, doc=r"""model_number : int""")

    def __init__(self, *args):
        r"""
        __init__(atom_spec_t self) -> atom_spec_t
        __init__(atom_spec_t self, std::string const & chain_in, int resno_in, std::string const & insertion_code_in, std::string const & atom_name_in, std::string const & alt_conf_in) -> atom_spec_t
        __init__(atom_spec_t self, mmdb::Atom * at) -> atom_spec_t
        __init__(atom_spec_t self, mmdb::Atom * at, std::string const & user_data_string) -> atom_spec_t
        """
        _coot.atom_spec_t_swiginit(self, _coot.new_atom_spec_t(*args))

    def empty(self):
        r"""empty(atom_spec_t self) -> bool"""
        return _coot.atom_spec_t_empty(self)

    def selectatoms(self, mol, SelHnd):
        r"""selectatoms(atom_spec_t self, mmdb::Manager * mol, int SelHnd)"""
        return _coot.atom_spec_t_selectatoms(self, mol, SelHnd)

    def matches_spec(self, atom):
        r"""matches_spec(atom_spec_t self, mmdb::Atom * atom) -> bool"""
        return _coot.atom_spec_t_matches_spec(self, atom)

    def format(self):
        r"""format(atom_spec_t self) -> std::string"""
        return _coot.atom_spec_t_format(self)

    def label(self, *args):
        r"""
        label(atom_spec_t self) -> std::string
        label(atom_spec_t self, std::string const & residue_name) -> std::string
        """
        return _coot.atom_spec_t_label(self, *args)

    def simple_label(self, *args):
        r"""simple_label(atom_spec_t self, std::string const & residue_name="") -> std::string"""
        return _coot.atom_spec_t_simple_label(self, *args)

    def is_same(self, matcher):
        r"""is_same(atom_spec_t self, atom_spec_t matcher) -> bool"""
        return _coot.atom_spec_t_is_same(self, matcher)

    def get_atom(self, mol):
        r"""get_atom(atom_spec_t self, mmdb::Manager * mol) -> mmdb::Atom *"""
        return _coot.atom_spec_t_get_atom(self, mol)
    __swig_destroy__ = _coot.delete_atom_spec_t

# Register atom_spec_t in _coot:
_coot.atom_spec_t_swigregister(atom_spec_t)

def compare_atom_specs_user_float(a1, a2):
    r"""compare_atom_specs_user_float(atom_spec_t a1, atom_spec_t a2) -> bool"""
    return _coot.compare_atom_specs_user_float(a1, a2)

def compare_atom_specs_user_float_in_pair(a, b):
    r"""compare_atom_specs_user_float_in_pair(std::pair< coot::atom_spec_t,std::string > const & a, std::pair< coot::atom_spec_t,std::string > const & b) -> bool"""
    return _coot.compare_atom_specs_user_float_in_pair(a, b)

def link_atoms(*args):
    r"""
    link_atoms(mmdb::Link * link, mmdb::Model * model_p=None) -> std::pair< coot::atom_spec_t,coot::atom_spec_t >
    link_atoms(mmdb::LinkR * link, mmdb::Model * model_p=None) -> std::pair< coot::atom_spec_t,coot::atom_spec_t >
    """
    return _coot.link_atoms(*args)
class residue_spec_t(object):
    r"""Proxy of C++ coot::residue_spec_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    model_number = property(_coot.residue_spec_t_model_number_get, _coot.residue_spec_t_model_number_set, doc=r"""model_number : int""")
    chain_id = property(_coot.residue_spec_t_chain_id_get, _coot.residue_spec_t_chain_id_set, doc=r"""chain_id : std::string""")
    res_no = property(_coot.residue_spec_t_res_no_get, _coot.residue_spec_t_res_no_set, doc=r"""res_no : int""")
    ins_code = property(_coot.residue_spec_t_ins_code_get, _coot.residue_spec_t_ins_code_set, doc=r"""ins_code : std::string""")
    int_user_data = property(_coot.residue_spec_t_int_user_data_get, _coot.residue_spec_t_int_user_data_set, doc=r"""int_user_data : int""")
    float_user_data = property(_coot.residue_spec_t_float_user_data_get, _coot.residue_spec_t_float_user_data_set, doc=r"""float_user_data : float""")
    string_user_data = property(_coot.residue_spec_t_string_user_data_get, _coot.residue_spec_t_string_user_data_set, doc=r"""string_user_data : std::string""")

    def __init__(self, *args):
        r"""
        __init__(residue_spec_t self, int r) -> residue_spec_t
        __init__(residue_spec_t self, std::string const & chain_in, int r) -> residue_spec_t
        __init__(residue_spec_t self, int model_number_in, std::string const & chain_in, int r, std::string const & ins_code_in) -> residue_spec_t
        __init__(residue_spec_t self, std::string const & chain_in, int r, std::string const & ins_code_in) -> residue_spec_t
        __init__(residue_spec_t self, mmdb::Residue * res) -> residue_spec_t
        __init__(residue_spec_t self, atom_spec_t atom_spec) -> residue_spec_t
        __init__(residue_spec_t self) -> residue_spec_t
        """
        _coot.residue_spec_t_swiginit(self, _coot.new_residue_spec_t(*args))

    def unset_p(self):
        r"""unset_p(residue_spec_t self) -> bool"""
        return _coot.residue_spec_t_unset_p(self)

    def empty(self):
        r"""empty(residue_spec_t self) -> bool"""
        return _coot.residue_spec_t_empty(self)

    def next(self):
        r"""next(residue_spec_t self) -> residue_spec_t"""
        return _coot.residue_spec_t_next(self)

    def previous(self):
        r"""previous(residue_spec_t self) -> residue_spec_t"""
        return _coot.residue_spec_t_previous(self)

    def format(self):
        r"""format(residue_spec_t self) -> std::string"""
        return _coot.residue_spec_t_format(self)

    def label(self, *args):
        r"""
        label(residue_spec_t self) -> std::string
        label(residue_spec_t self, std::string const & residue_name) -> std::string
        """
        return _coot.residue_spec_t_label(self, *args)

    def get_residue(self, mol):
        r"""get_residue(residue_spec_t self, mmdb::Manager * mol) -> mmdb::Residue *"""
        return _coot.residue_spec_t_get_residue(self, mol)

    def select_atoms(self, mol, selhnd, selection_key):
        r"""select_atoms(residue_spec_t self, mmdb::Manager * mol, int selhnd, mmdb::SELECTION_KEY selection_key) -> int"""
        return _coot.residue_spec_t_select_atoms(self, mol, selhnd, selection_key)
    __swig_destroy__ = _coot.delete_residue_spec_t

# Register residue_spec_t in _coot:
_coot.residue_spec_t_swigregister(residue_spec_t)
class probe_atom_spec_t(atom_spec_t):
    r"""Proxy of C++ coot::probe_atom_spec_t class."""

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

    def __init__(self, *args):
        r"""
        __init__(probe_atom_spec_t self, std::string const & s) -> probe_atom_spec_t
        __init__(probe_atom_spec_t self) -> probe_atom_spec_t
        """
        _coot.probe_atom_spec_t_swiginit(self, _coot.new_probe_atom_spec_t(*args))
    __swig_destroy__ = _coot.delete_probe_atom_spec_t

# Register probe_atom_spec_t in _coot:
_coot.probe_atom_spec_t_swigregister(probe_atom_spec_t)
class one_way_probe_contact_t(object):
    r"""Proxy of C++ coot::one_way_probe_contact_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    from_atom = property(_coot.one_way_probe_contact_t_from_atom_get, _coot.one_way_probe_contact_t_from_atom_set, doc=r"""from_atom : coot::probe_atom_spec_t""")
    to_atoms = property(_coot.one_way_probe_contact_t_to_atoms_get, _coot.one_way_probe_contact_t_to_atoms_set, doc=r"""to_atoms : std::vector<(coot::probe_atom_spec_t,std::allocator<(coot::probe_atom_spec_t)>)>""")

    def __init__(self, spec):
        r"""__init__(one_way_probe_contact_t self, probe_atom_spec_t spec) -> one_way_probe_contact_t"""
        _coot.one_way_probe_contact_t_swiginit(self, _coot.new_one_way_probe_contact_t(spec))

    def size(self):
        r"""size(one_way_probe_contact_t self) -> unsigned int"""
        return _coot.one_way_probe_contact_t_size(self)

    def add(self, spec):
        r"""add(one_way_probe_contact_t self, probe_atom_spec_t spec)"""
        return _coot.one_way_probe_contact_t_add(self, spec)
    __swig_destroy__ = _coot.delete_one_way_probe_contact_t

# Register one_way_probe_contact_t in _coot:
_coot.one_way_probe_contact_t_swigregister(one_way_probe_contact_t)
class one_way_probe_contact_container_t(object):
    r"""Proxy of C++ coot::one_way_probe_contact_container_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    contacts = property(_coot.one_way_probe_contact_container_t_contacts_get, _coot.one_way_probe_contact_container_t_contacts_set, doc=r"""contacts : std::vector<(coot::one_way_probe_contact_t,std::allocator<(coot::one_way_probe_contact_t)>)>""")

    def add(self, from_atom, to_atom):
        r"""add(one_way_probe_contact_container_t self, probe_atom_spec_t from_atom, probe_atom_spec_t to_atom)"""
        return _coot.one_way_probe_contact_container_t_add(self, from_atom, to_atom)

    def size(self):
        r"""size(one_way_probe_contact_container_t self) -> unsigned int"""
        return _coot.one_way_probe_contact_container_t_size(self)

    def __init__(self):
        r"""__init__(one_way_probe_contact_container_t self) -> one_way_probe_contact_container_t"""
        _coot.one_way_probe_contact_container_t_swiginit(self, _coot.new_one_way_probe_contact_container_t())
    __swig_destroy__ = _coot.delete_one_way_probe_contact_container_t

# Register one_way_probe_contact_container_t in _coot:
_coot.one_way_probe_contact_container_t_swigregister(one_way_probe_contact_container_t)
class probe_clash_score_t(object):
    r"""Proxy of C++ coot::probe_clash_score_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    filled = property(_coot.probe_clash_score_t_filled_get, _coot.probe_clash_score_t_filled_set, doc=r"""filled : bool""")
    n_bad_overlaps = property(_coot.probe_clash_score_t_n_bad_overlaps_get, _coot.probe_clash_score_t_n_bad_overlaps_set, doc=r"""n_bad_overlaps : int""")
    n_hydrogen_bonds = property(_coot.probe_clash_score_t_n_hydrogen_bonds_get, _coot.probe_clash_score_t_n_hydrogen_bonds_set, doc=r"""n_hydrogen_bonds : int""")
    n_small_overlaps = property(_coot.probe_clash_score_t_n_small_overlaps_get, _coot.probe_clash_score_t_n_small_overlaps_set, doc=r"""n_small_overlaps : int""")
    n_close_contacts = property(_coot.probe_clash_score_t_n_close_contacts_get, _coot.probe_clash_score_t_n_close_contacts_set, doc=r"""n_close_contacts : int""")
    n_wide_contacts = property(_coot.probe_clash_score_t_n_wide_contacts_get, _coot.probe_clash_score_t_n_wide_contacts_set, doc=r"""n_wide_contacts : int""")

    def __init__(self, *args):
        r"""
        __init__(probe_clash_score_t self) -> probe_clash_score_t
        __init__(probe_clash_score_t self, int n_bad_overlaps_in, int n_hydrogen_bonds_in, int n_small_overlaps_in, int n_close_contacts_in, int n_wide_contacts_in) -> probe_clash_score_t
        __init__(probe_clash_score_t self, std::string const & dots_file_name) -> probe_clash_score_t
        """
        _coot.probe_clash_score_t_swiginit(self, _coot.new_probe_clash_score_t(*args))
    __swig_destroy__ = _coot.delete_probe_clash_score_t

# Register probe_clash_score_t in _coot:
_coot.probe_clash_score_t_swigregister(probe_clash_score_t)
class spec_eraser(object):
    r"""Proxy of C++ coot::spec_eraser class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ref_specs = property(_coot.spec_eraser_ref_specs_get, _coot.spec_eraser_ref_specs_set, doc=r"""ref_specs : std::map<(std::pair<(coot::probe_atom_spec_t,coot::probe_atom_spec_t)>,bool)>""")

    def __init__(self, ref_specs_in):
        r"""__init__(spec_eraser self, std::map< std::pair< coot::probe_atom_spec_t,coot::probe_atom_spec_t >,bool > const & ref_specs_in) -> spec_eraser"""
        _coot.spec_eraser_swiginit(self, _coot.new_spec_eraser(ref_specs_in))
    __swig_destroy__ = _coot.delete_spec_eraser

# Register spec_eraser in _coot:
_coot.spec_eraser_swigregister(spec_eraser)

def probe_clash_score_py(dots_file_name):
    r"""probe_clash_score_py(std::string const & dots_file_name) -> PyObject *"""
    return _coot.probe_clash_score_py(dots_file_name)

def probe_clash_score_as_py(p):
    r"""probe_clash_score_as_py(probe_clash_score_t p) -> PyObject *"""
    return _coot.probe_clash_score_as_py(p)

def probe_clash_score_from_py(p):
    r"""probe_clash_score_from_py(PyObject * p) -> probe_clash_score_t"""
    return _coot.probe_clash_score_from_py(p)

def coot_version():
    r"""coot_version() -> std::string"""
    return _coot.coot_version()

def coot_version_extra_info():
    r"""coot_version_extra_info() -> std::string"""
    return _coot.coot_version_extra_info()

def get_monomer(comp_id):
    r"""get_monomer(std::string const & comp_id) -> int"""
    return _coot.get_monomer(comp_id)

def get_monomer_for_molecule(comp_id, imol):
    r"""get_monomer_for_molecule(std::string const & comp_id, int imol) -> int"""
    return _coot.get_monomer_for_molecule(comp_id, imol)

def get_monomer_from_dictionary(comp_id, idealised_flag):
    r"""get_monomer_from_dictionary(std::string const & comp_id, int idealised_flag) -> int"""
    return _coot.get_monomer_from_dictionary(comp_id, idealised_flag)

def register_extension(name, version):
    r"""register_extension(std::string const & name, std::string const & version)"""
    return _coot.register_extension(name, version)

def version_for_extension(name):
    r"""version_for_extension(std::string const & name) -> std::string"""
    return _coot.version_for_extension(name)

def remove_file_curlew_menu_item_maybe():
    r"""remove_file_curlew_menu_item_maybe()"""
    return _coot.remove_file_curlew_menu_item_maybe()

def curlew_get_extension_list():
    r"""curlew_get_extension_list() -> vector_pair_string_string"""
    return _coot.curlew_get_extension_list()

def curlew_download_and_install_extension(extension_file_name):
    r"""curlew_download_and_install_extension(std::string const & extension_file_name) -> int"""
    return _coot.curlew_download_and_install_extension(extension_file_name)

def c_beta_deviations_py(imol):
    r"""c_beta_deviations_py(int imol) -> PyObject *"""
    return _coot.c_beta_deviations_py(imol)

def add_unhappy_atom_marker_py(imol, atom_spec_list):
    r"""add_unhappy_atom_marker_py(int imol, PyObject * atom_spec_list)"""
    return _coot.add_unhappy_atom_marker_py(imol, atom_spec_list)

def remove_unhappy_atom_marker_py(imol, atom_spec_list):
    r"""remove_unhappy_atom_marker_py(int imol, PyObject * atom_spec_list)"""
    return _coot.remove_unhappy_atom_marker_py(imol, atom_spec_list)

def remove_all_unhappy_atom_markers():
    r"""remove_all_unhappy_atom_markers()"""
    return _coot.remove_all_unhappy_atom_markers()

def clear_generic_objects_dialog_pointer():
    r"""clear_generic_objects_dialog_pointer()"""
    return _coot.clear_generic_objects_dialog_pointer()

def set_display_all_generic_objects(state):
    r"""set_display_all_generic_objects(int state)"""
    return _coot.set_display_all_generic_objects(state)

def generic_objects_gui_wrapper():
    r"""generic_objects_gui_wrapper()"""
    return _coot.generic_objects_gui_wrapper()

def close_all_generic_objects():
    r"""close_all_generic_objects()"""
    return _coot.close_all_generic_objects()

def old_chemical_feature_clusters_py(environment_residues_py, solvated_ligand_info_py, radius_1, radius_2):
    r"""old_chemical_feature_clusters_py(PyObject * environment_residues_py, PyObject * solvated_ligand_info_py, double radius_1, double radius_2) -> PyObject *"""
    return _coot.old_chemical_feature_clusters_py(environment_residues_py, solvated_ligand_info_py, radius_1, radius_2)

def chemical_feature_clusters_accept_info_py(site_number, env_residue_py, mol_ligand_specs_py, cluster_info_py):
    r"""chemical_feature_clusters_accept_info_py(unsigned int site_number, PyObject * env_residue_py, PyObject * mol_ligand_specs_py, PyObject * cluster_info_py)"""
    return _coot.chemical_feature_clusters_accept_info_py(site_number, env_residue_py, mol_ligand_specs_py, cluster_info_py)

def chemical_feature_clusters_accept_site_clusters_info_py(site_info_py):
    r"""chemical_feature_clusters_accept_site_clusters_info_py(PyObject * site_info_py) -> PyObject *"""
    return _coot.chemical_feature_clusters_accept_site_clusters_info_py(site_info_py)
class water_cluster_info_from_python(object):
    r"""Proxy of C++ pythonic_cfc::water_cluster_info_from_python class."""

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

    def __init__(self, *args):
        r"""
        __init__(water_cluster_info_from_python self, clipper::Coord_orth const & pos_in, double w_in, double r_in) -> water_cluster_info_from_python
        __init__(water_cluster_info_from_python self) -> water_cluster_info_from_python
        """
        _coot.water_cluster_info_from_python_swiginit(self, _coot.new_water_cluster_info_from_python(*args))
    pos = property(_coot.water_cluster_info_from_python_pos_get, _coot.water_cluster_info_from_python_pos_set, doc=r"""pos : clipper::Coord_orth""")
    weight = property(_coot.water_cluster_info_from_python_weight_get, _coot.water_cluster_info_from_python_weight_set, doc=r"""weight : double""")
    radius = property(_coot.water_cluster_info_from_python_radius_get, _coot.water_cluster_info_from_python_radius_set, doc=r"""radius : double""")
    __swig_destroy__ = _coot.delete_water_cluster_info_from_python

# Register water_cluster_info_from_python in _coot:
_coot.water_cluster_info_from_python_swigregister(water_cluster_info_from_python)
class clustered_feature_info_from_python(object):
    r"""Proxy of C++ pythonic_cfc::clustered_feature_info_from_python class."""

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

    def __init__(self, *args):
        r"""
        __init__(clustered_feature_info_from_python self, int imol_in, residue_spec_t spec_in, unsigned int cluster_number_in) -> clustered_feature_info_from_python
        __init__(clustered_feature_info_from_python self) -> clustered_feature_info_from_python
        """
        _coot.clustered_feature_info_from_python_swiginit(self, _coot.new_clustered_feature_info_from_python(*args))
    imol = property(_coot.clustered_feature_info_from_python_imol_get, _coot.clustered_feature_info_from_python_imol_set, doc=r"""imol : int""")
    cluster_number = property(_coot.clustered_feature_info_from_python_cluster_number_get, _coot.clustered_feature_info_from_python_cluster_number_set, doc=r"""cluster_number : unsigned int""")
    residue_spec = property(_coot.clustered_feature_info_from_python_residue_spec_get, _coot.clustered_feature_info_from_python_residue_spec_set, doc=r"""residue_spec : coot::residue_spec_t""")
    __swig_destroy__ = _coot.delete_clustered_feature_info_from_python

# Register clustered_feature_info_from_python in _coot:
_coot.clustered_feature_info_from_python_swigregister(clustered_feature_info_from_python)
class extracted_cluster_info_from_python(object):
    r"""Proxy of C++ pythonic_cfc::extracted_cluster_info_from_python class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    wc = property(_coot.extracted_cluster_info_from_python_wc_get, _coot.extracted_cluster_info_from_python_wc_set, doc=r"""wc : std::vector<(pythonic_cfc::water_cluster_info_from_python,std::allocator<(pythonic_cfc::water_cluster_info_from_python)>)>""")
    cw = property(_coot.extracted_cluster_info_from_python_cw_get, _coot.extracted_cluster_info_from_python_cw_set, doc=r"""cw : std::vector<(pythonic_cfc::clustered_feature_info_from_python,std::allocator<(pythonic_cfc::clustered_feature_info_from_python)>)>""")

    def __init__(self, cluster_info_py):
        r"""__init__(extracted_cluster_info_from_python self, PyObject * cluster_info_py) -> extracted_cluster_info_from_python"""
        _coot.extracted_cluster_info_from_python_swiginit(self, _coot.new_extracted_cluster_info_from_python(cluster_info_py))

    def n_water_structures(self):
        r"""n_water_structures(extracted_cluster_info_from_python self) -> unsigned int"""
        return _coot.extracted_cluster_info_from_python_n_water_structures(self)

    def n_pharmacophore_structures(self):
        r"""n_pharmacophore_structures(extracted_cluster_info_from_python self) -> unsigned int"""
        return _coot.extracted_cluster_info_from_python_n_pharmacophore_structures(self)

    def water_structures_vec(self):
        r"""water_structures_vec(extracted_cluster_info_from_python self) -> IntVector"""
        return _coot.extracted_cluster_info_from_python_water_structures_vec(self)

    def pharmacophore_structures_vec(self):
        r"""pharmacophore_structures_vec(extracted_cluster_info_from_python self) -> IntVector"""
        return _coot.extracted_cluster_info_from_python_pharmacophore_structures_vec(self)

    def pharmacophore_structures_and_specs_vec(self):
        r"""pharmacophore_structures_and_specs_vec(extracted_cluster_info_from_python self) -> std::vector< std::pair< int,coot::residue_spec_t >,std::allocator< std::pair< int,coot::residue_spec_t > > >"""
        return _coot.extracted_cluster_info_from_python_pharmacophore_structures_and_specs_vec(self)

    def pharmacophores_centre(self):
        r"""pharmacophores_centre(extracted_cluster_info_from_python self) -> std::pair< bool,clipper::Coord_orth >"""
        return _coot.extracted_cluster_info_from_python_pharmacophores_centre(self)

    def water_cluster_imol_residue_spec_vec(self):
        r"""water_cluster_imol_residue_spec_vec(extracted_cluster_info_from_python self) -> std::vector< std::pair< int,coot::residue_spec_t >,std::allocator< std::pair< int,coot::residue_spec_t > > >"""
        return _coot.extracted_cluster_info_from_python_water_cluster_imol_residue_spec_vec(self)

    def pharmacophore_cluster_imol_residue_spec_vec(self, type, cluster_idx):
        r"""pharmacophore_cluster_imol_residue_spec_vec(extracted_cluster_info_from_python self, std::string const & type, unsigned int cluster_idx) -> std::vector< std::pair< int,coot::residue_spec_t >,std::allocator< std::pair< int,coot::residue_spec_t > > >"""
        return _coot.extracted_cluster_info_from_python_pharmacophore_cluster_imol_residue_spec_vec(self, type, cluster_idx)

    def water_cluster_idx_max(self):
        r"""water_cluster_idx_max(extracted_cluster_info_from_python self) -> unsigned int"""
        return _coot.extracted_cluster_info_from_python_water_cluster_idx_max(self)
    pharmacophore = property(_coot.extracted_cluster_info_from_python_pharmacophore_get, _coot.extracted_cluster_info_from_python_pharmacophore_set, doc=r"""pharmacophore : std::map<(std::string,std::vector<(pythonic_cfc::clustered_feature_info_from_python,std::allocator<(pythonic_cfc::clustered_feature_info_from_python)>)>)>""")
    pharmacophore_model_cluster_means = property(_coot.extracted_cluster_info_from_python_pharmacophore_model_cluster_means_get, _coot.extracted_cluster_info_from_python_pharmacophore_model_cluster_means_set, doc=r"""pharmacophore_model_cluster_means : std::map<(std::string,std::vector<(clipper::Coord_orth,std::allocator<(clipper::Coord_orth)>)>)>""")

    @staticmethod
    def cluster_vector_sorter(v1, v2):
        r"""cluster_vector_sorter(std::pair< std::vector< int,std::allocator< int > >,pythonic_cfc::water_cluster_info_from_python > const & v1, std::pair< std::vector< int,std::allocator< int > >,pythonic_cfc::water_cluster_info_from_python > const & v2) -> bool"""
        return _coot.extracted_cluster_info_from_python_cluster_vector_sorter(v1, v2)

    def show_water_balls(self, site_number):
        r"""show_water_balls(extracted_cluster_info_from_python self, unsigned int site_number) -> int"""
        return _coot.extracted_cluster_info_from_python_show_water_balls(self, site_number)
    __swig_destroy__ = _coot.delete_extracted_cluster_info_from_python

# Register extracted_cluster_info_from_python in _coot:
_coot.extracted_cluster_info_from_python_swigregister(extracted_cluster_info_from_python)

def chemical_feature_clusters_setup_dialog():
    r"""chemical_feature_clusters_setup_dialog()"""
    return _coot.chemical_feature_clusters_setup_dialog()

def regularize_residue():
    r"""
    regularize_residue()

    Regularize the currently active residue.

    Finds the currently active atom (via graphics_info_t::active_atom_spec()), obtains its residue and active alternate-conformation identifier (altLoc), builds a one-element residue vector and calls the internal regularize_residues_vec operation to regularize the residue coordinates. The function clears the flag that indicates a user-picked residue-range so that the regularization operation is treated as program-initiated.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.regularize_residue()

def regularize_tandem_3():
    r"""
    regularize_tandem_3()

    Regularize a contiguous block of up to 7 residues centred on the active residue.

    Finds the active atom and its residue, then collects up to three preceding and three following residues (if present) together with the active residue, preserving the active atom's alternate-conformation identifier (altLoc). Calls regularize_residues_vec on that residue list to regularize the fragment.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.regularize_tandem_3()

def regularize_sphere():
    r"""
    regularize_sphere()

    Regularize residues in a spherical neighbourhood around the active residue.

    Uses the active atom's residue as the centre and finds residues within a fixed radius (6.6 Angstroms). The active residue is included explicitly. The set of residues is converted to mmdb::Residue* and passed to regularize_residues_vec together with the current altLoc.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.regularize_sphere()

def regularize_fragment_active_atom():
    r"""
    regularize_fragment_active_atom()

    Regularize a small connected fragment around the active atom using a distance-based tree.

    Obtains the active atom's residue and constructs a simple residue tree (coot::simple_residue_tree) around that residue using a close-distance cutoff (2.0 Angstroms). The returned residues are regularized via regularize_residues_vec. The active atom's altLoc is used to restrict the operation to the selected alternate-conformation where applicable.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.regularize_fragment_active_atom()

def regularize_chain():
    r"""
    regularize_chain()

    Regularize all residues in the chain containing the active residue.

    Locates the chain for the active atom's residue and collects all residues in that chain (coot::util::residues_in_chain). The collected residues are passed to regularize_residues_vec for regularization. The active atom's alternate-conformation identifier (altLoc) is forwarded so that only the selected conformation is affected if appropriate.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.regularize_chain()

def rsr_refine_residue():
    r"""
    rsr_refine_residue()

    Perform real-space refinement (RSR) on the currently active residue.

    Builds a one-element vector containing the residue specification for the active atom and invokes refine_residues_with_alt_conf() with the active atom's altLoc to perform real-space refinement on that residue only.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.rsr_refine_residue()

def rsr_refine_chain():
    r"""
    rsr_refine_chain()

    Perform real-space refinement (RSR) on the chain containing the active residue.

    Collects all residues in the chain of the active residue and converts each to a coot::residue_spec_t. Passes the vector of residue specifications and the active atom's altLoc to refine_residues_with_alt_conf() to refine the entire chain (for the selected alt-conformation if applicable).

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.rsr_refine_chain()

def rsr_refine_all_atoms():
    r"""
    rsr_refine_all_atoms()

    Perform real-space refinement (RSR) on all residues in the current molecule.

    Gathers all residues in the molecule (coot::util::residues_in_molecule), converts them to coot::residue_spec_t and calls refine_residues_with_alt_conf() with the active atom's altLoc. Intended to refine the whole molecule (the function contains a comment noting this implementation may need reworking, particularly with respect to chain fixes).

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.rsr_refine_all_atoms()

def rsr_refine_tandem_5():
    r"""
    rsr_refine_tandem_5()

    Perform real-space refinement (RSR) on a block of up to 11 residues centred on the active residue.

    Locates up to five preceding and five following residues around the active residue (if present), constructs a vector of coot::residue_spec_t for them and calls refine_residues_with_alt_conf() with the active atom's altLoc. This is useful for refining a larger local stretch of residues together.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.rsr_refine_tandem_5()

def rsr_refine_tandem_3():
    r"""
    rsr_refine_tandem_3()

    Perform real-space refinement (RSR) on a block of up to 7 residues centred on the active residue.

    Similar to rsr_refine_tandem_5 but collects up to three preceding and three following residues around the active residue, converts them to coot::residue_spec_t and invokes refine_residues_with_alt_conf() using the active atom's altLoc.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.rsr_refine_tandem_3()

def rsr_sphere_refine_plus():
    r"""
    rsr_sphere_refine_plus()

    Perform real-space refinement (RSR) on residues within a larger spherical neighbourhood (radius 6.6 Å).

    Finds residues near the active residue using a radius of 6.6 Å (via graphics_info_t::molecules[imol].residues_near_residue), includes the active residue, and calls refine_residues_with_alt_conf() with the active atom's altLoc to refine that neighbourhood.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.rsr_sphere_refine_plus()

def rsr_sphere_refine():
    r"""
    rsr_sphere_refine()

    Perform real-space refinement (RSR) on residues within a spherical neighbourhood (radius 4.3 Å).

    As rsr_sphere_refine_plus but uses a smaller radius of 4.3 Å to collect a tighter neighbourhood around the active residue before calling refine_residues_with_alt_conf() with the active atom's altLoc.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.rsr_sphere_refine()

def rsr_refine_fragment_active_residue():
    r"""
    rsr_refine_fragment_active_residue()

    Perform real-space refinement (RSR) on a distance-based fragment around the active residue.

    Builds a fragment by calling coot::simple_residue_tree() with a close distance cutoff of 2.0 Å around the active residue, converts the returned mmdb::Residue* list to coot::residue_spec_t and invokes refine_residues_with_alt_conf() with the active atom's altLoc.

    No parameters. Uses the application-wide active atom selection. void

    """
    return _coot.rsr_refine_fragment_active_residue()

def set_user_defined_atom_colour_by_selection_py(imol, residue_specs_colour_index_tuple_list_py):
    r"""
    set_user_defined_atom_colour_by_selection_py(int imol, PyObject * residue_specs_colour_index_tuple_list_py)

    set the user-defined atom colour for use by add_molecular_representation_py()

    for the given molecule imol, pass a list of tuples of items with the first parameter begin the residue/selection CID and the second begin the colour index (an int).

    Parameters
    ----------
    imol : int
    residue_specs_colour_index_tuple_list_py : object

    """
    return _coot.set_user_defined_atom_colour_by_selection_py(imol, residue_specs_colour_index_tuple_list_py)

def set_user_defined_atom_colour_py(imol, atom_specs_colour_index_tuple_list_py):
    r"""
    set_user_defined_atom_colour_py(int imol, PyObject * atom_specs_colour_index_tuple_list_py)

    set the user-defined colours for use by add_molecular_representation_py()

    for the given molecule imol, pass a list of tuples of items with the first parameter being the atom spec and the second being the colour index (an int).

      imol  the molecule index

    Parameters
    ----------
    imol : int
        the molecule index
    atom_specs_colour_index_tuple_list_py : object

    """
    return _coot.set_user_defined_atom_colour_py(imol, atom_specs_colour_index_tuple_list_py)

def set_user_defined_colours_py(colour_list_py):
    r"""
    set_user_defined_colours_py(PyObject * colour_list_py)

    set the user-defined colours

    by default user-defined colour indices will use a colour wheel but here we can set them ourselves by passing something like: [(61, [0.2, 0.3, 0.4]), (62, [0.6, 0.4, 0.2])] i.e. a tuple for each colour index and colour (r,g,b list). If the colour index goes beyond the limit, or there is a missing value, then colour will be [0.5, 0.5, 0.5] The first 49 indices have internal colours already asigned. Those can be overridden using this function, but generally user-defined colours indices start at index 60.

      colour_list_py  is a list of indexed colour tuples for use by add_ribbon_representation_with_user_defined_colours() and add_molecular_representation_py().

    Parameters
    ----------
    colour_list_py : object
        is a list of indexed colour tuples for use by add_ribbon_representation_with_user_defined_colours() and add_molecular_representation_py().

    """
    return _coot.set_user_defined_colours_py(colour_list_py)

def clear_user_defined_atom_colours(imol):
    r"""
    clear_user_defined_atom_colours(int imol)

    clear user defined colour rules

      imol  the molecule index

    Parameters
    ----------
    imol : int
        the molecule index

    """
    return _coot.clear_user_defined_atom_colours(imol)

def parse_line_for_atom_spec(l):
    r"""parse_line_for_atom_spec(std::string const & l) -> atom_spec_t"""
    return _coot.parse_line_for_atom_spec(l)
class phenix_geo_bond(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_bond class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    atom_1 = property(_coot.phenix_geo_bond_atom_1_get, _coot.phenix_geo_bond_atom_1_set, doc=r"""atom_1 : coot::atom_spec_t""")
    atom_2 = property(_coot.phenix_geo_bond_atom_2_get, _coot.phenix_geo_bond_atom_2_set, doc=r"""atom_2 : coot::atom_spec_t""")
    ideal = property(_coot.phenix_geo_bond_ideal_get, _coot.phenix_geo_bond_ideal_set, doc=r"""ideal : double""")
    model = property(_coot.phenix_geo_bond_model_get, _coot.phenix_geo_bond_model_set, doc=r"""model : double""")
    delta = property(_coot.phenix_geo_bond_delta_get, _coot.phenix_geo_bond_delta_set, doc=r"""delta : double""")
    sigma = property(_coot.phenix_geo_bond_sigma_get, _coot.phenix_geo_bond_sigma_set, doc=r"""sigma : double""")
    weight = property(_coot.phenix_geo_bond_weight_get, _coot.phenix_geo_bond_weight_set, doc=r"""weight : double""")
    residual = property(_coot.phenix_geo_bond_residual_get, _coot.phenix_geo_bond_residual_set, doc=r"""residual : double""")
    geom_set_flag = property(_coot.phenix_geo_bond_geom_set_flag_get, _coot.phenix_geo_bond_geom_set_flag_set, doc=r"""geom_set_flag : bool""")

    def __init__(self, a1, a2):
        r"""__init__(phenix_geo_bond self, atom_spec_t a1, atom_spec_t a2) -> phenix_geo_bond"""
        _coot.phenix_geo_bond_swiginit(self, _coot.new_phenix_geo_bond(a1, a2))

    def set_geom(self, ideal_in, model_in, delta_in, sigma_in, weight_in, residual_in):
        r"""set_geom(phenix_geo_bond self, double ideal_in, double model_in, double delta_in, double sigma_in, double weight_in, double residual_in)"""
        return _coot.phenix_geo_bond_set_geom(self, ideal_in, model_in, delta_in, sigma_in, weight_in, residual_in)
    __swig_destroy__ = _coot.delete_phenix_geo_bond

# Register phenix_geo_bond in _coot:
_coot.phenix_geo_bond_swigregister(phenix_geo_bond)
class phenix_geo_angle(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_angle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    atom_1 = property(_coot.phenix_geo_angle_atom_1_get, _coot.phenix_geo_angle_atom_1_set, doc=r"""atom_1 : coot::atom_spec_t""")
    atom_2 = property(_coot.phenix_geo_angle_atom_2_get, _coot.phenix_geo_angle_atom_2_set, doc=r"""atom_2 : coot::atom_spec_t""")
    atom_3 = property(_coot.phenix_geo_angle_atom_3_get, _coot.phenix_geo_angle_atom_3_set, doc=r"""atom_3 : coot::atom_spec_t""")
    ideal = property(_coot.phenix_geo_angle_ideal_get, _coot.phenix_geo_angle_ideal_set, doc=r"""ideal : double""")
    model = property(_coot.phenix_geo_angle_model_get, _coot.phenix_geo_angle_model_set, doc=r"""model : double""")
    delta = property(_coot.phenix_geo_angle_delta_get, _coot.phenix_geo_angle_delta_set, doc=r"""delta : double""")
    sigma = property(_coot.phenix_geo_angle_sigma_get, _coot.phenix_geo_angle_sigma_set, doc=r"""sigma : double""")
    weight = property(_coot.phenix_geo_angle_weight_get, _coot.phenix_geo_angle_weight_set, doc=r"""weight : double""")
    residual = property(_coot.phenix_geo_angle_residual_get, _coot.phenix_geo_angle_residual_set, doc=r"""residual : double""")
    geom_set_flag = property(_coot.phenix_geo_angle_geom_set_flag_get, _coot.phenix_geo_angle_geom_set_flag_set, doc=r"""geom_set_flag : bool""")

    def __init__(self, a1, a2, a3):
        r"""__init__(phenix_geo_angle self, atom_spec_t a1, atom_spec_t a2, atom_spec_t a3) -> phenix_geo_angle"""
        _coot.phenix_geo_angle_swiginit(self, _coot.new_phenix_geo_angle(a1, a2, a3))

    def set_geom(self, ideal_in, model_in, delta_in, sigma_in, weight_in, residual_in):
        r"""set_geom(phenix_geo_angle self, double ideal_in, double model_in, double delta_in, double sigma_in, double weight_in, double residual_in)"""
        return _coot.phenix_geo_angle_set_geom(self, ideal_in, model_in, delta_in, sigma_in, weight_in, residual_in)
    __swig_destroy__ = _coot.delete_phenix_geo_angle

# Register phenix_geo_angle in _coot:
_coot.phenix_geo_angle_swigregister(phenix_geo_angle)
class phenix_geo_bonds(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_bonds class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    bonds = property(_coot.phenix_geo_bonds_bonds_get, _coot.phenix_geo_bonds_bonds_set, doc=r"""bonds : std::vector<(coot::phenix_geo::phenix_geo_bond,std::allocator<(coot::phenix_geo::phenix_geo_bond)>)>""")

    def __init__(self):
        r"""__init__(phenix_geo_bonds self) -> phenix_geo_bonds"""
        _coot.phenix_geo_bonds_swiginit(self, _coot.new_phenix_geo_bonds())

    def size(self):
        r"""size(phenix_geo_bonds self) -> unsigned int"""
        return _coot.phenix_geo_bonds_size(self)

    def add_bond(self, b):
        r"""add_bond(phenix_geo_bonds self, phenix_geo_bond b)"""
        return _coot.phenix_geo_bonds_add_bond(self, b)
    __swig_destroy__ = _coot.delete_phenix_geo_bonds

# Register phenix_geo_bonds in _coot:
_coot.phenix_geo_bonds_swigregister(phenix_geo_bonds)
class phenix_geo_angles(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_angles class."""

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

    def __init__(self):
        r"""__init__(phenix_geo_angles self) -> phenix_geo_angles"""
        _coot.phenix_geo_angles_swiginit(self, _coot.new_phenix_geo_angles())
    angles = property(_coot.phenix_geo_angles_angles_get, _coot.phenix_geo_angles_angles_set, doc=r"""angles : std::vector<(coot::phenix_geo::phenix_geo_angle,std::allocator<(coot::phenix_geo::phenix_geo_angle)>)>""")

    def size(self):
        r"""size(phenix_geo_angles self) -> unsigned int"""
        return _coot.phenix_geo_angles_size(self)

    def add_angle(self, a):
        r"""add_angle(phenix_geo_angles self, phenix_geo_angle a)"""
        return _coot.phenix_geo_angles_add_angle(self, a)
    __swig_destroy__ = _coot.delete_phenix_geo_angles

# Register phenix_geo_angles in _coot:
_coot.phenix_geo_angles_swigregister(phenix_geo_angles)
class phenix_geo_dihedral(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_dihedral class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    atom_1 = property(_coot.phenix_geo_dihedral_atom_1_get, _coot.phenix_geo_dihedral_atom_1_set, doc=r"""atom_1 : coot::atom_spec_t""")
    atom_2 = property(_coot.phenix_geo_dihedral_atom_2_get, _coot.phenix_geo_dihedral_atom_2_set, doc=r"""atom_2 : coot::atom_spec_t""")
    atom_3 = property(_coot.phenix_geo_dihedral_atom_3_get, _coot.phenix_geo_dihedral_atom_3_set, doc=r"""atom_3 : coot::atom_spec_t""")
    atom_4 = property(_coot.phenix_geo_dihedral_atom_4_get, _coot.phenix_geo_dihedral_atom_4_set, doc=r"""atom_4 : coot::atom_spec_t""")
    ideal = property(_coot.phenix_geo_dihedral_ideal_get, _coot.phenix_geo_dihedral_ideal_set, doc=r"""ideal : double""")
    model = property(_coot.phenix_geo_dihedral_model_get, _coot.phenix_geo_dihedral_model_set, doc=r"""model : double""")
    delta = property(_coot.phenix_geo_dihedral_delta_get, _coot.phenix_geo_dihedral_delta_set, doc=r"""delta : double""")
    periodicity = property(_coot.phenix_geo_dihedral_periodicity_get, _coot.phenix_geo_dihedral_periodicity_set, doc=r"""periodicity : int""")
    sigma = property(_coot.phenix_geo_dihedral_sigma_get, _coot.phenix_geo_dihedral_sigma_set, doc=r"""sigma : double""")
    weight = property(_coot.phenix_geo_dihedral_weight_get, _coot.phenix_geo_dihedral_weight_set, doc=r"""weight : double""")
    residual = property(_coot.phenix_geo_dihedral_residual_get, _coot.phenix_geo_dihedral_residual_set, doc=r"""residual : double""")
    is_sinusoidal = property(_coot.phenix_geo_dihedral_is_sinusoidal_get, _coot.phenix_geo_dihedral_is_sinusoidal_set, doc=r"""is_sinusoidal : bool""")
    geom_set_flag = property(_coot.phenix_geo_dihedral_geom_set_flag_get, _coot.phenix_geo_dihedral_geom_set_flag_set, doc=r"""geom_set_flag : bool""")

    def __init__(self, a1, a2, a3, a4):
        r"""__init__(phenix_geo_dihedral self, atom_spec_t a1, atom_spec_t a2, atom_spec_t a3, atom_spec_t a4) -> phenix_geo_dihedral"""
        _coot.phenix_geo_dihedral_swiginit(self, _coot.new_phenix_geo_dihedral(a1, a2, a3, a4))

    def set_geom(self, ideal_in, model_in, delta_in, periodicity_in, sigma_in, weight_in, residual_in, is_sinusoidal_in):
        r"""set_geom(phenix_geo_dihedral self, double ideal_in, double model_in, double delta_in, int periodicity_in, double sigma_in, double weight_in, double residual_in, bool is_sinusoidal_in)"""
        return _coot.phenix_geo_dihedral_set_geom(self, ideal_in, model_in, delta_in, periodicity_in, sigma_in, weight_in, residual_in, is_sinusoidal_in)
    __swig_destroy__ = _coot.delete_phenix_geo_dihedral

# Register phenix_geo_dihedral in _coot:
_coot.phenix_geo_dihedral_swigregister(phenix_geo_dihedral)
class phenix_geo_dihedrals(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_dihedrals class."""

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

    def __init__(self):
        r"""__init__(phenix_geo_dihedrals self) -> phenix_geo_dihedrals"""
        _coot.phenix_geo_dihedrals_swiginit(self, _coot.new_phenix_geo_dihedrals())
    dihedrals = property(_coot.phenix_geo_dihedrals_dihedrals_get, _coot.phenix_geo_dihedrals_dihedrals_set, doc=r"""dihedrals : std::vector<(coot::phenix_geo::phenix_geo_dihedral,std::allocator<(coot::phenix_geo::phenix_geo_dihedral)>)>""")

    def size(self):
        r"""size(phenix_geo_dihedrals self) -> unsigned int"""
        return _coot.phenix_geo_dihedrals_size(self)

    def add_dihedral(self, d):
        r"""add_dihedral(phenix_geo_dihedrals self, phenix_geo_dihedral d)"""
        return _coot.phenix_geo_dihedrals_add_dihedral(self, d)
    __swig_destroy__ = _coot.delete_phenix_geo_dihedrals

# Register phenix_geo_dihedrals in _coot:
_coot.phenix_geo_dihedrals_swigregister(phenix_geo_dihedrals)
class phenix_geo_chiral(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_chiral class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    atom_centre = property(_coot.phenix_geo_chiral_atom_centre_get, _coot.phenix_geo_chiral_atom_centre_set, doc=r"""atom_centre : coot::atom_spec_t""")
    atom_1 = property(_coot.phenix_geo_chiral_atom_1_get, _coot.phenix_geo_chiral_atom_1_set, doc=r"""atom_1 : coot::atom_spec_t""")
    atom_2 = property(_coot.phenix_geo_chiral_atom_2_get, _coot.phenix_geo_chiral_atom_2_set, doc=r"""atom_2 : coot::atom_spec_t""")
    atom_3 = property(_coot.phenix_geo_chiral_atom_3_get, _coot.phenix_geo_chiral_atom_3_set, doc=r"""atom_3 : coot::atom_spec_t""")
    both_signs = property(_coot.phenix_geo_chiral_both_signs_get, _coot.phenix_geo_chiral_both_signs_set, doc=r"""both_signs : bool""")
    ideal = property(_coot.phenix_geo_chiral_ideal_get, _coot.phenix_geo_chiral_ideal_set, doc=r"""ideal : double""")
    model = property(_coot.phenix_geo_chiral_model_get, _coot.phenix_geo_chiral_model_set, doc=r"""model : double""")
    delta = property(_coot.phenix_geo_chiral_delta_get, _coot.phenix_geo_chiral_delta_set, doc=r"""delta : double""")
    sigma = property(_coot.phenix_geo_chiral_sigma_get, _coot.phenix_geo_chiral_sigma_set, doc=r"""sigma : double""")
    weight = property(_coot.phenix_geo_chiral_weight_get, _coot.phenix_geo_chiral_weight_set, doc=r"""weight : double""")
    residual = property(_coot.phenix_geo_chiral_residual_get, _coot.phenix_geo_chiral_residual_set, doc=r"""residual : double""")
    geom_set_flag = property(_coot.phenix_geo_chiral_geom_set_flag_get, _coot.phenix_geo_chiral_geom_set_flag_set, doc=r"""geom_set_flag : bool""")

    def __init__(self, centre, a1, a2, a3):
        r"""__init__(phenix_geo_chiral self, atom_spec_t centre, atom_spec_t a1, atom_spec_t a2, atom_spec_t a3) -> phenix_geo_chiral"""
        _coot.phenix_geo_chiral_swiginit(self, _coot.new_phenix_geo_chiral(centre, a1, a2, a3))

    def set_geom(self, both_signs_in, ideal_in, model_in, delta_in, sigma_in, weight_in, residual_in):
        r"""set_geom(phenix_geo_chiral self, bool both_signs_in, double ideal_in, double model_in, double delta_in, double sigma_in, double weight_in, double residual_in)"""
        return _coot.phenix_geo_chiral_set_geom(self, both_signs_in, ideal_in, model_in, delta_in, sigma_in, weight_in, residual_in)
    __swig_destroy__ = _coot.delete_phenix_geo_chiral

# Register phenix_geo_chiral in _coot:
_coot.phenix_geo_chiral_swigregister(phenix_geo_chiral)
class phenix_geo_chirals(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_chirals class."""

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

    def __init__(self):
        r"""__init__(phenix_geo_chirals self) -> phenix_geo_chirals"""
        _coot.phenix_geo_chirals_swiginit(self, _coot.new_phenix_geo_chirals())
    chirals = property(_coot.phenix_geo_chirals_chirals_get, _coot.phenix_geo_chirals_chirals_set, doc=r"""chirals : std::vector<(coot::phenix_geo::phenix_geo_chiral,std::allocator<(coot::phenix_geo::phenix_geo_chiral)>)>""")

    def size(self):
        r"""size(phenix_geo_chirals self) -> unsigned int"""
        return _coot.phenix_geo_chirals_size(self)

    def add_chiral(self, c):
        r"""add_chiral(phenix_geo_chirals self, phenix_geo_chiral c)"""
        return _coot.phenix_geo_chirals_add_chiral(self, c)
    __swig_destroy__ = _coot.delete_phenix_geo_chirals

# Register phenix_geo_chirals in _coot:
_coot.phenix_geo_chirals_swigregister(phenix_geo_chirals)
class phenix_geo_nonbonded(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_nonbonded class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    atom_1 = property(_coot.phenix_geo_nonbonded_atom_1_get, _coot.phenix_geo_nonbonded_atom_1_set, doc=r"""atom_1 : coot::atom_spec_t""")
    atom_2 = property(_coot.phenix_geo_nonbonded_atom_2_get, _coot.phenix_geo_nonbonded_atom_2_set, doc=r"""atom_2 : coot::atom_spec_t""")
    model = property(_coot.phenix_geo_nonbonded_model_get, _coot.phenix_geo_nonbonded_model_set, doc=r"""model : double""")
    vdw = property(_coot.phenix_geo_nonbonded_vdw_get, _coot.phenix_geo_nonbonded_vdw_set, doc=r"""vdw : double""")
    geom_set_flag = property(_coot.phenix_geo_nonbonded_geom_set_flag_get, _coot.phenix_geo_nonbonded_geom_set_flag_set, doc=r"""geom_set_flag : bool""")

    def __init__(self, a1, a2):
        r"""__init__(phenix_geo_nonbonded self, atom_spec_t a1, atom_spec_t a2) -> phenix_geo_nonbonded"""
        _coot.phenix_geo_nonbonded_swiginit(self, _coot.new_phenix_geo_nonbonded(a1, a2))

    def set_geom(self, model_in, vdw_in):
        r"""set_geom(phenix_geo_nonbonded self, double model_in, double vdw_in)"""
        return _coot.phenix_geo_nonbonded_set_geom(self, model_in, vdw_in)
    __swig_destroy__ = _coot.delete_phenix_geo_nonbonded

# Register phenix_geo_nonbonded in _coot:
_coot.phenix_geo_nonbonded_swigregister(phenix_geo_nonbonded)
class phenix_geo_nonbondeds(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geo_nonbondeds class."""

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

    def __init__(self):
        r"""__init__(phenix_geo_nonbondeds self) -> phenix_geo_nonbondeds"""
        _coot.phenix_geo_nonbondeds_swiginit(self, _coot.new_phenix_geo_nonbondeds())
    nonbondeds = property(_coot.phenix_geo_nonbondeds_nonbondeds_get, _coot.phenix_geo_nonbondeds_nonbondeds_set, doc=r"""nonbondeds : std::vector<(coot::phenix_geo::phenix_geo_nonbonded,std::allocator<(coot::phenix_geo::phenix_geo_nonbonded)>)>""")

    def size(self):
        r"""size(phenix_geo_nonbondeds self) -> unsigned int"""
        return _coot.phenix_geo_nonbondeds_size(self)

    def add_nonbonded(self, nb):
        r"""add_nonbonded(phenix_geo_nonbondeds self, phenix_geo_nonbonded nb)"""
        return _coot.phenix_geo_nonbondeds_add_nonbonded(self, nb)
    __swig_destroy__ = _coot.delete_phenix_geo_nonbondeds

# Register phenix_geo_nonbondeds in _coot:
_coot.phenix_geo_nonbondeds_swigregister(phenix_geo_nonbondeds)
class phenix_geometry(object):
    r"""Proxy of C++ coot::phenix_geo::phenix_geometry class."""

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

    def __init__(self):
        r"""__init__(phenix_geometry self) -> phenix_geometry"""
        _coot.phenix_geometry_swiginit(self, _coot.new_phenix_geometry())
    geo_bonds = property(_coot.phenix_geometry_geo_bonds_get, _coot.phenix_geometry_geo_bonds_set, doc=r"""geo_bonds : coot::phenix_geo::phenix_geo_bonds""")
    geo_angles = property(_coot.phenix_geometry_geo_angles_get, _coot.phenix_geometry_geo_angles_set, doc=r"""geo_angles : coot::phenix_geo::phenix_geo_angles""")
    geo_dihedrals = property(_coot.phenix_geometry_geo_dihedrals_get, _coot.phenix_geometry_geo_dihedrals_set, doc=r"""geo_dihedrals : coot::phenix_geo::phenix_geo_dihedrals""")
    geo_chirals = property(_coot.phenix_geometry_geo_chirals_get, _coot.phenix_geometry_geo_chirals_set, doc=r"""geo_chirals : coot::phenix_geo::phenix_geo_chirals""")
    geo_nonbondeds = property(_coot.phenix_geometry_geo_nonbondeds_get, _coot.phenix_geometry_geo_nonbondeds_set, doc=r"""geo_nonbondeds : coot::phenix_geo::phenix_geo_nonbondeds""")

    def parse(self, file_name):
        r"""parse(phenix_geometry self, std::string const & file_name)"""
        return _coot.phenix_geometry_parse(self, file_name)
    __swig_destroy__ = _coot.delete_phenix_geometry

# Register phenix_geometry in _coot:
_coot.phenix_geometry_swigregister(phenix_geometry)

def coot_get_url(url, file_name):
    r"""coot_get_url(std::string const & url, std::string const & file_name) -> int"""
    return _coot.coot_get_url(url, file_name)

def coot_get_url_as_string_py(url):
    r"""coot_get_url_as_string_py(char const * url) -> PyObject *"""
    return _coot.coot_get_url_as_string_py(url)

def curl_progress_info_py(file_name):
    r"""curl_progress_info_py(char const * file_name) -> PyObject *"""
    return _coot.curl_progress_info_py(file_name)

def write_coot_curl_data(buffer, size, nmemb, userp):
    r"""write_coot_curl_data(void * buffer, size_t size, size_t nmemb, void * userp) -> size_t"""
    return _coot.write_coot_curl_data(buffer, size, nmemb, userp)

def write_coot_curl_data_to_file(buffer, size, nmemb, userp):
    r"""write_coot_curl_data_to_file(void * buffer, size_t size, size_t nmemb, void * userp) -> size_t"""
    return _coot.write_coot_curl_data_to_file(buffer, size, nmemb, userp)

def wrapped_curl_easy_perform(data):
    r"""wrapped_curl_easy_perform(void * data) -> void *"""
    return _coot.wrapped_curl_easy_perform(data)

def M2T_updateFloatParameter(imol, param_name, value):
    r"""M2T_updateFloatParameter(int imol, std::string const & param_name, float value)"""
    return _coot.M2T_updateFloatParameter(imol, param_name, value)

def M2T_updateIntParameter(imol, param_name, value):
    r"""M2T_updateIntParameter(int imol, std::string const & param_name, int value)"""
    return _coot.M2T_updateIntParameter(imol, param_name, value)

def associate_pir_alignment(imol, chain_id, pir_alignment):
    r"""associate_pir_alignment(int imol, std::string chain_id, std::string pir_alignment)"""
    return _coot.associate_pir_alignment(imol, chain_id, pir_alignment)

def associate_pir_alignment_from_file(imol, chain_id, pir_alignment_file_name):
    r"""associate_pir_alignment_from_file(int imol, std::string chain_id, std::string pir_alignment_file_name)"""
    return _coot.associate_pir_alignment_from_file(imol, chain_id, pir_alignment_file_name)

def apply_pir_alignment(imol, chain_id):
    r"""apply_pir_alignment(int imol, std::string chain_id)"""
    return _coot.apply_pir_alignment(imol, chain_id)

def show_coot_points_frame():
    r"""show_coot_points_frame()"""
    return _coot.show_coot_points_frame()

def set_view_from_json(view_as_json):
    r"""set_view_from_json(std::string const & view_as_json)"""
    return _coot.set_view_from_json(view_as_json)

def get_view_as_json():
    r"""get_view_as_json() -> std::string"""
    return _coot.get_view_as_json()

def new_chemical_feature_clustering_py(mol_infos):
    r"""new_chemical_feature_clustering_py(PyObject * mol_infos)"""
    return _coot.new_chemical_feature_clustering_py(mol_infos)

def read_nef(imol, file_name):
    r"""read_nef(int imol, std::string const & file_name)"""
    return _coot.read_nef(imol, file_name)

def show_nef_stuff(imol):
    r"""show_nef_stuff(int imol)"""
    return _coot.show_nef_stuff(imol)

