pydna 5.5.2__py3-none-any.whl → 5.5.4__py3-none-any.whl

pydna/cre_lox.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+from itertools import product
+from pydna.dseqrecord import Dseqrecord
+from Bio.Data.IUPACData import ambiguous_dna_values
+from Bio.Seq import reverse_complement
+from pydna.sequence_regex import compute_regex_site, dseqrecord_finditer
+from Bio.SeqFeature import Location, SimpleLocation, SeqFeature
+from pydna.utils import shift_location
+
+# We create a dictionary to map ambiguous bases to their consensus base
+# For example, ambigous_base_dict['ACGT'] -> 'N'
+ambiguous_base_dict = {}
+for ambiguous, bases in ambiguous_dna_values.items():
+    ambiguous_base_dict["".join(sorted(bases))] = ambiguous
+
+# To handle N values
+ambiguous_base_dict["N"] = "N"
+
+# This is the original loxP sequence, here for reference
+LOXP_SEQUENCE = "ATAACTTCGTATAGCATACATTATACGAAGTTAT"
+
+loxP_sequences = [
+    # https://blog.addgene.org/plasmids-101-cre-lox
+    # loxP
+    "ATAACTTCGTATANNNTANNNTATACGAAGTTAT",
+    # PMID:12202778
+    # lox66
+    "ATAACTTCGTATANNNTANNNTATACGAACGGTA",
+    # lox71
+    "TACCGTTCGTATANNNTANNNTATACGAAGTTAT",
+]
+
+loxP_consensus = ""
+
+for pos in range(len(LOXP_SEQUENCE)):
+    all_letters = set(seq[pos] for seq in loxP_sequences)
+    key = "".join(sorted(all_letters))
+    loxP_consensus += ambiguous_base_dict[key]
+
+# We compute the regex for the forward and reverse loxP sequences
+loxP_regex = (
+    compute_regex_site(loxP_consensus),
+    compute_regex_site(reverse_complement(loxP_consensus)),
+)
+
+
+def cre_loxP_overlap(
+    x: Dseqrecord, y: Dseqrecord, _l: None = None
+) -> list[tuple[int, int, int]]:
+    """Find matching loxP sites between two sequences."""
+    out = list()
+    for pattern in loxP_regex:
+        matches_x = dseqrecord_finditer(pattern, x)
+        matches_y = dseqrecord_finditer(pattern, y)
+
+        for match_x, match_y in product(matches_x, matches_y):
+            value_x = match_x.group()
+            value_y = match_y.group()
+            if value_x[13:21] == value_y[13:21]:
+                out.append((match_x.start() + 13, match_y.start() + 13, 8))
+    # Unique values (keeping the order)
+    unique_out = []
+    for item in out:
+        if item not in unique_out:
+            unique_out.append(item)
+    return unique_out
+
+
+loxP_dict = {
+    "loxP": "ATAACTTCGTATANNNTANNNTATACGAAGTTAT",
+    "lox66": "ATAACTTCGTATANNNTANNNTATACGAACGGTA",
+    "lox71": "TACCGTTCGTATANNNTANNNTATACGAAGTTAT",
+    "loxP_mutant": "TACCGTTCGTATANNNTANNNTATACGAACGGTA",
+}
+
+
+def get_regex_dict(original_dict: dict[str, str]) -> dict[str, str]:
+    """Get the regex dictionary for the original dictionary."""
+    out = dict()
+    for site in original_dict:
+        consensus_seq = original_dict[site]
+        is_palindromic = consensus_seq == reverse_complement(consensus_seq)
+        out[site] = {
+            "forward_regex": compute_regex_site(original_dict[site]),
+            "reverse_regex": (
+                None
+                if is_palindromic
+                else compute_regex_site(reverse_complement(original_dict[site]))
+            ),
+        }
+    return out
+
+
+def find_loxP_sites(seq: Dseqrecord) -> dict[str, list[Location]]:
+    """Find all loxP sites in a sequence and return a dictionary with the name and positions of the sites."""
+
+    out = dict()
+    regex_dict = get_regex_dict(loxP_dict)
+    for site in loxP_dict:
+
+        for pattern in ["forward_regex", "reverse_regex"]:
+            # Palindromic sequences have no reverse complement
+            if regex_dict[site][pattern] is None:
+                continue
+            matches = list(dseqrecord_finditer(regex_dict[site][pattern], seq))
+            for match in matches:
+                if site not in out:
+                    out[site] = []
+                strand = 1 if pattern == "forward_regex" else -1
+                loc = SimpleLocation(match.start(), match.end(), strand)
+                loc = shift_location(loc, 0, len(seq))
+                out[site].append(loc)
+    return out
+
+
+def annotate_loxP_sites(seq: Dseqrecord) -> Dseqrecord:
+    sites = find_loxP_sites(seq)
+    for site in sites:
+        for loc in sites[site]:
+            # Don't add the same feature twice
+            if not any(
+                f.location == loc
+                and f.type == "protein_bind"
+                and f.qualifiers.get("label", []) == [site]
+                for f in seq.features
+            ):
+                seq.features.append(
+                    SeqFeature(loc, type="protein_bind", qualifiers={"label": [site]})
+                )
+    return seq

pydna/dseqrecord.py

@@ -35,6 +35,11 @@ import os as _os
 import re as _re
 import time as _time
 import datetime as _datetime
+from typing import Union, TYPE_CHECKING
+from pydna.opencloning_models import SequenceCutSource
+
+if TYPE_CHECKING:  # pragma: no cover
+    from pydna.opencloning_models import Source
 
 
 # import logging as _logging
@@ -128,6 +133,7 @@ class Dseqrecord(_SeqRecord):
     """
 
     seq: _Dseq
+    source: Union["Source", None] = None
 
     def __init__(
         self,
@@ -135,6 +141,7 @@ class Dseqrecord(_SeqRecord):
         *args,
         circular=None,
         n=5e-14,  # mol ( = 0.05 pmol)
+        source=None,
         **kwargs,
     ):
         #        _module_logger.info("### Dseqrecord initialized ###")
@@ -202,6 +209,7 @@ class Dseqrecord(_SeqRecord):
         self.map_target = None
         self.n = n  # amount, set to 5E-14 which is 5 pmols
         self.annotations.update({"molecule_type": "DNA"})
+        self.source = source
 
     @classmethod
     def from_string(
@@ -256,6 +264,7 @@ class Dseqrecord(_SeqRecord):
         obj.features = record.features
         obj.map_target = None
         obj.n = n
+        obj.source = None
         if circular is None:
             circular = record.annotations.get("topology") == "circular"
         obj.seq = _Dseq.quick(
@@ -875,7 +884,11 @@ class Dseqrecord(_SeqRecord):
     def __eq__(self, other):
         """docstring."""
         try:
-            if self.seq == other.seq and str(self.__dict__) == str(other.__dict__):
+            this_dict = self.__dict__.copy()
+            other_dict = other.__dict__.copy()
+            del this_dict["source"]
+            del other_dict["source"]
+            if self.seq == other.seq and str(this_dict) == str(other_dict):
                 return True
         except AttributeError:
             pass
@@ -1419,4 +1432,39 @@ class Dseqrecord(_SeqRecord):
             right_edge = right_watson if right_ovhg > 0 else right_crick
             features = self[left_edge:right_edge].features
 
-        return Dseqrecord(dseq, features=features)
+        # This will need to be generalised to all types of cuts
+        source = SequenceCutSource.from_parent(self, left_cut, right_cut)
+        return Dseqrecord(dseq, features=features, source=source)
+
+    def history(self):
+        """
+        Returns a string representation of the cloning history of the sequence.
+        Returns an empty string if the sequence has no source.
+
+        Check the documentation notebooks for extensive examples.
+
+        Returns
+        -------
+            str: A string representation of the cloning history of the sequence.
+
+        Examples
+        --------
+        >>> from pydna.dseqrecord import Dseqrecord
+        >>> from pydna.assembly2 import gibson_assembly
+        >>> fragments = [
+        ...    Dseqrecord("TTTTacgatAAtgctccCCCC", circular=False, name="fragment1"),
+        ...    Dseqrecord("CCCCtcatGGGG", circular=False, name="fragment2"),
+        ...    Dseqrecord("GGGGatataTTTT", circular=False, name="fragment3"),
+        ... ]
+        >>> product, *_ = gibson_assembly(fragments, limit=4)
+        >>> product.name = "product_name"
+        >>> print(product.history())
+        ╙── product_name (Dseqrecord(o34))
+            └─╼ GibsonAssemblySource
+                ├─╼ fragment1 (Dseqrecord(-21))
+                ├─╼ fragment2 (Dseqrecord(-12))
+                └─╼ fragment3 (Dseqrecord(-13))
+        """
+        if self.source is None:
+            return ""
+        return self.source.history_string(self)

pydna/gateway.py

@@ -1,162 +1,164 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright 2013-2023 by Björn Johansson.  All rights reserved.
-# This code is part of the Python-dna distribution and governed by its
-# license.  Please see the LICENSE.txt file that should have been included
-# as part of this package.
-
-"""Assembly of sequences by Gateway recombination.
-
-Given a list of sequences (Dseqrecords), all sequences are analyzed for
-presence of att(P|B|L|R)N where N is 1,2,3 or 4.
-
-A graph is constructed where the att sites form a nodes and
-sequences separating att sites form edges.
-
-The NetworkX package is used to trace linear and circular paths through the
-graph.
-"""
-# from Bio.SeqFeature import ExactPosition as _ExactPosition
-# from Bio.SeqFeature import SimpleLocation as _SimpleLocation
-# from Bio.SeqFeature import CompoundLocation as _CompoundLocation
-# from pydna.utils import rc as _rc
-
-# from pydna._pretty import pretty_str as _pretty_str
-# from pydna.contig import Contig as _Contig
-# from pydna.common_sub_strings import common_sub_strings
-# from pydna.dseqrecord import Dseqrecord as _Dseqrecord
-# import networkx as _nx
-# from copy import deepcopy as _deepcopy
-# import itertools as _itertools
-# import logging as _logging
-
-# _module_logger = _logging.getLogger("pydna." + __name__)
-
-ambiguous_dna_regex = {
-    "A": "T",
-    "C": "G",
-    "G": "C",
-    "T": "A",
-    "M": "[ACM]",
-    "R": "[AGR]",
-    "W": "[ATW]",
-    "S": "[CGS]",
-    "Y": "[CTY]",
-    "K": "[GTK]",
-    "V": "[ACGVMSR]",
-    "H": "[ACTHMYW]",
-    "D": "[AGTDRWK]",
-    "B": "[CGTBSKY]",
-    "X": "X",
-    "N": "[ACGTBDHKMNRSVWY]",
+from Bio.Seq import reverse_complement
+from pydna.dseqrecord import Dseqrecord as _Dseqrecord
+import re
+import itertools as _itertools
+from Bio.SeqFeature import SimpleLocation, SeqFeature
+from pydna.utils import shift_location
+from pydna.sequence_regex import compute_regex_site, dseqrecord_finditer
+
+
+raw_gateway_common = {
+    "attB1": "CHWVTWTGTACAAAAAANNNG",
+    "attB2": "CHWVTWTGTACAAGAAANNNG",
+    "attB3": "CHWVTWTGTATAATAAANNNG",
+    "attB4": "CHWVTWTGTATAGAAAANNNG",
+    "attB5": "CHWVTWTGTATACAAAANNNG",
+    "attL1": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTACAAAAAANNNG",
+    "attL2": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTACAAGAAANNNG",
+    "attL3": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTATAATAAANNNG",
+    "attL4": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTATAGAAAANNNG",
+    "attL5": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTATACAAAANNNG",
+    "attR1": "CHWVTWTGTACAAAAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "attR2": "CHWVTWTGTACAAGAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "attR3": "CHWVTWTGTATAATAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "attR4": "CHWVTWTGTATAGAAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "attR5": "CHWVTWTGTATACAAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "overlap_1": "twtGTACAAAaaa",
+    "overlap_2": "twtGTACAAGaaa",
+    "overlap_3": "twtGTATAATaaa",
+    "overlap_4": "twtGTATAGAaaa",
+    "overlap_5": "twtGTATACAaaa",
 }
 
-atts = """
-attP1 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTACAAA AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG CMASTWT AAAGYWG
-attP2 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTACAAG AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG CMASTWT AAAGYWG
-attP3 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTATAAT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG CMASTWT AAAGYWG
-attP4 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTATAGA AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG CMASTWT AAAGYWG
-attP5 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTATACA AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG CMASTWT AAAGYWG
-
-attB1 CMASTWT GTACAAA AAAGYWG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-attB2 CMASTWT GTACAAG AAAGYWG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-attB3 CMASTWT GTATAAT AAAGYWG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-attB4 CMASTWT GTATAGA AAAGYWG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-attB5 CMASTWT GTATACA AAAGYWG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-
-attR1 CMASTWT GTACAAA AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWG
-attR2 CMASTWT GTACAAG AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWG
-attR3 CMASTWT GTATAAT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWG
-attR4 CMASTWT GTATAGA AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWG
-attR5 CMASTWT GTATACA AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT AAAGYWG
-
-attL1 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTACAAA AAAGYWG CMASTWT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-attL2 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTACAAG AAAGYWG CMASTWT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-attL3 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTATAAT AAAGYWG CMASTWT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-attL4 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTATAGA AAAGYWG CMASTWT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-attL5 AAATAATGATTTTATTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATKMTTTYTTATAATGCCMASTTT GTATACA AAAGYWG CMASTWT AAAGYWGAACGAGAAACGTAAAATGATATAAATATCAATATATTAAATTAGATTTTGCATAAAAAACAGACTACATAATRCTGTAAAACACAACATATSCAGTCAYWWTG
-"""
-
-
-retable = str.maketrans(ambiguous_dna_regex)
-
-for line in (line for line in atts.splitlines() if line.strip()):
-    name, *parts = line.split()
-    for part in parts:
-        part.translate(retable)
-
-
-class Gateway(object):
-    """Assembly of linear DNA fragments into linear or circular constructs.
-
-    The Assembly is meant to replace the Assembly method as it
-    is easier to use. Accepts a list of Dseqrecords (source fragments) to
-    initiate an Assembly object. Several methods are available for analysis
-    of overlapping sequences, graph construction and assembly.
-
-    Parameters
-    ----------
-    fragments : list
-        a list of Dseqrecord objects.
-    """
-
-    def __init__(self, molecules=None):
-        self.molecules = molecules
-
-
-"""
-Created on Sat Aug 21 15:41:42 2021
-
-@author: bjorn
-
-
-https://en.wikipedia.org/wiki/Cre-Lox_recombination
-
-13bp	      8bp	   13bp
-ATAACTTCGTATA-NNNTANNN-TATACGAAGTTAT
-
-
-Name	    13 bp  	        8 bp  	    13 bp
-            Recognition     Spacer      Recognition
-            Region          Region      Region
-
-Wild-Type	ATAACTTCGTATA	ATGTATGC	TATACGAAGTTAT
-lox 511	    ATAACTTCGTATA	ATGTATaC	TATACGAAGTTAT
-lox 5171	ATAACTTCGTATA	ATGTgTaC	TATACGAAGTTAT
-lox 2272	ATAACTTCGTATA	AaGTATcC	TATACGAAGTTAT
-M2	        ATAACTTCGTATA	AgaaAcca	TATACGAAGTTAT
-M3	        ATAACTTCGTATA	taaTACCA	TATACGAAGTTAT
-M7	        ATAACTTCGTATA	AgaTAGAA	TATACGAAGTTAT
-M11	        ATAACTTCGTATA	cgaTAcca	TATACGAAGTTAT
-lox 71	    TACCGTTCGTATA	NNNTANNN	TATACGAAGTTAT
-lox 66	    ATAACTTCGTATA	NNNTANNN	TATACGAACGGTA
 
-"""
-
-
-"""
-
-https://blog.addgene.org/plasmids-101-cre-lox
+raw_gateway_sites_greedy = {
+    **raw_gateway_common,
+    "attP1": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTACAAAAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "attP2": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTACAAGAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "attP3": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTATAATAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "attP4": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTATAGAAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+    "attP5": "VAAWWAWKRWTTTWWTTYGACTGATAGTGACCTGTWCGTYGMAACAVATTGATRAGCAATKMTTTYYTATAWTGHCMASTWTGTATACAAAAGYWGARCGAGAARCGTAARRTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATRCTGTAARACACAACATATBCAGTCV",
+}
 
-https://en.wikipedia.org/wiki/Cre-Lox_recombination
+raw_gateway_sites_conservative = {
+    **raw_gateway_common,
+    "attP1": "AAAWWAWKRWTTTWWTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATGCTTTYTTATAATGCCMASTTTGTACAAAAAAGYWGAACGAGAARCGTAAARTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATACTGTAAAACACAACATATSCAGTCACTATGAAYCAACTACTTAGATGGTATTAGTGACCTGTA",
+    "attP2": "AAAWWAWKRWTTTWWTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATGCTTTYTTATAATGCCMASTTTGTACAAGAAAGYWGAACGAGAARCGTAAARTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATACTGTAAAACACAACATATSCAGTCACTATGAAYCAACTACTTAGATGGTATTAGTGACCTGTA",
+    "attP3": "AAAWWAWKRWTTTWWTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATGCTTTYTTATAATGCCMASTTTGTATAATAAAGYWGAACGAGAARCGTAAARTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATACTGTAAAACACAACATATSCAGTCACTATGAAYCAACTACTTAGATGGTATTAGTGACCTGTA",
+    "attP4": "AAAWWAWKRWTTTWWTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATGCTTTYTTATAATGCCMASTTTGTATAGAAAAGYWGAACGAGAARCGTAAARTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATACTGTAAAACACAACATATSCAGTCACTATGAAYCAACTACTTAGATGGTATTAGTGACCTGTA",
+    "attP5": "AAAWWAWKRWTTTWWTTTGACTGATAGTGACCTGTTCGTTGCAACAMATTGATRAGCAATGCTTTYTTATAATGCCMASTTTGTATACAAAAGYWGAACGAGAARCGTAAARTGATATAAATATCAATATATTAAATTAGAYTTTGCATAAAAAACAGACTACATAATACTGTAAAACACAACATATSCAGTCACTATGAAYCAACTACTTAGATGGTATTAGTGACCTGTA",
+}
 
-13bp	      8bp	   13bp
-ATAACTTCGTATA-NNNTANNN-TATACGAAGTTAT
+gateway_sites_greedy = {
+    k: {
+        "forward_regex": compute_regex_site(v),
+        "reverse_regex": compute_regex_site(reverse_complement(v)),
+        "consensus_sequence": v,
+    }
+    for k, v in raw_gateway_sites_greedy.items()
+}
 
+gateway_sites_conservative = {
+    k: {
+        "forward_regex": compute_regex_site(v),
+        "reverse_regex": compute_regex_site(reverse_complement(v)),
+        "consensus_sequence": v,
+    }
+    for k, v in raw_gateway_sites_conservative.items()
+}
 
-Name	    13 bp  	        8 bp  	    13 bp
-            Recognition     Spacer      Recognition
-            Region          Region      Region
+# From snapgene - ask Valerie
+primer_design_attB = {
+    "attB1": "ACAAGTTTGTACAAAAAAGCAGGCT",
+    "attB2": "ACCACTTTGTACAAGAAAGCTGGGT",
+    "attB3": "ACAACTTTGTATAATAAAGTTGTA",
+    "attB4": "ACAACTTTGTATAGAAAAGTTGTA",
+    "attB5": "ACAACTTTGTATACAAAAGTTGTA",
+}
 
-Wild-Type	ATAACTTCGTATA	ATGTATGC	TATACGAAGTTAT
-lox511	    ATAACTTCGTATA	ATGTATaC	TATACGAAGTTAT
-lox5171	    ATAACTTCGTATA	ATGTgTaC	TATACGAAGTTAT
-lox2272	    ATAACTTCGTATA	AaGTATcC	TATACGAAGTTAT
-M2	        ATAACTTCGTATA	AgaaAcca	TATACGAAGTTAT
-M3	        ATAACTTCGTATA	taaTACCA	TATACGAAGTTAT
-M7	        ATAACTTCGTATA	AgaTAGAA	TATACGAAGTTAT
-M11	        ATAACTTCGTATA	cgaTAcca	TATACGAAGTTAT
-lox71	    TACCGTTCGTATA	NNNTANNN	TATACGAAGTTAT
-lox66	    ATAACTTCGTATA	NNNTANNN	TATACGAACGGTA
 
-"""
+def gateway_overlap(
+    seqx: _Dseqrecord, seqy: _Dseqrecord, reaction: str, greedy: bool
+) -> list[tuple[int, int, int]]:
+    """
+    Find gateway overlaps. If greedy is True, it uses a more greedy consensus site to find attP sites,
+    which might give false positives
+    """
+    if reaction not in ["BP", "LR"]:
+        raise ValueError(f"Invalid overlap type: {reaction}")
+
+    gateway_sites = gateway_sites_greedy if greedy else gateway_sites_conservative
+    out = list()
+    # Iterate over the four possible att sites
+    for num in range(1, 5):
+        # Iterate over the two possible orientations
+        # The sites have to be in the same orientation (fwd + fwd or rev + rev)
+        for pattern in ["forward_regex", "reverse_regex"]:
+            # The overlap regex is the same for all types
+            overlap_regex = gateway_sites[f"overlap_{num}"][pattern]
+
+            # Iterate over pairs B, P and P, B for BP and L, R and R, L for LR
+            for site_x, site_y in zip(reaction, reaction[::-1]):
+                site_x_regex = gateway_sites[f"att{site_x}{num}"][pattern]
+                matches_x = list(dseqrecord_finditer(site_x_regex, seqx))
+                if len(matches_x) == 0:
+                    continue
+
+                site_y_regex = gateway_sites[f"att{site_y}{num}"][pattern]
+                matches_y = list(dseqrecord_finditer(site_y_regex, seqy))
+                if len(matches_y) == 0:
+                    continue
+
+                for match_x, match_y in _itertools.product(matches_x, matches_y):
+                    # Find the overlap sequence within each match, and use the
+                    # core 7 pbs that are constant
+                    overlap_x = re.search(overlap_regex, match_x.group())
+                    overlap_y = re.search(overlap_regex, match_y.group())
+
+                    # Sanity check
+                    assert (
+                        overlap_x is not None and overlap_y is not None
+                    ), "Something went wrong, no overlap found within the matches"
+
+                    out.append(
+                        (
+                            match_x.start() + overlap_x.start() + 3,
+                            match_y.start() + overlap_y.start() + 3,
+                            7,
+                        )
+                    )
+
+    return out
+
+
+def find_gateway_sites(
+    seq: _Dseqrecord, greedy: bool
+) -> dict[str, list[SimpleLocation]]:
+    """Find all gateway sites in a sequence and return a dictionary with the name and positions of the sites."""
+    gateway_sites = gateway_sites_greedy if greedy else gateway_sites_conservative
+    out = dict()
+    for site in gateway_sites:
+        if not site.startswith("att"):
+            continue
+
+        for pattern in ["forward_regex", "reverse_regex"]:
+            matches = list(dseqrecord_finditer(gateway_sites[site][pattern], seq))
+            for match in matches:
+                if site not in out:
+                    out[site] = []
+                strand = 1 if pattern == "forward_regex" else -1
+                loc = SimpleLocation(match.start(), match.end(), strand)
+                loc = shift_location(loc, 0, len(seq))
+                out[site].append(loc)
+    return out
+
+
+def annotate_gateway_sites(seq: _Dseqrecord, greedy: bool) -> _Dseqrecord:
+    sites = find_gateway_sites(seq, greedy)
+    for site in sites:
+        for loc in sites[site]:
+            seq.features.append(
+                SeqFeature(loc, type="protein_bind", qualifiers={"label": [site]})
+            )
+    return seq