1.1 --- a/allpy/_monomer.py	Tue Dec 14 20:00:58 2010 +0300
     1.2 +++ b/allpy/_monomer.py	Tue Dec 14 20:05:13 2010 +0300
     1.3 @@ -1,99 +1,119 @@
     1.4  #!/usr/bin/python
     1.5  
     1.6 -from data.AAdict import AAdict
     1.7 -
     1.8 -index_code3 = {}
     1.9 -index_code1 = {}
    1.10 -index_name = {}
    1.11 +import data.codes as table
    1.12  
    1.13  class MonomerType(object):
    1.14 -    """ Monomer type
    1.15 -    
    1.16 -    name -- string like "Valine" 
    1.17 -    code1 -- one-letter code (in upper case)
    1.18 -    code3 -- three-letter code (in upper case)
    1.19 -    is_modified -- True of False
    1.20 +    """Class of monomer types.
    1.21 +
    1.22 +    Each MonomerType object represents a known monomer type, e.g. Valine,
    1.23 +    and is referenced to by each instance of monomer in a given sequence.
    1.24 +
    1.25 +    - `name`: full name of monomer type
    1.26 +    - `code1`: one-letter code
    1.27 +    - `code3`: three-letter code
    1.28 +    - `is_modified`: either of True or False
    1.29 +
    1.30 +    class atributes:
    1.31 +
    1.32 +    - `by_code1`: a mapping from one-letter code to MonomerType object
    1.33 +    - `by_code3`: a mapping from three-letter code to MonomerType object
    1.34 +    - `by_name`: a mapping from monomer name to MonomerType object
    1.35 +    - `instance_type`: class of Monomer objects to use when creating new
    1.36 +      objects; this must be redefined in descendent classes
    1.37 +
    1.38 +    All of the class attributes MUST be redefined when subclassing.
    1.39      """
    1.40  
    1.41 -    instance_type = None # Must be redefined when subclassing
    1.42 -    
    1.43 -    def __init__(self, name, code1, code3, is_modified=False):
    1.44 +    by_code1 = {}
    1.45 +    by_code3 = {}
    1.46 +    by_name = {}
    1.47 +    instance_type = None
    1.48 +
    1.49 +    def __init__(self, name="", code1="", code3="", is_modified=False):
    1.50          self.name = name.capitalize()
    1.51          self.code1 = code1.upper()
    1.52          self.code3 = code3.upper()
    1.53 -        self.is_modified = bool(is_modified) # ugly
    1.54 +        self.is_modified = bool(is_modified)
    1.55 +        if not is_modified:
    1.56 +            self.by_code1[self.code1] = self
    1.57 +        self.by_code3[code3] = self
    1.58 +        self.by_name[name] = self
    1.59 +        # We duplicate distinguished long names into MonomerType itself,
    1.60 +        # so that we can use MonomerType.from_code3 to create the relevant
    1.61 +        # type of monomer.
    1.62 +        MonomerType.by_code3[code3] = self
    1.63 +        MonomerType.by_name[name] = self
    1.64  
    1.65      @classmethod
    1.66 -    def create(cls, name, code1, code3, is_modified=False):
    1.67 -        self = cls(name, code1, code3, is_modified)
    1.68 -        index_name[self.name] = self
    1.69 -        index_code3[self.code3] = self
    1.70 -        if not is_modified:
    1.71 -            if cls not in index_code1:
    1.72 -                index_code1[cls] = {}
    1.73 -            index_code1[cls][code1] = self
    1.74 -    
    1.75 +    def _initialize(cls, type_letter, codes=table.codes):
    1.76 +        """Create all relevant instances of MonomerType.
    1.77 +
    1.78 +        `type_letter` is either of:
    1.79 +
    1.80 +        - 'p' for protein
    1.81 +        - 'd' for DNA
    1.82 +        - 'r' for RNA
    1.83 +
    1.84 +        `codes` is a table of monomer codes
    1.85 +        """
    1.86 +        for type, code1, is_modified, code3, name in codes:
    1.87 +            if type == type_letter:
    1.88 +                cls(name, code1, code3, is_modified)
    1.89 +
    1.90      @classmethod
    1.91      def from_code1(cls, code1):
    1.92 -        return index_code1[cls][code1.upper()]
    1.93 +        """Return monomer type by one-letter code."""
    1.94 +        return cls.by_code1[code1.upper()]
    1.95  
    1.96 -    @staticmethod
    1.97 -    def from_name(name):
    1.98 -        return index_name[name.capitalize()]
    1.99 -      
   1.100 -    @staticmethod
   1.101 -    def from_pdb_residue(pdb_residue):
   1.102 -        """ pdb_residue type is Bio.PDB.Residue """
   1.103 -        return MonomerType.from_code3(pdb_residue.get_resname())
   1.104 -        
   1.105 -    # TO DISCUSS
   1.106 -    def __eq__(self, other):
   1.107 -        return self.code1 == other.code1
   1.108 +    @classmethod
   1.109 +    def from_code3(cls, code3):
   1.110 +        """Return monomer type by three-letter code."""
   1.111 +        return cls.by_code3[code3.upper()]
   1.112  
   1.113 -    def __ne__(self, other):
   1.114 -        return not (self == other)
   1.115 -    
   1.116 +    @classmethod
   1.117 +    def from_name(cls, name):
   1.118 +        """Return monomer type by name."""
   1.119 +        return cls.by_name[name.capitalize()]
   1.120 +
   1.121      def instance(self):
   1.122 +        """Create a new monomer of given type."""
   1.123          return self.instance_type(self)
   1.124  
   1.125 +    def __eq__(self, other):
   1.126 +        if hasattr(other, "type"):
   1.127 +            return self is other.type
   1.128 +        return self is other
   1.129 +
   1.130  class Monomer(object):
   1.131 -    """ Monomer 
   1.132 -    
   1.133 -    type -- link to MonomerType object
   1.134 +    """Monomer object.
   1.135 +
   1.136 +    attributes:
   1.137 +
   1.138 +    - `type`: type of monomer (a MonomerType object)
   1.139 +
   1.140 +    class attribute `monomer_type` is MonomerType or either of it's subclasses,
   1.141 +    it is used when creating new monomers. It MUST be redefined when subclassing Monomer.
   1.142      """
   1.143 -    def __init__(self, monomer_type):
   1.144 -        self.type = monomer_type
   1.145 -        
   1.146 +    monomer_type = MonomerType
   1.147 +
   1.148 +    def __init__(self, type):
   1.149 +        self.type = type
   1.150 +
   1.151 +    @classmethod
   1.152 +    def from_code1(cls, code1):
   1.153 +        return cls(cls.monomer_type.by_code1[code1.upper()])
   1.154 +
   1.155 +    @classmethod
   1.156 +    def from_code3(cls, code3):
   1.157 +        return cls(cls.monomer_type.by_code3[code3.upper()])
   1.158 +
   1.159 +    @classmethod
   1.160 +    def from_name(cls, name):
   1.161 +        return cls(cls.monomer_type.by_name[name.capitalize()])
   1.162 +
   1.163      def __eq__(self, other):
   1.164 -        return self.type == other.type
   1.165 -
   1.166 -    def __ne__(self, other):
   1.167 -        return not (self == other)
   1.168 -
   1.169 -
   1.170 -class AminoAcidType(MonomerType):
   1.171 -    instance_type = AminoAcid
   1.172 -class DNAType(MonomerType):
   1.173 -    instance_type = DNA
   1.174 -class RNAType(MonomerType):
   1.175 -    instance_type = RNA
   1.176 -
   1.177 -class AminoAcid(Monomer):
   1.178 -    pass
   1.179 -class DNA(Monomer):
   1.180 -    pass
   1.181 -class RNA(Monomer):
   1.182 -    pass
   1.183 -
   1.184 -types = {'p': AminoAcidType, 'd': DNAType, 'r': RNAType}
   1.185 -
   1.186 -# prepare all aminoacids
   1.187 -
   1.188 -for code3, data in AAdict.items():
   1.189 -    code1, m_type, is_modified, none, name = data
   1.190 -    monomer_type = types[m_type]
   1.191 -    monomer_type.create(name, code1, code3, is_modified)
   1.192 -del code3, data, code1, m_type, is_modified, none, name
   1.193 -
   1.194 +        if hasattr(other, "type"):
   1.195 +            return self.type is other.type
   1.196 +        return self.type is other
   1.197  
   1.198  # vim: set ts=4 sts=4 sw=4 et: