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

pydna/amplicon.py

@@ -10,22 +10,17 @@
 This class is not meant to be use directly but is
 used by the :mod:`amplify` module"""
 
-from pydna.tm import dbd_program as _dbd_program
-from pydna.tm import program as _program
-from pydna.primer import Primer as _Primer
-from pydna._pretty import pretty_str as _pretty_str
-from pydna.dseqrecord import Dseqrecord as _Dseqrecord
-from pydna.seqrecord import SeqRecord as _SeqRecord
-import textwrap as _textwrap
-import copy as _copy
+from pydna.tm import dbd_program
+from pydna.tm import program
+from pydna.primer import Primer
+from pydna._pretty import pretty_str
+from pydna.dseqrecord import Dseqrecord
+from pydna.seqrecord import SeqRecord
+import textwrap
+import copy
 
-# import logging as _logging
 
-
-# _module_logger = _logging.getLogger("pydna." + __name__)
-
-
-class Amplicon(_Dseqrecord):
+class Amplicon(Dseqrecord):
     """The Amplicon class holds information about a PCR reaction involving two
     primers and one template. This class is used by the Anneal class and is not
     meant to be instantiated directly.
@@ -69,12 +64,12 @@ class Amplicon(_Dseqrecord):
         return obj
 
     def __getitem__(self, sl):
-        answer = _copy.copy(self)
+        answer = copy.copy(self)
         answer.seq = answer.seq.__getitem__(sl)
         # answer.seq.alphabet = self.seq.alphabet
-        sr = _SeqRecord("n" * len(self))
+        sr = SeqRecord("n" * len(self))
         sr.features = self.features
-        answer.features = _SeqRecord.__getitem__(sr, sl).features
+        answer.features = SeqRecord.__getitem__(sr, sl).features
         return answer
 
     def __repr__(self):
@@ -90,8 +85,8 @@ class Amplicon(_Dseqrecord):
     def reverse_complement(self):
         r = type(self)(super().reverse_complement())
         r.template = self.template.rc()
-        r.forward_primer = _copy.copy(self.reverse_primer)
-        r.reverse_primer = _copy.copy(self.forward_primer)
+        r.forward_primer = copy.copy(self.reverse_primer)
+        r.reverse_primer = copy.copy(self.forward_primer)
         r.forward_primer.position, r.reverse_primer.position = (
             r.reverse_primer.position,
             r.forward_primer.position,
@@ -143,23 +138,23 @@ class Amplicon(_Dseqrecord):
             {" " * ft}3{fzc}...{rzc}5
             """
         # breakpoint()
-        return _pretty_str(_textwrap.dedent(f).strip("\n"))
+        return pretty_str(textwrap.dedent(f).strip("\n"))
 
     def set_forward_primer_footprint(self, length):
-        self.forward_primer = _Primer(
+        self.forward_primer = Primer(
             self.forward_primer.tail + self.seq[:length], footprint=length
         )
 
     def set_reverse_primer_footprint(self, length):
-        self.reverse_primer = _Primer(
+        self.reverse_primer = Primer(
             self.reverse_primer.tail + self.seq[:length], footprint=length
         )
 
     def program(self):
-        return _program(self)
+        return program(self)
 
     def dbd_program(self):
-        return _dbd_program(self)
+        return dbd_program(self)
 
     def primers(self):
         return self.forward_primer, self.reverse_primer

pydna/amplify.py

@@ -13,48 +13,22 @@ PCR product. The Anneal class should be used if more flexibility is required.
 Primers with 5' tails as well as inverse PCR on circular templates are handled
 correctly."""
 
-from pydna._pretty import pretty_str as _pretty_str
-from pydna.utils import flatten as _flatten
-
-# from pydna.utils import memorize as _memorize
-from pydna.utils import rc as _rc, shift_feature as _shift_feature
-from pydna.amplicon import Amplicon as _Amplicon
-from pydna.primer import Primer as _Primer
-from pydna.seqrecord import SeqRecord as _SeqRecord
-from pydna.dseqrecord import Dseqrecord as _Dseqrecord
-from Bio.SeqFeature import SeqFeature as _SeqFeature
-from Bio.SeqFeature import SimpleLocation as _SimpleLocation
-from Bio.SeqFeature import CompoundLocation as _CompoundLocation
-from pydna.seq import Seq as _Seq
-import itertools as _itertools
-import re as _re
-import copy as _copy
-import operator as _operator
-
-# import os as _os
-
-# import logging as _logging
-
-# _module_logger = _logging.getLogger("pydna." + __name__)
-
-_table = {  # IUPAC Ambiguity Codes for Nucleotide Degeneracy and U for Uracile
-    "A": "A",
-    "C": "C",
-    "G": "G",
-    "T": "T",
-    "U": "A",  # XXX
-    "R": "(A|G)",
-    "Y": "(C|T)",
-    "S": "(G|C)",
-    "W": "(A|T)",
-    "K": "(G|T)",
-    "M": "(A|C)",
-    "B": "(C|G|T)",
-    "D": "(A|G|T)",
-    "H": "(A|C|T)",
-    "V": "(A|C|G)",
-    "N": "(A|G|C|T)",
-}
+from pydna._pretty import pretty_str
+from pydna.utils import flatten
+from pydna.utils import shift_feature
+from pydna.amplicon import Amplicon
+from pydna.primer import Primer
+from pydna.seqrecord import SeqRecord
+from pydna.dseqrecord import Dseqrecord
+from Bio.SeqFeature import SeqFeature
+from Bio.SeqFeature import SimpleLocation
+from Bio.SeqFeature import CompoundLocation
+from pydna.seq import Seq
+import re
+import copy
+import operator
+from pydna.alphabet import iupac_compl_regex
+from pydna.utils import anneal_from_left
 
 
 def _annealing_positions(primer, template, limit):
@@ -70,13 +44,14 @@ def _annealing_positions(primer, template, limit):
 
         <- - - - - - - - - - template - - - - - - - - - - - - - >
 
-        <------- start (int) ------>
-     5'-...gctactacacacgtactgactgcctccaagatagagtcagtaaccacactcgat...3'
+           < ----- start = 26 ------>
+       5'- gctactacacacgtactgactgcctccaagatagagtcagtaaccacactcgatag...3'
            ||||||||||||||||||||||||||||||||||||||||||||||||
                                   3'-gttctatctcagtcattggtgtATAGTG-5'
 
                                      <-footprint length -->
 
+
     Parameters
     ----------
     primer : string
@@ -85,7 +60,7 @@ def _annealing_positions(primer, template, limit):
     template : string
         The template sequence 5'-3'
 
-    limit : int = 15, optional
+    limit : int
         footprint needs to be at least of length limit.
 
     Returns
@@ -94,32 +69,37 @@ def _annealing_positions(primer, template, limit):
         [ (start1, footprint1), (start2, footprint2) ,..., ]
     """
 
+    #                            under_tail
+    #           anchor         AACCACACTCGAT
+    #           CAAGATAGAGTCAGT
+    #           |||||||||||||||
+    #           gttctatctcagtca
+    #                          ttggtgtATAGTG    revprimer
+    #                              tail
+    #
+    #           | <- limit -> |
+
     # return empty list if primer too short
     if len(primer) < limit:
         return []
 
-    prc = _rc(primer)
+    revprimer = primer[::-1]
 
     # head is minimum part of primer that must anneal
-    head = prc[:limit].upper()
+    head = revprimer[:limit].upper()
+    tail = revprimer[limit:].upper()
 
     # Make regex pattern that reflects extended IUPAC DNA code
-    head = "".join(_table[key] for key in head)
-
-    positions = [m.start() for m in _re.finditer(f"(?={head})", template, _re.I)]
-
-    if positions:
-        tail = prc[limit:].lower()
-        length = len(tail)
-        results = []
-        for match_start in positions:
-            tm = template[match_start + limit : match_start + limit + length].lower()
-            footprint = len(
-                list(_itertools.takewhile(lambda x: x[0] == x[1], zip(tail, tm)))
-            )
-            results.append((match_start, footprint + limit))
-        return results
-    return []
+    head_regex = "".join(iupac_compl_regex[key] for key in head)
+    primer_regex = f"(?:({head_regex})(.{{0,{len(primer) - limit}}}))"
+
+    results = []
+    for m in re.finditer(primer_regex, template.upper()):
+        anchor, under_tail = m.groups()
+        match_start = m.start()
+        match_extension = anneal_from_left(tail, under_tail[::-1])
+        results.append((match_start, limit + match_extension))
+    return results
 
 
 # class _Memoize(type):
@@ -219,7 +199,7 @@ class Anneal(object):  # ), metaclass=_Memoize):
 
         """
         self.primers = primers
-        self.template = _copy.deepcopy(template)
+        self.template = copy.deepcopy(template)
 
         self.limit = limit
         self.kwargs = kwargs
@@ -242,7 +222,7 @@ class Anneal(object):  # ), metaclass=_Memoize):
         for p in self.primers:
             self.forward_primers.extend(
                 (
-                    _Primer(
+                    Primer(
                         p,
                         #          template = self.template,
                         position=tcl - pos - min(self.template.seq.ovhg, 0),
@@ -254,7 +234,7 @@ class Anneal(object):  # ), metaclass=_Memoize):
             )
             self.reverse_primers.extend(
                 (
-                    _Primer(
+                    Primer(
                         p,
                         #          template = self.template,
                         position=pos + max(0, self.template.seq.ovhg),
@@ -265,16 +245,16 @@ class Anneal(object):  # ), metaclass=_Memoize):
                 )
             )
 
-        self.forward_primers.sort(key=_operator.attrgetter("position"))
-        self.reverse_primers.sort(key=_operator.attrgetter("position"), reverse=True)
+        self.forward_primers.sort(key=operator.attrgetter("position"))
+        self.reverse_primers.sort(key=operator.attrgetter("position"), reverse=True)
 
         for fp in self.forward_primers:
             if fp.position - fp._fp >= 0:
                 start = fp.position - fp._fp
                 end = fp.position
                 self.template.features.append(
-                    _SeqFeature(
-                        _SimpleLocation(start, end, strand=1),
+                    SeqFeature(
+                        SimpleLocation(start, end, strand=1),
                         type="primer_bind",
                         qualifiers={
                             "label": [fp.name],
@@ -287,11 +267,11 @@ class Anneal(object):  # ), metaclass=_Memoize):
             else:
                 start = len(self.template) - fp._fp + fp.position
                 end = start + fp._fp - len(self.template)
-                sf = _SeqFeature(
-                    _CompoundLocation(
+                sf = SeqFeature(
+                    CompoundLocation(
                         [
-                            _SimpleLocation(start, len(self.template)),
-                            _SimpleLocation(0, end),
+                            SimpleLocation(start, len(self.template)),
+                            SimpleLocation(0, end),
                         ]
                     ),
                     type="primer_bind",
@@ -309,8 +289,8 @@ class Anneal(object):  # ), metaclass=_Memoize):
                 start = rp.position
                 end = rp.position + rp._fp
                 self.template.features.append(
-                    _SeqFeature(
-                        _SimpleLocation(start, end, strand=-1),
+                    SeqFeature(
+                        SimpleLocation(start, end, strand=-1),
                         type="primer_bind",
                         qualifiers={
                             "label": [rp.name],
@@ -324,11 +304,11 @@ class Anneal(object):  # ), metaclass=_Memoize):
                 start = rp.position
                 end = rp.position + rp._fp - len(self.template)
                 self.template.features.append(
-                    _SeqFeature(
-                        _CompoundLocation(
+                    SeqFeature(
+                        CompoundLocation(
                             [
-                                _SimpleLocation(0, end, strand=-1),
-                                _SimpleLocation(start, len(self.template), strand=-1),
+                                SimpleLocation(0, end, strand=-1),
+                                SimpleLocation(start, len(self.template), strand=-1),
                             ],
                         ),
                         type="primer_bind",
@@ -368,15 +348,15 @@ class Anneal(object):  # ), metaclass=_Memoize):
                     continue
                 # Shift features to the right if there was a tail
                 shift_amount = len(fp.tail)
-                feats = [_shift_feature(f, shift_amount, None) for f in feats]
+                feats = [shift_feature(f, shift_amount, None) for f in feats]
 
                 if tpl.circular and fp.position == rp.position:
-                    prd = _Dseqrecord(fp) + _Dseqrecord(rp).reverse_complement()
+                    prd = Dseqrecord(fp) + Dseqrecord(rp).reverse_complement()
                 else:
                     prd = (
-                        _Dseqrecord(fp)
+                        Dseqrecord(fp)
                         + tpl[fp.position : rp.position]
-                        + _Dseqrecord(rp).reverse_complement()
+                        + Dseqrecord(rp).reverse_complement()
                     )
                 prd.features = feats
                 full_tmpl_features = [
@@ -393,16 +373,16 @@ class Anneal(object):  # ), metaclass=_Memoize):
                         new_identifier = " ".join(ft.qualifiers["note"])
 
                 from pydna.utils import (
-                    identifier_from_string as _identifier_from_string,
+                    identifier_from_string,
                 )  # TODO:  clean this up
 
                 prd.name = (
-                    _identifier_from_string(new_identifier)[:16]
+                    identifier_from_string(new_identifier)[:16]
                     or self.kwargs.get("name")
                     or f"{len(prd)}bp_PCR_prod"[:16]
                 )
                 prd.id = (
-                    _identifier_from_string(new_identifier)[:16]
+                    identifier_from_string(new_identifier)[:16]
                     or self.kwargs.get("id")
                     or f"{len(prd)}bp"[:16]
                 )
@@ -410,7 +390,7 @@ class Anneal(object):  # ), metaclass=_Memoize):
                     "description"
                 ) or "pcr_product_{}_{}".format(fp.description, rp.description)
 
-                amplicon = _Amplicon(
+                amplicon = Amplicon(
                     prd,
                     template=tpl,
                     forward_primer=fp,
@@ -456,12 +436,12 @@ class Anneal(object):  # ), metaclass=_Memoize):
                 )
         else:
             mystring += "No reverse primers anneal...\n"
-        return _pretty_str(mystring.strip())
+        return pretty_str(mystring.strip())
 
     report = __str__
 
 
-def pcr(*args, **kwargs) -> _Amplicon:
+def pcr(*args, **kwargs) -> Amplicon:
     """pcr is a convenience function for the Anneal class to simplify its
     usage, especially from the command line. If more than one or no PCR
     product is formed, a ValueError is raised.
@@ -523,15 +503,15 @@ tatcgactgtatcatctgatagcac")
 
     """
 
-    output = _flatten(args)  # flatten
+    output = flatten(args)  # flatten
     new = []
     for s in output:
         if hasattr(s, "watson"):
-            s = _SeqRecord(_Seq(s.watson))
+            s = SeqRecord(Seq(s.watson))
         elif hasattr(s, "transcribe"):
-            s = _SeqRecord(s)
+            s = SeqRecord(s)
         elif isinstance(s, str):
-            s = _SeqRecord(_Seq(s))
+            s = SeqRecord(Seq(s))
         elif hasattr(s, "features"):
             pass
         else:
@@ -546,7 +526,7 @@ tatcgactgtatcatctgatagcac")
         new = [new[0].forward_primer, new[0].reverse_primer, new[0].template]
 
     if not hasattr(new[-1].seq, "watson"):
-        new[-1] = _Dseqrecord(s)
+        new[-1] = Dseqrecord(s)
 
     anneal_primers = Anneal(new[:-1], new[-1], **kwargs)