notebooks/01_2_Trivial_Compression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.2 Trivial compression\n",
    "\n",
    "***\n",
    "\n",
    "### Python Bitwise Operators Review\n",
    "\n",
    "OPERATOR | DESCRIPTION  | SYNTAX\n",
    "---|---|---\n",
    "&  | AND |x & y\n",
    "\\| | OR | x \\| y\n",
    "~ | NOT | ~x\n",
    "^ | XOR | x ^ y\n",
    "\\>> | right shift | x>>\n",
    "<< | left shift\t| x<<\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 10 and binary(a) = 0b1010\n",
      "b = 5 and binary(b) = 0b101\n"
     ]
    }
   ],
   "source": [
    "a = 10 \n",
    "b = 5\n",
    "print(f\"a = {a} and binary(a) = {bin(a)}\")\n",
    "print(f\"b = {b} and binary(b) = {bin(b)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$a= 1010$\n",
    "\n",
    "$b= 0101$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a & b = 0 and binary(a & b) = 0b0\n"
     ]
    }
   ],
   "source": [
    "# Bitwise AND operator & \n",
    "print(f\"a & b = {a & b} and binary(a & b) = {bin(a & b)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$a= 1010$\n",
    "\n",
    "$\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\&$  AND\n",
    "\n",
    "$b= 0101$\n",
    "\n",
    "$r=  0000$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a | b = 15 and binary(a | b) = 0b1111\n"
     ]
    }
   ],
   "source": [
    "# Bitwise OR operator |\n",
    "print(f\"a | b = {a | b} and binary(a | b) = {bin(a | b)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$a= 1010$\n",
    "\n",
    "$\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ |$   OR\n",
    "\n",
    "$b= 0101$\n",
    "\n",
    "$r=  1111$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 9 and binary(x) = 0b1001\n",
      "y = 7 and binary(y) = 0b111\n"
     ]
    }
   ],
   "source": [
    "x = 9\n",
    "y = 7\n",
    "print(f\"x = {x} and binary(x) = {bin(x)}\")\n",
    "print(f\"y = {y} and binary(y) = {bin(y)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$x= 1001$\n",
    "\n",
    "$y= 0111$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x ^ y = 14 and binary(x ^ y) = 0b1110\n"
     ]
    }
   ],
   "source": [
    "# Bitwise XOR operator ^ \n",
    "print(f\"x ^ y = {x ^ y} and binary(x ^ y) = {bin(x ^ y)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$x= 1001$\n",
    "\n",
    "          ^  XOR\n",
    "\n",
    "$y= 0111$\n",
    "\n",
    "$r=  1110$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 9 and binary(x) = 0b1001\n",
      "~x = -10 and binary(~x) = -0b1010\n"
     ]
    }
   ],
   "source": [
    "# Bitwise NOT operator ~\n",
    "print(f\"x = {x} and binary(x) = {bin(x)}\")\n",
    "print(f\"~x = {~x} and binary(~x) = {bin(~x)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$x= 1001$\n",
    "\n",
    "$\\sim x=1010$ !!! Why we got  ```1010``` istead of ```110```?\n",
    "\n",
    "How to fix this problem we can use ~ with & to prevent this problem "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 9 and binary(x) = 0b1001\n",
      "x << 1 = 18 and binary(x << 1) = 0b10010\n",
      "x << 2 = 36 and binary(x << 2) = 0b100100\n",
      "x << 3 = 72 and binary(x << 3) = 0b1001000\n",
      "x << 4 = 144 and binary(x << 4) = 0b10010000\n"
     ]
    }
   ],
   "source": [
    "# Bitwise left shift operator << \n",
    "print(f\"x = {x} and binary(x) = {bin(x)}\")\n",
    "print(f\"x << 1 = {x << 1} and binary(x << 1) = {bin(x << 1)}\")\n",
    "print(f\"x << 2 = {x << 2} and binary(x << 2) = {bin(x << 2)}\")\n",
    "print(f\"x << 3 = {x << 3} and binary(x << 3) = {bin(x << 3)}\")\n",
    "print(f\"x << 4 = {x << 4} and binary(x << 4) = {bin(x << 4)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 9 and binary(x) = 0b1001\n",
      "x >> 1 = 4 and binary(x >> 1) = 0b100\n",
      "x >> 2 = 2 and binary(x >> 2) = 0b10\n",
      "x >> 3 = 1 and binary(x >> 3) = 0b1\n",
      "x >> 4 = 0 and binary(x >> 4) = 0b0\n"
     ]
    }
   ],
   "source": [
    "# Bitwise right shift operator >> \n",
    "print(f\"x = {x} and binary(x) = {bin(x)}\")\n",
    "print(f\"x >> 1 = {x >> 1} and binary(x >> 1) = {bin(x >> 1)}\")\n",
    "print(f\"x >> 2 = {x >> 2} and binary(x >> 2) = {bin(x >> 2)}\")\n",
    "print(f\"x >> 3 = {x >> 3} and binary(x >> 3) = {bin(x >> 3)}\")\n",
    "print(f\"x >> 4 = {x >> 4} and binary(x >> 4) = {bin(x >> 4)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The right shift operator acts like floor division operator //\n",
    "\n",
    "$x >> n = \\lfloor \\frac{x}{2^n} \\rfloor$\n",
    "\n",
    "$ x = 9\\ \\ \\ \\ {(1001)}_2 $\n",
    "\n",
    "$x >> 1 = \\lfloor \\frac{9}{2^1} \\rfloor = 4 = {(100)}_2$\n",
    "\n",
    "$x >> 2 = \\lfloor \\frac{9}{2^2} \\rfloor = 2 = {(10)}_2$\n",
    "\n",
    "$x >> 3 = \\lfloor \\frac{9}{2^3} \\rfloor = 1 = {(1)}_2$\n",
    "\n",
    "$x >> 4 = \\lfloor \\frac{9}{2^4} \\rfloor = 0 = {(0)}_2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Trivial compression\n",
    "In this section, we want to convert the DNA strand to bits(0 and 1) To reduce the amount of memory used. As you know, the DNA strand consists of 4 bases: **A**, **C**, **G**, and **T**, which can be mapped with two bits.  \n",
    "* **A**: 00\n",
    "* **C**: 01\n",
    "* **G**: 10\n",
    "* **T**: 11\n",
    "\n",
    "So we write a class that does this conversion. \n",
    "\n",
    "We have also stored a piece of human DNA in a file that is responsible for encoding **Homo sapiens beta globin chain gene**. \n",
    "\n",
    "Source: https://www.ncbi.nlm.nih.gov/nuccore/AY260740.1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original DNA: GGTATGGGGCCAAGAGATATATCTTAGAGGGAGGGCTGAGGGTTTGAAGTCCAACTCCTAAGCCAGTGCCAGAAGAGCCAAGGACAGGTACGGCTGTCATCACTTAGACCTCACCCTGTGGAGCCATACCCTAGGGTTGGCCAATCTACTCCCAGGAGCAGGGAGGGCAGGAGCCAGGGCTGGGCATAAAAGTCAGGGCAGAGCCATCTATTGCTTACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCACCTGACTCCTGAGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGTTGGTATCAAGGTTACAAGACAGGTTTAAGGAGACCAATAGAAACTGGGCATGTGGAGACAGAGAAGACTCTTGGGTTTCTGATAGGCACTGACTCTCTCTGCCTATTGGTCTATTTTCCCACCCTTAGGCTGCTGGTGGTCTACCCTTGGACCCAGAGGTTCTTTGAGTCCTTTGGGGATCTGTCCACTCCTGATGCTGTTATGGGCAACCCTAAGGTGAAGGCTCATGGCAAGAAAGTGCTCGGTGCCTTTAGTGATGGCCTGGCTCACCTGGACAACCTCAAGGGCACCTTTGCCACACTGAGTGAGCTGCACTGTGACAAGCTGCACGTGGATCCTGAGAACTTCAGGGTGAGTCTATGGGACCCTTGATGTTTTCTTTCCCCTTCTTTTCTATGGTTAAGTTCATGTCATAGGAAGGGGAGAAGTAACAGGGTACAGTTTAGAATGGGAAACAGACGAATGATTGCATCAGTGTGGAAGTCTCAGGATCGTTTTAGTTTCTTTTATTTGCTGTTCATAACAATTGTTTTCTTTTGTTTAATTCTTGCTTTCTTTTTTTTTCTTCTCCGCAATTTTTACTATTATACTTAATGCCTTAACATTGTGTATAACAAAAGGAAATATCTCTGAGATACATTAAGTAACTTAAAAAAAAACTTTACACAGTCTGCCTAGTACATTACTATTTGGAATATATGTGTGCTTATTTGCATATTCATAATCTCCCTACTTTATTTTCTTTTATTTTTAATTGATACATAATCATTATACATATTTATGGGTTAAAGTGTAATGTTTTAATATGTGTACACATATTGACCAAATCAGGGTAATTTTGCATTTGTAATTTTAAAAAATGCTTTCTTCTTTTAATATACTTTTTTGTTTATCTTATTTCTAATACTTTCCCTAATCTCTTTCTTTCAGGGCAATAATGATACAATGTATCATGCCTCTTTGCACCATTCTAAAGAATAACAGTGATAATTTCTGGGTTAAGGCAATAGCAATATTTCTGCATATAAATATTTCTGCATATAAATTGTAACTGATGTAAGAGGTTTCATATTGCTAATAGCAGCTACAATCCAGCTACCATTCTGCTTTTATTTTATGGTTGGGATAAGGCTGGATTATTCTGAGTCCAAGCTAGGCCCTTTTGCTAATCATGTTCATACCTCTTATCTTCCTCCCACAGCTCCTGGGCAACGTGCTGGTCTGTGTGCTGGCCCATCACTTTGGCAAAGAATTCACCCCACCAGTGCAGGCTGCCTATCAGAAAGTGGTGGCTGGTGTGGCTAATGCCCTGGCCCACAAGTATCACTAAGCTCGCTTTCTTGCTGTCCAATTTCTATTAAAGGTTCCTTTGTTCCCTAAGTCCAACTACTAAACTGGGGGATATTATGAAGGGCCTTGAGCATCTGGATTCTGCCTAATAAAAAACATTTATTTTCATTGCAATGATGTATTTAAATTATTTCTGAATATTTTACTAAAAAGGGAATGTGGGAGGTCAGTGCATTTAAAACATAAAGAAATGAAGAGCTAGTTCAAACC\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# >AY260740.1 Homo sapiens beta globin chain gene, complete cds\n",
    "# Reading dataset from file and store it into dna\n",
    "with open(\"../data/beta_globin_chain_gene.txt\", \"r\") as f:\n",
    "    original_dna = \"\".join([line.rstrip(\"\\n\") for line in f.readlines()])\n",
    "# show the original dna\n",
    "print(f\"Original DNA: {original_dna}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of original DNA: 1969 bytes\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "print(f\"Size of original DNA: {sys.getsizeof(original_dna)} bytes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert the dna into binary format \n",
    "class CompressedDNA:\n",
    "    def __init__(self: object, dna: str) -> None:\n",
    "        self.dna = dna.upper() # convert dna to uppercase \n",
    "        self._compress(dna) # compress the dna to binary format\n",
    "    \n",
    "    def _compress(self: object, dna: str) -> None:\n",
    "        nt2bin = {\"A\": 0b00, \"C\": 0b01, \"G\": 0b10, \"T\": 0b11}\n",
    "        self.binary: int = 0\n",
    "        for nt in dna:\n",
    "            self.binary <<= 2 # shift the binary to left by 2 bits\n",
    "            if nt in nt2bin:\n",
    "                self.binary |= nt2bin[nt] # or the binary with the nt2bin\n",
    "            else:\n",
    "                raise(ValueError(f\"Invalid DNA Nucleotide: {nt}\"))\n",
    "\n",
    "    def decompress(self: object) -> str:\n",
    "        bin2nt = {0b00: \"A\", 0b01: \"C\", 0b10: \"G\", 0b11: \"T\"}\n",
    "        decompress_dna = \"\"\n",
    "        bits = self.binary\n",
    "        while bits != 0: # while bits is not empty do the following\n",
    "            bit = bits & 0b11 # get the last 2 bits\n",
    "            decompress_dna += bin2nt[bit] # append the nt to the decompress_dna\n",
    "            bits >>= 2 # shift the binary to right by 2 bits\n",
    "        return decompress_dna[::-1] # return the reverse of decompress_dna\n",
    "    \n",
    "    def __repr__(self) -> str:\n",
    "        return f'{__class__.__name__}(\"{self.dna}\")'\n",
    "    \n",
    "    def __str__(self) -> str:\n",
    "        return self.decompress()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of Compressed DNA: 536 bytes\n",
      "Size of original DNA: 1969 bytes\n",
      "72.78% reduction in size\n"
     ]
    }
   ],
   "source": [
    "compressed_dna = CompressedDNA(original_dna)\n",
    "c_dna_size = sys.getsizeof(compressed_dna.binary) # get the size of compressed_dna\n",
    "o_dna_size = sys.getsizeof(original_dna) # get the size of original_dna\n",
    "print(f\"Size of Compressed DNA: {c_dna_size} bytes\")\n",
    "print(f\"Size of original DNA: {o_dna_size} bytes\")\n",
    "print(f\"{((o_dna_size-c_dna_size)/o_dna_size)*100:.2f}% reduction in size\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check if the compressed_dna is equal to original_dna\n",
    "compressed_dna.decompress() == original_dna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b101011001110101010010100001000100011001100110111110010001010100010101001111000101010111111100000101101010000011101011100001001010010111001010010000010001001010000101000010010101100011010011110110100110100011111001000010111010001010111101110100010010100110001010111001010101111101001010000110111000111010101001010001001001010100010101001001010001001010010101001111010100100110000000010110100101010010010001001010011011100111110011111000100111111100111110111100001000100000111101110111101000111001001000001011101000000010010000100010100111010111001000101111000011101011110001010001000001011011110010110111100011110010101111011101010100100001010111000000110111010001110000010111110101110101110001010010101111010100100101011111010110011010000101011110001000010000100101011111100001010001000010100001100100000000111101010010011101110100010000100100010000010000111011111101010111111011110001100101001000111100001110111011101111001011100111110101101110011111111010101000101011111001010011110011110101110101101110001010111111010000101010010001010111101111111100010110101111111101010100011011110110101000111010111100011100111101111001110101001000001010111000010101110000010100111010011101001000010000000101110011101101011100101111111001011100011101001011110100111010001011110100001000001011101000010101001000101111111100101000100011110001011100010011110010001111011100001000010011110010001101110100011010111100010000001111101001010101110001011011100111010100001010111111000111011111111011111110101010111110111111111011100111010111100001011110100111011010011001010000010101010001000001011000001001010101100010010111111001000001110101000000001001000011000001110001111100100110100101110111010000010110111010010100011011011111111001011111101111111110011111110011110111101001100000100001111101111111101111111111011111100001111011111100111111101111111111111111111011111011101011001000011111111110001110011110011000111110000111001011111000001001111101110110011000001000000001010000000110011011101111000100011000100111100001011000001111100000000000000000001111111000100010010110111100101110010110001001111000111001111111010000011001100111011101110011111001111111001001100111101001100001101110101011100011111110011111111011111111100111111111100001111100011000100110000110100111100110001001100111111001110101011110000001011101100001110111111110000110011101110110001000100110011111000010100000011010010101011000011111111100100111111101100001111111100000000000011100111111101111101111111110000110011000111111111111110111111001101111100111111011100001100011111110101011100001101110111111101111111010010101001000011000011100011000100001110110011010011100101110111111110010001010011110111000000100000110000010010111000110000111111011110101011110000101001000011001001000011001111110111100100110011000000110011111101111001001100110000001111101100000111100011101100001000101011111101001100111110011100001100100100100111000100001101010010011100010100111101111001111111110011111111001110101111101010001100001010011110100011110011110111100010110101000010011100101001010111111111100111000011010011101111010011000101110111110011011111010111010101000100100111010111101010010000011011100111101011011110111011100111101001010100110100011111111010010000001000001111010001010101000101001011100100101001111001011100110100100000001011101011101001111010111011101001110000111001010111101001010100010000101100110100011100001001110110011111110111111001111011010100001111110111001111000000101011110101111111101111010101110000101101010000011100011100000001111010101010001100111100111000001010100101111110001001001101111010001111011110010111000011000000000000010011111100111111110100111110010000111000111011001111110000001111001111110111100000110011111111000111000000000010101000001110111010100010101101001011100100111111000000000100110000001000000011100000100010011100101111010000000101'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the compressed_dna binary\n",
    "bin(compressed_dna.binary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GGTATGGGGCCAAGAGATATATCTTAGAGGGAGGGCTGAGGGTTTGAAGTCCAACTCCTAAGCCAGTGCCAGAAGAGCCAAGGACAGGTACGGCTGTCATCACTTAGACCTCACCCTGTGGAGCCATACCCTAGGGTTGGCCAATCTACTCCCAGGAGCAGGGAGGGCAGGAGCCAGGGCTGGGCATAAAAGTCAGGGCAGAGCCATCTATTGCTTACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCACCTGACTCCTGAGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGTTGGTATCAAGGTTACAAGACAGGTTTAAGGAGACCAATAGAAACTGGGCATGTGGAGACAGAGAAGACTCTTGGGTTTCTGATAGGCACTGACTCTCTCTGCCTATTGGTCTATTTTCCCACCCTTAGGCTGCTGGTGGTCTACCCTTGGACCCAGAGGTTCTTTGAGTCCTTTGGGGATCTGTCCACTCCTGATGCTGTTATGGGCAACCCTAAGGTGAAGGCTCATGGCAAGAAAGTGCTCGGTGCCTTTAGTGATGGCCTGGCTCACCTGGACAACCTCAAGGGCACCTTTGCCACACTGAGTGAGCTGCACTGTGACAAGCTGCACGTGGATCCTGAGAACTTCAGGGTGAGTCTATGGGACCCTTGATGTTTTCTTTCCCCTTCTTTTCTATGGTTAAGTTCATGTCATAGGAAGGGGAGAAGTAACAGGGTACAGTTTAGAATGGGAAACAGACGAATGATTGCATCAGTGTGGAAGTCTCAGGATCGTTTTAGTTTCTTTTATTTGCTGTTCATAACAATTGTTTTCTTTTGTTTAATTCTTGCTTTCTTTTTTTTTCTTCTCCGCAATTTTTACTATTATACTTAATGCCTTAACATTGTGTATAACAAAAGGAAATATCTCTGAGATACATTAAGTAACTTAAAAAAAAACTTTACACAGTCTGCCTAGTACATTACTATTTGGAATATATGTGTGCTTATTTGCATATTCATAATCTCCCTACTTTATTTTCTTTTATTTTTAATTGATACATAATCATTATACATATTTATGGGTTAAAGTGTAATGTTTTAATATGTGTACACATATTGACCAAATCAGGGTAATTTTGCATTTGTAATTTTAAAAAATGCTTTCTTCTTTTAATATACTTTTTTGTTTATCTTATTTCTAATACTTTCCCTAATCTCTTTCTTTCAGGGCAATAATGATACAATGTATCATGCCTCTTTGCACCATTCTAAAGAATAACAGTGATAATTTCTGGGTTAAGGCAATAGCAATATTTCTGCATATAAATATTTCTGCATATAAATTGTAACTGATGTAAGAGGTTTCATATTGCTAATAGCAGCTACAATCCAGCTACCATTCTGCTTTTATTTTATGGTTGGGATAAGGCTGGATTATTCTGAGTCCAAGCTAGGCCCTTTTGCTAATCATGTTCATACCTCTTATCTTCCTCCCACAGCTCCTGGGCAACGTGCTGGTCTGTGTGCTGGCCCATCACTTTGGCAAAGAATTCACCCCACCAGTGCAGGCTGCCTATCAGAAAGTGGTGGCTGGTGTGGCTAATGCCCTGGCCCACAAGTATCACTAAGCTCGCTTTCTTGCTGTCCAATTTCTATTAAAGGTTCCTTTGTTCCCTAAGTCCAACTACTAAACTGGGGGATATTATGAAGGGCCTTGAGCATCTGGATTCTGCCTAATAAAAAACATTTATTTTCATTGCAATGATGTATTTAAATTATTTCTGAATATTTTACTAAAAAGGGAATGTGGGAGGTCAGTGCATTTAAAACATAAAGAAATGAAGAGCTAGTTCAAACC'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the compressed_dna string representation\n",
    "str(compressed_dna)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "4ad2f88a263a6a2b65764c2632477ad9f3007975486c2226f2c86513342d2394"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 64-bit ('spark': conda)",
   "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.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}