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

pydna/types.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""
+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,
+)
+
+if TYPE_CHECKING:
+    from Bio.Restriction import AbstractCut as _AbstractCut
+    from Bio.Restriction import RestrictionBatch as _RestrictionBatch
+    from pydna.dseq import Dseq
+    from Bio.SeqFeature import Location as _Location
+    from pydna.dseqrecord import Dseqrecord as _Dseqrecord
+
+
+# To represent any subclass of Dseq
+DseqType = _TypeVar("DseqType", bound="Dseq")
+EnzymesType = _TypeVar(
+    "EnzymesType", "_RestrictionBatch", _Iterable["_AbstractCut"], "_AbstractCut"
+)
+CutSiteType = _Tuple[_Tuple[int, int], _Union["_AbstractCut", None]]
+AssemblyEdgeType = _Tuple[int, int, "_Location | None", "_Location | None"]
+AssemblySubFragmentType = _Tuple[int, "_Location | None", "_Location | None"]
+EdgeRepresentationAssembly = list[AssemblyEdgeType]
+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]
+]

pydna/utils.py

@@ -8,13 +8,15 @@
 
 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 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 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
@@ -31,13 +33,14 @@ from pydna.codon import rare_codons as _rare_codons
 
 from Bio.SeqFeature import SimpleLocation as _sl
 from Bio.SeqFeature import CompoundLocation as _cl
+from Bio.SeqFeature import Location as _Location
 
 from typing import Union as _Union, TypeVar as _TypeVar, List as _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__)
+# _module_logger = _logging.getLogger("pydna." + __name__)
 _ambiguous_dna_complement.update({"U": "A"})
 _complement_table = _maketrans(_ambiguous_dna_complement)
 
@@ -71,7 +74,9 @@ def three_frame_orfs(
                 pass
             else:
                 if stopindex - startindex >= limit:
-                    orfs.append((frame, startindex * 3 + frame, (stopindex + 1) * 3 + frame))
+                    orfs.append(
+                        (frame, startindex * 3 + frame, (stopindex + 1) * 3 + frame)
+                    )
                 # print(stopindex, startindex, limit)
     return orfs
 
@@ -82,13 +87,17 @@ def shift_location(original_location, shift, lim):
     strand = original_location.strand
     if lim is None:
         if min(original_location) + shift < 0:
-            raise ValueError("Shift moves location below zero, use a `lim` to loop around if sequence is circular.")
+            raise ValueError(
+                "Shift moves location below zero, use a `lim` to loop around if sequence is circular."
+            )
         lim = _sys.maxsize
 
     for part in original_location.parts:
         new_start = (part.start + shift) % lim
         new_end = (part.end + shift) % lim or lim
-        old_start, old_end = (newparts[-1].start, newparts[-1].end) if len(newparts) else (None, None)
+        old_start, old_end = (
+            (newparts[-1].start, newparts[-1].end) if len(newparts) else (None, None)
+        )
 
         # The "join with old" cases are for features with multiple parts
         # in which consecutive parts do not have any bases between them.
@@ -278,49 +287,49 @@ def complement(sequence: str):
     return sequence.translate(_complement_table)
 
 
-def memorize(filename):
-    """Cache functions and classes.
+# def memorize(filename):
+#     """Cache functions and classes.
 
-    see pydna.download
-    """
+#     see pydna.download
+#     """
 
-    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,
-            )
-            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
+#     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,
+#             )
+#             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
 
-        return wrappee
+#         return wrappee
 
-    return decorator
+#     return decorator
 
 
 def identifier_from_string(s: str) -> str:
@@ -505,7 +514,11 @@ def randomORF(length, maxlength=None):
     starts = ("ATG",)
     stops = ("TAA", "TAG", "TGA")
 
-    return random.choice(starts) + "".join([random.choice(cdns) for x in range(length)]) + random.choice(stops)
+    return (
+        random.choice(starts)
+        + "".join([random.choice(cdns) for x in range(length)])
+        + random.choice(stops)
+    )
 
 
 def randomprot(length, maxlength=None):
@@ -614,7 +627,9 @@ def eq(*args, **kwargs):
         if kwargs["circular"] is False:
             topology = "linear"
     else:
-        topology = set([arg.circular if hasattr(arg, "circular") else None for arg in args])
+        topology = set(
+            [arg.circular if hasattr(arg, "circular") else None for arg in args]
+        )
 
         if len(topology) != 1:
             raise ValueError("sequences have different topologies")
@@ -625,7 +640,10 @@ def eq(*args, **kwargs):
             topology = "circular"
 
     args = [arg.seq if hasattr(arg, "seq") else arg for arg in args]
-    args_string_list = [arg.watson.lower() if hasattr(arg, "watson") else str(arg).lower() for arg in args]
+    args_string_list = [
+        arg.watson.lower() if hasattr(arg, "watson") else str(arg).lower()
+        for arg in args
+    ]
 
     length = set((len(s) for s in args_string_list))
 
@@ -735,10 +753,107 @@ def locations_overlap(loc1: _Union[_sl, _cl], loc2: _Union[_sl, _cl], seq_len):
     return False
 
 
-if __name__ == "__main__":
-    cached = _os.getenv("pydna_cached_funcs", "")
-    _os.environ["pydna_cached_funcs"] = ""
-    import doctest
+def sum_is_sticky(
+    three_prime_end: tuple[str, str],
+    five_prime_end: tuple[str, str],
+    partial: bool = False,
+) -> int:
+    """Return the overlap length if the 3' end of seq1 and 5' end of seq2 ends are sticky and compatible for ligation.
+    Return 0 if they are not compatible."""
+    type_seq1, sticky_seq1 = three_prime_end
+    type_seq2, sticky_seq2 = five_prime_end
+
+    if (
+        "blunt" != type_seq2
+        and type_seq2 == type_seq1
+        and str(sticky_seq2) == str(rc(sticky_seq1))
+    ):
+        return len(sticky_seq1)
+
+    if not partial:
+        return 0
+
+    if type_seq1 != type_seq2 or type_seq2 == "blunt":
+        return 0
+    elif type_seq2 == "5'":
+        sticky_seq1 = str(rc(sticky_seq1))
+    elif type_seq2 == "3'":
+        sticky_seq2 = str(rc(sticky_seq2))
+
+    ovhg_len = min(len(sticky_seq1), len(sticky_seq2))
+    # [::-1] to try the longest overhangs first
+    for i in range(1, ovhg_len + 1)[::-1]:
+        if sticky_seq1[-i:] == sticky_seq2[:i]:
+            return i
+    else:
+        return 0
+
+
+def limit_iterator(iterator, limit):
+    """
+    Call the function with an iterator to raise an error if the number of items is greater than the limit.
+    """
+    for i, x in enumerate(iterator):
+        if i >= limit:
+            raise ValueError(f"Too many possible paths (more than {limit})")
+        yield x
+
+
+def create_location(
+    start: int, end: int, lim: int, strand: int | None = None
+) -> _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.
+
+    Parameters
+    ----------
+    start : int
+        The start position of the location.
+    end : int
+        The end position of the location.
+    lim : int
+        The length of the sequence.
+    strand : int, optional
+        The strand of the location. None, 1 or -1.
 
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS)
-    _os.environ["pydna_cached_funcs"] = cached
+    Returns
+    -------
+    location : Location
+        The location object. Can be a SimpleLocation or a CompoundLocation if the feature spans the origin of
+        a circular sequence.
+
+    Examples
+    --------
+    >>> from pydna.utils import create_location
+    >>> str(create_location(0, 5, 10,-1))
+    '[0:5](-)'
+    >>> str(create_location(0, 5, 10,+1))
+    '[0:5](+)'
+    >>> str(create_location(0, 5, 10))
+    '[0:5]'
+    >>> str(create_location(8, 2, 10))
+    'join{[8:10], [0:2]}'
+    >>> str(create_location(8, 2, 10,-1))
+    'join{[0:2](-), [8:10](-)}'
+    >>> str(create_location(-2, 2, 10))
+    'join{[8:10], [0:2]}'
+
+    Note this special case, 0 is the same as len(seq)
+    >>> str(create_location(5, 0, 10))
+    '[5:10]'
+
+    Note the special case where if start and end are the same,
+    the location spans the entire sequence (it's not empty).
+    >>> str(create_location(5, 5, 10))
+    'join{[5:10], [0:5]}'
+
+    """
+    while start < 0:
+        start += lim
+    while end < 0:
+        end += lim
+    if end > start:
+        return _sl(start, end, strand)
+    else:
+        return shift_location(_sl(start, end + lim, strand), 0, lim)

{pydna-5.5.1.dist-info → pydna-5.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pydna
-Version: 5.5.1
+Version: 5.5.2
 Summary: Representing double stranded DNA and functions for simulating cloning and homologous recombination between DNA molecules.
 License: BSD
 Author: Björn F. Johansson
@@ -36,6 +36,7 @@ Requires-Dist: pydivsufsort (>=0.0.14)
 Requires-Dist: pyfiglet (==0.8.post1)
 Requires-Dist: pyparsing (>=2.4.7) ; extra == "download"
 Requires-Dist: pyperclip (>=1.8.2) ; extra == "clipboard"
+Requires-Dist: regex (>=2024.11.6,<2025.0.0)
 Requires-Dist: requests (>=2.26.0) ; extra == "download"
 Requires-Dist: scipy (>=1.11.3) ; (python_version >= "3.12") and (extra == "gel")
 Requires-Dist: scipy (>=1.9.3) ; (python_version < "3.12") and (extra == "gel")
@@ -46,11 +47,11 @@ Project-URL: Homepage, https://github.com/pydna-group/pydna#-pydna
 Project-URL: Repository, https://github.com/pydna-group/pydna/tree/master
 Description-Content-Type: text/markdown
 
-# ![icon](https://github.com/pydna-group/pydna/blob/master/docs/_static/pydna.resized.png?raw=true) pydna
+# ![icon](https://github.com/pydna-group/pydna/blob/master/docs/_static/banner.png?raw=true)
 
 | [![Tests & Coverage](https://github.com/pydna-group/pydna/actions/workflows/pydna_test_and_coverage_workflow.yml/badge.svg?branch=dev_bjorn)](https://github.com/pydna-group/pydna/actions/workflows/pydna_test_and_coverage_workflow.yml) | [![codecov](https://codecov.io/gh/BjornFJohansson/pydna/branch/master/graph/badge.svg)](https://codecov.io/gh/BjornFJohansson/pydna/branch/master) | [![PyPI version](https://badge.fury.io/py/pydna.svg)](https://badge.fury.io/py/pydna)                                                  | [![Google group : pydna](https://img.shields.io/badge/Google%20Group-pydna-blue.svg)](https://groups.google.com/g/pydna)          |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
-| [![Documentation Status](https://github.com/pydna-group/pydna/actions/workflows/publish-docs.yml/badge.svg)](https://github.com/pydna-group/pydna/actions/workflows/publish-docs.yml)                                                      | [![GitHub issues](https://img.shields.io/github/issues/BjornFJohansson/pydna.svg)](https://github.com/pydna-group/pydna/issues)                    | [![Anaconda-Server Badge2](https://anaconda.org/bjornfjohansson/pydna/badges/license.svg)](https://anaconda.org/bjornfjohansson/pydna) | [![GitHub stars](https://img.shields.io/github/stars/BjornFJohansson/pydna.svg)](https://github.com/pydna-group/pydna/stargazers) |
+| [![Documentation Status](https://github.com/pydna-group/pydna/actions/workflows/publish-docs.yml/badge.svg)](https://github.com/pydna-group/pydna/actions/workflows/publish-docs.yml)                                                      | [![GitHub issues](https://img.shields.io/github/issues/BjornFJohansson/pydna.svg)](https://github.com/pydna-group/pydna/issues)                    |  [![GitHub stars](https://img.shields.io/github/stars/BjornFJohansson/pydna.svg)](https://github.com/pydna-group/pydna/stargazers) | |
 
 <!-- docs/index.rst-start -->
 
@@ -524,6 +525,19 @@ pre-commit install
    > **TIP:** The hooks are a series of checks that will be run before you commit your code. If any of the checks fail, the commit will not be allowed. Some of them auto-fix the code (e.g., `black` formatting), so you can simply do `git add .` and commit again. Others like `flake8` will prevent the commit to happen until the code is compliant.  For instance, if you import a module in a file and not use it, `flake8` will complain. For a full list of checks, see `.pre-commit-config.yaml`.
 5. Push the changes to your fork
 
+> **TIP:** The continuous integration pipeline also runs doctests. These are tests that validate that the docstring examples are correct. For example, the docstring of the function `pydna.utils.smallest_rotation` looks like this:
+> ```python
+> >>> from pydna.utils import smallest_rotation
+> >>> smallest_rotation("taaa")
+> 'aaat'
+> ```
+> doctest will fail if `smallest_rotation("taaa")` does not return `'aaat'`. If you make changes to some function, you may break the doctests, and this can be a bit hard to understand. If this happens, the CI tests will fail, with a message similar to this:
+> ```
+> =================================== 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!
+
 ### Creating a PR 🔗
 
  * From your fork, make a PR towards the branch `dev_bjorn` in the original repository.

pydna-5.5.2.dist-info/RECORD

@@ -0,0 +1,43 @@
+pydna/__init__.py,sha256=a08F6v_bfQLzTDkNEbjeSa3hadO_cuKH0mIAkoG1AtU,12867
+pydna/_pretty.py,sha256=foRAxdL3Jiupuz7l38THBQZ7tu-5vQvLm1cKdDa7n6A,923
+pydna/_thermodynamic_data.py,sha256=9_w-97DpkbsWbJGHVijscMvUS_SFt7GxzrxspMRPZSg,10903
+pydna/all.py,sha256=xwkbR5Hn52xVfgLAXaEfIgtNwaBiGDbJFTQfa3Zi6HQ,1781
+pydna/amplicon.py,sha256=X4rCSanhlx1sPN0eAtcdAWg4Lw0WKrGQhv-cgZKtM3s,5343
+pydna/amplify.py,sha256=XRwmSMQ2d8Y379zcl56yU6rt1xWbSulWWHLqp-HRDc0,19260
+pydna/assembly.py,sha256=LM3-s3YysFvvkl1oooxoBjYLt0iMc3E1YLoqE05i8bs,19936
+pydna/assembly2.py,sha256=IN5tP5-FgdqLpIkAEKy9tXDG8x58iIgc6FUZSMr5kS0,73307
+pydna/codon.py,sha256=Nxa_03n2wxXKACkzi55bUN1t5xUU_DBRRwh_ZLIb9_o,2568
+pydna/common_sub_strings.py,sha256=A-gJeA2cEyxKKGQSFoC0BKvcXUGJZcnTUU7x2xlAovc,11574
+pydna/conftest.py,sha256=T5-WmHWLZH3U3ifxnbxd_oOiIFibIrkYpwNacCHlvsY,999
+pydna/contig.py,sha256=m0XV0LO2AbArPZkjyNCf8c7_b1EkXFtYwXHJVG4eTY8,8168
+pydna/crispr.py,sha256=iwu0Cjskzdb2r-In9633QIxQYKGmSNVOEM_dLK6lC54,3619
+pydna/design.py,sha256=BAoPb4M47yMkF1p4gGmbomZPFyTl0WuXkv8sLSY_Tg0,29067
+pydna/download.py,sha256=7tT8LAEy2Vg05spGfbCea_sol6pUOOBVbxOtyk2mnlQ,1085
+pydna/dseq.py,sha256=2N_dXX36niJItQzN61PoVweee0xxP04_amJ3cSExAtU,54232
+pydna/dseqrecord.py,sha256=9OSuxLqcJse3aIVZCVeN7bZCyohGt7WEXnnv1qBIcB0,47983
+pydna/fakeseq.py,sha256=uxyu1PXF-sVasEqhmyhMcsbpTy84uUtubDiZuxHNb9c,1174
+pydna/fusionpcr.py,sha256=tfIfGGkNoZjg_dodcEx9wTc12aLRnC7J3g-Vg3Jg1uA,2821
+pydna/gateway.py,sha256=9OL6o9J_FQoQ5VExmHMIPDtDiJs3_4-whcS755BPCG0,8451
+pydna/gel.py,sha256=QE1uhnjWXLl2nXgbLs_1TWbPixgUa0-z_UR8jZaByS4,3371
+pydna/genbank.py,sha256=rH677VRklVKBpPoFRsl7Az8fZvrC8TD2lNrNoHO1wU8,8856
+pydna/genbankfile.py,sha256=ii0_RjNGnsfUThTN01c5PRLSZkQT3WlYDvoC6R6ozAA,1451
+pydna/genbankfixer.py,sha256=rJ7qMODx19aha6g8eHC28UfaCsRM983XbTMZXNRdE8w,20510
+pydna/genbankrecord.py,sha256=u9RNBifT0j8rrA2bSdWajodtwm42P52_VlXsxKeOvq0,5566
+pydna/goldengate.py,sha256=LvUWAzhG9OhN1wil7osJIkjfqwBLh355a18wCZO1TvI,1778
+pydna/ladders.py,sha256=fKfWwezxQpX4qon9YCMIwchMBkGVOu8-C02xXk90J-E,3310
+pydna/ligate.py,sha256=ap8xgS4aL9cH4w38e-kpw1Ixa7DtpYF_ipezrVXiHG0,1965
+pydna/parsers.py,sha256=RFYBCKrlqWzZbRWhg5lQE3pp31KjUNAarpAgHJuUpaU,6690
+pydna/primer.py,sha256=k9Z_fHfBcY_rGnOtfys806rQBDtvyKwKl2ceSx3_w9A,2272
+pydna/readers.py,sha256=tKoonGlIB9ACeOMnzjhbCya1ooqhFMQIO_G36azN81E,1575
+pydna/seq.py,sha256=82gR1g2D8jfPy1So1pSJvlXYk4zkcKx_qmgvcydxth4,7579
+pydna/seqrecord.py,sha256=rzUUecmf9RkQdYHL0b9Pu8ofXM3Q6KThm-wv43jH0SA,23368
+pydna/sequence_picker.py,sha256=Pco9IrUwNSiS0wQ5hp5FMfE9kIN9XOwXasKLF9OA6DM,1402
+pydna/threading_timer_decorator_exit.py,sha256=D91kqjKSavWDnXyc1Fo-CwPYtbmR2DjTXnBYSRXKmSA,2793
+pydna/tm.py,sha256=0r4Aqjt_qanfqR8GNvqNh8us7AKM6JvaQKqHYsswAz4,11143
+pydna/types.py,sha256=OE7iwA3b7f_T6EoBnYbRl9CFrY6OrSkAfuyY-R5kins,1389
+pydna/user_cloning.py,sha256=VSpYX1tdbcD_PzEt69Jz6Lud-yAkYMVXnzVd4v2usnE,692
+pydna/utils.py,sha256=BwBOcr2HyLAPAVdpXEEDiwJ5MeWW096EOekvfyXxbDM,25227
+pydna-5.5.2.dist-info/LICENSE.txt,sha256=u8QfcsnNXZM0UCexerK_MvyA2lPWgeGyUtSYXvLG6Oc,6119
+pydna-5.5.2.dist-info/METADATA,sha256=TsRUcktnk2S-D4iZncIM54BSgQJ3XYv8EyTRfAAOgJI,25439
+pydna-5.5.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pydna-5.5.2.dist-info/RECORD,,

pydna/editor.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Copyright 2013-2023 by Björn Johansson.  All rights reserved.
-# This code is part of the Python-dna distribution and governed by its
-# license.  Please see the LICENSE.txt file that should have been included
-# as part of this package.
-"""This module provides a class for opening a sequence using an editor
-that accepts a file as a command line argument.
-
-ApE - A plasmid Editor [#]_ is and excellent editor for this purpose.
-
-References
-----------
-
-.. [#] http://biologylabs.utah.edu/jorgensen/wayned/ape/
-
-"""
-
-import time as _time
-import tempfile as _tempfile
-import os as _os
-import subprocess as _subprocess
-import operator as _operator
-import string as _string
-import copy as _copy
-import uuid as _uuid
-
-_wl = "{}{}-_.()".format(_string.ascii_letters, _string.digits)
-
-
-class Editor:
-    """
-    The Editor class needs to be instantiated before use.
-
-    Parameters
-    ----------
-
-    shell_command_for_editor : str
-        String containing the path to the editor
-
-    tmpdir : str, optional
-        String containing path to the temprary directory where sequence
-        files are stored before opening.
-
-    Examples
-    --------
-
-    >>> import pydna
-    >>> #ape = pydna.Editor("tclsh8.6 /home/bjorn/.ApE/apeextractor/ApE.vfs/lib/app-AppMain/AppMain.tcl")
-    >>> #ape.open("aaa") # This command opens the sequence in the ApE editor
-
-    """
-
-    def __init__(self, shell_command_for_editor, tmpdir=None):
-        self.path_to_editor = shell_command_for_editor
-        self.tmpdir = tmpdir or _os.path.join(_tempfile.gettempdir(), "ApE")
-        try:
-            _os.makedirs(self.tmpdir)
-        except OSError:
-            pass
-
-    def open(self, seq_to_open):
-        """Open a sequence for editing in an external (DNA) editor.
-
-        Parameters
-        ----------
-        args : SeqRecord or Dseqrecord object
-
-        """
-        seq = _copy.deepcopy(seq_to_open)
-        for feature in seq.features:
-            qf = feature.qualifiers
-            if "label" not in qf:
-                try:
-                    qf["label"] = qf["note"]
-                except KeyError:
-                    qf["label"] = ["feat{}".format(len(feature))]
-            if "ApEinfo_fwdcolor" not in qf:
-                qf["ApEinfo_fwdcolor"] = "#ffff49"
-            if "ApEinfo_revcolor" not in qf:
-                qf["ApEinfo_revcolor"] = "#ffe6cc"
-
-        seq.features.sort(key=_operator.attrgetter("location.start"))
-        name = "{name}.gb".format(
-            name="".join(c for c in seq.name.strip().replace(" ", "_") if c in _wl)
-            or _uuid.uuid3(_uuid.NAMESPACE_DNS, seq.name)
-        )
-        tdir = _tempfile.mkdtemp(dir=self.tmpdir)
-        tpth = _os.path.join(tdir, name)
-
-        with open(tpth, "w") as f:
-            f.write(seq.format("gb"))
-
-        _subprocess.Popen(
-            "{} {}".format(self.path_to_editor, tpth),
-            shell=True,
-            stdout=_tempfile.TemporaryFile(),
-            stderr=_tempfile.TemporaryFile(),
-        ).pid
-        _time.sleep(0.5)
-
-
-apeloader = Editor(_os.getenv("pydna_ape"))
-
-
-def ape(*args, **kwargs):
-    """docstring."""
-    return apeloader.open(*args, **kwargs)
-
-
-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/myenzymes.py

@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Copyright 2013-2023 by Björn Johansson.  All rights reserved.
-# This code is part of the Python-dna distribution and governed by its
-# license.  Please see the LICENSE.txt file that should have been included
-# as part of this package.
-"""This module establish a RestrictionBatch based on enzymes found in a text file specified in the enzymes entry
-in the python.ini file or by the environment variable pydna_enzymes.
-
-The text file will be searched for all enzymes in the biopython
-AllEnzymes batch which is located in the Bio.Restriction package.
-
-The pydna.myenzymes.myenzymes contains a new restriction batch with the enzymes contained
-within the file specified.
-"""
-
-import os as _os
-import re as _re
-from Bio.Restriction import AllEnzymes as _AllEnzymes
-from Bio.Restriction import RestrictionBatch as _RestrictionBatch
-import logging as _logging
-import traceback as _traceback
-
-_module_logger = _logging.getLogger("pydna." + __name__)
-
-
-_text = ""
-
-
-try:
-    with open(_os.environ["pydna_enzymes"], encoding="utf-8") as _f:
-        _text = _f.read()
-except FileNotFoundError:
-    _module_logger.warning("%s not found.", _os.environ["pydna_enzymes"])
-except IsADirectoryError:
-    _module_logger.warning("%s is a directory.", _os.environ["pydna_enzymes"])
-except IOError:
-    _module_logger.warning("%s found, but could not be read.", _os.environ["pydna_enzymes"])
-except Exception:
-    _module_logger.warning(_traceback.format_exc())
-
-
-myenzymes = _RestrictionBatch([e for e in _AllEnzymes if str(e).lower() in _re.split(r"\W+", _text.lower())])
-
-if __name__ == "__main__":
-    cache = _os.getenv("pydna_cache")
-    _os.environ["pydna_cache"] = "nocache"
-    import doctest
-
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS)
-    _os.environ["pydna_cache"] = cache