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

pydna/common_sub_strings.py

@@ -389,16 +389,6 @@ def terminal_overlap(stringx: str, stringy: str, limit: int = 15) -> _List[Match
     return [
         m
         for m in common_sub_strings(stringx, stringy, limit)
-        if (m[0] == 0 and m[1] + m[2] == len(stringy)) or (m[1] == 0 and m[0] + m[2] == len(stringx))
+        if (m[0] == 0 and m[1] + m[2] == len(stringy))
+        or (m[1] == 0 and m[0] + m[2] == len(stringx))
     ]
-
-
-if __name__ == "__main__":
-    import os as _os
-
-    cached = _os.getenv("pydna_cached_funcs", "")
-    _os.environ["pydna_cached_funcs"] = ""
-    import doctest
-
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS)
-    _os.environ["pydna_cached_funcs"] = cached

pydna/contig.py

@@ -32,11 +32,15 @@ class Contig(_Dseqrecord):
         return obj
 
     def __repr__(self):
-        return "Contig({}{})".format({True: "-", False: "o"}[not self.circular], len(self))
+        return "Contig({}{})".format(
+            {True: "-", False: "o"}[not self.circular], len(self)
+        )
 
     def _repr_pretty_(self, p, cycle):
         """returns a short string representation of the object"""
-        p.text("Contig({}{})".format({True: "-", False: "o"}[not self.circular], len(self)))
+        p.text(
+            "Contig({}{})".format({True: "-", False: "o"}[not self.circular], len(self))
+        )
 
     def _repr_html_(self):
         return "<pre>" + self.figure() + "</pre>"
@@ -45,14 +49,22 @@ class Contig(_Dseqrecord):
         answer = type(self)(super().reverse_complement())
         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]])
+        g.add_edges_from(
+            [(nm[v], nm[u], d) for u, v, d in list(self.graph.edges(data=True))[::-1]]
+        )
         g.add_nodes_from((nm[n], d) for n, d in list(self.graph.nodes(data=True))[::-1])
         for u, v, ed in g.edges(data=True):
-            ed["name"] = ed["name"][:-3] if ed["name"].endswith("_rc") else "{}_rc".format(ed["name"])[:13]
+            ed["name"] = (
+                ed["name"][:-3]
+                if ed["name"].endswith("_rc")
+                else "{}_rc".format(ed["name"])[:13]
+            )
             ed["seq"] = _rc(ed["seq"])
             ln = len(ed["seq"])
             start, stop = ed["piece"].start, ed["piece"].stop
-            ed["piece"] = slice(ln - stop - g.nodes[u]["length"], ln - start - g.nodes[v]["length"])
+            ed["piece"] = slice(
+                ln - stop - g.nodes[u]["length"], ln - start - g.nodes[v]["length"]
+            )
             ed["features"] = [f._flip(ln) for f in ed["features"]]
         answer.graph = g
         answer.nodemap = {v: k for k, v in self.nodemap.items()}
@@ -180,10 +192,16 @@ class Contig(_Dseqrecord):
             space = space2  # len(f.name)
 
             for i, f in enumerate(edges[1:-1]):
-                name = "{o1:>2}|{name}|".format(o1=nodes[i + 1][1]["length"], name=f[2]["name"])
+                name = "{o1:>2}|{name}|".format(
+                    o1=nodes[i + 1][1]["length"], name=f[2]["name"]
+                )
                 space2 = len(name)
 
-                fig += ("{space} {name}{o2:>2}\n" "{space} {space2}\\/\n" "{space} {space2}/\\\n").format(
+                fig += (
+                    "{space} {name}{o2:>2}\n"
+                    "{space} {space2}\\/\n"
+                    "{space} {space2}/\\\n"
+                ).format(
                     name=name,
                     o2=nodes[i + 2][1]["length"],
                     space=" " * space,
@@ -193,7 +211,9 @@ class Contig(_Dseqrecord):
                 space += space2
 
             f = edges[-1]
-            fig += ("{space} {o1:>2}|{name}").format(name=f[2]["name"], o1=nodes[-2][1]["length"], space=" " * (space))
+            fig += ("{space} {o1:>2}|{name}").format(
+                name=f[2]["name"], o1=nodes[-2][1]["length"], space=" " * (space)
+            )
 
         else:  # circular
             r"""
@@ -221,9 +241,15 @@ class Contig(_Dseqrecord):
             )
 
             for i, f in enumerate(edges[1:]):
-                name = "{o1:>2}|{name}|".format(o1=nodes[i + 1][1]["length"], name=f[2]["name"])
+                name = "{o1:>2}|{name}|".format(
+                    o1=nodes[i + 1][1]["length"], name=f[2]["name"]
+                )
                 space2 = len(name)
-                fig += ("|{space}{name}{o2:>2}\n" "|{space}{space2}\\/\n" "|{space}{space2}/\\\n").format(
+                fig += (
+                    "|{space}{name}{o2:>2}\n"
+                    "|{space}{space2}\\/\n"
+                    "|{space}{space2}/\\\n"
+                ).format(
                     o2=nodes[i + 2][1]["length"],
                     name=name,
                     space=" " * space,
@@ -231,18 +257,9 @@ class Contig(_Dseqrecord):
                 )
                 space += space2
 
-            fig += "|{space}{o1:>2}-\n".format(space=" " * (space), o1=nodes[0][1]["length"])
+            fig += "|{space}{o1:>2}-\n".format(
+                space=" " * (space), o1=nodes[0][1]["length"]
+            )
             fig += "|{space}   |\n".format(space=" " * (space))
             fig += " {space}".format(space="-" * (space + 3))
         return _pretty_str(_textwrap.dedent(fig))
-
-
-if __name__ == "__main__":
-    import os as _os
-
-    cached = _os.getenv("pydna_cached_funcs", "")
-    _os.environ["pydna_cached_funcs"] = ""
-    import doctest
-
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS)
-    _os.environ["pydna_cached_funcs"] = cached

pydna/crispr.py

@@ -111,21 +111,16 @@ def protospacer(guide_construct, cas=cas9):
     """docstring."""
     in_watson = [
         mobj.group("ps")
-        for mobj in re.finditer(f"(?P<ps>.{{{cas.size}}})(?:{cas.scaffold})", str(guide_construct.seq).upper())
+        for mobj in re.finditer(
+            f"(?P<ps>.{{{cas.size}}})(?:{cas.scaffold})",
+            str(guide_construct.seq).upper(),
+        )
     ]
     in_crick = [
         rc(mobj.group("ps"))
-        for mobj in re.finditer(f"(?:{rc(cas.scaffold)})(?P<ps>.{{{cas.size}}})", str(guide_construct.seq).upper())
+        for mobj in re.finditer(
+            f"(?:{rc(cas.scaffold)})(?P<ps>.{{{cas.size}}})",
+            str(guide_construct.seq).upper(),
+        )
     ]
     return in_watson + in_crick
-
-
-if __name__ == "__main__":
-    import os as _os
-
-    cached = _os.getenv("pydna_cached_funcs", "")
-    _os.environ["pydna_cached_funcs"] = ""
-    import doctest
-
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS)
-    _os.environ["pydna_cached_funcs"] = cached

pydna/design.py

@@ -16,22 +16,28 @@
 
 from pydna.tm import tm_default as _tm_default
 import math as _math
-import os as _os
+
+# 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 logging as _logging
 import operator as _operator
 from typing import Tuple
 
-_module_logger = _logging.getLogger("pydna." + __name__)
+# _module_logger = _logging.getLogger("pydna." + __name__)
 
 
 def _design_primer(
-    target_tm: float, template: _Dseqrecord, limit: int, tm_func, starting_length: int = 0
+    target_tm: float,
+    template: _Dseqrecord,
+    limit: int,
+    tm_func,
+    starting_length: int = 0,
 ) -> Tuple[float, str]:
     """returns a tuple (temp, primer)"""
 
@@ -63,7 +69,7 @@ def _design_primer(
         if length < limit:
             return template.seq[:limit]
 
-    _module_logger.debug(((p, tmp), (prev_primer, prev_temp)))
+    # _module_logger.debug(((p, tmp), (prev_primer, prev_temp)))
     if abs(target_tm - tmp) < abs(target_tm - prev_temp):
         return p
     else:
@@ -71,7 +77,14 @@ def _design_primer(
 
 
 def primer_design(
-    template, fp=None, rp=None, limit=13, target_tm=55.0, tm_func=_tm_default, estimate_function=None, **kwargs
+    template,
+    fp=None,
+    rp=None,
+    limit=13,
+    target_tm=55.0,
+    tm_func=_tm_default,
+    estimate_function=None,
+    **kwargs,
 ):
     """This function designs a forward primer and a reverse primer for PCR amplification
     of a given template sequence.
@@ -178,10 +191,10 @@ 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:")
+        # _module_logger.debug("no primer given, design forward primer:")
         fp = _Primer((design(target_tm, template)))
         target_tm = tm_func(str(fp.seq))
-        _module_logger.debug("no primer given, design reverse primer:")
+        # _module_logger.debug("no primer given, design reverse primer:")
         rp = _Primer(design(target_tm, template.reverse_complement()))
     elif fp and not rp:
         try:
@@ -192,7 +205,7 @@ def primer_design(
             print("Unexpected error")
             raise
         target_tm = tm_func(fp.footprint)
-        _module_logger.debug("forward primer given, design reverse primer:")
+        # _module_logger.debug("forward primer given, design reverse primer:")
         rp = _Primer(design(target_tm, template.reverse_complement()))
     elif not fp and rp:
         try:
@@ -203,7 +216,7 @@ def primer_design(
             print("Unexpected error")
             raise
         target_tm = tm_func(rp.footprint)
-        _module_logger.debug("reverse primer given, design forward primer:")
+        # _module_logger.debug("reverse primer given, design forward primer:")
         fp = _Primer(design(target_tm, template))
     else:
         raise ValueError("Specify maximum one of the two primers.")
@@ -231,7 +244,9 @@ def primer_design(
         import warnings as _warnings
         from pydna import _PydnaWarning
 
-        _warnings.warn("designed primers do not yield a unique PCR product", _PydnaWarning)
+        _warnings.warn(
+            "designed primers do not yield a unique PCR product", _PydnaWarning
+        )
 
     return prod
 
@@ -626,20 +641,29 @@ def assembly_fragments(f, overlap=35, maxlink=40, circular=False):
 
     # Recursive call for circular assemblies
     if circular:
-        fragments = assembly_fragments(f + f[0:1], overlap=overlap, maxlink=maxlink, circular=False)
+        fragments = assembly_fragments(
+            f + f[0:1], overlap=overlap, maxlink=maxlink, circular=False
+        )
 
         if hasattr(fragments[0], "template"):
-            fragments[0] = _pcr((fragments[-1].forward_primer, fragments[0].reverse_primer), fragments[0].template)
+            fragments[0] = _pcr(
+                (fragments[-1].forward_primer, fragments[0].reverse_primer),
+                fragments[0].template,
+            )
         return fragments[:-1]
 
     # sanity check for arguments
     nf = [item for item in f if len(item) > maxlink]
-    if not all(hasattr(i[0], "template") or hasattr(i[1], "template") for i in zip(nf, nf[1:])):
-        raise ValueError("Every second fragment larger than maxlink has to be an Amplicon object")
+    if not all(
+        hasattr(i[0], "template") or hasattr(i[1], "template") for i in zip(nf, nf[1:])
+    ):
+        raise ValueError(
+            "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)
+    # _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]
 
@@ -649,23 +673,24 @@ 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)
+        # _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)
+    # 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[-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)
+    # _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("")
 
-    _module_logger.debug(f)
-
-    _module_logger.debug("loop through fragments in groups of three:")
+    # _module_logger.debug(f)
+    # _module_logger.debug("loop through fragments in groups of three:")
 
     tail_length = _math.ceil(overlap / 2)
 
@@ -675,42 +700,56 @@ 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))
+        # _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)")
+            # _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))
+            # _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"
-                )
+                # _module_logger.debug(
+                #    "secnd is is flanked by amplicons, so half of secnd should be added each flanking primers"
+                # )
 
                 first.reverse_primer = (
-                    secnd.seq.reverse_complement()._data.decode("ASCII")[secnd_len // 2 :] + first.reverse_primer
+                    secnd.seq.reverse_complement()._data.decode("ASCII")[
+                        secnd_len // 2 :
+                    ]
+                    + first.reverse_primer
+                )
+                third.forward_primer = (
+                    secnd.seq._data.decode("ASCII")[secnd_len // 2 :]
+                    + third.forward_primer
                 )
-                third.forward_primer = secnd.seq._data.decode("ASCII")[secnd_len // 2 :] + third.forward_primer
 
                 lnk = (
                     third.seq.reverse_complement()._data.decode("ASCII")
-                    + secnd.reverse_complement().seq._data.decode("ASCII")[: secnd_len // 2]
+                    + secnd.reverse_complement().seq._data.decode("ASCII")[
+                        : secnd_len // 2
+                    ]
                 )[-tail_length:]
-                _module_logger.debug("1 %s", lnk)
+                # _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)
+                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"):
-                first.reverse_primer = secnd.seq.reverse_complement()._data.decode("ASCII") + first.reverse_primer
+                first.reverse_primer = (
+                    secnd.seq.reverse_complement()._data.decode("ASCII")
+                    + first.reverse_primer
+                )
                 lnk = str(third.seq[:overlap].reverse_complement())
                 first.reverse_primer = lnk + first.reverse_primer
             elif hasattr(third, "template"):
-                third.forward_primer = secnd.seq._data.decode("ASCII") + third.forward_primer
+                third.forward_primer = (
+                    secnd.seq._data.decode("ASCII") + third.forward_primer
+                )
                 lnk = str(first.seq[-overlap:])
                 third.forward_primer = lnk + third.forward_primer
             secnd = empty
@@ -718,23 +757,23 @@ def assembly_fragments(f, overlap=35, maxlink=40, circular=False):
         else:  # secnd is larger than maxlink
             if hasattr(first, "template") and hasattr(secnd, "template"):
                 lnk = str(first.seq[-tail_length:])
-                # _module_logger.debug("4 %s", lnk)
+                # #_module_logger.debug("4 %s", lnk)
                 secnd.forward_primer = lnk + secnd.forward_primer
                 lnk = str(secnd.seq[:tail_length].reverse_complement())
-                # _module_logger.debug("5 %s", lnk)
+                # #_module_logger.debug("5 %s", lnk)
                 first.reverse_primer = lnk + first.reverse_primer
             elif hasattr(first, "template"):
                 lnk = str(secnd.seq[:overlap].reverse_complement())
-                # _module_logger.debug("6 %s", lnk)
+                # #_module_logger.debug("6 %s", lnk)
                 first.reverse_primer = lnk + first.reverse_primer
             elif hasattr(secnd, "template"):
                 lnk = str(first.seq[-overlap:])
-                # _module_logger.debug("7 %s", lnk)
+                # #_module_logger.debug("7 %s", lnk)
                 secnd.forward_primer = lnk + secnd.forward_primer
         f[i] = first
         f[i + 1] = secnd
 
-    _module_logger.debug("loop ended")
+    # _module_logger.debug("loop ended")
 
     f = [item for item in f if len(item)]
 
@@ -767,12 +806,3 @@ def circular_assembly_fragments(f, overlap=35, maxlink=40):
         stacklevel=2,
     )
     return assembly_fragments(f, overlap=overlap, maxlink=maxlink, circular=True)
-
-
-if __name__ == "__main__":
-    cached = _os.getenv("pydna_cached_funcs", "")
-    _os.environ["pydna_cached_funcs"] = ""
-    import doctest
-
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS)
-    _os.environ["pydna_cached_funcs"] = cached

pydna/download.py

@@ -8,33 +8,25 @@
 
 import textwrap as _textwrap
 
-import os as _os
+# import os as _os
 from pydna._pretty import pretty_str as _pretty_str
-from pydna.utils import memorize as _memorize
-import logging as _logging
 
-_module_logger = _logging.getLogger("pydna." + __name__)
+# from pydna.utils import memorize as _memorize
+# import logging as _logging
 
+# _module_logger = _logging.getLogger("pydna." + __name__)
 
-@_memorize("pydna.download.download_text")
+
+# @_memorize("pydna.download.download_text")
 def download_text(url):
     """docstring."""
     import requests
 
-    _module_logger.info("#### DOWNLOAD TEXT ####")
-    _module_logger.info("url = %s", url)
+    #    _module_logger.info("#### DOWNLOAD TEXT ####")
+    #    _module_logger.info("url = %s", url)
     req = requests.get(url)
-    _module_logger.info("url = %s", str(req))
+    #    _module_logger.info("url = %s", str(req))
     result = _textwrap.dedent(req.text).strip()
     result = result.replace("\r\n", "\n").replace("\r", "\n")
-    _module_logger.info("result[:160] = %s", result[:160])
+    #    _module_logger.info("result[:160] = %s", result[:160])
     return _pretty_str(result)
-
-
-if __name__ == "__main__":
-    cached = _os.getenv("pydna_cached_funcs", "")
-    _os.environ["pydna_cached_funcs"] = ""
-    import doctest
-
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS)
-    _os.environ["pydna_cached_funcs"] = cached