/usr/share/pyshared/Bio/PDB/Entity.py is in python-biopython 1.58-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 | # Copyright (C) 2002, Thomas Hamelryck (thamelry@binf.ku.dk)
# This code is part of the Biopython distribution and governed by its
# license. Please see the LICENSE file that should have been included
# as part of this package.
from copy import copy
from Bio.PDB.PDBExceptions import PDBConstructionException, PDBException
"""Base class for Residue, Chain, Model and Structure classes.
It is a simple container class, with list and dictionary like properties.
"""
class Entity(object):
"""
Basic container object. Structure, Model, Chain and Residue
are subclasses of Entity. It deals with storage and lookup.
"""
def __init__(self, id):
self.id=id
self.full_id=None
self.parent=None
self.child_list=[]
self.child_dict={}
# Dictionary that keeps addictional properties
self.xtra={}
# Special methods
def __len__(self):
"Return the number of children."
return len(self.child_list)
def __getitem__(self, id):
"Return the child with given id."
return self.child_dict[id]
def __delitem__(self, id):
"Remove a child."
return self.detach_child(id)
def __iter__(self):
"Iterate over children."
for child in self.child_list:
yield child
# Public methods
def get_level(self):
"""Return level in hierarchy.
A - atom
R - residue
C - chain
M - model
S - structure
"""
return self.level
def set_parent(self, entity):
"Set the parent Entity object."
self.parent=entity
def detach_parent(self):
"Detach the parent."
self.parent=None
def detach_child(self, id):
"Remove a child."
child=self.child_dict[id]
child.detach_parent()
del self.child_dict[id]
self.child_list.remove(child)
def add(self, entity):
"Add a child to the Entity."
entity_id=entity.get_id()
if self.has_id(entity_id):
raise PDBConstructionException( \
"%s defined twice" % str(entity_id))
entity.set_parent(self)
self.child_list.append(entity)
self.child_dict[entity_id]=entity
def get_iterator(self):
"Return iterator over children."
for child in self.child_list:
yield child
def get_list(self):
"Return a copy of the list of children."
return copy(self.child_list)
def has_id(self, id):
"""True if a child with given id exists."""
return (id in self.child_dict)
def get_parent(self):
"Return the parent Entity object."
return self.parent
def get_id(self):
"Return the id."
return self.id
def get_full_id(self):
"""Return the full id.
The full id is a tuple containing all id's starting from
the top object (Structure) down to the current object. A full id for
a Residue object e.g. is something like:
("1abc", 0, "A", (" ", 10, "A"))
This corresponds to:
Structure with id "1abc"
Model with id 0
Chain with id "A"
Residue with id (" ", 10, "A")
The Residue id indicates that the residue is not a hetero-residue
(or a water) beacuse it has a blank hetero field, that its sequence
identifier is 10 and its insertion code "A".
"""
if self.full_id==None:
entity_id=self.get_id()
l=[entity_id]
parent=self.get_parent()
while not (parent is None):
entity_id=parent.get_id()
l.append(entity_id)
parent=parent.get_parent()
l.reverse()
self.full_id=tuple(l)
return self.full_id
class DisorderedEntityWrapper(object):
"""
This class is a simple wrapper class that groups a number of equivalent
Entities and forwards all method calls to one of them (the currently selected
object). DisorderedResidue and DisorderedAtom are subclasses of this class.
E.g.: A DisorderedAtom object contains a number of Atom objects,
where each Atom object represents a specific position of a disordered
atom in the structure.
"""
def __init__(self, id):
self.id=id
self.child_dict={}
self.selected_child=None
self.parent=None
# Special methods
def __getattr__(self, method):
"Forward the method call to the selected child."
if not hasattr(self, 'selected_child'):
# Avoid problems with pickling
# Unpickling goes into infinite loop!
raise AttributeError
return getattr(self.selected_child, method)
def __getitem__(self, id):
"Return the child with the given id."
return self.selected_child[id]
# XXX Why doesn't this forward to selected_child?
# (NB: setitem was here before getitem, iter, len, sub)
def __setitem__(self, id, child):
"Add a child, associated with a certain id."
self.child_dict[id]=child
def __iter__(self):
"Return the number of children."
return iter(self.selected_child)
def __len__(self):
"Return the number of children."
return len(self.selected_child)
def __sub__(self, other):
"""Subtraction with another object."""
return self.selected_child - other
# Public methods
def get_id(self):
"Return the id."
return self.id
def disordered_has_id(self, id):
"""True if there is an object present associated with this id."""
return (id in self.child_dict)
def detach_parent(self):
"Detach the parent"
self.parent=None
for child in self.disordered_get_list():
child.detach_parent()
def get_parent(self):
"Return parent."
return self.parent
def set_parent(self, parent):
"Set the parent for the object and its children."
self.parent=parent
for child in self.disordered_get_list():
child.set_parent(parent)
def disordered_select(self, id):
"""Select the object with given id as the currently active object.
Uncaught method calls are forwarded to the selected child object.
"""
self.selected_child=self.child_dict[id]
def disordered_add(self, child):
"This is implemented by DisorderedAtom and DisorderedResidue."
raise NotImplementedError
def is_disordered(self):
"""
Return 2, indicating that this Entity is a collection of Entities.
"""
return 2
def disordered_get_id_list(self):
"Return a list of id's."
l=self.child_dict.keys()
# sort id list alphabetically
l.sort()
return l
def disordered_get(self, id=None):
"""Get the child object associated with id.
If id is None, the currently selected child is returned.
"""
if id==None:
return self.selected_child
return self.child_dict[id]
def disordered_get_list(self):
"Return list of children."
return self.child_dict.values()
|