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

pydna/seq.py

@@ -25,9 +25,10 @@ from Bio.Seq import Seq as _Seq
 from pydna._pretty import PrettyTable as _PrettyTable
 
 from typing import List as _List, Optional as _Optional, Tuple as _Tuple
-import logging as _logging
 
-_module_logger = _logging.getLogger("pydna." + __name__)
+# import logging as _logging
+
+# _module_logger = _logging.getLogger("pydna." + __name__)
 
 
 class Seq(_Seq):
@@ -43,7 +44,9 @@ class Seq(_Seq):
         **kwargs,
     ) -> "ProteinSeq":
         """Translate.."""
-        p = super().translate(*args, stop_symbol=stop_symbol, to_stop=to_stop, cds=cds, gap=gap, **kwargs)
+        p = super().translate(
+            *args, stop_symbol=stop_symbol, to_stop=to_stop, cds=cds, gap=gap, **kwargs
+        )
         return ProteinSeq(p._data)
 
     def gc(self) -> float:
@@ -78,10 +81,17 @@ class Seq(_Seq):
 
     def express(self, organism: str = "sce") -> _PrettyTable:
         """docstring."""
-        x = _PrettyTable(["cds", "len", "cai", "gc", "sta", "stp", "n-end"] + _rare_codons[organism] + ["rare"])
+        x = _PrettyTable(
+            ["cds", "len", "cai", "gc", "sta", "stp", "n-end"]
+            + _rare_codons[organism]
+            + ["rare"]
+        )
         val = []
 
-        val.append(f"{self._data.upper().decode('ASCII')[:3]}..." f"{self._data.upper().decode('ASCII')[-3:]}")
+        val.append(
+            f"{self._data.upper().decode('ASCII')[:3]}..."
+            f"{self._data.upper().decode('ASCII')[-3:]}"
+        )
         val.append(len(self) / 3)
         val.append(self.cai(organism))
         val.append(self.gc())
@@ -103,7 +113,9 @@ class Seq(_Seq):
 
     def orfs2(self, minsize: int = 30) -> _List[str]:
         """docstring."""
-        orf = _re.compile(f"ATG(?:...){{{minsize},}}?(?:TAG|TAA|TGA)", flags=_re.IGNORECASE)
+        orf = _re.compile(
+            f"ATG(?:...){{{minsize},}}?(?:TAG|TAA|TGA)", flags=_re.IGNORECASE
+        )
         start = 0
         matches: _List[slice] = []
         s = self._data.decode("ASCII")
@@ -203,7 +215,9 @@ class ProteinSeq(_Seq):
         ----------
         .. [#] http://wiki.christophchamp.com/index.php/SEGUID
         """
-        return _lsseguid(self._data.decode("utf8").upper(), alphabet="{protein-extended}")
+        return _lsseguid(
+            self._data.decode("utf8").upper(), alphabet="{protein-extended}"
+        )
 
     def __getitem__(self, key):
         result = super().__getitem__(key)
@@ -232,14 +246,3 @@ class ProteinSeq(_Seq):
         Guruprasad K., Reddy B.V.B., Pandit M.W. Protein Engineering 4:155-161(1990).
         """
         return self._pa().instability_index()
-
-
-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/seqrecord.py

@@ -35,10 +35,10 @@ from copy import copy as _copy
 from pydna import _PydnaWarning
 from warnings import warn as _warn
 
-import logging as _logging
+# import logging as _logging
 import datetime
 
-_module_logger = _logging.getLogger("pydna." + __name__)
+# _module_logger = _logging.getLogger("pydna." + __name__)
 
 
 class SeqRecord(_SeqRecord):
@@ -87,7 +87,9 @@ class SeqRecord(_SeqRecord):
             self.seq = _Seq(self.seq)
 
         self.seq._data = b"".join(self.seq._data.split())  # remove whitespaces
-        self.annotations = {_pretty_str(k): _pretty_str(v) for k, v in self.annotations.items()}
+        self.annotations = {
+            _pretty_str(k): _pretty_str(v) for k, v in self.annotations.items()
+        }
 
     @classmethod
     def from_Bio_SeqRecord(clc, sr: _SeqRecord):
@@ -109,7 +111,9 @@ class SeqRecord(_SeqRecord):
         if len(value) > 16:
             shortvalue = value[:16]
             _warn(
-                ("locus property {} truncated" "to 16 chars {}").format(value, shortvalue),
+                ("locus property {} truncated" "to 16 chars {}").format(
+                    value, shortvalue
+                ),
                 _PydnaWarning,
                 stacklevel=2,
             )
@@ -193,7 +197,7 @@ class SeqRecord(_SeqRecord):
     def translate(self):
         """docstring."""
         p = super().translate()
-        return ProteinSeqRecord(_ProteinSeq(p.seq[:-1]))
+        return ProteinSeqRecord(_ProteinSeq(p.seq))
 
     def add_colors_to_features_for_ape(self):
         """Assign colors to features.
@@ -239,7 +243,9 @@ class SeqRecord(_SeqRecord):
             f.qualifiers["ApEinfo_fwdcolor"] = [cols[i % len(cols)]]
             f.qualifiers["ApEinfo_revcolor"] = [cols[::-1][i % len(cols)]]
 
-    def add_feature(self, x=None, y=None, seq=None, type_="misc", strand=1, *args, **kwargs):
+    def add_feature(
+        self, x=None, y=None, seq=None, type_="misc", strand=1, *args, **kwargs
+    ):
         """Add a feature of type misc to the feature list of the sequence.
 
         Parameters
@@ -327,7 +333,9 @@ class SeqRecord(_SeqRecord):
         |   0 | L:ft2         | --> | 2   | 4   |   2 | misc |  no  |
         +-----+---------------+-----+-----+-----+-----+------+------+
         """
-        x = _PrettyTable(["Ft#", "Label or Note", "Dir", "Sta", "End", "Len", "type", "orf?"])
+        x = _PrettyTable(
+            ["Ft#", "Label or Note", "Dir", "Sta", "End", "Len", "type", "orf?"]
+        )
         x.align["Ft#"] = "r"  # Left align
         x.align["Label or Note"] = "l"  # Left align
         x.align["Len"] = "r"
@@ -357,7 +365,8 @@ class SeqRecord(_SeqRecord):
                     len(sf),
                     sf.type,
                     {True: "yes", False: "no"}[
-                        self.extract_feature(i).isorf() or self.extract_feature(i).reverse_complement().isorf()
+                        self.extract_feature(i).isorf()
+                        or self.extract_feature(i).reverse_complement().isorf()
                     ],
                 ]
             )
@@ -480,7 +489,9 @@ class SeqRecord(_SeqRecord):
                 f"Stamp change.\nNew: {chksum}\nOld: {oldstamp[0]}",
                 _PydnaWarning,
             )
-        self.annotations["comment"] = (f"{oldcomment}\n" f"{tool} {chksum} {now()} {comment}").strip()
+        self.annotations["comment"] = (
+            f"{oldcomment}\n" f"{tool} {chksum} {now()} {comment}"
+        ).strip()
         return _pretty_str(chksum)
 
     def lcs(self, other, *args, limit=25, **kwargs):
@@ -729,14 +740,3 @@ class ProteinSeqRecord(SeqRecord):
     def __format__(self, format):
         """docstring."""
         return _pretty_str(_SeqRecord.__format__(self, format))
-
-
-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 | doctest.NORMALIZE_WHITESPACE))
-    _os.environ["pydna_cached_funcs"] = cached

pydna/sequence_picker.py

@@ -7,11 +7,12 @@
 
 from pydna.dseqrecord import Dseqrecord
 import os as _os
-import logging as _logging
+
+# import logging as _logging
 from Bio.Blast import NCBIWWW
 from Bio.Blast import NCBIXML
 
-_module_logger = _logging.getLogger("pydna." + __name__)
+# _module_logger = _logging.getLogger("pydna." + __name__)
 
 
 email = _os.getenv("pydna_email")
@@ -51,13 +52,3 @@ def genbank_accession(s: str) -> Dseqrecord:
         description=(f"{best_alignment.accession} " f"REGION: {start}..{stop}"),
     )
     return 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
-    pass

pydna/sequence_regex.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+from pydna.dseqrecord import Dseqrecord as _Dseqrecord
+import re
+from Bio.Data.IUPACData import ambiguous_dna_values as _ambiguous_dna_values
+
+ambiguous_only_dna_values = {**_ambiguous_dna_values}
+for normal_base in "ACGT":
+    del ambiguous_only_dna_values[normal_base]
+
+
+def compute_regex_site(site: str) -> str:
+    """
+    Creates a regex pattern from a string that may contain degenerate bases.
+
+    Args:
+        site: The string to convert to a regex pattern.
+
+    Returns:
+        The regex pattern.
+    """
+    upper_site = site.upper()
+    for k, v in ambiguous_only_dna_values.items():
+        if len(v) > 1:
+            upper_site = upper_site.replace(k, f"[{''.join(v)}]")
+
+    # Make case insensitive
+    upper_site = f"(?i){upper_site}"
+    return upper_site
+
+
+def dseqrecord_finditer(pattern: str, seq: _Dseqrecord) -> list[re.Match]:
+    """
+    Finds all matches of a regex pattern in a Dseqrecord.
+
+    Args:
+        pattern: The regex pattern to search for.
+        seq: The Dseqrecord to search in.
+
+    Returns:
+        A list of matches.
+    """
+    query = str(seq.seq) if not seq.circular else str(seq.seq) * 2
+    matches = re.finditer(pattern, query)
+    return (m for m in matches if m.start() <= len(seq))

pydna/tm.py

@@ -213,7 +213,9 @@ def dbd_program(amplicon, tm=tm_dbd, ta=ta_dbd):
 
     """
     PfuSso7d_extension_rate = 15  # seconds/kB PCR product
-    extension_time_PfuSso7d = max(10, int(PfuSso7d_extension_rate * len(amplicon) / 1000))  # seconds
+    extension_time_PfuSso7d = max(
+        10, int(PfuSso7d_extension_rate * len(amplicon) / 1000)
+    )  # seconds
 
     # The program returned is eaither a two step or three step progrem
     # This depends on the tm and length of the primers in the
@@ -324,7 +326,10 @@ def tmbresluc(primer: str, *args, primerc=500.0, saltc=50, **kwargs):
         dH += _thermodynamic_data.dHBr[n1 - 97][n2 - 97]
         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)) - 273.15
+    tm = (
+        dH / (1.9872 * _math.log(pri / 1600) + dS)
+        + (16.6 * _math.log(saltc)) / _math.log(10)
+    ) - 273.15
 
     return tm
 
@@ -365,25 +370,18 @@ def tm_neb(primer, conc=0.5, prodcode="q5-0"):
     try:
         res = requests.get(url, params=params, headers=headers)
     except requests.exceptions.ConnectionError as e:
-        raise requests.exceptions.ConnectionError("Could not connect to NEB API.") from e
+        raise requests.exceptions.ConnectionError(
+            "Could not connect to NEB API."
+        ) from e
     if res.status_code != 200:
         if "error" in res.json():
             raise requests.exceptions.HTTPError(res.status_code, res.json()["error"])
         else:
-            raise requests.exceptions.HTTPError(res.status_code, res.text)  # pragma: no cover
+            raise requests.exceptions.HTTPError(
+                res.status_code, res.text
+            )  # pragma: no cover
     r = res.json()
     if r["success"]:
         return r["data"]["tm1"]
     else:
         raise requests.exceptions.HTTPError(r["error"])
-
-
-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/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)