docs/notebooks/readme_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## README Example\n",
    "\n",
    "This notebook contains the example shown in the README file.\n",
    "\n",
    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/BjornFJohansson/pydna/blob/dev_bjorn/docs/notebooks/Example_Restriction.ipynb\">\n",
    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
    "</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install pydna (only when running on Colab)\n",
    "import sys\n",
    "if 'google.colab' in sys.modules:\n",
    "    %%capture\n",
    "    # Install the current development version of pydna (comment to install pip version)\n",
    "    !pip install git+https://github.com/BjornFJohansson/pydna@dev_bjorn\n",
    "    # Install pip version instead (uncomment to install)\n",
    "    # !pip install pydna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dseqrecord(-60)\n",
       "\u001b[48;5;11mATGCAAACAGTAATGATGGATGACATTCAAAGCACTGATTCTATTGCTGAAAAAGATAAT\u001b[0m\n",
       "TACGTTTGTCATTACTACCTACTGTAAGTTTCGTGACTAAGATAACGACTTTTTCTATTA"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pydna.dseqrecord import Dseqrecord\n",
    "# Let's create a DNA sequence record, and add a feature to it\n",
    "dsr = Dseqrecord(\"ATGCAAACAGTAATGATGGATGACATTCAAAGCACTGATTCTATTGCTGAAAAAGATAAT\")\n",
    "dsr.add_feature(x=0, y=60,type=\"gene\", label=\"my_gene\") # We add a feature to highlight the sequence as a gene\n",
    "dsr.figure()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LOCUS       name                      60 bp    DNA     linear   UNK 01-JAN-1980\n",
      "DEFINITION  description.\n",
      "ACCESSION   id\n",
      "VERSION     id\n",
      "KEYWORDS    .\n",
      "SOURCE      .\n",
      "  ORGANISM  .\n",
      "            .\n",
      "FEATURES             Location/Qualifiers\n",
      "     misc            1..60\n",
      "                     /type=\"gene\"\n",
      "                     /label=\"my_gene\"\n",
      "ORIGIN\n",
      "        1 atgcaaacag taatgatgga tgacattcaa agcactgatt ctattgctga aaaagataat\n",
      "//\n"
     ]
    }
   ],
   "source": [
    "# This is how it would look as a genbank file\n",
    "print(dsr.format(\"genbank\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "forward primer: ATGCAAACAGTAATGATGGA\n",
      "reverse primer: ATTATCTTTTTCAGCAATAGAATCA\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5ATGCAAACAGTAATGATGGA...TGATTCTATTGCTGAAAAAGATAAT3\n",
       "                        |||||||||||||||||||||||||\n",
       "                       3ACTAAGATAACGACTTTTTCTATTA5\n",
       "5ATGCAAACAGTAATGATGGA3\n",
       " ||||||||||||||||||||\n",
       "3TACGTTTGTCATTACTACCT...ACTAAGATAACGACTTTTTCTATTA5"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now let's design primers to amplify it\n",
    "from pydna.design import primer_design\n",
    "# limit is the minimum length of the primer, target_tm is the desired melting temperature of the primer\n",
    "amplicon = primer_design(dsr, limit=13, target_tm=55)\n",
    "# Let's print the primers, and a figure that shows where they align with the template sequence\n",
    "print(\"forward primer:\", amplicon.forward_primer.seq)\n",
    "print(\"reverse primer:\", amplicon.reverse_primer.seq)\n",
    "amplicon.figure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "          5ATGCAAACAGTAATGATGGA...TGATTCTATTGCTGAAAAAGATAAT3\n",
       "                                  |||||||||||||||||||||||||\n",
       "                                 3ACTAAGATAACGACTTTTTCTATTACCTAGGtttt5\n",
       "5ccccGGATCCATGCAAACAGTAATGATGGA3\n",
       "           ||||||||||||||||||||\n",
       "          3TACGTTTGTCATTACTACCT...ACTAAGATAACGACTTTTTCTATTA5"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's say we don't want to just amplify it, but we want to add restriction sites to it!\n",
    "\n",
    "from pydna.amplify import pcr\n",
    "# We add the restriction sites to the primers\n",
    "forward_primer = \"ccccGGATCC\" + amplicon.forward_primer\n",
    "reverse_primer = \"ttttGGATCC\" + amplicon.reverse_primer\n",
    "\n",
    "# We do the PCR\n",
    "pcr_product = pcr(forward_primer, reverse_primer, dsr)\n",
    "# The PCR product is of class `Amplicon`, a subclass of `Dseqrecord`.\n",
    "# When doing a figure, it shows where primers anneal.\n",
    "pcr_product.figure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dseqrecord(-80)\n",
       "ccccGGATCC\u001b[48;5;11mATGCAAACAGTAATGATGGATGACATTCAAAGCACTGATTCTATTGCTGAAAAAGATAAT\u001b[0mGGATCCaaaa\n",
       "ggggCCTAGGTACGTTTGTCATTACTACCTACTGTAAGTTTCGTGACTAAGATAACGACTTTTTCTATTACCTAGGtttt"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If we want to see the sequence more clearly, we can turn it into a `Dseqrecord`\n",
    "pcr_product = Dseqrecord(pcr_product)\n",
    "pcr_product.figure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dseqrecord(-9)\n",
      "\u001b[48;5;11m\u001b[0mccccG    \n",
      "ggggCCTAG\n",
      "\n",
      "Dseqrecord(-70)\n",
      "GATCC\u001b[48;5;11mATGCAAACAGTAATGATGGATGACATTCAAAGCACTGATTCTATTGCTGAAAAAGATAAT\u001b[0mG    \n",
      "    GTACGTTTGTCATTACTACCTACTGTAAGTTTCGTGACTAAGATAACGACTTTTTCTATTACCTAG\n",
      "\n",
      "Dseqrecord(-9)\n",
      "\u001b[48;5;11m\u001b[0mGATCCaaaa\n",
      "    Gtttt\n"
     ]
    }
   ],
   "source": [
    "from Bio.Restriction import BamHI # cuts GGATCC\n",
    "# a, payload, c are the cut fragments\n",
    "a, payload, c = pcr_product.cut (BamHI)\n",
    "print(a.figure())\n",
    "print()\n",
    "print (payload.figure())\n",
    "print()\n",
    "print(c.figure())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dseqrecord(o50)\n",
       "\u001b[48;5;11m\u001b[0maatgtttttccctCCCGGGcaaaatAGATCTtgctatgcatcatcgatct\n",
       "ttacaaaaagggaGGGCCCgttttaTCTAGAacgatacgtagtagctaga"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We create a circular vector to insert the amplicon into\n",
    "vector = Dseqrecord(\"aatgtttttccctCCCGGGcaaaatAGATCTtgctatgcatcatcgatct\", circular=True, name=\"vect\")\n",
    "vector.figure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dseqrecord(o116)\n",
       "aatgtttttccctCCCGGGcaaaatAGATCC\u001b[48;5;11mATGCAAACAGTAATGATGGATGACATTCAAAGCACTGATTCTATTGCTGAAAAAGATAAT\u001b[0mGGATCTtgctatgcatcatcgatct\n",
       "ttacaaaaagggaGGGCCCgttttaTCTAGGTACGTTTGTCATTACTACCTACTGTAAGTTTCGTGACTAAGATAACGACTTTTTCTATTACCTAGAacgatacgtagtagctaga"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from Bio.Restriction import BglII # cuts AGATCT\n",
    "linear_vector_bgl = vector.cut(BglII)[0] # Linearize the vector at BglII (produces only one fragment)\n",
    "\n",
    "# Ligate the fragment of interest to the vector, and call looped() to circularize it\n",
    "# synced is used to place the origin coordinate (0) in the same place for rec_vector and vector\n",
    "rec_vector= (linear_vector_bgl + payload).looped().synced(vector)\n",
    "rec_vector.figure()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       " -|fragment_A|13\n",
       "|             \\/\n",
       "|             /\\\n",
       "|             13|fragment_B|13\n",
       "|                           \\/\n",
       "|                           /\\\n",
       "|                           13|fragment_C|13\n",
       "|                                         \\/\n",
       "|                                         /\\\n",
       "|                                         13-\n",
       "|                                            |\n",
       " --------------------------------------------"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's simulate a Gibson assembly\n",
    "from pydna.assembly import Assembly\n",
    "\n",
    "fragments = [\n",
    "    Dseqrecord('aatgtttttccctCACTACGtgctatgcatcat', name=\"fragment_A\"),\n",
    "    Dseqrecord('tgctatgcatcatCTATGGAcactctaataatg', name=\"fragment_B\"),\n",
    "    Dseqrecord('cactctaataatgTTACATAaatgtttttccct', name=\"fragment_C\"),\n",
    "]\n",
    "\n",
    "# limit is the min. homology length between fragments in the assembly\n",
    "asm = Assembly(fragments, limit=10)\n",
    "\n",
    "# From the assembly object, which can generate all possible products, get a circular\n",
    "product, *rest = asm.assemble_circular()\n",
    "\n",
    "# We can print a figure that shows the overlaps between fragments\n",
    "product.figure()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dseqrecord(o60)\n",
       "\u001b[48;5;11m\u001b[0maatgtttttccctCACTACGtgctatgcatcatCTATGGAcactctaataatgTTACATA\n",
       "ttacaaaaagggaGTGATGCacgatacgtagtaGATACCTgtgagattattacAATGTAT"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Or show the final sequence:\n",
    "Dseqrecord(product).figure()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}