opencloning 0.2.7.3__py3-none-any.whl → 0.2.8.1__py3-none-any.whl

opencloning/cre_lox.py

@@ -0,0 +1,58 @@
+from itertools import product
+from pydna.dseqrecord import Dseqrecord
+from Bio.Data.IUPACData import ambiguous_dna_values
+from Bio.Seq import reverse_complement
+from .dna_utils import compute_regex_site, dseqrecord_finditer
+
+# We create a dictionary to map ambiguous bases to their consensus base
+# For example, ambigous_base_dict['ACGT'] -> 'N'
+ambiguous_base_dict = {}
+for ambiguous, bases in ambiguous_dna_values.items():
+    ambiguous_base_dict[''.join(sorted(bases))] = ambiguous
+
+# To handle N values
+ambiguous_base_dict['N'] = 'N'
+
+# This is the original loxP sequence, here for reference
+LOXP_SEQUENCE = 'ATAACTTCGTATAGCATACATTATACGAAGTTAT'
+
+loxP_sequences = [
+    # https://blog.addgene.org/plasmids-101-cre-lox
+    # loxP
+    'ATAACTTCGTATANNNTANNNTATACGAAGTTAT',
+    # PMID:12202778
+    # lox66
+    'ATAACTTCGTATANNNTANNNTATACGAACGGTA',
+    # lox71
+    'TACCGTTCGTATANNNTANNNTATACGAAGTTAT',
+]
+
+loxP_consensus = ''
+
+for pos in range(len(LOXP_SEQUENCE)):
+    all_letters = set(seq[pos] for seq in loxP_sequences)
+    key = ''.join(sorted(all_letters))
+    loxP_consensus += ambiguous_base_dict[key]
+
+# We compute the regex for the forward and reverse loxP sequences
+loxP_regex = (compute_regex_site(loxP_consensus), compute_regex_site(reverse_complement(loxP_consensus)))
+
+
+def cre_loxP_overlap(x: Dseqrecord, y: Dseqrecord, _l: None = None) -> list[tuple[int, int, int]]:
+    """Find matching loxP sites between two sequences."""
+    out = list()
+    for pattern in loxP_regex:
+        matches_x = dseqrecord_finditer(pattern, x)
+        matches_y = dseqrecord_finditer(pattern, y)
+
+        for match_x, match_y in product(matches_x, matches_y):
+            value_x = match_x.group()
+            value_y = match_y.group()
+            if value_x[13:21] == value_y[13:21]:
+                out.append((match_x.start() + 13, match_y.start() + 13, 8))
+    # Unique values (keeping the order)
+    unique_out = []
+    for item in out:
+        if item not in unique_out:
+            unique_out.append(item)
+    return unique_out

opencloning/dna_utils.py

@@ -11,9 +11,15 @@ import os
 import shutil
 from pydna.parsers import parse
 from Bio.Align import PairwiseAligner
+from Bio.Data.IUPACData import ambiguous_dna_values as _ambiguous_dna_values
+import re
 
 aligner = PairwiseAligner(scoring='blastn')
 
+ambiguous_only_dna_values = {**_ambiguous_dna_values}
+for normal_base in 'ACGT':
+    del ambiguous_only_dna_values[normal_base]
+
 
 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.
@@ -144,3 +150,20 @@ def align_sanger_traces(dseqr: Dseqrecord, sanger_traces: list[str]) -> list[str
         sanger_traces = traces_oriented
 
     return align_with_mafft([query_str, *sanger_traces], True)
+
+
+def compute_regex_site(site: str) -> str:
+    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]:
+    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))

opencloning/endpoints/assembly.py

@@ -5,7 +5,7 @@ from pydna.primer import Primer as PydnaPrimer
 from pydna.crispr import cas9
 from pydantic import conlist, create_model
 from Bio.Restriction.Restriction import RestrictionBatch
-
+from opencloning.cre_lox import cre_loxP_overlap
 from ..dna_functions import (
     get_invalid_enzyme_names,
     format_sequence_genbank,
@@ -24,6 +24,8 @@ from ..pydantic_models import (
     AssemblySource,
     OverlapExtensionPCRLigationSource,
     GatewaySource,
+    CreLoxRecombinationSource,
+    InVivoAssemblySource,
 )
 from ..assembly2 import (
     Assembly,
@@ -159,6 +161,7 @@ def generate_assemblies(
     allow_insertion_assemblies: bool,
     assembly_kwargs: dict | None = None,
     product_callback: Callable[[Dseqrecord], Dseqrecord] = lambda x: x,
+    recombination_mode: bool = False,
 ) -> dict[Literal['sources', 'sequences'], list[AssemblySource] | list[TextFileSequence]]:
     if assembly_kwargs is None:
         assembly_kwargs = {}
@@ -175,10 +178,15 @@ def generate_assemblies(
             circular_assemblies = asm.get_circular_assemblies()
             out_sources += [create_source(a, True) for a in circular_assemblies]
             if not circular_only:
-                out_sources += [
-                    create_source(a, False)
-                    for a in filter_linear_subassemblies(asm.get_linear_assemblies(), circular_assemblies, fragments)
-                ]
+                if not recombination_mode:
+                    out_sources += [
+                        create_source(a, False)
+                        for a in filter_linear_subassemblies(
+                            asm.get_linear_assemblies(), circular_assemblies, fragments
+                        )
+                    ]
+                else:
+                    out_sources += [create_source(a, False) for a in asm.get_insertion_assemblies()]
         else:
             asm = SingleFragmentAssembly(fragments, algorithm=algo, **assembly_kwargs)
             out_sources.extend(create_source(a, True) for a in asm.get_circular_assemblies())
@@ -385,13 +393,16 @@ async def homologous_recombination(
     '/gibson_assembly',
     response_model=create_model(
         'GibsonAssemblyResponse',
-        sources=(list[Union[GibsonAssemblySource, OverlapExtensionPCRLigationSource, InFusionSource]], ...),
+        sources=(
+            list[Union[GibsonAssemblySource, OverlapExtensionPCRLigationSource, InFusionSource, InVivoAssemblySource]],
+            ...,
+        ),
         sequences=(list[TextFileSequence], ...),
     ),
 )
 async def gibson_assembly(
     sequences: conlist(TextFileSequence, min_length=1),
-    source: Union[GibsonAssemblySource, OverlapExtensionPCRLigationSource, InFusionSource],
+    source: Union[GibsonAssemblySource, OverlapExtensionPCRLigationSource, InFusionSource, InVivoAssemblySource],
     minimal_homology: int = Query(
         40, description='The minimum homology between consecutive fragments in the assembly.'
     ),
@@ -522,3 +533,30 @@ async def gateway(
         return {'sources': sources, 'sequences': sequences}
 
     return resp
+
+
+@router.post(
+    '/cre_lox_recombination',
+    response_model=create_model(
+        'CreLoxRecombinationResponse',
+        sources=(list[CreLoxRecombinationSource], ...),
+        sequences=(list[TextFileSequence], ...),
+    ),
+)
+async def cre_lox_recombination(source: CreLoxRecombinationSource, sequences: conlist(TextFileSequence, min_length=1)):
+    fragments = [read_dsrecord_from_json(seq) for seq in sequences]
+
+    # Lambda function for code clarity
+    def create_source(a, is_circular):
+        return CreLoxRecombinationSource.from_assembly(
+            assembly=a, circular=is_circular, id=source.id, fragments=fragments
+        )
+
+    resp = generate_assemblies(
+        source, create_source, fragments, False, cre_loxP_overlap, True, recombination_mode=True
+    )
+
+    if len(resp['sources']) == 0:
+        raise HTTPException(400, 'No compatible Cre/Lox recombination was found.')
+
+    return resp

opencloning/endpoints/external_import.py

@@ -8,6 +8,8 @@ from starlette.responses import RedirectResponse
 from Bio import BiopythonParserWarning
 from typing import Annotated
 from urllib.error import HTTPError
+from pydna.utils import location_boundaries
+
 from ..get_router import get_router
 from ..pydantic_models import (
     TextFileSequence,
@@ -22,6 +24,7 @@ from ..pydantic_models import (
     GenomeCoordinatesSource,
     SequenceFileFormat,
     SEVASource,
+    SimpleSequenceLocation,
 )
 from ..dna_functions import (
     format_sequence_genbank,
@@ -51,13 +54,13 @@ router = get_router()
             'description': 'The sequence was successfully parsed',
             'headers': {
                 'x-warning': {
-                    'description': 'A warning returned if the file can be read but is not in the expected format',
+                    'description': 'A warning returned if the file can be read but is not in the expected format or if some sequences were not extracted because they are incompatible with the provided coordinates',
                     'schema': {'type': 'string'},
                 },
             },
         },
         422: {
-            'description': 'Biopython cannot process this file.',
+            'description': 'Biopython cannot process this file or provided coordinates are invalid.',
         },
         404: {
             'description': 'The index_in_file is out of range.',
@@ -83,6 +86,12 @@ async def read_from_file(
         None,
         description='Name of the output sequence',
     ),
+    start: int | None = Query(None, description='Start position of the sequence to read (0-based)', ge=0),
+    end: int | None = Query(
+        None,
+        description='End position of the sequence to read (0-based)',
+        ge=0,
+    ),
 ):
     """Return a json sequence from a sequence file"""
 
@@ -107,6 +116,7 @@ async def read_from_file(
         sequence_file_format = SequenceFileFormat(extension_dict[extension])
 
     dseqs = list()
+    warning_messages = list()
 
     file_content = await file.read()
     if sequence_file_format == 'snapgene':
@@ -124,7 +134,6 @@ async def read_from_file(
 
         if warnings_captured:
             warning_messages = [str(w.message) for w in warnings_captured]
-            response.headers['x-warning'] = '; '.join(warning_messages)
 
     except ValueError as e:
         raise HTTPException(422, f'Biopython cannot process this file: {e}.')
@@ -134,25 +143,62 @@ async def read_from_file(
     if len(dseqs) == 0:
         raise HTTPException(422, 'Biopython cannot process this file.')
 
+    if index_in_file is not None:
+        if index_in_file >= len(dseqs):
+            raise HTTPException(404, 'The index_in_file is out of range.')
+        dseqs = [dseqs[index_in_file]]
+
+    seq_feature = None
+    if start is not None and end is not None:
+        seq_feature = SimpleSequenceLocation(start=start, end=end)
+        extracted_sequences = list()
+        for dseq in dseqs:
+            try:
+                # TODO: We could use extract when this is addressed: https://github.com/biopython/biopython/issues/4989
+                location = seq_feature.to_biopython_location(circular=dseq.circular, seq_len=len(dseq))
+                i, j = location_boundaries(location)
+                extracted_sequence = dseq[i:j]
+                # Only add the sequence if the interval is not out of bounds
+                if len(extracted_sequence) == len(location):
+                    extracted_sequences.append(extracted_sequence)
+                else:
+                    extracted_sequences.append(None)
+            except Exception:
+                extracted_sequences.append(None)
+        dseqs = extracted_sequences
+
     # The common part
-    # TODO: using id=0 is not great
     parent_source = UploadedFileSource(
-        id=0, sequence_file_format=sequence_file_format, file_name=file.filename, circularize=circularize
+        id=0,
+        sequence_file_format=sequence_file_format,
+        file_name=file.filename,
+        circularize=circularize,
+        coordinates=seq_feature,
     )
+
+    # If coordinates are provided, we only keep the sequences compatible with those coordinates
     out_sources = list()
+    out_sequences = list()
     for i in range(len(dseqs)):
+        if dseqs[i] is None:
+            continue
         new_source = parent_source.model_copy()
-        new_source.index_in_file = i
+        new_source.index_in_file = index_in_file if index_in_file is not None else i
         out_sources.append(new_source)
+        out_sequences.append(format_sequence_genbank(dseqs[i], output_name))
 
-    out_sequences = [format_sequence_genbank(s, output_name) for s in dseqs]
+    if len(out_sequences) == 0:
+        raise HTTPException(422, 'Provided coordinates are incompatible with sequences in the file.')
 
-    if index_in_file is not None:
-        if index_in_file >= len(out_sources):
-            raise HTTPException(404, 'The index_in_file is out of range.')
-        return {'sequences': [out_sequences[index_in_file]], 'sources': [out_sources[index_in_file]]}
-    else:
-        return {'sequences': out_sequences, 'sources': out_sources}
+    if len(out_sequences) < len(dseqs):
+        warning_messages.append(
+            'Some sequences were not extracted because they are incompatible with the provided coordinates.'
+        )
+
+    if len(warning_messages) > 0:
+        response.headers['x-warning'] = '; '.join(warning_messages)
+
+    return {'sequences': out_sequences, 'sources': out_sources}
 
 
 # TODO: a bit inconsistent that here you don't put {source: {...}} in the request, but

opencloning/gateway.py

@@ -1,31 +1,10 @@
-from Bio.Data.IUPACData import ambiguous_dna_values as _ambiguous_dna_values
 from Bio.Seq import reverse_complement
 from pydna.dseqrecord import Dseqrecord as _Dseqrecord
 import re
 import itertools as _itertools
 from Bio.SeqFeature import SimpleLocation, SeqFeature
 from pydna.utils import shift_location
-
-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:
-    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]:
-    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))
+from .dna_utils import compute_regex_site, dseqrecord_finditer
 
 
 raw_gateway_common = {

opencloning/pydantic_models.py

@@ -45,6 +45,8 @@ from opencloning_linkml.datamodel import (
     IGEMSource as _IGEMSource,
     ReverseComplementSource as _ReverseComplementSource,
     SEVASource as _SEVASource,
+    CreLoxRecombinationSource as _CreLoxRecombinationSource,
+    InVivoAssemblySource as _InVivoAssemblySource,
 )
 from pydna.utils import shift_location as _shift_location
 from .assembly2 import edge_representation2subfragment_representation, subfragment_representation2edge_representation
@@ -338,6 +340,10 @@ class InFusionSource(AssemblySourceCommonClass, _InFusionSource):
     pass
 
 
+class InVivoAssemblySource(AssemblySourceCommonClass, _InVivoAssemblySource):
+    pass
+
+
 class CRISPRSource(AssemblySourceCommonClass, _CRISPRSource):
 
     # TODO
@@ -384,6 +390,10 @@ class GatewaySource(AssemblySourceCommonClass, _GatewaySource):
         return super().from_assembly(assembly, id, circular, fragments, reaction_type=reaction_type)
 
 
+class CreLoxRecombinationSource(AssemblySourceCommonClass, _CreLoxRecombinationSource):
+    pass
+
+
 class OligoHybridizationSource(SourceCommonClass, _OligoHybridizationSource):
     pass
 

{opencloning-0.2.7.3.dist-info → opencloning-0.2.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opencloning
-Version: 0.2.7.3
+Version: 0.2.8.1
 Summary: Backend of OpenCloning, a web application to generate molecular cloning strategies in json format, and share them with others.
 License: MIT
 Author: Manuel Lera-Ramirez
@@ -15,7 +15,7 @@ Requires-Dist: beautifulsoup4 (>=4.11.1,<5.0.0)
 Requires-Dist: biopython (==1.84)
 Requires-Dist: fastapi
 Requires-Dist: httpx (>=0.25.0,<0.26.0)
-Requires-Dist: opencloning-linkml (==0.2.5.2a0)
+Requires-Dist: opencloning-linkml (==0.2.6.1a0)
 Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: primer3-py (>=2.0.3,<3.0.0)

{opencloning-0.2.7.3.dist-info → opencloning-0.2.8.1.dist-info}/RECORD

@@ -19,27 +19,28 @@ opencloning/batch_cloning/pombe/pombe_summary.py,sha256=W9DLpnCuwK7w2DhHLu60N7L6
 opencloning/batch_cloning/ziqiang_et_al2024/__init__.py,sha256=zZUbj3uMzd9rKMXi5s9LQ1yUg7sccdS0f_4kpw7SQlk,7584
 opencloning/batch_cloning/ziqiang_et_al2024/index.html,sha256=EDncANDhhQkhi5FjnnAP6liHkG5srf4_Y46IrnMUG5g,4607
 opencloning/batch_cloning/ziqiang_et_al2024/ziqiang_et_al2024.json,sha256=mB81j2qWam7uRc-980YFjfqq2CiWTXJYfKFAoKuGtRw,157148
+opencloning/cre_lox.py,sha256=mb2ZddjrPIrUBT3xxMub5-c97WkKZ4Z-HkGFVzuR8pQ,2031
 opencloning/dna_functions.py,sha256=W-SxEfvYpN1JVZbTeCNitpQXkazEHvFyqZBUndd-jpY,16329
-opencloning/dna_utils.py,sha256=emms1omBhQKuVNEv6YXcHReP69tvUU1iRpLgjXn5p9o,5541
+opencloning/dna_utils.py,sha256=uv97aO04dbk3NnqbN6GlnwOu0MOpK88rl2np2QcEQ4Y,6301
 opencloning/ebic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opencloning/ebic/primer_design.py,sha256=gPZTF9w5SV7WGgnefp_HBM831y0z73M1Kb0QUPnbfIM,2270
 opencloning/ebic/primer_design_settings.py,sha256=OnFsuh0QCvplUEPXLZouzRo9R7rm4nLbcd2LkDCiIDM,1896
 opencloning/endpoints/annotation.py,sha256=3rlIXeNQzoqPD9lJUEBGLGxvlhUCTcfkqno814A8P0U,2283
-opencloning/endpoints/assembly.py,sha256=0kcWchgN5ulj_I7ZOpFhsgq74SBT_7A7xbZz7s5-1C0,19330
-opencloning/endpoints/external_import.py,sha256=dDG7DiNb8WYE46nLGnkyRbGVVNUDXp3h0_1ixsJAh5o,16242
+opencloning/endpoints/assembly.py,sha256=H1b7CRx1JZ5pcUGd3uyJG2syYugkXiIo8HRCA11TQfE,20704
+opencloning/endpoints/external_import.py,sha256=DG8WSvyvr-9xy-odEwLHHA4FWiIh8sw4DvTblw5NCYc,18179
 opencloning/endpoints/no_assembly.py,sha256=NY6rhEDCNoZVn6Xk81cen2n-FkMr7ierfxM8G0npbQs,4722
 opencloning/endpoints/no_input.py,sha256=DuqKD3Ph3a44ZxPMEzZv1nwD5xlxYsN7YyxXcfjSUFc,3844
 opencloning/endpoints/other.py,sha256=TzfCJLDmZFWeKYxKhEfXOvlQrWWyBIGJ5FR0yA7tuvI,1673
 opencloning/endpoints/primer_design.py,sha256=ItPUa7bBW9JOOfTuLj0yNnF9UmQ-I_0l3i8wHpnUc6k,12854
-opencloning/gateway.py,sha256=qaefWKjfASuVU_nXnCCoDepQq1jhNINNW0VifkCLVC0,9123
+opencloning/gateway.py,sha256=jzpLbB8UCSlks0S6Qe9PXJ7CdzHiH2ko_O7MzYQLR14,8435
 opencloning/get_router.py,sha256=l2DXaTbeL2tDqlnVMlcewutzt1sjaHlxku1X9HVUwJk,252
 opencloning/main.py,sha256=l9PrPBMtGMEWxAPiPWR15Qv2oDNnRoNd8H8E3bZW6Do,3750
 opencloning/ncbi_requests.py,sha256=JrFc-Ugr1r1F4LqsdpJZEiERj7ZemvZSgiIltl2Chx8,5547
 opencloning/primer_design.py,sha256=nqCmYIZ7UvU4CQwVGJwX7T5LTHwt3-51_ZcTZZAgT_Y,9175
-opencloning/pydantic_models.py,sha256=S3ehXeynVlYJQK-G96D0jApMp7dn-eRg1di9d0DbsEc,15045
+opencloning/pydantic_models.py,sha256=gsipVXhjQOXVz2NL-MiNpLuOZYDVo2Pli9F--bp6tjs,15345
 opencloning/request_examples.py,sha256=QAsJxVaq5tHwlPB404IiJ9WC6SA7iNY7XnJm63BWT_E,2944
 opencloning/utils.py,sha256=wsdTJYliap-t3oa7yQE3pWDa1CR19mr5lUQfocp4hoM,1875
-opencloning-0.2.7.3.dist-info/LICENSE,sha256=VSdVE1f8axjIh6gvo9ZZygJdTVkRFMcwCW_hvjOHC_w,1058
-opencloning-0.2.7.3.dist-info/METADATA,sha256=SFtmhPNvDi61Qp9JYNcsiQop9I_zYOPyGfeus-Etbf4,8429
-opencloning-0.2.7.3.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-opencloning-0.2.7.3.dist-info/RECORD,,
+opencloning-0.2.8.1.dist-info/LICENSE,sha256=VSdVE1f8axjIh6gvo9ZZygJdTVkRFMcwCW_hvjOHC_w,1058
+opencloning-0.2.8.1.dist-info/METADATA,sha256=rp3mHAG3x49YfumIjM5teZL6iAtRbhQG1tl64bOjPfI,8429
+opencloning-0.2.8.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+opencloning-0.2.8.1.dist-info/RECORD,,