OOPLab3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "049bdc07",
   "metadata": {},
   "source": [
    "Add one more class called FileSequenceReader. The purpose of this class is to control how FASTA (and potentially other formats) files are read and converted into our SequenceRecord objects. A very large portion of this class will be the function you originally wrote back in OOP Lab 1, which read in the FASTA file and made your collection of SequenceRecord objects. \n",
    " \n",
    "\n",
    "Before you go copying and pasting that code into a method in your new class though, consider the following:\n",
    "\n",
    "Should that method be an instance, class, or static method?\n",
    "Does it make sense to create FileSequenceReader objects? If so, will it need instance variables?\n",
    "Does this class need class variables? What would those be?\n",
    "Can you think of any class or static method that would be helpful? Does it make sense for any of your other methods to be a part of this class instead of where you originally wrote them?\n",
    " \n",
    "\n",
    "Remember, there are no correct answers to these questions. You do, however, need to think them through and include your justification for how you've chosen to structure your classes in a Markdown cell. At minimum, this justification should include answers to each of these questions, but I highly recommend going into more detail.\n",
    " \n",
    "\n",
    "Finally, write a Markdown cell that explains how to use your classes. Put yourself in the shoes of someone who is coming in with a FASTA file, and wants to use your code to read and eventually analyze it. How does this person use what you've written to go from that starting point to usable objects? What is produced at each step? What attributes do your objects have? What are the things each object type can do, how do you use those methods, and what do they return if anything? Be comprehensive and carefully consider your formatting and presentation. Make good use of those options in Markdown cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "9eee23f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sequence class\n",
    "from functools import total_ordering\n",
    "\n",
    "@total_ordering\n",
    "class Sequence:\n",
    "\n",
    "    def __init__(self,seq):\n",
    "        valid_char = \"MFLCYWPHQRITNKSVADEG*\"\n",
    "        for i in range(len(seq)):\n",
    "            if seq[i] in valid_char:\n",
    "                continue\n",
    "            else:\n",
    "                raise ValueError(f'Error at position {i+1}')\n",
    "        self.seq = seq\n",
    "       \n",
    "    def __str__(self):\n",
    "        return self.seq\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'Sequence: {self.seq}'\n",
    "    \n",
    "    def __eq__(self,other): #this will only allow objects of the same class to be equal\n",
    "        if isinstance(other,DNAseq):\n",
    "            if isinstance(self,DNAseq) and self.seq == other.seq:\n",
    "                return True\n",
    "            else:\n",
    "                return False            \n",
    "        elif isinstance(other,ProteinSeq):\n",
    "            if isinstance(self,ProteinSeq) and self.seq == other.seq:\n",
    "                return True\n",
    "            else:\n",
    "                return False            \n",
    "        elif isinstance(other,Sequence):\n",
    "            if isinstance(self,DNAseq):\n",
    "                return False\n",
    "            elif isinstance(self,ProteinSeq):\n",
    "                return False\n",
    "            elif isinstance(self,Sequence) and self.seq == other.seq:\n",
    "                return True\n",
    "            else:\n",
    "                return False            \n",
    "        else:\n",
    "            return False\n",
    "        \n",
    "    def __add__(self,other): #this will only allow objects of the same class to be added to each other\n",
    "        if isinstance(other,DNAseq):\n",
    "            if isinstance(self,DNAseq):\n",
    "                return DNAseq(self.seq + other.seq)\n",
    "            else:\n",
    "                print(\"cannot add sequences of different classes\")\n",
    "                return False            \n",
    "        elif isinstance(other,ProteinSeq):\n",
    "            if isinstance(self,ProteinSeq):\n",
    "                return ProteinSeq(self.seq + other.seq)\n",
    "            else:\n",
    "                print(\"cannot add sequences of different classes\")\n",
    "                return False           \n",
    "        elif isinstance(other,Sequence):\n",
    "            if isinstance(self,Sequence):\n",
    "                return Sequence(self.seq + other.seq)\n",
    "            else:\n",
    "                print(\"cannot add sequences of different classes\")\n",
    "                return False           \n",
    "        else:\n",
    "            return False\n",
    "        \n",
    "    def __lt__(self,other):\n",
    "        if type(self.seq) == type(other.seq):\n",
    "            return len(self.seq) < len(other.seq)\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.seq)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "691ecac3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#DNA sequence class\n",
    "\n",
    "@total_ordering\n",
    "class DNAseq(Sequence):\n",
    "    \n",
    "    def __init__(self,seq):\n",
    "        valid_char = \"ATCG\"\n",
    "        for i in range(len(seq)):\n",
    "            if seq[i] in valid_char:\n",
    "                continue\n",
    "            else:\n",
    "                raise ValueError(f'Invalid base at position {i+1}')\n",
    "        super().__init__(seq)\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'DNA Sequence: {self.seq}'\n",
    "    \n",
    "    def translate_to_protein(self): #translates DNA to Amino Acids. Utilized last semester notes as an aid\n",
    "        aa_dict = {'M':['ATG'], 'F':['TTT', 'TTC'], 'L':['TTA', 'TTG', 'CTT', 'CTC', 'CTA', 'CTG'], 'C':['TGT', 'TGC'], 'Y':['TAC', 'TAT'], 'W':['TGG'], 'P':['CCT', 'CCC', 'CCA', 'CCG'], 'H':['CAT', 'CAC'], 'Q':['CAA', 'CAG'], 'R':['CGT', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG'], 'I':['ATT', 'ATC', 'ATA'], 'T':['ACT', 'ACC', 'ACA', 'ACG'], 'N':['AAT', 'AAC'], 'K':['AAA', 'AAG'], 'S':['AGT', 'AGC', 'TCT', 'TCC', 'TCA', 'TCG'], 'V':['GTT', 'GTC', 'GTA', 'GTG'], 'A':['GCT', 'GCC', 'GCA', 'GCG'], 'D':['GAT', 'GAC'], 'E':['GAA', 'GAG'], 'G':['GGT', 'GGC', 'GGA', 'GGG'], '*':['TAA','TAG','TGA']}\n",
    "        protein_seq = \"\"\n",
    "        for i in range(0,len(self.seq),3):\n",
    "            codon = self.seq[i:i+3]\n",
    "            for aa,codons in aa_dict.items():\n",
    "                if codon in codons:\n",
    "                    protein_seq += aa\n",
    "                    \n",
    "        return ProteinSeq(protein_seq)\n",
    "    \n",
    "    def __GC_content__(self): #produces the proportion of the sequence that is G and C base pairs\n",
    "        GC_count = 0\n",
    "        for base in self.seq:\n",
    "            if base == \"G\" or base == \"C\":\n",
    "                GC_count += 1\n",
    "            else:\n",
    "                continue\n",
    "        proportionGC = GC_count/len(self.seq)\n",
    "        return proportionGC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "830b8304",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Protein Sequence Class\n",
    "\n",
    "@total_ordering\n",
    "class ProteinSeq(Sequence):\n",
    "    \n",
    "    def __init__(self,seq):        \n",
    "        valid_char = \"MFLCYWPHQRITNKSVADEG*\"\n",
    "        for i in range(len(seq)):\n",
    "            if seq[i] in valid_char:\n",
    "                continue\n",
    "            else:\n",
    "                raise ValueError(f'Invalid Amino Acid at position {i+1}')\n",
    "        super().__init__(seq)\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'Protein Sequence: {self.seq}'\n",
    "    \n",
    "    def __highest_AA_content__(self): #returns the amino acid found most in the sequence\n",
    "        aa_counter = {}\n",
    "        aa_highest = []\n",
    "        for aa in self.seq:\n",
    "            if aa in aa_counter.keys():\n",
    "                aa_counter[aa] += 1\n",
    "            else:\n",
    "                aa_counter[aa] = 1\n",
    "        highest_value = max(aa_counter.values())\n",
    "        for aa,value in aa_counter.items():\n",
    "            if value == highest_value:\n",
    "                aa_highest.append(aa)\n",
    "            \n",
    "        return aa_highest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "21adf790",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SequenceRecord class \n",
    "from functools import total_ordering\n",
    "\n",
    "@total_ordering\n",
    "class SequenceRecord:\n",
    "\n",
    "    def __init__(self,title,*args):\n",
    "        self.title = title\n",
    "        for seq in args:\n",
    "            if isinstance(seq,Sequence):\n",
    "                self.sequence = seq\n",
    "            elif isinstance(seq,str):\n",
    "                new_seq = Sequence(seq)\n",
    "                self.sequence = new_seq\n",
    "  \n",
    "    def __str__(self):\n",
    "        return str(self.title)+ \"\\n\" + str(self.sequence)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'{self.title}: {self.sequence}'\n",
    "    \n",
    "    def __eq__(self,other):\n",
    "        if self.sequence == other.sequence:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    \n",
    "    def __lt__(self,other):\n",
    "        return len(self.sequence) < len(other.sequence)\n",
    "    \n",
    "    def __gt__(self,other):\n",
    "        return len(self.sequence) > len(other.sequence)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "5f50d7a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#FileSequenceReader Class\n",
    "\n",
    "class FileSequenceReader:\n",
    "    \n",
    "    def __init__(self,file):\n",
    "        self.file = file\n",
    "              \n",
    "    def __Fasta__(self):\n",
    "        name = None\n",
    "        seq = \"\"\n",
    "        with open(str(self.file)) as fh:\n",
    "            for line in fh:\n",
    "                line = line.rstrip()\n",
    "                if line.startswith(\">\"):\n",
    "                    if name:\n",
    "                        record = SequenceRecord(name,seq)\n",
    "                        yield record\n",
    "                    name = line\n",
    "                    seq = \"\"\n",
    "                else:\n",
    "                    seq += line\n",
    "            if name:\n",
    "                record = SequenceRecord(name,seq)\n",
    "                yield record\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "d98be6b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.FileSequenceReader object at 0x7fe6508db190>\n",
      "<generator object FileSequenceReader.__Fasta__ at 0x7fe6100c1040>\n",
      ">NC_000913.3:1368079-1368747 Escherichia coli str. K-12 substr. MG1655, complete genome\n",
      "ATGGGTATTTTTTCTCGCTTTGCCGACATCGTGAATGCCAACATCAACGCTCTGTTAGAGAAAGCGGAAGATCCACAGAAACTGGTTCGTCTGATGATCCAGGAGATGGAAGATACACTGGTTGAAGTACGTTCTACTTCGGCGCGCGCGTTGGCAGAAAAGAAACAGCTGACTCGCCGTATTGAACAAGCGTCGGCGCGTGAGGTTGAATGGCAGGAAAAAGCCGAACTGGCGCTGCTGAAAGAGAGAGAGGATCTGGCACGTGCAGCGTTAATTGAAAAACAGAAACTGACCGATCTGATTAAGTCCCTGGAACATGAAGTGACGCTGGTGGACGATACGCTGGCACGCATGAAGAAAGAGATTGGCGAGCTGGAAAACAAATTGAGCGAAACACGCGCTCGCCAGCAGGCATTGATGTTACGTCATCAGGCGGCAAACTCGTCGCGCGATGTGCGTCGTCAGCTGGACAGTGGCAAACTGGATGAAGCAATGGCTCGTTTCGAATCTTTCGAACGTCGTATTGACCAGATGGAAGCGGAAGCAGAAAGCCACAGCTTCGGTAAACAAAAATCGCTGGACGATCAGTTTGCCGAACTGAAAGCCGATGATGCAATCAGCGAACAACTGGCACAATTAAAAGCCAAAATGAAGCAAGACAATCAATAA\n",
      ">NC_000913.3:167484-169727 Escherichia coli str. K-12 substr. MG1655, complete genome\n",
      "ATGGCGCGTTCCAAAACTGCTCAGCCAAAACACTCACTGCGTAAAATCGCAGTTGTAGTAGCCACAGCGGTTAGCGGCATGTCTGTTTATGCACAGGCAGCGGTTGAACCGAAAGAAGACACTATCACCGTTACCGCTGCACCTGCGCCGCAAGAAAGCGCATGGGGGCCTGCTGCAACTATTGCGGCGCGACAGTCTGCTACCGGCACTAAAACCGATACGCCGATTCAAAAAGTGCCACAGTCTATTTCTGTTGTGACCGCCGAAGAGATGGCGCTGCATCAGCCGAAGTCGGTAAAAGAAGCGCTTAGCTACACGCCGGGTGTCTCTGTTGGTACGCGTGGCGCATCCAACACCTATGACCACCTGATCATTCGCGGCTTTGCGGCAGAAGGCCAAAGCCAGAATAACTATCTGAATGGCCTGAAGTTGCAGGGCAACTTCTATAACGATGCGGTCATTGACCCGTATATGCTGGAACGCGCTGAAATTATGCGTGGCCCGGTTTCCGTGCTTTACGGTAAAAGCAGTCCTGGCGGCCTGTTGAATATGGTCAGCAAGCGTCCGACCACCGAACCGCTGAAAGAAGTTCAGTTTAAAGCCGGTACTGACAGCCTGTTCCAGACTGGTTTTGACTTTAGCGATTCGTTGGATGATGACGGTGTTTACTCTTATCGCCTGACCGGTCTTGCGCGTTCTGCCAATGCCCAGCAGAAAGGGTCAGAAGAGCAGCGTTATGCTATTGCACCGGCGTTCACCTGGCGTCCGGATGATAAAACCAATTTTACCTTCCTTTCTTACTTCCAGAACGAGCCGGAAACCGGTTATTACGGCTGGTTGCCGAAAGAGGGAACCGTTGAGCCGCTGCCGAACGGTAAGCGTCTGCCGACAGACTTTAATGAAGGGGCGAAGAACAACACCTATTCTCGTAATGAGAAGATGGTCGGCTACAGCTTCGATCACGAATTTAACGACACCTTTACTGTGCGTCAGAACCTGCGCTTTGCTGAAAACAAAACCTCGCAAAACAGCGTTTATGGTTACGGCGTCTGCTCCGATCCGGCGAATGCTTACAGCAAACAGTGTGCGGCATTAGCGCCAGCGGATAAAGGCCATTATCTGGCACGTAAATACGTCGTTGATGATGAGAAGCTGCAAAACTTCTCCGTTGATACCCAGTTGCAGAGCAAGTTTGCCACTGGCGATATCGACCACACCCTGCTGACCGGTGTCGACTTTATGCGTATGCGTAATGACATCAACGCCTGGTTTGGTTACGACGACTCTGTGCCACTGCTCAATCTGTACAATCCGGTGAATACCGATTTCGACTTCAATGCCAAAGATCCGGCAAACTCCGGCCCTTACCGCATTCTGAATAAACAGAAACAAACGGGCGTTTATGTTCAGGATCAGGCGCAGTGGGATAAAGTGCTGGTCACCCTAGGCGGTCGTTATGACTGGGCAGATCAAGAATCTCTTAACCGCGTTGCCGGGACGACCGATAAACGTGATGACAAACAGTTTACCTGGCGTGGTGGTGTTAACTACCTGTTTGATAATGGTGTAACACCTTACTTCAGCTATAGCGAATCGTTTGAACCTTCTTCGCAAGTTGGGAAGGATGGTAATATTTTCGCACCGTCTAAAGGTAAGCAGTATGAAGTCGGCGTGAAATATGTACCGGAAGATCGTCCGATTGTAGTTACTGGTGCCGTGTATAATCTCACTAAAACCAACAACCTGATGGCGGACCCTGAGGGTTCCTTCTTCTCGGTTGAAGGTGGCGAGATCCGCGCACGTGGCGTAGAAATCGAAGCGAAAGCGGCGCTGTCGGCGAGTGTTAACGTAGTCGGTTCTTATACTTACACCGATGCGGAATACACCACCGATACTACCTATAAAGGCAATACGCCTGCACAGGTGCCAAAACACATGGCTTCGTTGTGGGCTGACTACACCTTCTTTGACGGTCCGCTTTCAGGTCTGACGCTGGGCACCGGTGGTCGTTATACTGGCTCCAGTTATGGTGATCCGGCTAACTCCTTTAAAGTGGGAAGTTATACGGTCGTGGATGCGTTAGTACGTTATGATCTGGCGCGAGTCGGCATGGCTGGCTCCAACGTGGCGCTGCATGTTAACAACCTGTTCGATCGTGAATACGTCGCCAGCTGCTTTAACACTTATGGCTGCTTCTGGGGCGCAGAACGTCAGGTCGTTGCAACCGCAACCTTCCGTTTCTAA\n",
      ">NC_000913.3:4247971-4249311 Escherichia coli str. K-12 substr. MG1655, complete genome\n",
      "ATGATGATTACTCTGCGCAAACTTCCTCTGGCGGTTGCCGTCGCAGCGGGCGTAATGTCTGCTCAGGCAATGGCTGTTGATTTCCACGGCTATGCACGTTCCGGTATTGGTTGGACAGGTAGCGGCGGTGAACAACAGTGTTTCCAGACTACCGGTGCTCAAAGTAAATACCGTCTTGGCAACGAATGTGAAACTTATGCTGAATTAAAATTGGGTCAGGAAGTGTGGAAAGAGGGCGATAAGAGCTTCTATTTCGACACTAACGTGGCCTATTCCGTCGCACAACAGAATGACTGGGAAGCTACCGATCCGGCCTTCCGTGAAGCAAACGTGCAGGGTAAAAACCTGATCGAATGGCTGCCAGGCTCCACCATCTGGGCAGGTAAGCGCTTCTACCAACGTCATGACGTTCATATGATCGACTTCTACTACTGGGATATTTCTGGTCCTGGTGCCGGTCTGGAAAACATCGATGTTGGCTTCGGTAAACTCTCTCTGGCAGCAACCCGCTCCTCTGAAGCTGGTGGTTCTTCCTCTTTCGCCAGCAACAATATTTATGACTATACCAACGAAACCGCGAACGACGTTTTCGATGTGCGTTTAGCGCAGATGGAAATCAACCCGGGCGGCACATTAGAACTGGGTGTCGACTACGGTCGTGCCAACTTGCGTGATAACTATCGTCTGGTTGATGGCGCATCGAAAGACGGCTGGTTATTCACTGCTGAACATACTCAGAGTGTCCTGAAGGGCTTTAACAAGTTTGTTGTTCAGTACGCTACTGACTCGATGACCTCGCAGGGTAAAGGGCTGTCGCAGGGTTCTGGCGTTGCATTTGATAACGAAAAATTTGCCTACAATATCAACAACAACGGTCACATGCTGCGTATCCTCGACCACGGTGCGATCTCCATGGGCGACAACTGGGACATGATGTACGTGGGTATGTACCAGGATATCAACTGGGATAACGACAACGGCACCAAGTGGTGGACCGTCGGTATTCGCCCGATGTACAAGTGGACGCCAATCATGAGCACCGTGATGGAAATCGGCTACGACAACGTCGAATCCCAGCGCACCGGCGACAAGAACAATCAGTACAAAATTACCCTCGCACAACAATGGCAGGCTGGCGACAGCATCTGGTCACGCCCGGCTATTCGTGTCTTCGCAACCTACGCCAAGTGGGATGAGAAATGGGGTTACGACTACACCGGTAACGCTGATAACAACGCGAACTTCGGCAAAGCCGTTCCTGCTGATTTCAACGGCGGCAGCTTCGGTCGTGGCGACAGCGACGAGTGGACCTTCGGTGCCCAGATGGAAATCTGGTGGTAA\n",
      "<class '__main__.SequenceRecord'>\n",
      "<class '__main__.SequenceRecord'>\n",
      "<class '__main__.SequenceRecord'>\n",
      "<class '__main__.Sequence'>\n",
      "<class '__main__.Sequence'>\n",
      "<class '__main__.Sequence'>\n"
     ]
    }
   ],
   "source": [
    "try1 = FileSequenceReader(\"OOPlab1.fasta\")\n",
    "print(try1)\n",
    "print(try1.__Fasta__())\n",
    "for record in try1.__Fasta__():\n",
    "    print(record)\n",
    "for record in try1.__Fasta__():\n",
    "    print(type(record))\n",
    "for record in try1.__Fasta__():\n",
    "    print(type(record.sequence))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4451b6bf",
   "metadata": {},
   "source": [
    "Questions:\n",
    "\n",
    "- Should that method be an instance, class, or static method?\n",
    "The method should be a class method because a static method cannot access the instance variables and an instance method would be defined in __init__ \n",
    "\n",
    "- Does it make sense to create FileSequenceReader objects? If so, will it need instance variables?\n",
    "It could make sense to make reader objects and yes it would need instance variables in that case, but I chose not to because it might make more sense in the future to have child classes for different types of files, and a file reader generator as the parent class (would have to move the current generator to new class and put a generic line by line reader as the parent class). That's what I would do.\n",
    "\n",
    "- Does this class need class variables? What would those be?\n",
    "This class didn't need class variables. One could be added to describe the parser generator though. I did not have time to add this.\n",
    "\n",
    "- Can you think of any class or static method that would be helpful? Does it make sense for any of your other methods to be a part of this class instead of where you originally wrote them?\n",
    "Another helpful method would be a way to read the file without having to write a generator. I couldn't figure this out though, because I could make another method with print() instead of yield and that kind of worked, so I think something there would be beneficial. I think it would make sense to check the proper characters, but when it gets sent through the other classes that gets checked anyways, so I don't think it is necessary. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82886504",
   "metadata": {},
   "source": [
    "How To Use My Code:\n",
    "\n",
    "1. Sequence Class\n",
    "To use the Sequence Class you need a string (initialized by \"\") with only the following characters: MFLCYWPHQRITNKSVADEG*. To put your string through the sequence class you can call it using Sequence(yourString). \n",
    "There are some commands you can use if you set yourVariable = Sequence(yourString):\n",
    "type(yourVariable) #should return Sequence type object\n",
    "yourVariable.__str__() #returns sequence as a string\n",
    "yourVariable.__repr__() #returns sequence with a header of \"Sequence: \"\n",
    "yourVariable.__len__() #returns length of the sequence\n",
    "yourVariable.__add__(yourVariable2) #adds two sequences to each other\n",
    "\n",
    "2. DNA Sequence Class\n",
    "To use the DNA Sequence Class you need a string (initialized by \"\") with only the following characters: ATCG. To put your string through the DNA sequence class you can call it using DNAseq(yourString).There are some commands you can use if you set yourVariable = DNAseq(yourString): \n",
    "type(yourVariable) #should return DNASeq type object\n",
    "yourVariable.__str__() #returns sequence as a string\n",
    "yourVariable.__repr__() #returns sequence with a header of \"DNA Sequence: \"\n",
    "yourVariable.__len__() #returns length of the sequence\n",
    "yourVariable.__translate_to_protein__() #returns the corresponding protein sequence\n",
    "yourVariable.__GC_content__() #returns GC content of your sequence\n",
    "\n",
    "3. Protein Seq Class\n",
    "To use the Protein Sequence Class you need a string (initialized by \"\") with only the following characters: MFLCYWPHQRITNKSVADEG*. To put your string through the sequence class you can call it using ProteinSeq(yourString). There are some commands you can use if you set yourVariable = ProteinSeq(yourString):\n",
    "type(yourVariable) #should return ProteinSeq type object\n",
    "yourVariable.__str__() #returns sequence as a string\n",
    "yourVariable.__repr__() #returns sequence with a header of \"Protein Sequence: \"\n",
    "yourVariable.__len__() #returns length of the sequence\n",
    "yourVariable.__highest_AA_content__() #returns which amino acids are in the sequence the most\n",
    "\n",
    "4. Sequence Record Class\n",
    "To use the Sequence Record Class you need two strings (initialized by \"\"), one with the header and the other with the corresponding sequence. The sequence string can only contain the following characters: MFLCYWPHQRITNKSVADEG*. To put your strings in the sequence record class you can call it using SequenceRecord(header,sequence).There are some commands you can use if you set yourVariable = SequenceRecord(header,sequence):\n",
    "type(yourVariable) #should return SequenceRecord type object\n",
    "yourVariable.__str__() #returns header then the corresponding sequence on a new line\n",
    "yourVariable.__repr__() #returns header: sequence\n",
    "\n",
    "5. File Sequence Reader Class\n",
    "To use the File Sequence Reader Class you need a fasta file (a header line beginning with '>' and the next line containing sequence, in this pattern for the whole file). To put your file in the file sequence reader class you can call it using FileSequenceReader(\"yourfilename.fasta\").There are some commands you can use if you set yourVariable = FileSequenceReader(\"yourfilename.fasta\"):\n",
    "type(yourVariable) #should return FileSequenceReader type object\n",
    "for record in yourVariable.__Fasta__():\n",
    "    print(record) #returns the fasta file, with any new line characters removed\n",
    "for record in try1.__Fasta__():\n",
    "    print(type(record)) #should return SequenceRecord object for each iteration\n",
    "for record in try1.__Fasta__():\n",
    "    print(type(record.sequence)) #should return a Sequence object for each iteration"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}