Iteratory

Celem tego zadania jest dodanie brakujących iteratorów do klas Chain i Structure.

Klasy opisujące biomakromolekuły

Makromolekuły z których zbudowane są organizmy żywe: białka oraz kwasy nukleinowe składają się z oddzielnych łańcuchów. Każdy z nich składa się z reszt aminokwasowych (w przypadku białek) bądź nukleotydów (kwasy nukleinowe). Każda z reszt zaś zbudowana jest z atomów. Poniższy program jest odtworzeniem tej biochemicznej konstrukcji w postaci klas Structure, Chain, Residue i Atom. Struktura biomolekuły (Structure) przechowuje w prywatnym słowniku swoje łańcuchy. Każdy z łańcuchów (Chain) zawiera słownik reszt. Wreszcie, każda z reszt (Residue) zawiera listę jej atomów. Kompletny kod tych klas znajduje się na dole strony.

Iteratory

W przyjętej konstrukcji odwiedzenie wszystkich atomów ze struktury wymaga de facto trzech petli:

from protein_structure import *

strctr = read_pdb_content("2GB1", open("2gb1.pdb"))
for chain in strctr.chains():
    for residue in chain.residues():
        for atom in residue.atoms():
            print(atom.name)

Zaimplementuj brakujące metody: atoms() i residues() w klasie Structure, oraz atoms() w klasie Chain tak, aby możliwe było iterowanie po atomach i resztach w jednej pętli. Dla przykładu, poniższy kod powinien prawidłowo policzyć środek masy całego białka.

from protein_structure import *

strctr = read_pdb_content("2GB1", open("2gb1.pdb"))
n, cm_x, cm_y, cm_z = 0, 0.0, 0.0, 0.0
for a in strctr.atoms():
    cm_x += a.x
    cm_y += a.y
    cm_z += a.z
    n += 1
cm_x /= n
cm_y /= n
cm_z /= n

Zaimplementowanie iteratorów przyniesie także inne korzyści. Dla przykładu, użytkownicy będą mogli wykorzystać bibliotekę itertools w analizie struktur. Poniżej, oprócz klas reprezentujących biomolekuły, dołączono prosty test obliczający mapę odległości pomiędzy węglami alfa (atomy o nazwie ” CA “) wczytanego białka.

from __future__ import annotations

import itertools
import math
from dataclasses import dataclass, field
from typing import Dict


@dataclass
class Structure:
    id_code: str
    __chains: Dict[str, Chain] = field(default_factory=dict)

    def get_chain(self, chain_id: str):
        return self.__chains.get(chain_id, None)

    def add_chain(self, chain: Chain):
        self.__chains[chain.code] = chain

    def chains(self):
        return self.__chains.values()

    def atoms(self):
        raise NotImplemented

    def residues(self):
        raise NotImplemented

@dataclass
class Chain:
    code: str
    __residues: Dict[str, Residue] = field(default_factory=dict)

    def get_residue(self, res_seq: int, i_code: str):
        key = str(res_seq) + i_code
        return self.__residues.get(key, None)

    def add_residue(self, res: Residue):
        key = str(res.res_seq) + res.i_code
        self.__residues[key] = res

    def residues(self):
        return self.__residues.values()

    def atoms(self):
        raise NotImplemented


@dataclass
class Residue:
    res_name: str
    res_seq: int
    i_code: str
    __atoms: list[Atom] = field(default_factory=list)

    def add_atom(self, atom):
        self.__atoms.append(atom)

    def ca(self):
        """Returns the alpha carbon of this residue or None when not present"""
        return next((a for a in self.__atoms if a.name == " CA "), None)

    def atoms(self):
        return self.__atoms

    def __str__(self):
        return f"{self.res_name} {self.res_seq}{self.i_code}"

@dataclass
class Atom:
    serial: int
    name: str
    x: float
    y: float
    z: float

    def distance_to(self, a):
        d2 = (self.x - a.x) * (self.x - a.x)
        d2 += (self.y - a.y) * (self.y - a.y)
        return math.sqrt(d2 + (self.z - a.z) * (self.z - a.z))

def read_pdb_content(code, input_lines):

    strctr = Structure(code)

    for line in input_lines:
        if not line.startswith("ATOM") and not line.startswith("HETAT"): continue
        name = line[12:16]
        serial = int(line[6:11].strip())
        res_name = line[17:20]
        res_seq = int(line[22:26].strip())
        i_code = line[26]
        chain_id = line[21]
        x = float(line[30:38].strip())
        y = float(line[38:46].strip())
        z = float(line[46:54].strip())
        chain = strctr.get_chain(chain_id)
        if chain is None:
            chain = Chain(chain_id)
            strctr.add_chain(chain)
        resid = chain.get_residue(res_seq, i_code)
        if resid is None:
            resid = Residue(res_name, res_seq, i_code)
            chain.add_residue(resid)
        atom = Atom(serial, name, x, y, z)
        resid.add_atom(atom)

    return strctr


if __name__ == "__main__":
    strctr = read_pdb_content("2GB1",open("2gb1.pdb"))
    for c in strctr.chains():
        print(c.code)

    chain_A = strctr.get_chain("A")
    for ri, rj in itertools.combinations(chain_A.residues(), 2):
        print(ri, rj, ri.ca().distance_to(rj.ca()))

Przykładowy plik w formacie PDB znajduje się tutaj.

Poniżej zaś znajduje się szkic rozwiązania tego zadania:

(rozwiń szkic rozwiązania)

from protein_structure import Structure, Chain


class AtomsInChainIterator:
    def __init__(self, chain: Chain):
        self.__residues = list(chain.residues())
        self.__current_residue = 0
        self.__current_atom = 0

    def __next__(self):
        # sprawdź, czy możesz dać (__current_atom+1) atom z __current_residue
        # TAK:
        #    __current_atom+=1
        #    zwróć __current_atom-1
        # NIE:
        #    __current_residue += 1
        #    sprawdź, czy nie wyszliśmy poza łańcuch
        #    NIE:
        #        __current_residue += 1
        #        __current_atom = 1
        #        zwróć atom 0
        #    TAK:
        #        raise StopIteration
        pass


class AtomsInStructureIterator:
    def __init__(self, strctr: Structure):
        self.__chains = list(strctr.chains())
        self.__current_chain = 0
        self.__current_chain_it = AtomsInChainIterator(self.__chains[0])

    def __next__(self):
        try:
            a = self.__current_chain_it.__next__()
            return a
        except:
            # przesuń AtomsInChainIterator o jeden łańcuch
            # zwróć atom
            pass


class Structure:

    def atoms(self):
        return AtomsInStructureIterator(self)