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

pydna/tm.py

@@ -8,12 +8,12 @@
 """This module provide functions for melting temperature calculations."""
 
 
-import math as _math
-from Bio.SeqUtils import MeltingTemp as _mt
-from Bio.SeqUtils import gc_fraction as _GC
+import math
+from Bio.SeqUtils import MeltingTemp as mt
+from Bio.SeqUtils import gc_fraction
 
-import textwrap as _textwrap
-from pydna._pretty import pretty_str as _pretty_str
+import textwrap
+from pydna._pretty import pretty_str as ps
 
 # See the documentation for Bio.SeqUtils.MeltingTemp for more details
 # The 10X Taq Buffer with (NH4)2SO4 is commercialized by companies like
@@ -30,7 +30,7 @@ def tm_default(
     strict=True,
     c_seq=None,
     shift=0,
-    nn_table=_mt.DNA_NN4,  # DNA_NN4: values from SantaLucia & Hicks (2004)
+    nn_table=mt.DNA_NN4,  # DNA_NN4: values from SantaLucia & Hicks (2004)
     tmm_table=None,
     imm_table=None,
     de_table=None,
@@ -43,7 +43,7 @@ def tm_default(
     Mg=1.5,  # 1.5 mM Mg2+ is often seen in modern protocols
     dNTPs=0.8,  # I assume 200 µM of each dNTP
     saltcorr=7,  # Tm = 81.5 + 0.41(%GC) - 600/N + 16.6 x log[Na+]
-    func=_mt.Tm_NN,  # Used by Primer3Plus to calculate the product Tm.
+    func=mt.Tm_NN,  # Used by Primer3Plus to calculate the product Tm.
 ):
     return func(
         seq,
@@ -73,7 +73,7 @@ def tm_dbd(
     strict=True,
     c_seq=None,
     shift=0,
-    nn_table=_mt.DNA_NN3,
+    nn_table=mt.DNA_NN3,
     tmm_table=None,
     imm_table=None,
     de_table=None,
@@ -86,7 +86,7 @@ def tm_dbd(
     Mg=1.5,
     dNTPs=0.8,
     saltcorr=1,
-    func=_mt.Tm_NN,
+    func=mt.Tm_NN,
 ):
     return func(
         seq,
@@ -119,7 +119,7 @@ def tm_product(seq: str, K=0.050):
     ing temperature for DNA amplification in vitro
     http://www.ncbi.nlm.nih.gov/pubmed/2243783
     """
-    tmp = 81.5 + 0.41 * _GC(seq) * 100 + 16.6 * _math.log10(K) - 675 / len(seq)
+    tmp = 81.5 + 0.41 * gc_fraction(seq) * 100 + 16.6 * math.log10(K) - 675 / len(seq)
     return tmp
 
 
@@ -160,7 +160,7 @@ def program(amplicon, tm=tm_default, ta=ta_default):
     extension_time_taq = max(30, int(taq_extension_rate * len(amplicon) / 1000))
     # seconds
 
-    f = _textwrap.dedent(
+    f = textwrap.dedent(
         r"""
         |95°C|95°C               |    |tmf:{tmf:.1f}
         |____|_____          72°C|72°C|tmr:{tmr:.1f}
@@ -185,7 +185,7 @@ def program(amplicon, tm=tm_default, ta=ta_default):
         )
     ).strip()
 
-    return _pretty_str(f)
+    return ps(f)
 
 
 taq_program = program
@@ -228,7 +228,7 @@ def dbd_program(amplicon, tm=tm_dbd, ta=ta_dbd):
     tmr = tm(amplicon.reverse_primer.footprint)
 
     if tmf >= 69.0 and tmr >= 69.0:
-        f = _textwrap.dedent(
+        f = textwrap.dedent(
             r"""
                               |98°C|98°C      |    |tmf:{tmf:.1f}
                               |____|____      |    |tmr:{tmr:.1f}
@@ -245,7 +245,7 @@ def dbd_program(amplicon, tm=tm_dbd, ta=ta_dbd):
             )
         ).strip()
     else:
-        f = _textwrap.dedent(
+        f = textwrap.dedent(
             r"""
              |98°C|98°C               |    |tmf:{tmf:.1f}
              |____|_____          72°C|72°C|tmr:{tmr:.1f}
@@ -270,7 +270,7 @@ def dbd_program(amplicon, tm=tm_dbd, ta=ta_dbd):
             )
         ).strip()
 
-    return _pretty_str(f)
+    return ps(f)
 
 
 pfu_sso7d_program = dbd_program
@@ -327,8 +327,8 @@ def tmbresluc(primer: str, *args, primerc=500.0, saltc=50, **kwargs):
         dS += _thermodynamic_data.dSBr[n1 - 97][n2 - 97]
 
     tm = (
-        dH / (1.9872 * _math.log(pri / 1600) + dS)
-        + (16.6 * _math.log(saltc)) / _math.log(10)
+        dH / (1.9872 * math.log(pri / 1600) + dS)
+        + (16.6 * math.log(saltc)) / math.log(10)
     ) - 273.15
 
     return tm

pydna/types.py

@@ -5,32 +5,32 @@ Types used in the pydna package.
 
 from typing import (
     TYPE_CHECKING,
-    Tuple as _Tuple,
-    Union as _Union,
-    TypeVar as _TypeVar,
-    Iterable as _Iterable,
-    Callable as _Callable,
+    Tuple,
+    Union,
+    TypeVar,
+    Iterable,
+    Callable,
 )
 
 # Import AbstractCut at runtime for CutSiteType
-from Bio.Restriction.Restriction import AbstractCut as _AbstractCut
-from pydna.crispr import _cas as __cas
+from Bio.Restriction.Restriction import AbstractCut
+from pydna.crispr import _cas
 
 if TYPE_CHECKING:
-    from Bio.Restriction import RestrictionBatch as _RestrictionBatch
+    from Bio.Restriction import RestrictionBatch
     from pydna.dseq import Dseq
-    from Bio.SeqFeature import Location as _Location
-    from pydna.dseqrecord import Dseqrecord as _Dseqrecord
+    from Bio.SeqFeature import Location
+    from pydna.dseqrecord import Dseqrecord
 
 
 # To represent any subclass of Dseq
-DseqType = _TypeVar("DseqType", bound="Dseq")
-EnzymesType = _TypeVar(
-    "EnzymesType", "_RestrictionBatch", _Iterable["_AbstractCut"], "_AbstractCut"
+DseqType = TypeVar("DseqType", bound="Dseq")
+EnzymesType = TypeVar(
+    "EnzymesType", "RestrictionBatch", Iterable["AbstractCut"], "AbstractCut"
 )
-CutSiteType = _Tuple[_Tuple[int, int], _Union[_AbstractCut, None, __cas]]
-AssemblyEdgeType = _Tuple[int, int, "_Location | None", "_Location | None"]
-AssemblySubFragmentType = _Tuple[int, "_Location | None", "_Location | None"]
+CutSiteType = Tuple[Tuple[int, int], Union[AbstractCut, None, _cas]]
+AssemblyEdgeType = Tuple[int, int, "Location | None", "Location | None"]
+AssemblySubFragmentType = Tuple[int, "Location | None", "Location | None"]
 EdgeRepresentationAssembly = list[AssemblyEdgeType]
 SubFragmentRepresentationAssembly = list[AssemblySubFragmentType]
 
@@ -38,7 +38,7 @@ SubFragmentRepresentationAssembly = list[AssemblySubFragmentType]
 # Type alias that describes overlap between two sequences x and y
 # the two first numbers are the positions where the overlap starts on x and y
 # the third number is the length of the overlap
-SequenceOverlap = _Tuple[int, int, int]
-AssemblyAlgorithmType = _Callable[
-    ["_Dseqrecord", "_Dseqrecord", int], list[SequenceOverlap]
+SequenceOverlap = Tuple[int, int, int]
+AssemblyAlgorithmType = Callable[
+    ["Dseqrecord", "Dseqrecord", int], list[SequenceOverlap]
 ]

pydna/utils.py

@@ -6,43 +6,30 @@
 # as part of this package.
 """Miscellaneous functions."""
 
-from Bio.Data.IUPACData import ambiguous_dna_complement as _ambiguous_dna_complement
-from Bio.Seq import _maketrans
-
-# import shelve as _shelve
-# import os as _os
-import re as _re
-
-# import logging as _logging
-# import base64 as _base64
-# import pickle as _pickle
-# import hashlib as _hashlib
-import keyword as _keyword
-import collections as _collections
-import itertools as _itertools
-from copy import deepcopy as _deepcopy
-
-import sys as _sys
-import random
-import subprocess as _subprocess
-from bisect import bisect as _bisect
-from math import ceil as _ceil
+import re
+import keyword
+import collections
+import itertools
+from copy import deepcopy
 
-from pydna.codon import weights as _weights
-from pydna.codon import rare_codons as _rare_codons
+import sys
+import random
+import subprocess
+from bisect import bisect
+from math import ceil
 
-from Bio.SeqFeature import SimpleLocation as _sl
-from Bio.SeqFeature import CompoundLocation as _cl
-from Bio.SeqFeature import Location as _Location
+from pydna.codon import weights
+from pydna.codon import rare_codons
+from pydna.alphabet import basepair_dict
+from pydna.alphabet import complement_table_for_dscode
+from Bio.SeqFeature import SimpleLocation
+from Bio.SeqFeature import CompoundLocation
+from Bio.SeqFeature import Location
 
-from typing import Union as _Union, TypeVar as _TypeVar, List as _List
+from typing import Union, TypeVar, List
 
 # For functions that take str or bytes as input and return str or bytes as output, matching the input type
-StrOrBytes = _TypeVar("StrOrBytes", str, bytes)
-
-# _module_logger = _logging.getLogger("pydna." + __name__)
-_ambiguous_dna_complement.update({"U": "A"})
-_complement_table = _maketrans(_ambiguous_dna_complement)
+StrOrBytes = TypeVar("StrOrBytes", str, bytes)
 
 
 def three_frame_orfs(
@@ -55,7 +42,7 @@ def three_frame_orfs(
 ):
     """Overlapping orfs in three frames."""
     # breakpoint()
-    limit = _ceil(limit / 3) - 1
+    limit = ceil(limit / 3) - 1
     dna = dna.upper()
 
     orfs = []
@@ -69,7 +56,7 @@ def three_frame_orfs(
 
         for startindex in startdindices:
             try:
-                stopindex = stopdindices[_bisect(stopdindices, startindex)]
+                stopindex = stopdindices[bisect(stopdindices, startindex)]
             except IndexError:
                 pass
             else:
@@ -90,7 +77,7 @@ def shift_location(original_location, shift, lim):
             raise ValueError(
                 "Shift moves location below zero, use a `lim` to loop around if sequence is circular."
             )
-        lim = _sys.maxsize
+        lim = sys.maxsize
 
     for part in original_location.parts:
         new_start = (part.start + shift) % lim
@@ -106,7 +93,7 @@ def shift_location(original_location, shift, lim):
         # https://github.com/pydna-group/pydna/issues/195
 
         if len(part) == 0:
-            newparts.append(_sl(new_start, new_start, strand))
+            newparts.append(SimpleLocation(new_start, new_start, strand))
             continue
         # Join with old, case 1
         elif strand != -1 and old_end == new_start:
@@ -119,12 +106,15 @@ def shift_location(original_location, shift, lim):
             part._start = new_start
             new_end = part.end
         if new_start < new_end:
-            newparts.append(_sl(new_start, new_end, strand))
+            newparts.append(SimpleLocation(new_start, new_end, strand))
         else:
-            parttuple = (_sl(new_start, lim, strand), _sl(0, new_end, strand))
+            parttuple = (
+                SimpleLocation(new_start, lim, strand),
+                SimpleLocation(0, new_end, strand),
+            )
             newparts.extend(parttuple if strand != -1 else parttuple[::-1])
     try:
-        newloc = _cl(newparts)
+        newloc = CompoundLocation(newparts)
     except ValueError:
         newloc, *n = newparts
     assert len(newloc) == len(original_location)
@@ -144,7 +134,7 @@ def shift_feature(feature, shift, lim):
     """Return a new feature with shifted location."""
     # TODO: Missing tests
     new_location = shift_location(feature.location, shift, lim)
-    new_feature = _deepcopy(feature)
+    new_feature = deepcopy(feature)
     new_feature.location = new_location
     return new_feature
 
@@ -210,16 +200,42 @@ def smallest_rotation(s):
     return s[k:] + s[:k]
 
 
-def cai(seq: str, organism: str = "sce", weights: dict = _weights):
+def anneal_from_left(watson: str, crick: str) -> int:
+    """
+    The length of the common prefix shared by two strings.
+
+    Args:
+        str1 (str): The first string.
+        str2 (str): The second string.
+
+    Returns:
+        int: The length of the common prefix.
+    """
+
+    result = len(
+        list(
+            itertools.takewhile(
+                lambda x: basepair_dict.get((x[0], x[1])), zip(watson, crick[::-1])
+            )
+        )
+    )
+
+    return result
+
+
+def cai(seq: str, organism: str = "sce", weights_dict: dict = None):
     """docstring."""
-    from cai2 import CAI as _CAI
+    from cai2 import CAI
 
-    return round(_CAI(seq.upper(), weights=weights[organism]), 3)
+    if weights_dict is None:
+        weights_dict = weights
+
+    return round(CAI(seq.upper(), weights=weights_dict[organism]), 3)
 
 
 def rarecodons(seq: str, organism="sce"):
     """docstring."""
-    rare = _rare_codons[organism]
+    rare = rare_codons[organism]
     s = seq.upper()
     slices = []
     for i in range(0, len(seq) // 3):
@@ -260,13 +276,13 @@ def express(seq: str, organism="sce"):
 
 def open_folder(pth):
     """docstring."""
-    if _sys.platform == "win32":
-        _subprocess.run(["start", pth], shell=True)
-    elif _sys.platform == "darwin":
-        _subprocess.run(["open", pth])
+    if sys.platform == "win32":
+        subprocess.run(["start", pth], shell=True)
+    elif sys.platform == "darwin":
+        subprocess.run(["open", pth])
     else:
         try:
-            _subprocess.run(["xdg-open", pth])
+            subprocess.run(["xdg-open", pth])
         except OSError:
             return "no cache to open."
 
@@ -276,15 +292,15 @@ def rc(sequence: StrOrBytes) -> StrOrBytes:
 
     accepts mixed DNA/RNA
     """
-    return sequence.translate(_complement_table)[::-1]
+    return complement(sequence)[::-1]
 
 
-def complement(sequence: str):
+def complement(sequence: StrOrBytes) -> StrOrBytes:
     """Complement.
 
     accepts mixed DNA/RNA
     """
-    return sequence.translate(_complement_table)
+    return sequence.translate(complement_table_for_dscode)
 
 
 # def memorize(filename):
@@ -295,17 +311,16 @@ def complement(sequence: str):
 
 #     def decorator(f):
 #         def wrappee(*args, **kwargs):
-#             _module_logger.info("#### memorizer ####")
-#             _module_logger.info("cache filename                   = %s", filename)
-#             _module_logger.info(
+
+
 #                 "os.environ['pydna_cached_funcs'] = %s",
 #                 _os.getenv("pydna_cached_funcs", ""),
 #             )
 #             if filename not in _os.getenv("pydna_cached_funcs", ""):
-#                 _module_logger.info("cache filename not among cached functions, made it new!")
+
 #                 return f(*args, **kwargs)
 #             key = _base64.urlsafe_b64encode(_hashlib.sha1(_pickle.dumps((args, kwargs))).digest()).decode("ascii")
-#             _module_logger.info("key = %s", key)
+
 #             cache = _shelve.open(
 #                 _os.path.join(_os.environ["pydna_data_dir"], identifier_from_string(filename)),
 #                 writeback=False,
@@ -313,17 +328,17 @@ def complement(sequence: str):
 #             try:
 #                 result = cache[key]
 #             except KeyError:
-#                 _module_logger.info(
+
 #                     "no result for key %s in shelve %s",
 #                     key,
 #                     identifier_from_string(filename),
 #                 )
 #                 result = f(*args, **kwargs)
-#                 _module_logger.info("made it new!")
+
 #                 cache[key] = result
-#                 _module_logger.info("saved result under key %s", key)
+
 #             else:
-#                 _module_logger.info("found %s in cache", key)
+
 #             cache.close()
 #             return result
 
@@ -338,16 +353,16 @@ def identifier_from_string(s: str) -> str:
     based on the argument s or an empty string
     """
     s = s.strip()
-    s = _re.sub(r"\s+", r"_", s)
+    s = re.sub(r"\s+", r"_", s)
     s.replace("-", "_")
-    s = _re.sub("[^0-9a-zA-Z_]", "", s)
-    if s and not s[0].isidentifier() or _keyword.iskeyword(s):
+    s = re.sub("[^0-9a-zA-Z_]", "", s)
+    if s and not s[0].isidentifier() or keyword.iskeyword(s):
         s = "_{s}".format(s=s)
     assert s == "" or s.isidentifier()
     return s
 
 
-def flatten(*args) -> _List:
+def flatten(*args) -> List:
     """Flattens an iterable of iterables.
 
     Down to str, bytes, bytearray or any of the pydna or Biopython seq objects
@@ -357,7 +372,7 @@ def flatten(*args) -> _List:
     while args:
         top = args.pop()
         if (
-            isinstance(top, _collections.abc.Iterable)
+            isinstance(top, collections.abc.Iterable)
             and not isinstance(top, (str, bytes, bytearray))
             and not hasattr(top, "reverse_complement")
         ):
@@ -653,12 +668,12 @@ def eq(*args, **kwargs):
 
     if topology == "circular":
         # force circular comparison of all given sequences
-        for s1, s2 in _itertools.combinations(args_string_list, 2):
+        for s1, s2 in itertools.combinations(args_string_list, 2):
             if not (s1 in s2 + s2 or rc(s1) in s2 + s2):
                 same = False
     elif topology == "linear":
         # force linear comparison of all given sequences
-        for s1, s2 in _itertools.combinations(args_string_list, 2):
+        for s1, s2 in itertools.combinations(args_string_list, 2):
             if not (s1 == s2 or s1 == rc(s2)):
                 same = False
     return same
@@ -697,6 +712,7 @@ def eq(*args, **kwargs):
 
 
 def cuts_overlap(left_cut, right_cut, seq_len):
+
     # Special cases:
     if left_cut is None or right_cut is None or left_cut == right_cut:
         return False
@@ -718,17 +734,23 @@ def cuts_overlap(left_cut, right_cut, seq_len):
     # Convert into ranges x and y and see if ranges overlap
     x = sorted([left_watson, left_crick])
     y = sorted([right_watson, right_crick])
-    return (x[1] > y[0]) != (y[1] < x[0])
+    # if (x[1] >= y[0]) != (y[1] <= x[0]):
+    #     breakpoint()
+    return (x[1] >= y[0]) != (y[1] <= x[0])  # (x[1] > y[0]) != (y[1] < x[0])
 
 
-def location_boundaries(loc: _Union[_sl, _cl]):
+def location_boundaries(loc: Union[SimpleLocation, CompoundLocation]):
     if loc.strand == -1:
         return loc.parts[-1].start, loc.parts[0].end
     else:
         return loc.parts[0].start, loc.parts[-1].end
 
 
-def locations_overlap(loc1: _Union[_sl, _cl], loc2: _Union[_sl, _cl], seq_len):
+def locations_overlap(
+    loc1: Union[SimpleLocation, CompoundLocation],
+    loc2: Union[SimpleLocation, CompoundLocation],
+    seq_len,
+):
     start1, end1 = location_boundaries(loc1)
     start2, end2 = location_boundaries(loc2)
 
@@ -746,7 +768,7 @@ def locations_overlap(loc1: _Union[_sl, _cl], loc2: _Union[_sl, _cl], seq_len):
             [start2 - seq_len, end2],
         ]
 
-    for b1, b2 in _itertools.product(boundaries1, boundaries2):
+    for b1, b2 in itertools.product(boundaries1, boundaries2):
         if b1[0] < b2[1] and b1[1] > b2[0]:
             return True
 
@@ -801,7 +823,7 @@ def limit_iterator(iterator, limit):
 
 def create_location(
     start: int, end: int, lim: int, strand: int | None = None
-) -> _Location:
+) -> Location:
     """
     Create a location object from a start and end position.
     If the end position is less than the start position, the location is circular. It handles negative positions.
@@ -854,6 +876,6 @@ def create_location(
     while end < 0:
         end += lim
     if end > start:
-        return _sl(start, end, strand)
+        return SimpleLocation(start, end, strand)
     else:
-        return shift_location(_sl(start, end + lim, strand), 0, lim)
+        return shift_location(SimpleLocation(start, end + lim, strand), 0, lim)

{pydna-5.5.4.dist-info → pydna-5.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydna
-Version: 5.5.4
+Version: 5.5.6
 Summary: Representing double stranded DNA and functions for simulating cloning and homologous recombination between DNA molecules.
 License: BSD
 License-File: LICENSE.txt
@@ -23,6 +23,7 @@ Provides-Extra: clipboard
 Provides-Extra: download
 Provides-Extra: express
 Provides-Extra: gel
+Provides-Extra: primer-screen
 Requires-Dist: appdirs (>=1.4.4)
 Requires-Dist: biopython (==1.85)
 Requires-Dist: cai2 (>=1.0.5) ; extra == "express"
@@ -30,9 +31,10 @@ Requires-Dist: matplotlib (>=3.4.3) ; extra == "gel"
 Requires-Dist: networkx (>=2.8.8)
 Requires-Dist: numpy (>1.26) ; python_version < "3.12"
 Requires-Dist: numpy (>=2.3.0) ; python_version >= "3.12"
-Requires-Dist: opencloning-linkml (==0.4.5)
+Requires-Dist: opencloning-linkml (>=0.4.9,<0.5.0)
 Requires-Dist: pillow (>=8.4.0) ; extra == "gel"
 Requires-Dist: prettytable (>=3.5.0)
+Requires-Dist: pyahocorasick (>=2.2.0) ; extra == "primer-screen"
 Requires-Dist: pydivsufsort (>=0.0.14)
 Requires-Dist: pyfiglet (==0.8.post1)
 Requires-Dist: pyparsing (>=2.4.7) ; extra == "download"
@@ -506,7 +508,7 @@ poetry run pre-commit install
 > =================================== FAILURES ===================================
 > ___________________ [doctest] pydna.assembly2.blunt_overlap ____________________
 > ```
-> This means that the doctest of the function `blunt_overlap` failed. You can run the same test locally with `python -m doctest src/pydna/assembly2.py` (use the appropriate path to the module file). That will give you information of what's failing. Fix, and re-run until it passes!
+> This means that the doctest of the function `blunt_overlap` failed. You can run the same test locally with `pytest src/pydna --doctest-modules` (use the appropriate path to the module file). That will give you information of what's failing. Fix, and re-run until it passes!
 
 ### Creating a PR 🔗
 
@@ -531,17 +533,15 @@ To work locally with the documentation, check the [documentation README](docs/RE
 See the [releases](https://github.com/pydna-group/pydna/releases) for changes and releases.
 
 The build workflow builds a PyPI packages using poetry. This workflow is triggered by publishing a Github release manually from the Github web interface.
+We keep future release names [here](https://docs.google.com/document/d/1PrBYKzDh6QBcqfH9ksjpgArJo3ibDhMRNcibfXtYmCc/edit?tab=t.0). Please edit to
+reflect used release names.
 
-![----]( http://bit.ly/coloredline)
+![----](http://bit.ly/coloredline)
 
 ## History 📜
 
 Pydna was made public in 2012 on [Google code](https://code.google.com/archive/p/pydna).
 
-:microbe:
-
-:portugal:
-
 ## Who is using pydna? 🧪
 
 Taylor, L. J., & Strebel, K. (2017).

pydna-5.5.6.dist-info/RECORD

@@ -0,0 +1,42 @@
+pydna/__init__.py,sha256=4u9wd3RbQkivNRKpEGXHT7Lrk7W7G5V64PJLOiSXKAk,7086
+pydna/_pretty.py,sha256=S3J0z_czeP1HpR-lj5fXQo9OeZc3ONsvxEGAc-Oqvjo,885
+pydna/_thermodynamic_data.py,sha256=ctOCzI0SclCBQVk7tG01bDv76fMeOROrp_WdVG5jp20,10885
+pydna/all.py,sha256=jPeYTAPh5uNXnqsK-HfMFzlVXE6sSqsonHCgmt6lf2I,1502
+pydna/alphabet.py,sha256=NOWIcsVjdPSR9aAZx5wzWD8061Pq2fOE1qAKfjqDzGg,29654
+pydna/amplicon.py,sha256=zql6MVqoKu9XEDlEmqxCQa5oZMDk3pyayP536k-yS38,5135
+pydna/amplify.py,sha256=DsMDJi6bRmP1CMku-jZ1_QXQ3-gbQ_P2M9kHR30zJ-Y,18738
+pydna/assembly.py,sha256=1bAaFZDAEAlz_LB31sjAPRtAkIFK_VIXpMIQpTf_8xU,19291
+pydna/assembly2.py,sha256=WmzygtYKLONRoccaqHM5O3xjbNzaSeOHR15EH-tVOmk,108764
+pydna/codon.py,sha256=AZb8DjrS5lBAzNhL32GvE_P9V5DvSBbc7w9TaSeQHlc,2553
+pydna/common_sub_strings.py,sha256=pnSx3OAjwf2uclYxv-90XYZT3bMl_d8ZTDeoGtlgtWs,11467
+pydna/contig.py,sha256=yBF4TMq1pLL0Pe3tefl2sDzNFaeSddBpytN-z-xBeSw,14971
+pydna/cre_lox.py,sha256=sOj9R8_oFPGWs68vc4jf6LqWOXjMsVSwtJaeKl6ZF2M,4476
+pydna/crispr.py,sha256=iwu0Cjskzdb2r-In9633QIxQYKGmSNVOEM_dLK6lC54,3619
+pydna/design.py,sha256=GQTyH4fKsvd6fSel0uC8DNQIulq3HMg-jYHxqsQzoLw,31743
+pydna/dseq.py,sha256=cZN1Micwlgt8L73WjaIUlblb9KuQBxLzhM91cd5ijKo,83324
+pydna/dseqrecord.py,sha256=jzo8jr6i4zZ6SdJJfbabdkGh_6U8PI0Ywa9LCdn91XE,49598
+pydna/fakeseq.py,sha256=uxyu1PXF-sVasEqhmyhMcsbpTy84uUtubDiZuxHNb9c,1174
+pydna/fusionpcr.py,sha256=tfIfGGkNoZjg_dodcEx9wTc12aLRnC7J3g-Vg3Jg1uA,2821
+pydna/gateway.py,sha256=2AluaHCvgWwIq3f4ICK27iX1uSSpg97F3c_xv4o0lQM,8651
+pydna/gel.py,sha256=cZ8IctRO62BXK3BQe4_8c4IgOOspHawi1WZKr0PNGss,3338
+pydna/genbank.py,sha256=TZExxq5NVAL23Rb4y_tdbN32FFTUE_kddb_Zpv5RO6E,8574
+pydna/genbankfixer.py,sha256=ackTNoGk9aiXdWeH4ReXjGPmhTh9kl3FkfHsnZPi_eY,20302
+pydna/ladders.py,sha256=2Y5gcqmxCXdYFgW4MAosbqISSHD_uEQj_05ZYBREBOY,3284
+pydna/oligonucleotide_hybridization.py,sha256=x75pVVNvUn8N0F2j8fY_oOT61VlrlFauk0Iq5QFJ2XY,4165
+pydna/opencloning_models.py,sha256=gMWAwcxDQx7T4xXftUTKA99NHdA7CCRSMB0HFJ5UXok,23892
+pydna/parsers.py,sha256=mAkkkIv14KFmZt0TrROtE0Z54otpB11MrM3ihhdd3Ow,7847
+pydna/primer.py,sha256=s3CoPheB4PUuQJU_11VGEBZW62DesEiWmTC2HHzD7so,2248
+pydna/primer_screen.py,sha256=0CodBc9JThE-qkk5Z2DacSYIvSqhsFCGARzh-Bu236U,26418
+pydna/readers.py,sha256=9ZopQFW0CyYCmW4jy-6_w0_0BRUMLV2VAVDmHH4Ns5w,1731
+pydna/seq.py,sha256=H-MPWo2qQG6s5N0LKSziTKmb79ORCCNHofE2Gs0R5U8,10979
+pydna/seqrecord.py,sha256=aQtkx8Wjy_FbnD2_uVY--ULuWwLtxiVeQ0wlsZs2OXA,22816
+pydna/sequence_picker.py,sha256=wuRfQhuMgxrK6rrNykBFbRqErk-qXBPRvmEEIM0ji4o,1305
+pydna/sequence_regex.py,sha256=bp0JhUILRlXQ-zOjK6oz-cxjca46LBjA5wCuzga-Hmw,1238
+pydna/threading_timer_decorator_exit.py,sha256=D91kqjKSavWDnXyc1Fo-CwPYtbmR2DjTXnBYSRXKmSA,2793
+pydna/tm.py,sha256=kM31byeBog17xi-NnVL6yXPLyZrzpXRY9J6XfEAJa9I,11083
+pydna/types.py,sha256=W1qY6TSRv1nIj9dxEwTlc4XB3778arSeMg713fPnT9U,1337
+pydna/utils.py,sha256=vYJJnJlaSTVxmbusv-WDNid54nBUqs8pTFDcJG_I7tA,24989
+pydna-5.5.6.dist-info/METADATA,sha256=jUQ1ZJ5NYSJe71DHPnRWDYF1_pUeWqoMeOcLvYjitFE,24626
+pydna-5.5.6.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+pydna-5.5.6.dist-info/licenses/LICENSE.txt,sha256=u8QfcsnNXZM0UCexerK_MvyA2lPWgeGyUtSYXvLG6Oc,6119
+pydna-5.5.6.dist-info/RECORD,,

{pydna-5.5.4.dist-info → pydna-5.5.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.0
 Root-Is-Purelib: true
 Tag: py3-none-any