diff --git a/ci/conda-recipe/meta.yaml b/ci/conda-recipe/meta.yaml index e5734db..a612606 100644 --- a/ci/conda-recipe/meta.yaml +++ b/ci/conda-recipe/meta.yaml @@ -1,7 +1,7 @@ package: name: contact_map # add ".dev0" for unreleased versions - version: "0.5.1" + version: "0.6.0" source: path: ../../ diff --git a/ci/pip-install/testing_requirements.txt b/ci/pip-install/testing_requirements.txt index 20fd3c1..7c53b98 100644 --- a/ci/pip-install/testing_requirements.txt +++ b/ci/pip-install/testing_requirements.txt @@ -1,5 +1,5 @@ pytest pytest-cov -python-coveralls +coveralls codacy-coverage autorelease diff --git a/contact_map/__init__.py b/contact_map/__init__.py index b46f5b6..d3f3f44 100644 --- a/contact_map/__init__.py +++ b/contact_map/__init__.py @@ -11,6 +11,8 @@ from .contact_count import ContactCount +from .contact_trajectory import ContactTrajectory, RollingContactFrequency + from .min_dist import NearestAtoms, MinimumDistanceCounter from .concurrence import ( diff --git a/contact_map/contact_count.py b/contact_map/contact_count.py index 4e57732..5d8e410 100644 --- a/contact_map/contact_count.py +++ b/contact_map/contact_count.py @@ -16,13 +16,14 @@ # pandas 0.25 not available on py27; can drop this when we drop py27 _PD_VERSION = tuple(int(x) for x in pd.__version__.split('.')[:2]) -def _colorbar(with_colorbar, cmap_f, norm, min_val): + +def _colorbar(with_colorbar, cmap_f, norm, min_val, ax=None): if with_colorbar is False: return None elif with_colorbar is True: cbmin = np.floor(min_val) # [-1.0..0.0] => -1; [0.0..1.0] => 0 cbmax = 1.0 - cb = ranged_colorbar(cmap_f, norm, cbmin, cbmax) + cb = ranged_colorbar(cmap_f, norm, cbmin, cbmax, ax=ax) # leave open other inputs to be parsed later (like tuples) return cb @@ -30,7 +31,7 @@ def _colorbar(with_colorbar, cmap_f, norm, min_val): # TODO: remove following: this is a monkeypatch for a bug in pandas # see: https://github.com/pandas-dev/pandas/issues/29814 from pandas._libs.sparse import BlockIndex, IntIndex, SparseIndex -def _patch_from_spmatrix(cls, data): +def _patch_from_spmatrix(cls, data): # -no-cov- length, ncol = data.shape if ncol != 1: @@ -129,7 +130,7 @@ def df(self): index = list(range(self.n_x)) columns = list(range(self.n_y)) - if _PD_VERSION < (0, 25): # py27 only + if _PD_VERSION < (0, 25): # py27 only -no-cov- mtx = mtx.tocoo() return pd.SparseDataFrame(mtx, index=index, columns=columns) @@ -198,18 +199,39 @@ def plot(self, cmap='seismic', vmin=-1.0, vmax=1.0, with_colorbar=True, """ if not HAS_MATPLOTLIB: # pragma: no cover raise RuntimeError("Error importing matplotlib") + fig, ax = plt.subplots(**kwargs) + + # Check the number of pixels of the figure + self._check_number_of_pixels(fig) + self.plot_axes(ax=ax, cmap=cmap, vmin=vmin, vmax=vmax) + + return (fig, ax) + + def plot_axes(self, ax, cmap='seismic', vmin=-1.0, vmax=1.0, + with_colorbar=True): + """ + Plot contact matrix on a matplotlib.axes + + Parameters + ---------- + ax : matplotlib.axes + axes to plot the contact matrix on + cmap : str + color map name, default 'seismic' + vmin : float + minimum value for color map interpolation; default -1.0 + vmax : float + maximum value for color map interpolation; default 1.0 + with_colorbar : bool + If a colorbar is added to the axes + """ + norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax) cmap_f = plt.get_cmap(cmap) - - fig, ax = plt.subplots(**kwargs) ax.axis([0, self.n_x, 0, self.n_y]) ax.set_facecolor(cmap_f(norm(0.0))) min_val = 0.0 - - # Check the number of pixels of the figure - self._check_number_of_pixels(fig) - for (pair, value) in self.counter.items(): if value < min_val: min_val = value @@ -227,9 +249,7 @@ def plot(self, cmap='seismic', vmin=-1.0, vmax=1.0, with_colorbar=True, ax.add_patch(patch_0) ax.add_patch(patch_1) - _colorbar(with_colorbar, cmap_f, norm, min_val) - - return (fig, ax) + _colorbar(with_colorbar, cmap_f, norm, min_val, ax=ax) def most_common(self, obj=None): """ diff --git a/contact_map/contact_map.py b/contact_map/contact_map.py index ea069c6..6af9b6f 100644 --- a/contact_map/contact_map.py +++ b/contact_map/contact_map.py @@ -7,6 +7,9 @@ import itertools import pickle import json + +import warnings + import numpy as np import pandas as pd import mdtraj as md @@ -171,6 +174,24 @@ def __init__(self, topology, query, haystack, cutoff, n_neighbors_ignored): } self._atom_idx_to_residue_idx = self._set_atom_idx_to_residue_idx() + @classmethod + def from_contacts(cls, atom_contacts, residue_contacts, topology, + query=None, haystack=None, cutoff=0.45, + n_neighbors_ignored=2): + obj = cls.__new__(cls) + super(cls, obj).__init__(topology, query, haystack, cutoff, + n_neighbors_ignored) + + def get_contact_counter(contact): + if isinstance(contact, ContactCount): + return contact.counter + else: + return contact + + obj._atom_contacts = get_contact_counter(atom_contacts) + obj._residue_contacts = get_contact_counter(residue_contacts) + return obj + def _set_atom_slice(self): """ Set atom slice logic """ if (self._class_use_atom_slice is None and @@ -675,13 +696,25 @@ def residue_contacts(self): class ContactMap(ContactObject): """ Contact map (atomic and residue) for a single frame. + + .. deprecated:: 0.6.0 + ``ContactMap`` will be removed in Contact Map Explorer 0.7.0 because + it is redundant with ``ContactFrequency``. For more, see + https://github.com/dwhswenson/contact_map/issues/82. + """ # Default for use_atom_slice, None tries to be smart _class_use_atom_slice = None + _deprecation_message=( + "The ContactMap class will be removed in Contact Map Explorer 0.7. " + + "Use ContactFrequency instead. For more, see: " + + "https://github.com/dwhswenson/contact_map/issues/82." + ) + def __init__(self, frame, query=None, haystack=None, cutoff=0.45, n_neighbors_ignored=2): - + warnings.warn(self._deprecation_message, FutureWarning) self._frame = frame # TODO: remove this? super(ContactMap, self).__init__(frame.topology, query, haystack, cutoff, n_neighbors_ignored) @@ -692,6 +725,19 @@ def __init__(self, frame, query=None, haystack=None, cutoff=0.45, (atom_contacts, self._residue_contacts) = contact_maps self._atom_contacts = self.convert_atom_contacts(atom_contacts) + @classmethod + def from_dict(cls, dct): + warnings.warn(cls._deprecation_message, FutureWarning) + return super(ContactMap, cls).from_dict(dct) + + # don't need to add deprecation in from_json because it uses from_dict + + @classmethod + def from_file(cls, filename): + warnings.warn(cls._deprecation_message, FutureWarning) + return super(ContactMap, cls).from_file(filename) + + def __hash__(self): return hash((super(ContactMap, self).__hash__(), tuple(self._atom_contacts.items()), @@ -746,6 +792,17 @@ def __init__(self, trajectory, query=None, haystack=None, cutoff=0.45, contacts = self._build_contact_map(trajectory) (self._atom_contacts, self._residue_contacts) = contacts + @classmethod + def from_contacts(cls, atom_contacts, residue_contacts, n_frames, + topology, query=None, haystack=None, cutoff=0.45, + n_neighbors_ignored=2): + obj = super(ContactFrequency, cls).from_contacts( + atom_contacts, residue_contacts, topology, query, haystack, + cutoff, n_neighbors_ignored + ) + obj._n_frames = n_frames + return obj + def __hash__(self): return hash((super(ContactFrequency, self).__hash__(), tuple(self._atom_contacts.items()), @@ -923,6 +980,10 @@ def __sub__(self, other): def contact_map(self, *args, **kwargs): #pylint: disable=W0221 raise NotImplementedError + @classmethod + def from_contacts(self, *args, **kwargs): #pylint: disable=W0221 + raise NotImplementedError + @property def atom_contacts(self): n_x = self.topology.n_atoms diff --git a/contact_map/contact_trajectory.py b/contact_map/contact_trajectory.py new file mode 100644 index 0000000..3bda7c8 --- /dev/null +++ b/contact_map/contact_trajectory.py @@ -0,0 +1,368 @@ +from collections import abc, Counter + +from .contact_map import ContactFrequency, ContactObject +import json + +class ContactTrajectory(ContactObject, abc.Sequence): + """Track all the contacts over a trajectory, frame-by-frame. + + Internally, this has a single-frame :class:`.ContactFrequency` for each + frame of the trajectory. + + Parameters + ---------- + trajectory : mdtraj.Trajectory + the trajectory to calculate contacts for + query : list of int + Indices of the atoms to be included as query. Default ``None`` + means all heavy, non-water atoms. + haystack : list of int + Indices of the atoms to be included as haystack. Default ``None`` + means all heavy, non-water atoms. + cutoff : float + Cutoff distance for contacts, in nanometers. Default 0.45. + n_neighbors_ignored : int + Number of neighboring residues (in the same chain) to ignore. + Default 2. + """ + _class_use_atom_slice = None + def __init__(self, trajectory, query=None, haystack=None, cutoff=0.45, + n_neighbors_ignored=2): + super(ContactTrajectory, self).__init__(trajectory.topology, query, + haystack, cutoff, + n_neighbors_ignored) + contacts = self._build_contacts(trajectory) + self._contact_maps = [ + ContactFrequency.from_contacts( + topology=self.topology, + query=self.query, + haystack=self.haystack, + cutoff=self.cutoff, + n_neighbors_ignored=self.n_neighbors_ignored, + atom_contacts=atom_contacts, + residue_contacts=residue_contacts, + n_frames=1 + ) + for atom_contacts, residue_contacts in zip(*contacts) + ] + + def __getitem__(self, num): + return self._contact_maps[num] + + def __len__(self): + return len(self._contact_maps) + + def __hash__(self): + return hash((super(ContactTrajectory, self).__hash__(), + tuple([frozenset(frame.counter.items()) + for frame in self.atom_contacts]), + tuple([frozenset(frame.counter.items()) + for frame in self.residue_contacts]))) + + def __eq__(self, other): + return hash(self) == hash(other) + + @classmethod + def from_contacts(cls, atom_contacts, residue_contacts, topology, + query=None, haystack=None, cutoff=0.45, + n_neighbors_ignored=2): + contact_maps = [ + ContactFrequency.from_contacts( + atom_cs, + res_cs, + n_frames=1, + topology=topology, + query=query, + haystack=haystack, + cutoff=cutoff, + n_neighbors_ignored=n_neighbors_ignored + ) + for atom_cs, res_cs in zip(atom_contacts, residue_contacts) + ] + return cls.from_contact_maps(contact_maps) + + def _build_contacts(self, trajectory): + # atom_contacts, residue_contacts = self._empty_contacts() + atom_contacts = [] + residue_contacts = [] + + residue_ignore_atom_idxs = self.residue_ignore_atom_idxs + residue_query_atom_idxs = self.residue_query_atom_idxs + used_trajectory = self.slice_trajectory(trajectory) + + # range(len(trajectory)) avoids recopying topology, as would occur + # in `for frame in trajectory` + for frame_num in range(len(trajectory)): + frame_contacts = self.contact_map(used_trajectory, frame_num, + residue_query_atom_idxs, + residue_ignore_atom_idxs) + frame_atom_contacts, frame_residue_contacts = frame_contacts + frame_atom_contacts = \ + self.convert_atom_contacts(frame_atom_contacts) + # TODO unify contact building with something like this? + # atom_contacts, residue_contact = self._update_contacts(...) + atom_contacts.append(frame_atom_contacts) + residue_contacts.append(frame_residue_contacts) + return atom_contacts, residue_contacts + + def contact_frequency(self): + """Create a :class:`.ContactFrequency` from this contact trajectory + """ + freq = ContactFrequency.from_contacts( + atom_contacts=Counter(), + residue_contacts=Counter(), + n_frames=0, + topology=self.topology, + query=self.query, + haystack=self.haystack, + cutoff=self.cutoff, + n_neighbors_ignored=self.n_neighbors_ignored + ) + for cmap in self._contact_maps: + # TODO: skipping compatibility checks would help performance; we + # know that everything in here *should* be compatible + freq.add_contact_frequency(cmap) + + return freq + + def to_dict(self): + return { + 'contact_maps': [cmap.to_dict() for cmap in self._contact_maps] + } + + @classmethod + def from_dict(cls, dct): + contact_maps = [ContactFrequency.from_dict(cmap) + for cmap in dct['contact_maps']] + obj = cls.from_contact_maps(contact_maps) + return obj + + @property + def atom_contacts(self): + return [cmap.atom_contacts for cmap in self._contact_maps] + + @property + def residue_contacts(self): + return [cmap.residue_contacts for cmap in self._contact_maps] + + @classmethod + def from_contact_maps(cls, maps): + obj = cls.__new__(cls) + super(cls, obj).__init__(maps[0].topology, maps[0].query, + maps[0].haystack, maps[0].cutoff, + maps[0].n_neighbors_ignored) + + for cmap in maps: + obj._check_compatibility(cmap) + + obj._contact_maps = maps + return obj + + @classmethod + def join(cls, others): + """Concatenate ContactTrajectory instances + + Parameters + ---------- + others : List[:class:.ContactTrajectory] + contact trajectories to concatenate + + Returns + ------- + :class:`.ContactTrajectory` : + concatenated contact trajectory + """ + contact_maps = sum([o._contact_maps for o in others], []) + return cls.from_contact_maps(contact_maps) + + def rolling_frequency(self, window_size=1, step=1): + """:class:`.RollingContactFrequency` iterator for this trajectory + + Parameters + ---------- + window_size : int + the number of frames in the window + step : int + the number of frames between successive starting points of the + window (like the ``step`` parameter in a Python slice object) + + Returns + ------- + :class:`.RollingContactFrequency` : + windowed iterator for this trajectory + """ + return RollingContactFrequency(self, width=window_size, step=step) + + +class MutableContactTrajectory(ContactTrajectory, abc.MutableSequence): + """Mutable version of :class:`.ContactTrajectory` + + Parameters + ---------- + trajectory : mdtraj.Trajectory + the trajectory to calculate contacts for + query : list of int + Indices of the atoms to be included as query. Default ``None`` + means all heavy, non-water atoms. + haystack : list of int + Indices of the atoms to be included as haystack. Default ``None`` + means all heavy, non-water atoms. + cutoff : float + Cutoff distance for contacts, in nanometers. Default 0.45. + n_neighbors_ignored : int + Number of neighboring residues (in the same chain) to ignore. + Default 2. + + """ + def __setitem__(self, key, value): + self._contact_maps[key] = value + + def __delitem__(self, key): + del self._contact_maps[key] + + def insert(self, key, value): + self._contact_maps.insert(key, value) + + def __hash__(self): + # mutable objects must have unique hashes + return id(self) + + +class WindowedIterator(abc.Iterator): + """ + Helper for windowed ("rolling average") iterators. + + The idea is that this is an easy and reusable code for getting windowed + quantitiies such as needed for rolling averages. This iterator itself + just returns sets of indices/slices to add/remove from whatever counter + is being tracked. The idea is that it will be used inside of another + iterator. + + + Parameters + ---------- + length : int + the length of the list windowed over + width : int + the number of items in the window + step : int + the number of items skipped between successive windows (as with the + ``step`` parameter in slices) + slow_build : bool + if True, the iterator builds up the window "step" objects at a time. + Otherwise, the first value is the full width of the window. + + Attributes + ---------- + min : int + the index of the first object in the cached window + max : int + the index of the last object in the cached window (note that this is + included in the window, unlike Python slices) + """ + def __init__(self, length, width, step, slow_build): + self.length = length + self.width = width + self.step = step + self.slow_build = slow_build + self.min = -1 + self.max = -1 + + def _startup(self): + to_sub = slice(0, 0) + self.min = max(self.min, 0) + if self.slow_build: + to_add = slice(self.max + 1, self.max + self.step + 1) + self.max += self.step + else: + self.max = self.width - 1 + to_add = slice(self.min, self.max + 1) + return to_add, to_sub + + def _normal(self): + self.min = max(0, self.min) + new_max = self.max + self.step + + if not self.slow_build: + new_max = max(new_max, self.width - 1) + + new_min = max(self.min, new_max - self.width + 1) + + to_sub = slice(self.min, new_min) + to_add = slice(self.max + 1, new_max + 1) + self.min = new_min + self.max = new_max + return to_add, to_sub + + def __next__(self): + # if self.max + self.step < self.width: + # to_add, to_sub = self._startup() + if self.max + self.step < self.length: + to_add, to_sub = self._normal() + else: + raise StopIteration + + return to_add, to_sub + + +class RollingContactFrequency(abc.Iterator): + """Iterator for "rolling-average" contact frequencies over a trajectory + + Parameters + ---------- + contact_trajectory : :class:`.ContactTrajectory` + input trajectory + width : int + the number of frames in the window + step : int + the number of frames between successive starting points of the + window (like the ``step`` parameter in a Python slice object) + """ + + _slow_build_iter = False + + def __init__(self, contact_trajectory, width=1, step=1): + self.trajectory = contact_trajectory + self.width = width + self.step = step + self.slow_build_iter = self._slow_build_iter + self._window_iter = None + self._contact_map = None + + def __iter__(self): + self._window_iter = WindowedIterator(length=len(self.trajectory), + width=self.width, + step=self.step, + slow_build=self.slow_build_iter) + self._contact_map = ContactFrequency.from_contacts( + Counter(), Counter(), + topology=self.trajectory.topology, + query=self.trajectory.query, + haystack=self.trajectory.haystack, + cutoff=self.trajectory.cutoff, + n_neighbors_ignored=self.trajectory.n_neighbors_ignored, + n_frames=0 + ) + return self + + def __next__(self): + to_add, to_sub = next(self._window_iter) + for frame in self.trajectory[to_add]: + self._contact_map.add_contact_frequency(frame) + for frame in self.trajectory[to_sub]: + self._contact_map.subtract_contact_frequency(frame) + + # need to make a copy in case the user does list(rolling_freq), + # otherwise they get copies of only the last version! + cmap = self._contact_map + map_copy = ContactFrequency.from_contacts( + cmap._atom_contacts.copy(), + cmap._residue_contacts.copy(), + topology=cmap.topology, + query=cmap.query, + haystack=cmap.haystack, + cutoff=cmap.cutoff, + n_neighbors_ignored=cmap.n_neighbors_ignored, + n_frames=cmap.n_frames + ) + return map_copy diff --git a/contact_map/plot_utils.py b/contact_map/plot_utils.py index 4d86260..43e74e8 100644 --- a/contact_map/plot_utils.py +++ b/contact_map/plot_utils.py @@ -7,7 +7,8 @@ except ImportError: # pragma: no cover pass -def ranged_colorbar(cmap, norm, cbmin, cbmax, name="Partial Map"): + +def ranged_colorbar(cmap, norm, cbmin, cbmax, ax=None): """Create a colorbar with given endpoints. Parameters @@ -20,8 +21,8 @@ def ranged_colorbar(cmap, norm, cbmin, cbmax, name="Partial Map"): minimum value for the colorbar cbmax : float maximum value for the colorbar - name : str - name for the submap to be created + ax : matplotlib.Axes + the axes to take space from to plot the colorbar Returns ------- @@ -33,6 +34,12 @@ def ranged_colorbar(cmap, norm, cbmin, cbmax, name="Partial Map"): cmap_f = plt.get_cmap(cmap) else: cmap_f = cmap + + if ax is None: + fig = plt + else: + fig = ax.figure + cbmin_normed = float(cbmin - norm.vmin) / (norm.vmax - norm.vmin) cbmax_normed = float(cbmax - norm.vmin) / (norm.vmax - norm.vmin) n_colors = int(round((cbmax_normed - cbmin_normed) * cmap_f.N)) @@ -42,7 +49,5 @@ def ranged_colorbar(cmap, norm, cbmin, cbmax, name="Partial Map"): new_norm = matplotlib.colors.Normalize(vmin=cbmin, vmax=cbmax) sm = plt.cm.ScalarMappable(cmap=new_cmap, norm=new_norm) sm._A = [] - cb = plt.colorbar(sm, fraction=0.046, pad=0.04) + cb = fig.colorbar(sm, ax=ax, fraction=0.046, pad=0.04) return cb - - diff --git a/contact_map/py_2_3.py b/contact_map/py_2_3.py index 7c99be8..b0b703c 100644 --- a/contact_map/py_2_3.py +++ b/contact_map/py_2_3.py @@ -2,7 +2,7 @@ try: getargspec = inspect.getfullargspec -except AttributeError: +except AttributeError: # -no-cov- getargspec = inspect.getargspec def inspect_method_arguments(method, no_self=True): diff --git a/contact_map/tests/test_contact_map.py b/contact_map/tests/test_contact_map.py index 2d02445..11a2c58 100644 --- a/contact_map/tests/test_contact_map.py +++ b/contact_map/tests/test_contact_map.py @@ -12,7 +12,7 @@ # stuff to be testing in this file from contact_map.contact_map import * -from contact_map.contact_count import HAS_MATPLOTLIB +from contact_map.contact_count import HAS_MATPLOTLIB, ContactCount traj = md.load(find_testfile("trajectory.pdb")) @@ -158,6 +158,25 @@ def test_counters(self, idx): assert m._residue_contacts == expected assert m.residue_contacts.counter == expected + @pytest.mark.parametrize('contactcount', [True, False]) + def test_from_contacts(self, idx, contactcount): + expected = self.maps[idx] + atom_contact_list = self.expected_atom_contacts[expected] + residue_contact_list = self.expected_residue_contacts[expected] + atom_contacts = counter_of_inner_list(atom_contact_list) + residue_contacts = counter_of_inner_list(residue_contact_list) + if contactcount: + atom_contacts = ContactCount(atom_contacts, self.topology.atom, + 10, 10) + residue_contacts = ContactCount(residue_contacts, + self.topology.residue, 5, 5) + + cmap = ContactMap.from_contacts(atom_contacts, residue_contacts, + topology=self.topology, + cutoff=0.075, + n_neighbors_ignored=0) + _contact_object_compare(cmap, expected) + def test_to_dict(self, idx): m = self.maps[idx] dct = m.to_dict() @@ -374,6 +393,25 @@ def test_counters(self): def test_contacts_dict(self): _check_contacts_dict_names(self.map) + @pytest.mark.parametrize('contactcount', [True, False]) + def test_from_contacts(self, contactcount): + atom_contacts = self.expected_atom_contact_count + residue_contacts = self.expected_residue_contact_count + top = traj.topology + if contactcount: + atom_contacts = ContactCount(atom_contacts, top.atom, + 10, 10) + residue_contacts = ContactCount(residue_contacts, top.residue, + 5, 5) + + cmap = ContactFrequency.from_contacts(atom_contacts, + residue_contacts, + n_frames=5, + topology=top, + cutoff=0.075, + n_neighbors_ignored=0) + _contact_object_compare(cmap, self.map) + def test_check_compatibility_true(self): map2 = ContactFrequency(trajectory=traj[0:2], cutoff=0.075, diff --git a/contact_map/tests/test_contact_trajectory.py b/contact_map/tests/test_contact_trajectory.py new file mode 100644 index 0000000..c9575a4 --- /dev/null +++ b/contact_map/tests/test_contact_trajectory.py @@ -0,0 +1,348 @@ +# pylint: disable=wildcard-import, missing-docstring, protected-access +# pylint: disable=attribute-defined-outside-init, invalid-name, no-self-use +# pylint: disable=wrong-import-order, unused-wildcard-import + +from .utils import * +from .test_contact_map import ( + counter_of_inner_list, _contact_object_compare, traj_atom_contact_count, + traj_residue_contact_count +) + +import mdtraj as md + +from contact_map.contact_trajectory import * +from contact_map.contact_count import ContactCount + +TRAJ_ATOM_CONTACTS = [ + [[1, 4], [4, 6], [5, 6]], + [[1, 5], [4, 6], [5, 6]], + [[1, 4], [4, 6], [5, 6]], + [[1, 4], [4, 6], [4, 7], [5, 6], [5, 7]], + [[0, 9], [0, 8], [1, 8], [1, 9], [1, 4], [8, 4], [8, 5], [4, 6], [4, 7], + [5, 6], [5, 7]] +] + +TRAJ_RES_CONTACTS = [ + [[0, 2], [2, 3]], + [[0, 2], [2, 3]], + [[0, 2], [2, 3]], + [[0, 2], [2, 3]], + [[0, 2], [2, 3], [0, 4], [2, 4]] +] + +class TestContactTrajectory(object): + def setup(self): + self.traj = md.load(find_testfile("trajectory.pdb")) + self.map = ContactTrajectory(self.traj, cutoff=0.075, + n_neighbors_ignored=0) + self.expected_atom_contacts = TRAJ_ATOM_CONTACTS + self.expected_residue_contacts = TRAJ_RES_CONTACTS + + @pytest.mark.parametrize('contact_type', ['atom', 'residue']) + def test_contacts(self, contact_type): + assert len(self.map) == 5 + contacts = {'atom': self.map.atom_contacts, + 'residue': self.map.residue_contacts}[contact_type] + expected = {'atom': self.expected_atom_contacts, + 'residue': self.expected_residue_contacts}[contact_type] + + for contact, expect in zip(contacts, expected): + expected_counter = counter_of_inner_list(expect) + assert contact.counter == expected_counter + + @pytest.mark.parametrize('contact_type', ['atom', 'residue']) + def test_contacts_sliced(self, contact_type): + selected_atoms = [2, 3, 4, 5, 6, 7, 8, 9] + cmap = ContactTrajectory(self.traj, query=selected_atoms, + haystack=selected_atoms, cutoff=0.075, + n_neighbors_ignored=0) + contacts = {'atom': cmap.atom_contacts, + 'residue': cmap.residue_contacts}[contact_type] + expected = { + 'atom': [ + [[4, 6], [5, 6]], + [[4, 6], [5, 6]], + [[4, 6], [5, 6]], + [[4, 6], [4, 7], [5, 6], [5, 7]], + [[8, 4], [8, 5], [4, 6], [4, 7], [5, 6], [5, 7]] + ], + 'residue': [ + [[2, 3]], + [[2, 3]], + [[2, 3]], + [[2, 3]], + [[2, 3], [2, 4]] + ] + }[contact_type] + + for contact, expect in zip(contacts, expected): + expected_counter = counter_of_inner_list(expect) + assert contact.counter == expected_counter + + + @pytest.mark.parametrize('contactcount', [True, False]) + def test_from_contacts(self, contactcount): + atom_contacts = [ + counter_of_inner_list(frame_contacts) + for frame_contacts in self.expected_atom_contacts + ] + residue_contacts = [ + counter_of_inner_list(frame_contacts) + for frame_contacts in self.expected_residue_contacts + ] + top = self.traj.topology + if contactcount: + atom_contacts = [ContactCount(contact, top.atom, 10, 10) + for contact in atom_contacts] + residue_contacts = [ContactCount(contact, top.residue, 5, 5) + for contact in residue_contacts] + + cmap = ContactTrajectory.from_contacts(atom_contacts, + residue_contacts, + topology=top, + cutoff=0.075, + n_neighbors_ignored=0) + for truth, beauty in zip(self.map, cmap): + _contact_object_compare(truth, beauty) + assert truth == beauty + _contact_object_compare(cmap, self.map) + assert cmap == self.map + + + def test_contact_frequency(self): + freq = self.map.contact_frequency() + expected_atom_count = { + key: val / 5.0 for key, val in traj_atom_contact_count.items() + } + expected_res_count = { + key: val / 5.0 + for key, val in traj_residue_contact_count.items() + } + assert freq.atom_contacts.counter == expected_atom_count + assert freq.residue_contacts.counter == expected_res_count + + @pytest.mark.parametrize("intermediate", ["dict", "json"]) + def test_serialization_cycle(self, intermediate): + # NOTE: this is identical to TestContactFrequency; can probably + # abstract it out + serializer, deserializer = { + 'json': (self.map.to_json, ContactTrajectory.from_json), + 'dict': (self.map.to_dict, ContactTrajectory.from_dict) + }[intermediate] + + serialized = serializer() + reloaded = deserializer(serialized) + _contact_object_compare(self.map, reloaded) + assert self.map == reloaded + + def test_from_contact_maps(self): + maps = [ContactFrequency(frame, cutoff=0.075, n_neighbors_ignored=0) + for frame in self.traj] + cmap = ContactTrajectory.from_contact_maps(maps) + _contact_object_compare(self.map, cmap) + assert self.map == cmap + + def test_from_contact_maps_incompatible(self): + map0 = ContactFrequency(self.traj[0], cutoff=0.075, + n_neighbors_ignored=0) + maps = [map0] + [ContactFrequency(frame) for frame in self.traj[1:]] + with pytest.raises(AssertionError): + _ = ContactTrajectory.from_contact_maps(maps) + + def test_join(self): + segments = self.traj[0], self.traj[1:3], self.traj[3:] + assert [len(s) for s in segments] == [1, 2, 2] + assert md.join(segments) == self.traj + + cmaps = [ContactTrajectory(segment, cutoff=0.075, + n_neighbors_ignored=0) + for segment in segments] + + cmap = ContactTrajectory.join(cmaps) + + assert len(cmap) == len(self.map) + for i, (truth, beauty) in enumerate(zip(self.map, cmap)): + _contact_object_compare(truth, beauty) + assert truth == beauty + + _contact_object_compare(self.map, cmap) + assert self.map == cmap + + def test_rolling_frequency(self): + # smoke test; correctness is tested in tests for + # RollingContactFrequency + assert len(list(self.map.rolling_frequency(window_size=2))) == 4 + + +class TestMutableContactTrajectory(object): + def setup(self): + self.traj = md.load(find_testfile("trajectory.pdb")) + self.map = MutableContactTrajectory(self.traj, cutoff=0.075, + n_neighbors_ignored=0) + self.expected_atom_contacts = TRAJ_ATOM_CONTACTS.copy() + self.expected_residue_contacts = TRAJ_RES_CONTACTS.copy() + + def _test_expected_contacts(self, traj_map, exp_atoms, exp_res): + for cmap, exp_a, exp_r in zip(traj_map, exp_atoms, exp_res): + atom_counter = cmap.atom_contacts.counter + res_counter = cmap.residue_contacts.counter + assert atom_counter == counter_of_inner_list(exp_a) + assert res_counter == counter_of_inner_list(exp_r) + + def test_setitem(self): + cmap4 = ContactFrequency(self.traj[4], cutoff=0.075, + n_neighbors_ignored=0) + self.map[1] = cmap4 + expected_atoms = self.expected_atom_contacts + expected_atoms[1] = expected_atoms[4] + expected_res = self.expected_residue_contacts + expected_res[1] = expected_res[4] + self._test_expected_contacts(self.map, expected_atoms, expected_res) + + def test_delitem(self): + del self.map[1] + assert len(self.map) == 4 + expected_atoms = (self.expected_atom_contacts[:1] + + self.expected_atom_contacts[2:]) + expected_res = (self.expected_residue_contacts[:1] + + self.expected_residue_contacts[2:]) + self._test_expected_contacts(self.map, expected_atoms, expected_res) + + def test_insert(self): + cmap4 = self.map[4] + self.map.insert(0, cmap4) + expected_atoms = [TRAJ_ATOM_CONTACTS[4]] + TRAJ_ATOM_CONTACTS + expected_res = [TRAJ_RES_CONTACTS[4]] + TRAJ_RES_CONTACTS + self._test_expected_contacts(self.map, expected_atoms, expected_res) + + def test_hash_eq(self): + cmap = MutableContactTrajectory(self.traj, cutoff=0.075, + n_neighbors_ignored=0) + assert hash(cmap) != hash(self.map) + assert cmap != self.map + + +class TestWindowedIterator(object): + def setup(self): + self.iter = WindowedIterator(length=10, width=3, step=2, + slow_build=False) + + def test_startup_normal(self): + to_add, to_sub = self.iter._startup() + assert to_sub == slice(0, 0) + assert to_add == slice(0, 3) + assert self.iter.min == 0 + assert self.iter.max == 2 + + def test_startup_slow_build_step1(self): + itr = WindowedIterator(length=10, width=3, step=1, slow_build=True) + to_add, to_sub = itr._startup() + assert to_sub == slice(0, 0) + assert to_add == slice(0, 1) + assert itr.min == 0 + assert itr.max == 0 + + to_add, to_sub = itr._startup() + assert to_sub == slice(0, 0) + assert to_add == slice(1, 2) + assert itr.min == 0 + assert itr.max == 1 + + def test_normal(self): + self.iter.min = 0 + self.iter.max = 2 + to_add, to_sub = self.iter._normal() + assert to_sub == slice(0, 2) + assert to_add == slice(3, 5) + assert self.iter.min == 2 + assert self.iter.max == 4 + + @pytest.mark.parametrize('length,width,step,slow_build,expected', [ + (5, 3, 2, False, [(slice(0, 0), slice(0, 3), 0, 2), + (slice(0, 2), slice(3, 5), 2, 4)]), + (5, 3, 1, True, [(slice(0, 0), slice(0, 1), 0, 0), + (slice(0, 0), slice(1, 2), 0, 1), + (slice(0, 0), slice(2, 3), 0, 2), + (slice(0, 1), slice(3, 4), 1, 3), + (slice(1, 2), slice(4, 5), 2, 4)]), + (5, 3, 2, True, [(slice(0, 0), slice(0, 2), 0, 1), + (slice(0, 1), slice(2, 4), 1, 3)]), + (6, 3, 3, False, [(slice(0, 0), slice(0, 3), 0, 2), + (slice(0, 3), slice(3, 6), 3, 5)]), + (6, 3, 3, True, [(slice(0, 0), slice(0, 3), 0, 2), + (slice(0, 3), slice(3, 6), 3, 5)]), + ]) + def test_next(self, length, width, step, slow_build, expected): + itr = WindowedIterator(length, width, step, slow_build) + for expect in expected: + exp_sub, exp_add, exp_min, exp_max = expect + to_add, to_sub = next(itr) + assert to_add == exp_add + assert to_sub == exp_sub + assert itr.min == exp_min + assert itr.max == exp_max + with pytest.raises(StopIteration): + next(itr) + + +class TestRollingContactFrequency(object): + def setup(self): + self.traj = md.load(find_testfile("trajectory.pdb")) + self.map = ContactTrajectory(self.traj, cutoff=0.075, + n_neighbors_ignored=0) + self.rolling_freq = RollingContactFrequency(self.map, width=2, + step=1) + self.expected_atoms = [ + {frozenset([1, 4]): 0.5, frozenset([4, 6]): 1.0, + frozenset([5, 6]): 1.0, frozenset([1, 5]): 0.5}, + {frozenset([1, 5]): 0.5, frozenset([4, 6]): 1.0, + frozenset([5, 6]): 1.0, frozenset([1, 4]): 0.5}, + {frozenset([1, 4]): 1.0, frozenset([4, 6]): 1.0, + frozenset([5, 6]): 1.0, frozenset([4, 7]): 0.5, + frozenset([5, 7]): 0.5}, + {frozenset([0, 9]): 0.5, frozenset([0, 8]): 0.5, + frozenset([1, 8]): 0.5, frozenset([1, 9]): 0.5, + frozenset([1, 4]): 1.0, frozenset([8, 4]): 0.5, + frozenset([8, 5]): 0.5, frozenset([4, 6]): 1.0, + frozenset([4, 7]): 1.0, frozenset([5, 6]): 1.0, + frozenset([5, 7]): 1.0} + ] + self.expected_residues = [ + {frozenset([0, 2]): 1.0, frozenset([2, 3]): 1.0}, + {frozenset([0, 2]): 1.0, frozenset([2, 3]): 1.0}, + {frozenset([0, 2]): 1.0, frozenset([2, 3]): 1.0}, + {frozenset([0, 2]): 1.0, frozenset([2, 3]): 1.0, + frozenset([0, 4]): 0.5, frozenset([2, 4]): 0.5} + ] + + def test_normal_iteration(self): + results = list(freq for freq in self.rolling_freq) + assert len(results) == 4 + + atom_contacts = [r.atom_contacts.counter for r in results] + for beauty, truth in zip(atom_contacts, self.expected_atoms): + assert beauty == truth + + residue_contacts = [r.residue_contacts.counter for r in results] + for beauty, truth in zip(residue_contacts, self.expected_residues): + assert beauty == truth + + def test_slow_build_iteration(self): + self.rolling_freq.slow_build_iter = True + results = list(freq for freq in self.rolling_freq) + assert len(results) == 5 + + expected_atoms = [{frozenset([1, 4]): 1.0, frozenset([4, 6]): 1.0, + frozenset([5, 6]): 1.0}] + self.expected_atoms + expected_residues = ( + [{frozenset([0, 2]): 1.0, frozenset([2, 3]): 1.0}] + + self.expected_residues + ) + + atom_contacts = [r.atom_contacts.counter for r in results] + for beauty, truth in zip(atom_contacts, expected_atoms): + assert beauty == truth + + residue_contacts = [r.residue_contacts.counter for r in results] + for beauty, truth in zip(residue_contacts, expected_residues): + assert beauty == truth diff --git a/docs/api.rst b/docs/api.rst index 57e8502..7d0884a 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -17,6 +17,8 @@ Contact maps ContactMap ContactFrequency ContactDifference + ContactTrajectory + RollingContactFrequency Contact Concurrences -------------------- diff --git a/examples/concurrences.ipynb b/examples/concurrences.ipynb index 895da5d..b3aab4f 100644 --- a/examples/concurrences.ipynb +++ b/examples/concurrences.ipynb @@ -225,6 +225,48 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false } }, "nbformat": 4, diff --git a/examples/contact_map.ipynb b/examples/contact_map.ipynb index 55d6df1..4774c0a 100644 --- a/examples/contact_map.ipynb +++ b/examples/contact_map.ipynb @@ -30,14 +30,14 @@ "metadata": {}, "outputs": [], "source": [ - "from contact_map import ContactMap, ContactFrequency, ContactDifference" + "from contact_map import ContactFrequency, ContactDifference" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Look at a single frame: `ContactMap`\n", + "## Look at a single frame\n", "\n", "First we make the contact map for the 0th frame. For default parameters (and how to change them) see section \"Changing the defaults\" below." ] @@ -53,14 +53,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 266 ms, sys: 3.72 ms, total: 270 ms\n", - "Wall time: 75.7 ms\n" + "CPU times: user 148 ms, sys: 9.23 ms, total: 157 ms\n", + "Wall time: 156 ms\n" ] } ], "source": [ "%%time\n", - "frame_contacts = ContactMap(traj[0])" + "frame_contacts = ContactFrequency(traj[0])" ] }, { @@ -81,13 +81,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 493 ms, sys: 8.42 ms, total: 501 ms\n", - "Wall time: 495 ms\n" + "CPU times: user 569 ms, sys: 14 ms, total: 583 ms\n", + "Wall time: 583 ms\n" ] }, { "data": { - "image/png": "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\n", + "text/plain": [ + "Text(0, 0.5, 'Residue')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -102,7 +112,7 @@ "%%time\n", "(fig, ax) = frame_contacts.residue_contacts.plot(cmap='seismic', vmin=-1, vmax=1)\n", "plt.xlabel(\"Residue\")\n", - "plt.ylabel(\"Residue\")" + "plt.ylabel(\"Residue\");" ] }, { @@ -123,10 +133,10 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/sander/github_files/contact_map/contact_map/contact_count.py:131: RuntimeWarning: The number of pixels in the figure is insufficient to show all the contacts.\n", + "/Users/dwhs/Dropbox/pysrc/contact_map/contact_map/contact_count.py:175: RuntimeWarning: The number of pixels in the figure is insufficient to show all the contacts.\n", " Please save this as a vector image (such as a PDF) to view the correct result.\n", - " Another option is to increase the 'dpi' (currently: 72.0), or the 'figsize' (curently: (6.0, 4.0)).\n", - " Adviced minimum amount of pixels = (2722, 2722) (width, height).\n", + " Another option is to increase the 'dpi' (currently: 72.0), or the 'figsize' (currently: (6.0, 4.0)).\n", + " Recommended minimum amount of pixels = (2722, 2722) (width, height).\n", " warnings.warn(msg, RuntimeWarning)\n" ] }, @@ -134,15 +144,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2.82 s, sys: 187 ms, total: 3.01 s\n", - "Wall time: 2.83 s\n" + "CPU times: user 4 s, sys: 88.3 ms, total: 4.09 s\n", + "Wall time: 4.6 s\n" ] }, { "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 5, @@ -151,7 +161,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -193,14 +203,15 @@ "# frame_contacts.atom_contacts.plot(cmap='seismic', vmin=-1, vmax=1, figsize=(38, 38));\n", "\n", "# If you want to increase the dpi (and make the image square):\n", - "# frame_contacts.atom_contacts.plot(cmap='seismic', vmin=-1, vmax=1, figsize=(6, 6), dpi=454);" + "# frame_contacts.atom_contacts.plot(cmap='seismic', vmin=-1, vmax=1, figsize=(6, 6), \n", + "# dpi=454);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Look at a trajectory: `ContactFrequency`\n", + "## Look at a trajectory\n", "\n", "`ContactFrequency` finds the fraction of frames where each contact exists." ] @@ -214,8 +225,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 20.6 s, sys: 137 ms, total: 20.8 s\n", - "Wall time: 3.22 s\n" + "CPU times: user 4.79 s, sys: 69.2 ms, total: 4.86 s\n", + "Wall time: 6.68 s\n" ] } ], @@ -244,13 +255,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.75 s, sys: 13.1 ms, total: 1.76 s\n", - "Wall time: 1.76 s\n" + "CPU times: user 2.6 s, sys: 47 ms, total: 2.65 s\n", + "Wall time: 3.04 s\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -286,8 +297,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 59.6 ms, sys: 52.3 ms, total: 112 ms\n", - "Wall time: 37.1 ms\n" + "CPU times: user 32 ms, sys: 1.5 ms, total: 33.5 ms\n", + "Wall time: 32.9 ms\n" ] } ], @@ -312,15 +323,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.65 s, sys: 69.6 ms, total: 1.72 s\n", - "Wall time: 1.64 s\n" + "CPU times: user 2.17 s, sys: 37.6 ms, total: 2.21 s\n", + "Wall time: 2.23 s\n" ] }, { "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 11, @@ -329,7 +340,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -358,6 +369,49 @@ "but the simple notation using `-` is much more straightforward. However, note that `ContactDifference` makes a difference between the *frequencies* in the two objects, not the absolute count. Otherwise the trajectory would swamp the single frame, and there would be no blue in that picture!" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot more than one ContactObject in a figure.\n", + "\n", + "It can be benificial to look at the contact maps of multiple different trajectories, or representations next to eachother in the same figure. This can be done by using `plot_axes(ax=ax)` after making `subplots`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Make a subplot with 1 row but three columns and a bigger figsize\n", + "fig, axs = plt.subplots(nrows=1, ncols=3, figsize=(30, 8))\n", + "\n", + "# Flatten the axis to a list\n", + "axs = axs.flatten()\n", + "\n", + "# Make a list of the contact objects we want to plot in this case: frame, trajectory, \n", + "# difference\n", + "contacts = [frame_contacts, trajectory_contacts, diff]\n", + "\n", + "# Now loop and make the plot\n", + "for ax, contact in zip(axs, contacts):\n", + " contact.residue_contacts.plot_axes(ax=ax)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -368,20 +422,20 @@ "\n", "The `.most_common()` method gives a list of the contact pairs and the frequency, sorted by frequency. See also `collections.Counter.most_common()` in the standard Python `collections` module.\n", "\n", - "Here we do this with the `ContactDifference` we created, although it works the same for `ContactFrequency` and `ContactMap` (with the single-frame contact map, the ordering is a bit nonsensical, since every entry is either 0 or 1)." + "Here we do this with the `ContactDifference` we created, although it works the same for `ContactFrequency` (with the single-frame contact map, the ordering is a bit nonsensical, since every entry is either 0 or 1)." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.73 ms, sys: 3.52 ms, total: 7.25 ms\n", - "Wall time: 2.43 ms\n" + "CPU times: user 5.52 ms, sys: 265 µs, total: 5.78 ms\n", + "Wall time: 6.06 ms\n" ] }, { @@ -399,7 +453,7 @@ " ([VAL81, ILE93], 0.9405940594059405)]" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -412,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -430,7 +484,7 @@ " ([NA6842, GLY13], -0.9900990099009901)]" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -457,7 +511,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -484,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -534,7 +588,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -557,7 +611,7 @@ " ([GTP201-O6, LYS117-CB], 0.45544554455445546)]" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -575,7 +629,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -587,7 +641,7 @@ " ([VAL81-CG1, ASN116-N], 0.0594059405940594)]" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -611,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -639,7 +693,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -653,15 +707,15 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 11.3 s, sys: 0 ns, total: 11.3 s\n", - "Wall time: 1.1 s\n" + "CPU times: user 1.1 s, sys: 17.5 ms, total: 1.12 s\n", + "Wall time: 1.19 s\n" ] } ], @@ -672,7 +726,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": { "scrolled": true }, @@ -681,16 +735,16 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -714,15 +768,15 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2.37 s, sys: 138 ms, total: 2.51 s\n", - "Wall time: 503 ms\n" + "CPU times: user 99.3 ms, sys: 2.58 ms, total: 102 ms\n", + "Wall time: 101 ms\n" ] } ], @@ -733,12 +787,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -762,12 +816,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -793,7 +847,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -817,7 +871,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -854,15 +908,15 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 24.5 s, sys: 143 ms, total: 24.6 s\n", - "Wall time: 5.35 s\n" + "CPU times: user 6.76 s, sys: 50.5 ms, total: 6.81 s\n", + "Wall time: 6.88 s\n" ] } ], @@ -873,12 +927,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -904,15 +958,15 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2min 17s, sys: 348 ms, total: 2min 17s\n", - "Wall time: 1min 59s\n" + "CPU times: user 2min 54s, sys: 1.47 s, total: 2min 55s\n", + "Wall time: 3min 4s\n" ] } ], @@ -930,31 +984,31 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 17.7 s, sys: 109 ms, total: 17.8 s\n", - "Wall time: 17.8 s\n" + "CPU times: user 30 s, sys: 675 ms, total: 30.7 s\n", + "Wall time: 41.6 s\n" ] }, { "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 30, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -972,20 +1026,20 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 985 ms, sys: 83 µs, total: 985 ms\n", - "Wall time: 986 ms\n" + "CPU times: user 3.33 s, sys: 56.7 ms, total: 3.39 s\n", + "Wall time: 3.52 s\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1002,7 +1056,8 @@ "cmap = matplotlib.pyplot.get_cmap('seismic')\n", "norm = matplotlib.colors.Normalize(vmin=-1, vmax=1)\n", "\n", - "plot = matplotlib.pyplot.pcolor(large_cutoff.residue_contacts.df, cmap='seismic', vmin=-1, vmax=1)\n", + "plot = matplotlib.pyplot.pcolor(large_cutoff.residue_contacts.df, cmap='seismic',\n", + " vmin=-1, vmax=1)\n", "plot.cmap.set_under(cmap(norm(0)));" ] }, @@ -1033,6 +1088,48 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false } }, "nbformat": 4, diff --git a/examples/contact_map_without_atom_slice.ipynb b/examples/contact_map_without_atom_slice.ipynb index 59cef36..ac03faf 100644 --- a/examples/contact_map_without_atom_slice.ipynb +++ b/examples/contact_map_without_atom_slice.ipynb @@ -17,7 +17,7 @@ "metadata": {}, "source": [ "## The worst case example\n", - "This is only adding a noticeable overhead for `ContactMap` in this case, but this could be worse for other systems" + "This is only adding a noticeable overhead for a single frame trajectory in this case, but this could be worse for other systems" ] }, { @@ -39,7 +39,7 @@ "metadata": {}, "outputs": [], "source": [ - "from contact_map import ContactMap, ContactFrequency, ContactDifference" + "from contact_map import ContactFrequency, ContactDifference" ] }, { @@ -58,22 +58,20 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "scrolled": true - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 824 ms, sys: 48 ms, total: 872 ms\n", - "Wall time: 291 ms\n" + "CPU times: user 251 ms, sys: 14.7 ms, total: 266 ms\n", + "Wall time: 293 ms\n" ] } ], "source": [ "%%time\n", - "frame_contacts = ContactMap(traj[0], query=used_atoms, haystack=used_atoms)" + "frame_contacts = ContactFrequency(traj[0], query=used_atoms, haystack=used_atoms)" ] }, { @@ -85,8 +83,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1min 12s, sys: 3.28 s, total: 1min 16s\n", - "Wall time: 20.6 s\n" + "CPU times: user 12.9 s, sys: 76.4 ms, total: 13 s\n", + "Wall time: 13.3 s\n" ] } ], @@ -132,7 +130,6 @@ "metadata": {}, "outputs": [], "source": [ - "ContactMap._class_use_atom_slice = False\n", "ContactFrequency._class_use_atom_slice = False\n", "ContactDifference._class_use_atom_slice = False" ] @@ -140,22 +137,20 @@ { "cell_type": "code", "execution_count": 8, - "metadata": { - "scrolled": true - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 668 ms, sys: 20 ms, total: 688 ms\n", - "Wall time: 204 ms\n" + "CPU times: user 150 ms, sys: 4.99 ms, total: 155 ms\n", + "Wall time: 171 ms\n" ] } ], "source": [ "%%time\n", - "frame_contacts = ContactMap(traj[0], query=used_atoms, haystack=used_atoms)" + "frame_contacts = ContactFrequency(traj[0], query=used_atoms, haystack=used_atoms)" ] }, { @@ -167,8 +162,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1min 12s, sys: 3.42 s, total: 1min 15s\n", - "Wall time: 21.1 s\n" + "CPU times: user 13.2 s, sys: 76 ms, total: 13.3 s\n", + "Wall time: 13.4 s\n" ] } ], @@ -209,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -219,27 +214,26 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Set class_atom_slice to True\n", - "ContactMap._class_use_atom_slice = True\n", "ContactFrequency._class_use_atom_slice = True\n", "ContactDifference._class_use_atom_slice = True" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 536 ms, sys: 32 ms, total: 568 ms\n", - "Wall time: 167 ms\n" + "CPU times: user 112 ms, sys: 3.98 ms, total: 116 ms\n", + "Wall time: 124 ms\n" ] } ], @@ -250,27 +244,26 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Set class_atom_slice to False\n", - "ContactMap._class_use_atom_slice = False\n", "ContactFrequency._class_use_atom_slice = False\n", "ContactDifference._class_use_atom_slice = False" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 7.35 s, sys: 316 ms, total: 7.66 s\n", - "Wall time: 1.99 s\n" + "CPU times: user 1.89 s, sys: 15.1 ms, total: 1.9 s\n", + "Wall time: 1.93 s\n" ] } ], @@ -297,6 +290,48 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false } }, "nbformat": 4, diff --git a/examples/contact_trajectory.ipynb b/examples/contact_trajectory.ipynb new file mode 100644 index 0000000..93592f4 --- /dev/null +++ b/examples/contact_trajectory.ipynb @@ -0,0 +1,342 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Contact Trajectories\n", + "\n", + "Sometimes you're interested in how contacts evolve in a trajectory, frame-by-frame. Contact Map Explorer provides the `ContactTrajectory` class for this purpose.\n", + "\n", + "We'll look at this using a trajectory of a specific inhibitor during its binding process to GSK3B. This system is also studied in the notebook on contact concurrences (with very similar initial discussion)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from __future__ import print_function\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from contact_map import ContactTrajectory, RollingContactFrequency\n", + "import mdtraj as md\n", + "traj = md.load(\"data/gsk3b_example.h5\")\n", + "print(traj) # to see number of frames; size of system" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we'll use MDTraj's [atom selection language](http://mdtraj.org/latest/atom_selection.html) to split out the protein and the ligand, which has residue name YYG in the input files. We're only interested in contacts between the protein and the ligand (not contacts within the protein). We'll also only look at heavy atom contacts." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "topology = traj.topology\n", + "yyg = topology.select('resname YYG and element != \"H\"')\n", + "protein = topology.select('protein and element != \"H\"')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Making an accessing a contact trajectory\n", + "\n", + "Contact trajectories have the same keyword arguments as other contact objects" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "contacts = ContactTrajectory(traj, query=yyg, haystack=protein)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once the `ContactTrajectory` has been made, contacts for individual frames can be accessed either by taking the index of the `ContactTrajectory` itself, or by getting the list of contact (e.g., all the residue contacts frame-by-frame) and selecting the frame of interest." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[([YYG351, SER32], 1.0), ([YYG351, GLY31], 1.0), ([ASN30, YYG351], 1.0)]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "contacts[0].residue_contacts.most_common()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[([YYG351, SER32], 1.0), ([YYG351, GLY31], 1.0), ([ASN30, YYG351], 1.0)]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "contacts.residue_contacts[0].most_common()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Advanced Python indexing is also allowed. In this example, note how the most common partners for YYG change! This is also what we see in the contact concurrences example." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[([VAL27, YYG351], 1.0), ([ARG107, YYG351], 1.0), ([ILE28, YYG351], 1.0)]\n", + "[([VAL27, YYG351], 1.0), ([ILE28, YYG351], 1.0), ([GLN151, YYG351], 1.0)]\n", + "[([VAL27, YYG351], 1.0), ([ASN30, YYG351], 1.0), ([GLY34, YYG351], 1.0)]\n", + "[([ASP166, YYG351], 1.0), ([PHE33, YYG351], 1.0), ([LYS149, YYG351], 1.0)]\n", + "[([YYG351, SER32], 1.0), ([VAL53, YYG351], 1.0), ([PHE33, YYG351], 1.0)]\n", + "[([GLU63, YYG351], 1.0), ([VAL53, YYG351], 1.0), ([PHE33, YYG351], 1.0)]\n", + "[([ASP166, YYG351], 1.0), ([VAL53, YYG351], 1.0), ([PHE33, YYG351], 1.0)]\n", + "[([YYG351, GLY168], 1.0), ([YYG351, SER32], 1.0), ([ASP166, YYG351], 1.0)]\n" + ] + } + ], + "source": [ + "for contact in contacts[50:80:4]:\n", + " print(contact.residue_contacts.most_common()[:3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can easily turn the `ContactTrajectory` into `ContactFrequency`:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "freq = contacts.contact_frequency()\n", + "\n", + "fig, ax = plt.subplots(figsize=(5.5,5))\n", + "freq.residue_contacts.plot_axes(ax=ax)\n", + "ax.set_xlim(*contacts.query_residue_range);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rolling Contact Frequencies\n", + "\n", + "A `ContactTrajectory` keeps all the time-dependent information about the contacts, whereas a `ContactFrequency`, as plotted above, loses all of it. What about something in between? For this, we have a `RollingContactFrequency`, which acts like a rolling average. It creates a contact frequency over a certain window of frames, with a certain step size between each window.\n", + "\n", + "This can be created either with the `RollingContactFrequency` object, or, more easily, with the `ContactTrajectory.rolling_frequency()` method." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "RollingContactFrequency(contacts, width=30, step=14)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rolling_frequencies = contacts.rolling_frequency(window_size=30, step=14)\n", + "rolling_frequencies" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll plot each windowed frequency, and we will see the transition as some contacts fade out and others grow in." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(3, 2, figsize=(12, 10))\n", + "for ax, freq in zip(axs.flatten(), rolling_frequencies):\n", + " freq.residue_contacts.plot_axes(ax=ax)\n", + " ax.set_xlim(*contacts.query_residue_range);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/setup.cfg b/setup.cfg index dfaa6e6..0d02228 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,6 +1,6 @@ [metadata] name = contact_map -version = 0.5.1 +version = 0.6.0 description = Contact maps based on MDTraj long_description = file: README.md long_description_content_type = text/markdown diff --git a/setup.py b/setup.py index 2a7d0df..a246dfb 100644 --- a/setup.py +++ b/setup.py @@ -76,11 +76,7 @@ def __init__(self, import_name): def visit_ImportFrom(self, node): if node.module == self.import_name: - replacement = ast.Raise(exc=ast.Call( - func=ast.Name(id='ImportError', ctx=ast.Load()), - args=[], - keywords=[], - ), cause=None) + replacement = ast.parse("raise ImportError()").body[0] return ast.copy_location(replacement, node) else: return node