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

pydna/gateway.py

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 from Bio.Seq import reverse_complement
-from pydna.dseqrecord import Dseqrecord as _Dseqrecord
+from pydna.dseqrecord import Dseqrecord
 import re
-import itertools as _itertools
+import itertools
 from Bio.SeqFeature import SimpleLocation, SeqFeature
 from pydna.utils import shift_location
 from pydna.sequence_regex import compute_regex_site, dseqrecord_finditer
@@ -79,7 +79,7 @@ primer_design_attB = {
 
 
 def gateway_overlap(
-    seqx: _Dseqrecord, seqy: _Dseqrecord, reaction: str, greedy: bool
+    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,
@@ -110,7 +110,7 @@ def gateway_overlap(
                 if len(matches_y) == 0:
                     continue
 
-                for match_x, match_y in _itertools.product(matches_x, matches_y):
+                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())
@@ -133,7 +133,7 @@ def gateway_overlap(
 
 
 def find_gateway_sites(
-    seq: _Dseqrecord, greedy: bool
+    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
@@ -154,7 +154,7 @@ def find_gateway_sites(
     return out
 
 
-def annotate_gateway_sites(seq: _Dseqrecord, greedy: bool) -> _Dseqrecord:
+def annotate_gateway_sites(seq: Dseqrecord, greedy: bool) -> Dseqrecord:
     sites = find_gateway_sites(seq, greedy)
     for site in sites:
         for loc in sites[site]:

pydna/gel.py

@@ -9,7 +9,7 @@
 
 """docstring."""
 
-import math as _math
+import math
 from pydna.ladders import GeneRuler_1kb_plus as _mwstd
 
 
@@ -31,8 +31,8 @@ def gel(
     samples=None, gel_length=600, margin=50, interpolator=interpolator(mwstd=_mwstd)
 ):
     import numpy as np
-    from PIL import Image as Image
-    from PIL import ImageDraw as ImageDraw
+    from PIL import Image
+    from PIL import ImageDraw
 
     """docstring."""
     max_intensity = 256
@@ -54,7 +54,7 @@ def gel(
 
     for lane_number, lane in enumerate(samples):
         for band in lane:
-            log = _math.log(len(band), 10)
+            log = math.log(len(band), 10)
             height = (band.m() / (240 * log)) * 1e10
             peak_centre = interpolator(len(band)) * scale + start
             max_spread = 10
@@ -68,7 +68,7 @@ def gel(
                 y2 = peak_centre + i
                 intensity = (
                     height
-                    * _math.exp(
+                    * math.exp(
                         -float(((y1 - peak_centre) ** 2)) / (2 * (band_spread**2))
                     )
                     * max_intensity

pydna/genbank.py

@@ -11,21 +11,17 @@ The function can be used if the environmental variable **pydna_email** has
 been set to a valid email address. The easiest way to do this permanantly is to edit the
 `pydna.ini` file. See the documentation of :func:`pydna.open_config_folder`"""
 
-# from pydna.utils import memorize as _memorize
-from pydna.genbankrecord import GenbankRecord as _GenbankRecord
-from pydna.readers import read as _read
 
-from Bio import Entrez as _Entrez
-from typing import Literal as _Literal, Optional as _Optional
-import re as _re
-import os as _os
+from pydna.opencloning_models import NCBISequenceSource
+from pydna.readers import read
+from pydna.dseqrecord import Dseqrecord
 
-# import logging as _logging
+from Bio import Entrez
+from Bio.SeqFeature import SimpleLocation
 
-# _module_logger = _logging.getLogger("pydna." + __name__)
-
-
-# TODO http://httpbin.org/ use for testing?
+from typing import Literal, Optional
+import re
+import os
 
 
 class Genbank:
@@ -54,15 +50,11 @@ class Genbank:
         *,
         tool: str = "pydna",
     ) -> None:
-        if not _re.match(
-            r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}", users_email, _re.IGNORECASE
+        if not re.match(
+            r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}", users_email, re.IGNORECASE
         ):
             raise ValueError("email address {} is not valid.".format(users_email))
 
-        # _module_logger.info("#### Genbank ititiation ####")
-        # _module_logger.info("Genbank initiated with email: %s", users_email)
-        # _module_logger.info("Genbank initiated with tool : %s", tool)
-
         if users_email == "someone@example.com":
             raise ValueError(
                 "you have to set your email address in order to download from Genbank"
@@ -78,10 +70,10 @@ class Genbank:
     def nucleotide(
         self,
         item: str,
-        seq_start: _Optional[int] = None,
-        seq_stop: _Optional[int] = None,
-        strand: _Literal[1, 2] = 1,
-    ) -> _GenbankRecord:
+        seq_start: Optional[int] = None,
+        seq_stop: Optional[int] = None,
+        strand: Literal[1, 2] = 1,
+    ) -> Dseqrecord:
         """This method downloads a genbank nuclotide record from genbank. This method is
         cached by default. This can be controlled by editing the **pydna_cached_funcs** environment
         variable. The best way to do this permanently is to edit the edit the
@@ -120,7 +112,7 @@ class Genbank:
         "2", 2, "-" or "-1", the antisense (Crick) strand is returned, otherwise
         the sense (Watson) strand is returned.
 
-        Result is returned as a :class:`pydna.genbankrecord.GenbankRecord` object.
+        Result is returned as a :class:`Dseqrecord` object.
 
         References
         ----------
@@ -129,15 +121,15 @@ class Genbank:
         .. [#]   http://www.ncbi.nlm.nih.gov/books/NBK25499/#chapter4.EFetch
         """
         matches = (
-            (1, _re.search(r"(REGION:\s(?P<start>\d+)\.\.(?P<stop>\d+))", item)),
+            (1, re.search(r"(REGION:\s(?P<start>\d+)\.\.(?P<stop>\d+))", item)),
             (
                 2,
-                _re.search(
+                re.search(
                     r"(REGION: complement\((?P<start>\d+)\.\.(?P<stop>\d+)\))", item
                 ),
             ),
-            (1, _re.search(r"(:|\s)(?P<start>\d+)-(?P<stop>\d+)", item)),
-            (2, _re.search(r"(:|\s)c(?P<start>\d+)-(?P<stop>\d+)", item)),
+            (1, re.search(r"(:|\s)(?P<start>\d+)-(?P<stop>\d+)", item)),
+            (2, re.search(r"(:|\s)c(?P<start>\d+)-(?P<stop>\d+)", item)),
         )
 
         for strand_, match in matches:
@@ -156,18 +148,10 @@ class Genbank:
             except (KeyError, AttributeError):
                 strand = 1
 
-        # _module_logger.info("#### Genbank download ####")
-        # _module_logger.info("item  %s", item)
-        # _module_logger.info("start %s", seq_start)
-        # _module_logger.info("stop  %s", seq_stop)
-
-        # _module_logger.info("strand  %s", str(strand))
+        Entrez.email = self.email
+        Entrez.tool = self.tool
 
-        _Entrez.email = self.email
-        _Entrez.tool = self.tool
-
-        # _module_logger.info("Entrez.email  %s", self.email)
-        text = _Entrez.efetch(
+        text = Entrez.efetch(
             db="nuccore",
             id=item,
             rettype="gbwithparts",
@@ -177,14 +161,30 @@ class Genbank:
             retmode="text",
         ).read()
 
-        # _module_logger.info("text[:160]  %s", text[:160])
+        result = read(text)
+        # TODO: Address this for cases where only one is defined
+        if seq_start is not None and seq_stop is not None:
+            location = SimpleLocation(
+                int(seq_start) - 1, int(seq_stop), -1 if strand == 2 else strand
+            )
+        elif seq_start is None and seq_stop is None:
+            location = None
+        elif seq_stop is not None:
+            location = SimpleLocation(0, int(seq_stop), -1 if strand == 2 else strand)
+        else:
+            st = int(seq_start) - 1
+            location = SimpleLocation(
+                st, st + len(result), -1 if strand == 2 else strand
+            )
 
-        return _GenbankRecord(
-            _read(text), item=item, start=seq_start, stop=seq_stop, strand=strand
+        result.source = NCBISequenceSource(
+            repository_id=item,
+            coordinates=location,
         )
+        return result
 
 
-def genbank(accession: str = "CS570233.1", *args, **kwargs) -> _GenbankRecord:
+def genbank(accession: str = "CS570233.1", *args, email=None, **kwargs) -> Dseqrecord:
     """
     Download a genbank nuclotide record.
 
@@ -229,9 +229,6 @@ def genbank(accession: str = "CS570233.1", *args, **kwargs) -> _GenbankRecord:
         //
 
     """
-    email = _os.getenv("pydna_email")
-    # _module_logger.info("#### genbank function called ####")
-    # _module_logger.info("email      %s", email)
-    # _module_logger.info("accession  %s", email)
+    email = email or os.getenv("pydna_email")
     gb = Genbank(email)
     return gb.nucleotide(accession, *args, **kwargs)

pydna/genbankfixer.py

@@ -24,63 +24,63 @@ This should not be a difficult fix. The returned result has two properties,
 which is the formatted genbank string."""
 
 
-import re as _re
-import pyparsing as _pp
+import re
+import pyparsing as pp
 
 GoodLocus = (
-    _pp.Literal("LOCUS")
-    + _pp.Word(_pp.alphas + _pp.nums + "-_()." + "\\").setResultsName("name")
-    + _pp.Word(_pp.nums).setResultsName("size")
-    + _pp.Suppress(_pp.CaselessLiteral("bp"))
-    + _pp.Word(_pp.alphas + "-").setResultsName("seqtype")
-    + (_pp.CaselessLiteral("linear") | _pp.CaselessLiteral("circular")).setResultsName(
+    pp.Literal("LOCUS")
+    + pp.Word(pp.alphas + pp.nums + "-_()." + "\\").setResultsName("name")
+    + pp.Word(pp.nums).setResultsName("size")
+    + pp.Suppress(pp.CaselessLiteral("bp"))
+    + pp.Word(pp.alphas + "-").setResultsName("seqtype")
+    + (pp.CaselessLiteral("linear") | pp.CaselessLiteral("circular")).setResultsName(
         "topology"
     )
-    + _pp.Optional(_pp.Word(_pp.alphas), default="   ").setResultsName("divcode")
-    + _pp.Regex(r"(\d{2})-(\S{3})-(\d{4})").setResultsName("date")
+    + pp.Optional(pp.Word(pp.alphas), default="   ").setResultsName("divcode")
+    + pp.Regex(r"(\d{2})-(\S{3})-(\d{4})").setResultsName("date")
 )
 
 # Older versions of ApE don't include a LOCUS name! Need separate def for this case:
 BrokenLocus1 = (
-    _pp.Literal("LOCUS").setResultsName("name")
-    + _pp.Word(_pp.nums).setResultsName("size")
-    + _pp.Suppress(_pp.CaselessLiteral("bp"))
-    + _pp.Word(_pp.alphas + "-").setResultsName("seqtype")
-    + (_pp.CaselessLiteral("linear") | _pp.CaselessLiteral("circular")).setResultsName(
+    pp.Literal("LOCUS").setResultsName("name")
+    + pp.Word(pp.nums).setResultsName("size")
+    + pp.Suppress(pp.CaselessLiteral("bp"))
+    + pp.Word(pp.alphas + "-").setResultsName("seqtype")
+    + (pp.CaselessLiteral("linear") | pp.CaselessLiteral("circular")).setResultsName(
         "topology"
     )
-    + _pp.Optional(_pp.Word(_pp.alphas), default="   ").setResultsName("divcode")
-    + _pp.Regex(r"(\d{2})-(\S{3})-(\d{4})").setResultsName("date")
+    + pp.Optional(pp.Word(pp.alphas), default="   ").setResultsName("divcode")
+    + pp.Regex(r"(\d{2})-(\S{3})-(\d{4})").setResultsName("date")
 )
 
 # LOCUS       YEplac181	5741 bp 	DNA	SYN
 BrokenLocus2 = (
-    _pp.Literal("LOCUS")
-    + _pp.Word(_pp.alphas + _pp.nums + "-_()." + "\\").setResultsName("name")
-    + _pp.Word(_pp.nums).setResultsName("size")
-    + _pp.Suppress(_pp.CaselessLiteral("bp"))
-    + _pp.Word(_pp.alphas + "-").setResultsName("seqtype")
-    + _pp.Optional(
-        _pp.CaselessLiteral("linear") | _pp.CaselessLiteral("circular"),
+    pp.Literal("LOCUS")
+    + pp.Word(pp.alphas + pp.nums + "-_()." + "\\").setResultsName("name")
+    + pp.Word(pp.nums).setResultsName("size")
+    + pp.Suppress(pp.CaselessLiteral("bp"))
+    + pp.Word(pp.alphas + "-").setResultsName("seqtype")
+    + pp.Optional(
+        pp.CaselessLiteral("linear") | pp.CaselessLiteral("circular"),
         default="linear",
     ).setResultsName("topology")
-    + _pp.Optional(_pp.Word(_pp.alphas), default="   ").setResultsName("divcode")
-    + _pp.Regex(r"(\d{2})-(\S{3})-(\d{4})").setResultsName("date")
+    + pp.Optional(pp.Word(pp.alphas), default="   ").setResultsName("divcode")
+    + pp.Regex(r"(\d{2})-(\S{3})-(\d{4})").setResultsName("date")
 )
 
 BrokenLocus3 = (
-    _pp.Literal("LOCUS")
-    + _pp.Word(_pp.alphas + _pp.nums + "-_()." + "\\").setResultsName("name")
-    + _pp.Word(_pp.nums).setResultsName("size")
-    + _pp.Suppress(_pp.CaselessLiteral("bp"))
-    + _pp.Word(_pp.alphas + "-").setResultsName("seqtype")
-    + _pp.Optional(
-        _pp.CaselessLiteral("linear") | _pp.CaselessLiteral("circular"),
+    pp.Literal("LOCUS")
+    + pp.Word(pp.alphas + pp.nums + "-_()." + "\\").setResultsName("name")
+    + pp.Word(pp.nums).setResultsName("size")
+    + pp.Suppress(pp.CaselessLiteral("bp"))
+    + pp.Word(pp.alphas + "-").setResultsName("seqtype")
+    + pp.Optional(
+        pp.CaselessLiteral("linear") | pp.CaselessLiteral("circular"),
         default="linear",
     ).setResultsName("topology")
-    + _pp.Word(_pp.alphas).setResultsName("divcode")
-    + _pp.Optional(
-        _pp.Regex(r"(\d{2})-(\S{3})-(\d{4})").setResultsName("date"),
+    + pp.Word(pp.alphas).setResultsName("divcode")
+    + pp.Optional(
+        pp.Regex(r"(\d{2})-(\S{3})-(\d{4})").setResultsName("date"),
         default="19-MAR-1970",
     ).setResultsName("date")
 )
@@ -95,14 +95,13 @@ LocusEntry = GoodLocus | BrokenLocus1 | BrokenLocus2 | BrokenLocus3
 # (Though these entries are generally useless when it comes to hacking on DNA)
 
 # All entries in a genbank file headed by an all-caps title with no space between start-of-line and title
-CapWord = _pp.Word("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+CapWord = pp.Word("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
 # after titled line, all subsequent lines have to have at least one space in front of them
 # this is how we split up the genbank record
-SpacedLine = _pp.White(min=1) + _pp.CharsNotIn("\n") + _pp.LineEnd()
+SpacedLine = pp.White(min=1) + pp.CharsNotIn("\n") + pp.LineEnd()
 # HeaderLine = CapWord + CharsNotIn("\n") + LineEnd()
-GenericEntry = _pp.Group(
-    CapWord
-    + _pp.Combine(_pp.CharsNotIn("\n") + _pp.LineEnd() + _pp.ZeroOrMore(SpacedLine))
+GenericEntry = pp.Group(
+    CapWord + pp.Combine(pp.CharsNotIn("\n") + pp.LineEnd() + pp.ZeroOrMore(SpacedLine))
 ).setResultsName("generics", listAllMatches=True)
 
 
@@ -135,28 +134,28 @@ GenericEntry = _pp.Group(
 #
 # if you don't know where something is, don't use it or guess and move on
 
-LPAREN = _pp.Suppress("(")
-RPAREN = _pp.Suppress(")")
-SEP = _pp.Suppress(_pp.Literal(".."))
+LPAREN = pp.Suppress("(")
+RPAREN = pp.Suppress(")")
+SEP = pp.Suppress(pp.Literal(".."))
 
 # recognize numbers w. < & > uncertainty specs, then strip the <> chars to make it fixed
-gbIndex = _pp.Word(_pp.nums + "<>").setParseAction(
+gbIndex = pp.Word(pp.nums + "<>").setParseAction(
     lambda s, l_, t: int(t[0].replace("<", "").replace(">", ""))
 )
-SimpleSlice = _pp.Group(gbIndex + SEP + gbIndex) | _pp.Group(gbIndex).setParseAction(
+SimpleSlice = pp.Group(gbIndex + SEP + gbIndex) | pp.Group(gbIndex).setParseAction(
     lambda s, l_, t: [[t[0][0], t[0][0]]]
 )
 
 # recursive def for nested function syntax:  f( g(), g() )
-complexSlice = _pp.Forward()
+complexSlice = pp.Forward()
 (
     complexSlice
-    << (_pp.Literal("complement") | _pp.Literal("join"))
+    << (pp.Literal("complement") | pp.Literal("join"))
     + LPAREN
-    + (_pp.delimitedList(complexSlice) | _pp.delimitedList(SimpleSlice))
+    + (pp.delimitedList(complexSlice) | pp.delimitedList(SimpleSlice))
     + RPAREN
 )
-featLocation = _pp.Group(SimpleSlice | complexSlice)
+featLocation = pp.Group(SimpleSlice | complexSlice)
 
 
 def parseGBLoc(s, l_, t):
@@ -183,7 +182,7 @@ featLocation.setParseAction(parseGBLoc)
 
 
 def strip_multiline(s, l_, t):
-    whitespace = _re.compile("[\n]{1}[ ]+")
+    whitespace = re.compile("[\n]{1}[ ]+")
     return whitespace.sub(" ", t[0])
 
 
@@ -192,59 +191,57 @@ def toInt(s, l_, t):
 
 
 # Quoted KeyVal:   /key="value"
-QuoteFeaturekeyval = _pp.Group(
-    _pp.Suppress("/")
-    + _pp.Word(_pp.alphas + _pp.nums + "_-")
-    + _pp.Suppress("=")
-    + _pp.QuotedString('"', multiline=True).setParseAction(strip_multiline)
+QuoteFeaturekeyval = pp.Group(
+    pp.Suppress("/")
+    + pp.Word(pp.alphas + pp.nums + "_-")
+    + pp.Suppress("=")
+    + pp.QuotedString('"', multiline=True).setParseAction(strip_multiline)
 )
 
 # UnQuoted KeyVal: /key=value  (I'm assuming it doesn't do multilines this way? wrong! ApE does store long labels this way! sigh.)
 # NoQuoteFeaturekeyval = Group(Suppress('/') + Word(alphas+nums+"_-") + Suppress('=') + OneOrMore(CharsNotIn("\n")) )
 keyvalspacedline = (
-    _pp.White(exact=21)
-    + _pp.CharsNotIn("/")
-    + _pp.OneOrMore(_pp.CharsNotIn("\n"))
-    + _pp.LineEnd()
+    pp.White(exact=21)
+    + pp.CharsNotIn("/")
+    + pp.OneOrMore(pp.CharsNotIn("\n"))
+    + pp.LineEnd()
 )
-NoQuoteFeaturekeyval = _pp.Group(
-    _pp.Suppress("/")
-    + _pp.Word(_pp.alphas + _pp.nums + "_-")
-    + _pp.Suppress("=")
-    + _pp.Combine(
-        _pp.CharsNotIn("\n") + _pp.LineEnd() + _pp.ZeroOrMore(keyvalspacedline)
-    )
+NoQuoteFeaturekeyval = pp.Group(
+    pp.Suppress("/")
+    + pp.Word(pp.alphas + pp.nums + "_-")
+    + pp.Suppress("=")
+    + pp.Combine(pp.CharsNotIn("\n") + pp.LineEnd() + pp.ZeroOrMore(keyvalspacedline))
 )
 
 # Special Case for Numerical Vals:  /bases=12  OR  /bases="12"
-NumFeaturekeyval = _pp.Group(
-    _pp.Suppress("/")
-    + _pp.Word(_pp.alphas + _pp.nums + "_-")
-    + _pp.Suppress("=")
-    + (_pp.Suppress('"') + _pp.Word(_pp.nums).setParseAction(toInt) + _pp.Suppress('"'))
-    | (_pp.Word(_pp.nums).setParseAction(toInt))
+NumFeaturekeyval = pp.Group(
+    pp.Suppress("/")
+    + pp.Word(pp.alphas + pp.nums + "_-")
+    + pp.Suppress("=")
+    + (pp.Suppress('"') + pp.Word(pp.nums).setParseAction(toInt) + pp.Suppress('"'))
+    | (pp.Word(pp.nums).setParseAction(toInt))
 )
 
 # Key Only KeyVal: /pseudo
 # post-parse convert it into a pair to resemble the structure of the first three cases i.e. [pseudo, True]
-FlagFeaturekeyval = _pp.Group(
-    _pp.Suppress("/") + _pp.Word(_pp.alphas + _pp.nums + "_-")
+FlagFeaturekeyval = pp.Group(
+    pp.Suppress("/") + pp.Word(pp.alphas + pp.nums + "_-")
 ).setParseAction(lambda s, l_, t: [[t[0][0], True]])
 
-Feature = _pp.Group(
-    _pp.Word(_pp.alphas + _pp.nums + "_-").setParseAction(
+Feature = pp.Group(
+    pp.Word(pp.alphas + pp.nums + "_-").setParseAction(
         lambda s, l_, t: [["type", t[0]]]
     )
     + featLocation.setResultsName("location")
-    + _pp.OneOrMore(
+    + pp.OneOrMore(
         NumFeaturekeyval | QuoteFeaturekeyval | NoQuoteFeaturekeyval | FlagFeaturekeyval
     )
 )
 
 FeaturesEntry = (
-    _pp.Literal("FEATURES")
-    + _pp.Literal("Location/Qualifiers")
-    + _pp.Group(_pp.OneOrMore(Feature)).setResultsName("features")
+    pp.Literal("FEATURES")
+    + pp.Literal("Location/Qualifiers")
+    + pp.Group(pp.OneOrMore(Feature)).setResultsName("features")
 )
 
 # ===============================================================================
@@ -252,12 +249,12 @@ FeaturesEntry = (
 
 # sequence is just a column-spaced big table of dna nucleotides
 # should it recognize full IUPAC alphabet?  NCBI uses n for unknown region
-Sequence = _pp.OneOrMore(
-    _pp.Suppress(_pp.Word(_pp.nums)) + _pp.OneOrMore(_pp.Word("ACGTacgtNn"))
+Sequence = pp.OneOrMore(
+    pp.Suppress(pp.Word(pp.nums)) + pp.OneOrMore(pp.Word("ACGTacgtNn"))
 )
 
 # Group(  ) hides the setResultsName names def'd inside, such that one needs to first access this group and then access the dict of contents inside
-SequenceEntry = _pp.Suppress(_pp.Literal("ORIGIN")) + Sequence.setParseAction(
+SequenceEntry = pp.Suppress(pp.Literal("ORIGIN")) + Sequence.setParseAction(
     lambda s, l_, t: "".join(t)
 ).setResultsName("sequence")
 
@@ -266,13 +263,13 @@ SequenceEntry = _pp.Suppress(_pp.Literal("ORIGIN")) + Sequence.setParseAction(
 # Final GenBank Parser
 
 # GB files with multiple records split by "//" sequence at beginning of line
-GBEnd = _pp.Literal("//")
+GBEnd = pp.Literal("//")
 
 # Begin w. LOCUS, slurp all entries, then stop at the end!
-GB = LocusEntry + _pp.OneOrMore(FeaturesEntry | SequenceEntry | GenericEntry) + GBEnd
+GB = LocusEntry + pp.OneOrMore(FeaturesEntry | SequenceEntry | GenericEntry) + GBEnd
 
 # NCBI often returns sets of GB files
-multipleGB = _pp.OneOrMore(_pp.Group(GB))
+multipleGB = pp.OneOrMore(pp.Group(GB))
 
 # ===============================================================================
 # End Genbank Parser
@@ -284,7 +281,7 @@ multipleGB = _pp.OneOrMore(_pp.Group(GB))
 
 
 def strip_indent(str):
-    whitespace = _re.compile("[\n]{1}(COMMENT){0,1}[ ]+")
+    whitespace = re.compile("[\n]{1}(COMMENT){0,1}[ ]+")
     return whitespace.sub("\n", str)
 
 
@@ -588,9 +585,9 @@ def gbtext_clean(gbtext):
 
     jseqlist = toJSON(gbtext)
     jseq = jseqlist.pop()
-    from collections import namedtuple as _namedtuple
-    from pydna._pretty import pretty_str as _pretty_str
+    from collections import namedtuple
+    from pydna._pretty import pretty_str as ps
 
-    Result = _namedtuple("Result", "gbtext jseq")
-    result = Result(_pretty_str(toGB(jseq).strip()), jseq)
+    Result = namedtuple("Result", "gbtext jseq")
+    result = Result(ps(toGB(jseq).strip()), jseq)
     return result

pydna/ladders.py

@@ -16,17 +16,16 @@ a gel image. Exampel can be found in scripts/molecular_weight_standards.ods.
 """
 
 
-from pydna.fakeseq import FakeSeq as _FakeSeq
+from pydna.fakeseq import FakeSeq
 
 
 PennStateLadder = [
-    _FakeSeq(int(n))
-    for n in (10000, 7750, 5000, 4000, 3000, 2000, 1500, 1000, 750, 500)
+    FakeSeq(int(n)) for n in (10000, 7750, 5000, 4000, 3000, 2000, 1500, 1000, 750, 500)
 ]
 
 
 GeneRuler_1kb = [
-    _FakeSeq(int(n))
+    FakeSeq(int(n))
     for n in (
         10000,
         8000,
@@ -49,7 +48,7 @@ GeneRuler_1kb = [
 # https://docs.google.com/spreadsheets/d/1vN0y75ibxPrG6yJQjq1uF2FXP0L-qGSn_fzInUHeTs4/edit#gid=0
 
 GeneRuler_1kb_plus = [
-    _FakeSeq(ln, n=n * 1e-15, rf=rf)
+    FakeSeq(ln, n=n * 1e-15, rf=rf)
     for ln, n, rf in (
         # (length, fmol, Rf )
         (20000, 1.538, 0.000),
@@ -72,7 +71,7 @@ GeneRuler_1kb_plus = [
 
 
 HI_LO_DNA_MARKER = [
-    _FakeSeq(ln, n=n * 1e-15, rf=rf)
+    FakeSeq(ln, n=n * 1e-15, rf=rf)
     for ln, n, rf in (
         # (length, fmol, Rf )
         (10000, 4.545, 0.000),
@@ -121,16 +120,16 @@ HI_LO_DNA_MARKER = [
 
 FakeGel = [
     [
-        _FakeSeq(1000),
-        _FakeSeq(2000),
+        FakeSeq(1000),
+        FakeSeq(2000),
     ],
     [
-        _FakeSeq(3000),
-        _FakeSeq(4000),
+        FakeSeq(3000),
+        FakeSeq(4000),
     ],
     [
-        _FakeSeq(5000),
-        _FakeSeq(6000),
+        FakeSeq(5000),
+        FakeSeq(6000),
     ],
     PennStateLadder,
 ]