# Bio.SCOP.Raf module

ASTRAL RAF (Rapid Access Format) Sequence Maps.

The ASTRAL RAF Sequence Maps record the relationship between the PDB SEQRES records (representing the sequence of the molecule used in an experiment) to the ATOM records (representing the atoms experimentally observed).

This data is derived from the Protein Data Bank CIF files. Known errors in the CIF files are corrected manually, with the original PDB file serving as the final arbiter in case of discrepancies.

Residues are referenced by residue ID. This consists of a the PDB residue sequence number (up to 4 digits) and an optional PDB insertion code (an ascii alphabetic character, a-z, A-Z). e.g. “1”, “10A”, “1010b”, “-1”

See “ASTRAL RAF Sequence Maps”:http://astral.stanford.edu/raf.html

Dictionary protein_letters_3to1_extended provides a mapping from the 3-letter amino acid codes found in PDB files to 1-letter codes. The 3-letter codes include chemically modified residues.

Bio.SCOP.Raf.normalize_letters(one_letter_code)

  Convert RAF one-letter amino acid codes into IUPAC standard codes.

  Letters are uppercased, and “.” (“Unknown”) is converted to “X”.

class Bio.SCOP.Raf.SeqMapIndex(filename)

  Bases: `dict`

  An RAF file index.

  The RAF file itself is about 50 MB. This index provides rapid, random access of RAF records without having to load the entire file into memory.

  The index key is a concatenation of the PDB ID and chain ID. e.g “2drcA”, `"155c_"`. RAF uses an underscore to indicate blank chain IDs.

  __init__(filename)

    Initialize the RAF file index.

    Arguments:

      - filename – The file to index

  __getitem__(key)

    Return an item from the indexed file.

  getSeqMap(residues)

    Get the sequence map for a collection of residues.

    Arguments:

      - residues – A Residues instance, or a string that can be converted into a Residues instance.

  __annotate_func__ = None
  __annotations_cache__ = {}
  __firstlineno__ = 44
  __static_attributes__ = ('filename',)

class Bio.SCOP.Raf.SeqMap(line=None)

  Bases: `object`

  An ASTRAL RAF (Rapid Access Format) Sequence Map.

  This is a list like object; You can find the location of particular residues with index(), slice this SeqMap into fragments, and glue fragments back together with extend().

  Attributes:

    - pdbid – The PDB 4 character ID

    - pdb_datestamp – From the PDB file

    - version – The RAF format version. e.g. 0.01

    - flags – RAF flags. (See release notes for more information.)

    - res – A list of Res objects, one for each residue in this sequence map

  __init__(line=None)

    Initialize the class.

  index(resid, chainid='_')

    Return the index of the SeqMap for the given resid and chainid.

  __getitem__(index)

    Extract a single Res object from the SeqMap.

  append(res)

    Append another Res object onto the list of residue mappings.

  extend(other)

    Append another SeqMap onto the end of self.

    Both SeqMaps must have the same PDB ID, PDB datestamp and RAF version. The RAF flags are erased if they are inconsistent. This may happen when fragments are taken from different chains.

  __iadd__(other)

    In place addition of SeqMap objects.

  __add__(other)

    Addition of SeqMap objects.

  getAtoms(pdb_handle, out_handle)

    Extract all relevant ATOM and HETATOM records from a PDB file.

    The PDB file is scanned for ATOM and HETATOM records. If the chain ID, residue ID (seqNum and iCode), and residue type match a residue in this sequence map, then the record is echoed to the output handle.

    This is typically used to find the coordinates of a domain, or other residue subset.

    Arguments:

      - pdb_handle – A handle to the relevant PDB file.

      - out_handle – All output is written to this file like object.

  __annotate_func__ = None
  __annotations_cache__ = {}
  __firstlineno__ = 129
  __static_attributes__ = ('flags', 'pdb_datestamp', 'pdbid', 'res', 'version')

class Bio.SCOP.Raf.Res

  Bases: `object`

  A single residue mapping from a RAF record.

  Attributes:

    - chainid – A single character chain ID.

    - resid – The residue ID.

    - atom – amino acid one-letter code from ATOM records.

    - seqres – amino acid one-letter code from SEQRES records.

  __init__()

    Initialize the class.

  __annotate_func__ = None
  __annotations_cache__ = {}
  __firstlineno__ = 292
  __static_attributes__ = ('atom', 'chainid', 'resid', 'seqres')

Bio.SCOP.Raf.parse(handle)

  Iterate over RAF file, giving a SeqMap object for each line.

  Arguments:

    - handle – file-like object.

Biopython v: 1.86

Versions
  Previous
  Latest
  Develop

Biopython Project
  Homepage
  On GitHub