allpy: 60fd4c001ad9 allpy/markups.py

allpy

view allpy/markups.py @ 871:60fd4c001ad9

Removed "doc" target from default Makefile targets. The doc target is used to re-generate templates for the ReST documentation for Sphinx for new modules. The results are stored in the repository and are supposed to be manually edited later (some of them do). It also makes a new dependency: sphinx-autotools, which is not a widely distributed package. So, there is no use to have this target for new downloads.

author	Daniil Alexeyevsky <dendik@kodomo.fbb.msu.ru>
date	Fri, 29 Jul 2011 20:59:28 +0400
parents	137981a4686f
children	9b253b69f8f1

line source

1 import base

3 by_name = {}

4 """A dictionary of default markup name -> markup class."""

6 def update(*args):

7 """Update `by_name` dictionary.

9 If any arguments are given, add them to markups namespace beforehands.

10 """

11 # Add user classes if necessary

12 for markup_class in args:

13 class_name = markup_class.__name__

14 assert class_name not in globals(), "SameNamed markup already exists!"

15 globals()[class_name] = markup_class

16 # Update `by_name` dictonary

17 global by_name

18 by_name = {}

19 for markup_class in globals().values():

20 if hasattr(markup_class, 'name') and hasattr(markup_class, 'kind'):

21 fullname = markup_class.kind, markup_class.name

22 assert fullname not in by_name, "Samenamed markup already exists!"

23 by_name[fullname] = markup_class

25 class MarkupIOMixin(base.Markup):

26 """Standard helper mixin for creating saveable markups."""

28 separator = ','

29 """Separator to use when saving/loading markup."""

31 io_class = None

32 """MUST be overloaded when subclassing. io_class in file."""

34 @staticmethod

35 def parse_item(key, value):

36 """Deserialize one item of markup. Overload when subclassing."""

37 return value

39 @staticmethod

40 def repr_item(key, value):

41 """Serialize one item of markup. Overload when subclassing."""

42 return str(value)

44 @classmethod

45 def from_record(cls, container, record, name=None):

46 """Read markup from semi-parsed record from 'markup' file."""

47 assert record['io_class'] == cls.io_class

48 separator = record.get('separator', cls.separator)

49 values = record['markup'].split(separator)

50 result = container.add_markup(name, markup_class=cls)

51 assert len(values) == len(result.sorted_keys())

52 for key, value in zip(result.sorted_keys(), values):

53 if value:

54 result[key] = cls.parse_item(key, value)

55 return result

57 def to_record(self):

58 """Write markup to semi-serialized record for 'markup' file."""

59 values = []

60 for key in self.sorted_keys():

61 if key in self:

62 values.append(self.repr_item(key, self[key]))

63 else:

64 values.append('')

65 markup = self.separator.join(values)

66 return {

67 'markup': markup,

68 'io_class': self.io_class,

69 'separator': self.separator,

70 }

72 class IntMarkupMixin(MarkupIOMixin):

73 """Markup that has integer values."""

75 io_class = 'IntMarkup'

77 @staticmethod

78 def parse_item(key, value):

79 return int(value)

81 class SequenceNumberMarkup(base.SequenceMarkup):

83 name = 'number'

85 def refresh(self):

86 for number, monomer in enumerate(self.sequence, 1):

87 monomer.number = number

89 class SequenceIndexMarkup(base.SequenceMarkup):

91 name = 'index'

93 def refresh(self):

94 for index, monomer in enumerate(self.sequence):

95 monomer.index = index

97 class AlignmentNumberMarkup(base.AlignmentMarkup):

99 name = 'number'

100

101 def refresh(self):

102 for number, column in enumerate(self.alignment.columns, 1):

103 self[column] = number

104

105 class AlignmentIndexMarkup(base.AlignmentMarkup):

106

107 name = 'index'

108

109 def refresh(self):

110 for index, column in enumerate(self.alignment.columns):

111 self[column] = index

112

113 class SequenceCaseMarkup(base.SequenceMarkup, MarkupIOMixin):

114

115 name = 'case'

116 io_class = 'SequenceCaseMarkup'

117

118 def refresh(self):

119 for monomer in self.sequence:

120 if monomer.input_code1.isupper():

121 monomer.case = 'upper'

122 elif monomer.input_code1.islower():

123 monomer.case = 'lower'

124

125 @staticmethod

126 def parse_value(monomer, value):

127 assert mnomer.code1 == value.upper()

128 if value.isupper():

129 return 'upper'

130 if value.islower():

131 return 'lower'

132

133 @staticmethod

134 def repr_value(monomer, value):

135 if monomer.case == 'upper':

136 return monomer.code1.upper()

137 if monomer.case == 'lower':

138 return monomer.code1.lower()

139 raise AssertionError("Unknown monomer case")

140

141 class SequencePdbResiMarkup(base.SequenceMarkup, IntMarkupMixin):

142 name = 'pdb_resi'

143

144 def from_pdb(self):

145 for monomer in self.sequence:

146 try:

147 monomer.pdb_resi = monomer.pdb_residue.id[1]

148 except Exception:

149 pass

150

151 def add_pdb(self, download_pdb=None, xyz_only=False):

152 import structure

153 if download_pdb is None:

154 download_pdb = structure.cached_download_pdb

155

156 match = structure.pdb_id_parse(self.sequence.name)

157 code, model , chain = match['code'], match['model'], match['chain']

158 pdb_file = download_pdb(code)

159 pdb_structure = structure.get_structure(pdb_file, self.sequence.name)

160 pdb_chain = pdb_structure[0][chain]

161 if not xyz_only:

162 self.sequence.pdb_chain = pdb_chain

163 for monomer in self.sequence:

164 if monomer in self:

165 pdb_residue = pdb_chain[' ', monomer.pdb_resi, ' ']

166 monomer.ca_xyz = pdb_residue['CA'].get_vector()

167 if not xyz_only:

168 monomer.pdb_residue = pdb_residue

169

170 # This MUST be the last statement in this module.

171 update()

172

173 # vim: set ts=4 sts=4 sw=4 et: