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

pydna/codon.py

@@ -6,7 +6,7 @@
 
 # https://www.genome.jp/kegg/catalog/org_list.html
 
-from typing import Dict as _Dict
+from typing import Dict
 
 _sce_weights = {
     "TTT": 1.0,
@@ -81,7 +81,7 @@ weights = {"sce": _sce_weights}
 # PMID: 11589713
 
 
-start: _Dict[str, _Dict[str, float]] = {
+start: Dict[str, Dict[str, float]] = {
     "sce": {"ATG": 1.000, "TTG": 0.069, "ATA": 0.005},
     "eco": {},
 }
@@ -99,13 +99,13 @@ rare_codons = {
     "eco": ["AGG", "AGA", "ATA", "CTA", "CGA", "CGG", "CCC", "TCG"],
 }
 
-stop: _Dict[str, _Dict[str, float]] = {
+stop: Dict[str, Dict[str, float]] = {
     "sce": {"TAA": 0.470, "TAG": 0.230, "TGA": 0.300},
     "eco": {},
 }
 
 
-n_end: _Dict[str, _Dict[str, str]] = {
+n_end: Dict[str, Dict[str, str]] = {
     "sce": {
         "Val": ">30 h",
         "Met": ">30 h",

pydna/common_sub_strings.py

@@ -13,12 +13,10 @@ https://github.com/gip0/py-rstr-max
 the original code was covered by an MIT licence."""
 
 
-# from array import array as _array
-# import itertools as _itertools
-from operator import itemgetter as _itemgetter
-from typing import List as _List, Tuple as _Tuple
+from operator import itemgetter
+from typing import List, Tuple
 
-Match = _Tuple[int, int, int]  # (x_start, y_start, length)
+Match = Tuple[int, int, int]  # (x_start, y_start, length)
 
 # def _kark_sort(s, SA, n, K):
 #     def radixpass(a, b, r, s, n, k):
@@ -314,7 +312,7 @@ Match = _Tuple[int, int, int]  # (x_start, y_start, length)
 #     return match
 
 
-def common_sub_strings(stringx: str, stringy: str, limit: int = 25) -> _List[Match]:
+def common_sub_strings(stringx: str, stringy: str, limit: int = 25) -> List[Match]:
     """
     Finds all common substrings between stringx and stringy, and returns
     them sorted by length.
@@ -340,11 +338,11 @@ def common_sub_strings(stringx: str, stringy: str, limit: int = 25) -> _List[Mat
 
     matches = common_substrings(stringx, stringy, limit=limit)
     matches.sort()
-    matches.sort(key=_itemgetter(2), reverse=True)
+    matches.sort(key=itemgetter(2), reverse=True)
     return matches
 
 
-def terminal_overlap(stringx: str, stringy: str, limit: int = 15) -> _List[Match]:
+def terminal_overlap(stringx: str, stringy: str, limit: int = 15) -> List[Match]:
     """Finds the the flanking common substrings between stringx and stringy
     longer than limit. This means that the results only contains substrings
     that starts or ends at the the ends of stringx and stringy.

pydna/contig.py

@@ -1,12 +1,13 @@
 # -*- coding: utf-8 -*-
-import textwrap as _textwrap
-import networkx as _nx
-from pydna._pretty import pretty_str as _pretty_str
-from pydna.dseqrecord import Dseqrecord as _Dseqrecord
-from pydna.utils import rc as _rc
+import textwrap
+import networkx as nx
+from pydna._pretty import pretty_str as ps
+from pydna.dseqrecord import Dseqrecord
+from pydna.utils import rc
+import numpy as np
 
 
-class Contig(_Dseqrecord):
+class Contig(Dseqrecord):
     """This class holds information about a DNA assembly. This class is instantiated by
     the :class:`Assembly` class and is not meant to be used directly.
 
@@ -47,7 +48,7 @@ class Contig(_Dseqrecord):
 
     def reverse_complement(self):
         answer = type(self)(super().reverse_complement())
-        g = _nx.DiGraph()
+        g = nx.DiGraph()
         nm = self.nodemap
         g.add_edges_from(
             [(nm[v], nm[u], d) for u, v, d in list(self.graph.edges(data=True))[::-1]]
@@ -59,7 +60,7 @@ class Contig(_Dseqrecord):
                 if ed["name"].endswith("_rc")
                 else "{}_rc".format(ed["name"])[:13]
             )
-            ed["seq"] = _rc(ed["seq"])
+            ed["seq"] = rc(ed["seq"])
             ln = len(ed["seq"])
             start, stop = ed["piece"].start, ed["piece"].stop
             ed["piece"] = slice(
@@ -124,7 +125,7 @@ class Contig(_Dseqrecord):
         for p, s in mylist:
             fig += "{}{}\n".format(" " * (p + firstpos), s)
 
-        return _pretty_str(fig)
+        return ps(fig)
 
     def figure(self):
         r"""Compact ascii representation of the assembled fragments.
@@ -262,4 +263,196 @@ class Contig(_Dseqrecord):
             )
             fig += "|{space}   |\n".format(space=" " * (space))
             fig += " {space}".format(space="-" * (space + 3))
-        return _pretty_str(_textwrap.dedent(fig))
+        return ps(textwrap.dedent(fig))
+
+    def figure_mpl(self):
+        """
+        Graphic representation of the assembly.
+
+        Returns
+        -------
+        matplotlib.figure.Figure
+            A representation of a linear or culrcular assembly.
+
+        """
+        # lazy imports in case matplotlib is not installed
+        import matplotlib.pyplot as plt
+        import matplotlib.patches as mpatches
+
+        plt.ioff()  # Disable interactive mode, otherwise two plots are shown in Spyder.
+        # https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.isinteractive.html#matplotlib.pyplot.isinteractive
+
+        def pick_n_colors(n, cmap_name="tab20"):
+            cmap = plt.get_cmap(cmap_name)
+            return [cmap(i / n) for i in range(n)]
+
+        fig, ax = plt.subplots()
+        edges = list(self.graph.edges(data=True))
+        colors = pick_n_colors(len(edges))
+
+        if self.circular:
+            # Circle parameters for Circular assembly
+            center = 0, 0
+            outer_radius = 1.5  # fragments on the outer lane
+            middle_radius = 1.3  # fragments on the inner lane
+            small_radius = 1.1  # odd number of fragments require an extra radius
+            arc_width = 0.1  # Arc thickness
+
+            circle = len(self)  # The circle has the length of the assembly
+            radii = [outer_radius, middle_radius] * (
+                len(edges) // 2
+            )  # radii alternates, starting with outer.
+
+            if len(edges) % 2 != 0:  # last fragment get a smaller radius
+                radii.append(small_radius)
+
+            assert (
+                len(colors) == len(radii) == len(edges)
+            )  # One color and one radius for each edge.
+
+            # The recombination between last and first fragments
+            # end at the origin (twelve o'clock).
+            start = 0 - len(edges[0][0])
+
+            for edge, radius, color in zip(edges, radii, colors):
+
+                node1, node2, meta = edge
+                slc = meta["piece"]
+                extra = len(node2)
+                # slc contain the first but not the second node, so add extra to the length
+                length = slc.stop - slc.start + extra
+
+                theta1 = 90.0 - 360.0 / circle * start
+                theta2 = 90.0 - 360.0 / circle * (start + length)
+
+                # Create arc
+                arc_patch = mpatches.Wedge(
+                    center=center,
+                    r=radius,
+                    theta1=theta2,
+                    theta2=theta1,
+                    width=arc_width,
+                    edgecolor=color,
+                    facecolor=(1, 1, 1, 0),
+                    linewidth=1,
+                )
+                ax.add_patch(arc_patch)
+
+                # Compute label position slightly outside the arc
+                mid_angle = (theta1 + theta2) / 2
+                rad = np.deg2rad(mid_angle)
+                label_radius = radius + arc_width + 0.1  # place outside the arc
+                x = label_radius * np.cos(rad)
+                y = label_radius * np.sin(rad)
+
+                # Choose alignment based on angle
+                ha = "left" if np.cos(rad) >= 0 else "right"
+                va = "center"
+
+                ax.text(x, y, meta["name"], ha=ha, va=va, fontsize=10)
+
+                start += length - len(node2)
+            ax.axis("off")
+            ax.set_aspect("equal")
+            ax.set_xlim(-1.6, 1.6)  # This should be enough, but not extensively tested.
+            ax.set_ylim(-1.6, 1.6)
+
+        else:  # Linear assembly
+            import itertools  # 3131 bp
+
+            unit = len(self) / 50
+            upper = 4 * unit
+            lower = 1 * unit
+            height = 1 * unit
+            x = 0
+
+            for edge, y, color in zip(edges, itertools.cycle((lower, upper)), colors):
+                node1, node2, metadict = edge
+                slc = metadict["piece"]
+                # slc contain the first but not the second node, so add extra to the length if not begin or end.
+                extra = len(node2) if node2 not in ("begin", "end") else 0
+                length = slc.stop - slc.start + extra
+                box = mpatches.FancyBboxPatch(
+                    (x, y),
+                    length,
+                    height,
+                    linewidth=1,
+                    boxstyle="round",
+                    edgecolor=color,
+                    facecolor=(1, 1, 1, 0),
+                )
+                ax.add_patch(box)
+                ax.text(
+                    x + length / 2,
+                    y + height * 2 if y == upper else y - height * 2,
+                    metadict["name"],
+                    ha="center",
+                    va="center",
+                    fontsize=10,
+                )
+                x += length - len(node2)
+            ax.axis("off")
+            ax.set_aspect("equal")
+            ax.set_xlim(-1, len(self) + 1)
+            ax.set_ylim(-height, height * 2 + upper)
+        return fig
+
+    # FIXME: This code uses plotly, but I see no reason for it at this point.
+    # def figure_plotly(self):
+    #     import plotly.graph_objects as go
+    #     import numpy as np
+
+    #     circ = len(self)
+    #     arcs = list(self.graph.edges(data=True))
+
+    #     # Radii setup
+    #     small_radius = 1.1
+    #     middle_radius = 1.3
+    #     outer_radius = 1.5
+    #     arc_width = 0.1
+
+    #     radii = [outer_radius, middle_radius] * (len(arcs) // 2)
+    #     if len(arcs) % 2 != 0:
+    #         radii.append(small_radius)
+
+    #     fig = go.Figure()
+    #     start = 0 - len(arcs[0][0])
+
+    #     for (node1, node2, meta), radius in zip(arcs, radii):
+    #         slc = meta["piece"]
+    #         length = slc.stop - slc.start + len(node1)
+
+    #         theta1 = 90.0 - 360.0 / circ * start
+    #         theta2 = 90.0 - 360.0 / circ * (start + length)
+
+    #         # Generate arc points
+    #         theta = np.linspace(theta1, theta2, 50)
+    #         theta_rev = theta[::-1]
+
+    #         r_outer = np.full_like(theta, radius)
+    #         r_inner = np.full_like(theta_rev, radius - arc_width)
+
+    #         r = np.concatenate([r_outer, r_inner])
+    #         t = np.concatenate([theta, theta_rev])
+
+    #         fig.add_trace(
+    #             go.Scatterpolar(
+    #                 r=r,
+    #                 theta=t,
+    #                 fill="toself",
+    #                 mode="lines",
+    #                 line_color="rgba(0,100,200,0.6)",
+    #                 hoverinfo="text",
+    #                 text=meta["name"],
+    #                 name=meta["name"],
+    #             )
+    #         )
+
+    #         start += length - len(node2)
+
+    #     fig.update_layout(
+    #         polar=dict(radialaxis=dict(visible=False), angularaxis=dict(visible=False)),
+    #         showlegend=False,
+    #     )
+
+    #     fig.show("browser")

pydna/design.py

@@ -14,27 +14,23 @@
 
 """
 
-from pydna.tm import tm_default as _tm_default
-import math as _math
-
-# import os as _os
-import copy as _copy
-from pydna.amplicon import Amplicon as _Amplicon
-from pydna.amplify import Anneal as _Anneal
-from pydna.amplify import pcr as _pcr
-from pydna.dseqrecord import Dseqrecord as _Dseqrecord
-from pydna.primer import Primer as _Primer
-
-# import logging as _logging
-import operator as _operator
+from pydna.tm import tm_default
+import math
+import copy
+from pydna.amplicon import Amplicon
+from pydna.amplify import Anneal
+from pydna.amplify import pcr
+from pydna.dseqrecord import Dseqrecord
+from pydna.primer import Primer
+import operator
 from typing import Tuple
-
-# _module_logger = _logging.getLogger("pydna." + __name__)
+from itertools import pairwise, product
+import re
 
 
 def _design_primer(
     target_tm: float,
-    template: _Dseqrecord,
+    template: Dseqrecord,
     limit: int,
     tm_func,
     starting_length: int = 0,
@@ -52,10 +48,10 @@ def _design_primer(
     p = str(template.seq[:length])
 
     if tmp < target_tm:
-        condition = _operator.le
+        condition = operator.le
         increment = 1
     else:
-        condition = _operator.ge
+        condition = operator.ge
         increment = -1
     while condition(tmp, target_tm):
         prev_temp = tmp
@@ -69,7 +65,6 @@ def _design_primer(
         if length < limit:
             return template.seq[:limit]
 
-    # _module_logger.debug(((p, tmp), (prev_primer, prev_temp)))
     if abs(target_tm - tmp) < abs(target_tm - prev_temp):
         return p
     else:
@@ -82,7 +77,7 @@ def primer_design(
     rp=None,
     limit=13,
     target_tm=55.0,
-    tm_func=_tm_default,
+    tm_func=tm_default,
     estimate_function=None,
     **kwargs,
 ):
@@ -191,33 +186,33 @@ def primer_design(
             return _design_primer(target_tm, template, limit, tm_func)
 
     if not fp and not rp:
-        # _module_logger.debug("no primer given, design forward primer:")
-        fp = _Primer((design(target_tm, template)))
+
+        fp = Primer((design(target_tm, template)))
         target_tm = tm_func(str(fp.seq))
-        # _module_logger.debug("no primer given, design reverse primer:")
-        rp = _Primer(design(target_tm, template.reverse_complement()))
+
+        rp = Primer(design(target_tm, template.reverse_complement()))
     elif fp and not rp:
         try:
-            fp = _Anneal((fp,), template).forward_primers.pop()
+            fp = Anneal((fp,), template).forward_primers.pop()
         except IndexError:
             raise ValueError("Forward primer does not anneal")
         except Exception:  # pragma: no cover
             print("Unexpected error")
             raise
         target_tm = tm_func(fp.footprint)
-        # _module_logger.debug("forward primer given, design reverse primer:")
-        rp = _Primer(design(target_tm, template.reverse_complement()))
+
+        rp = Primer(design(target_tm, template.reverse_complement()))
     elif not fp and rp:
         try:
-            rp = _Anneal((rp,), template).reverse_primers.pop()
+            rp = Anneal((rp,), template).reverse_primers.pop()
         except IndexError:
             raise ValueError("Reverse primer does not anneal")
         except Exception:  # pragma: no cover
             print("Unexpected error")
             raise
         target_tm = tm_func(rp.footprint)
-        # _module_logger.debug("reverse primer given, design forward primer:")
-        fp = _Primer(design(target_tm, template))
+
+        fp = Primer(design(target_tm, template))
     else:
         raise ValueError("Specify maximum one of the two primers.")
 
@@ -236,15 +231,15 @@ def primer_design(
     fp.description = fp.id + " " + template.accession
     rp.description = rp.id + " " + template.accession
 
-    ampl = _Anneal((fp, rp), template, limit=limit)
+    ampl = Anneal((fp, rp), template, limit=limit)
 
-    prod = ampl.products[0] if ampl.products else _Amplicon("")
+    prod = ampl.products[0] if ampl.products else Amplicon("")
 
     if len(ampl.products) > 1:
-        import warnings as _warnings
+        import warnings
         from pydna import _PydnaWarning
 
-        _warnings.warn(
+        warnings.warn(
             "designed primers do not yield a unique PCR product", _PydnaWarning
         )
 
@@ -646,7 +641,7 @@ def assembly_fragments(f, overlap=35, maxlink=40, circular=False):
         )
 
         if hasattr(fragments[0], "template"):
-            fragments[0] = _pcr(
+            fragments[0] = pcr(
                 (fragments[-1].forward_primer, fragments[0].reverse_primer),
                 fragments[0].template,
             )
@@ -661,11 +656,7 @@ def assembly_fragments(f, overlap=35, maxlink=40, circular=False):
             "Every second fragment larger than maxlink has to be an Amplicon object"
         )
 
-    # _module_logger.debug("### assembly fragments ###")
-    # _module_logger.debug("overlap     = %s", overlap)
-    # _module_logger.debug("max_link    = %s", maxlink)
-
-    f = [_copy.copy(f) for f in f]
+    f = [copy.copy(f) for f in f]
 
     first_fragment_length = len(f[0])
     last_fragment_length = len(f[-1])
@@ -673,26 +664,21 @@ def assembly_fragments(f, overlap=35, maxlink=40, circular=False):
     if first_fragment_length <= maxlink:
         # first fragment should be removed and added to second fragment (new first fragment) forward primer
         f[1].forward_primer = f[0].seq._data.decode("ASCII") + f[1].forward_primer
-        # _module_logger.debug("first fragment removed since len(f[0]) = %s", first_fragment_length)
+
         f = f[1:]
     # else:
-    # _module_logger.debug("first fragment stays since len(f[0]) = %s", first_fragment_length)
 
     if last_fragment_length <= maxlink:
         f[-2].reverse_primer = (
             f[-1].seq.reverse_complement()._data.decode("ASCII") + f[-2].reverse_primer
         )
         f = f[:-1]
-    # _module_logger.debug("last fragment removed since len(f[%s]) = %s", len(f), last_fragment_length)
-    # else:
-    # _module_logger.debug("last fragment stays since len(f[%s]) = %s", len(f), last_fragment_length)
 
-    empty = _Dseqrecord("")
+    # else:
 
-    # _module_logger.debug(f)
-    # _module_logger.debug("loop through fragments in groups of three:")
+    empty = Dseqrecord("")
 
-    tail_length = _math.ceil(overlap / 2)
+    tail_length = math.ceil(overlap / 2)
 
     for i in range(len(f) - 1):
         first = f[i]
@@ -700,15 +686,12 @@ def assembly_fragments(f, overlap=35, maxlink=40, circular=False):
 
         secnd_len = len(secnd)
 
-        # _module_logger.debug("first = %s", str(first.seq))
-        # _module_logger.debug("secnd = %s", str(secnd.seq))
-
         if secnd_len <= maxlink:
-            # _module_logger.debug("secnd is smaller or equal to maxlink; should be added to primer(s)")
+
             third = f[i + 2]
-            # _module_logger.debug("third = %s", str(third.seq))
+
             if hasattr(f[i], "template") and hasattr(third, "template"):
-                # _module_logger.debug(
+
                 #    "secnd is is flanked by amplicons, so half of secnd should be added each flanking primers"
                 # )
 
@@ -729,14 +712,14 @@ def assembly_fragments(f, overlap=35, maxlink=40, circular=False):
                         : secnd_len // 2
                     ]
                 )[-tail_length:]
-                # _module_logger.debug("1 %s", lnk)
+
                 first.reverse_primer = lnk + first.reverse_primer
 
                 lnk = (
                     first.seq._data.decode("ASCII")
                     + secnd.seq._data.decode("ASCII")[: secnd_len // 2]
                 )[-tail_length:]
-                # _module_logger.debug("2 %s", lnk)
+
                 third.forward_primer = lnk + third.forward_primer
 
             elif hasattr(first, "template"):
@@ -773,13 +756,11 @@ def assembly_fragments(f, overlap=35, maxlink=40, circular=False):
         f[i] = first
         f[i + 1] = secnd
 
-    # _module_logger.debug("loop ended")
-
     f = [item for item in f if len(item)]
 
     return [
         (
-            _pcr(
+            pcr(
                 p.forward_primer,
                 p.reverse_primer,
                 p.template,
@@ -806,3 +787,138 @@ def circular_assembly_fragments(f, overlap=35, maxlink=40):
         stacklevel=2,
     )
     return assembly_fragments(f, overlap=overlap, maxlink=maxlink, circular=True)
+
+
+def user_assembly_design(
+    f: list[Amplicon], max_overlap: int = 15, min_overlap: int = 4, max_tail=50
+) -> list[Amplicon]:
+
+    import warnings
+
+    warnings.warn(
+        "The user_assembly_design function is experimental and "
+        "may change in future versions.",
+        category=FutureWarning,
+        stacklevel=2,
+    )
+
+    assert max_overlap > min_overlap, (
+        f"max_overlap ({max_overlap}) "
+        "has to be larger than min_overlap "
+        f"({min_overlap})"
+    )
+    amplicons = []
+
+    for fragment in f:
+        amplicons.append(primer_design(fragment))
+
+    flag = True
+
+    for ths, nxt in pairwise(amplicons):
+
+        A_positions_in_ths = [m.start() for m in re.finditer("A|a", str(ths.seq))]
+        T_positions_in_nxt = [m.start() for m in re.finditer("T|t", str(nxt.seq))]
+
+        for ths_a, ths_t in zip(A_positions_in_ths[::-1], T_positions_in_nxt):
+
+            sticky_length = ths_t + len(ths) - ths_a
+
+            if sticky_length < min_overlap:
+                continue
+
+            if sticky_length > max_overlap:
+                flag = False
+                break
+
+            rp = bytearray(
+                nxt.seq[: ths_t + 1].rc()._data + ths.reverse_primer.seq._data
+            )
+            fp = bytearray(ths.seq[ths_a:]._data + nxt.forward_primer.seq._data)
+
+            fp[sticky_length] = ord(b"U")
+            rp[sticky_length] = ord(b"U")
+
+            ths.reverse_primer = Primer(rp)
+            nxt.forward_primer = Primer(fp)
+
+            break  # Primers were designed.
+        else:
+            flag = False
+
+        if flag:
+            continue
+
+        # No suitable T-A pair was found on opposite sides of both fragments
+        # Look for T-A pairs contained in either sequence
+        # Distance between the T-A and proximity to the junction are important
+        # factors
+        T_positions_in_ths = [m.start() for m in re.finditer("T|t", str(ths.seq))]
+        pairs_ths = product(A_positions_in_ths[::-1], T_positions_in_ths[::-1])
+
+        for ths_a, ths_t in pairs_ths:
+            if ths_a > ths_t:
+                continue
+            sticky_length = ths_t - ths_a
+            if sticky_length < min_overlap:
+                continue
+            if sticky_length > max_overlap:
+                continue
+            pair_ths = ths_a, ths_t
+            break
+        else:
+            pair_ths = tuple()
+            ths_a, ths_t = 0, 0
+
+        A_positions_in_nxt = [m.start() for m in re.finditer("A|a", str(nxt.seq))]
+        pairs_nxt = product(A_positions_in_nxt, T_positions_in_nxt)
+
+        for nxt_a, nxt_t in pairs_nxt:
+            if nxt_a > nxt_t:
+                continue
+            sticky_length = nxt_t - nxt_a
+            if sticky_length < min_overlap:
+                continue
+            if sticky_length > max_overlap:
+                continue
+            pair_nxt = nxt_a, nxt_t
+            break
+        else:
+            pair_nxt = tuple()
+            nxt_a, nxt_t = 0, 0
+
+        if (pair_ths and not pair_nxt) or len(ths) - ths_a <= nxt_t:
+            # T-A pair in ths;
+            # Move ths reverse primer downstream
+            # Extend nxt foward primer tail
+
+            fp = bytearray(ths.seq[ths_a:]._data + nxt.forward_primer.seq._data)
+            fp[ths_t - ths_a] = ord(b"U")
+            nxt.forward_primer = Primer(fp)
+            shorter_ths = ths[: ths_t + 1]
+            rp = bytearray(
+                primer_design(
+                    shorter_ths, limit=ths_t - ths_a + 1
+                ).reverse_primer.seq._data
+            )
+            rp[ths_t - ths_a] = ord(b"U")
+            ths.reverse_primer = Primer(rp)
+
+        elif (not pair_ths and pair_nxt) or len(ths) - ths_a >= nxt_t:
+            # T-A pair in nxt; modify ths reverse primer
+            # Move nxt forward primer upstream
+            # Extend ths reverse primer tail
+            rp = bytearray(
+                nxt.seq[: nxt_t + 1].rc()._data + ths.reverse_primer.seq._data
+            )
+            rp[nxt_t - nxt_a] = ord(b"U")
+            ths.reverse_primer = Primer(rp)
+            shorter_nxt = nxt[nxt_a:]
+            fp = bytearray(
+                primer_design(
+                    shorter_nxt, limit=nxt_t - nxt_a + 1
+                ).forward_primer.seq._data
+            )
+            fp[nxt_t - nxt_a] = ord(b"U")
+            nxt.forward_primer = Primer(fp)
+
+    return amplicons