opencloning 0.4.8__py3-none-any.whl → 0.5__py3-none-any.whl

opencloning/endpoints/endpoint_utils.py

@@ -0,0 +1,52 @@
+from fastapi import HTTPException
+from pydna.dseqrecord import Dseqrecord
+from opencloning_linkml.datamodel import Source, TextFileSequence
+from typing import Literal
+from opencloning.dna_functions import format_sequence_genbank
+from pydna.opencloning_models import id_mode
+from opencloning.dna_functions import get_invalid_enzyme_names
+from Bio.Restriction.Restriction import RestrictionBatch
+
+
+def format_products(
+    source_id: int,
+    products: list[Dseqrecord],
+    completed_source: Source | None,
+    output_name: str,
+    no_products_error_message: str = 'No products were found.',
+    wrong_completed_source_error_message: str = 'The provided assembly is not valid.',
+) -> dict[Literal['sources', 'sequences'], list[Source] | list[TextFileSequence]]:
+
+    formatted_products = [format_sequence_genbank(p, output_name) for p in products]
+    for p in formatted_products:
+        p.id = source_id
+
+    with id_mode(use_python_internal_id=False):
+        formatted_sources = [p.source.to_pydantic_model(source_id).model_dump() for p in products]
+        for source in formatted_sources:
+            source['output_name'] = output_name
+
+    if completed_source is not None:
+        this_source_dict = completed_source.model_dump()
+        for prod, source in zip(formatted_products, formatted_sources):
+            if source == this_source_dict:
+                return {
+                    'sources': [source],
+                    'sequences': [prod],
+                }
+        raise HTTPException(400, wrong_completed_source_error_message)
+
+    if len(products) == 0:
+        raise HTTPException(400, no_products_error_message)
+
+    return {
+        'sources': formatted_sources,
+        'sequences': formatted_products,
+    }
+
+
+def parse_restriction_enzymes(enzymes: list[str]) -> RestrictionBatch:
+    invalid_enzymes = get_invalid_enzyme_names(enzymes)
+    if len(invalid_enzymes):
+        raise HTTPException(404, 'These enzymes do not exist: ' + ', '.join(invalid_enzymes))
+    return RestrictionBatch(first=[e for e in enzymes if e is not None])

opencloning/endpoints/external_import.py

@@ -1,4 +1,5 @@
 from fastapi import Body, Query, HTTPException, Response, UploadFile, File
+from opencloning.app_settings import settings
 from pydantic import create_model
 import io
 import warnings
@@ -6,11 +7,12 @@ import asyncio
 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 opencloning.endpoints.endpoint_utils import format_products
+
 from ..get_router import get_router
-from ..pydantic_models import (
+from opencloning_linkml.datamodel import (
     TextFileSequence,
     UploadedFileSource,
     RepositoryIdSource,
@@ -23,18 +25,22 @@ from ..pydantic_models import (
     GenomeCoordinatesSource,
     SequenceFileFormat,
     SEVASource,
-    SequenceLocationStr,
     OpenDNACollectionsSource,
+    NCBISequenceSource,
 )
+from pydna.opencloning_models import SequenceLocationStr
 from ..dna_functions import (
     format_sequence_genbank,
+    get_sequence_from_benchling_url,
+    get_sequence_from_iGEM2024,
+    get_sequence_from_openDNA_collections,
     request_from_addgene,
+    request_from_snapgene,
     request_from_wekwikgene,
-    get_sequences_from_file_url,
-    get_sequence_from_snapgene_url,
     custom_file_parser,
     get_sequence_from_euroscarf_url,
     get_seva_plasmid,
+    read_dsrecord_from_json,
 )
 from .. import request_examples
 from .. import ncbi_requests
@@ -137,12 +143,7 @@ async def read_from_file(
             warning_messages = [str(w.message) for w in warnings_captured]
 
     except ValueError as e:
-        raise HTTPException(422, f'Biopython cannot process this file: {e}.')
-
-    # This happens when textfiles are empty or contain something else, or when reading a text file as snapgene file,
-    # since StringIO does not raise an error when "Unexpected end of packet" is found
-    if len(dseqs) == 0:
-        raise HTTPException(422, 'Biopython cannot process this file.')
+        raise HTTPException(422, f'Biopython cannot process this file: {e}.') from e
 
     if index_in_file is not None:
         if index_in_file >= len(dseqs):
@@ -199,6 +200,10 @@ async def read_from_file(
     if len(warning_messages) > 0:
         response.headers['x-warning'] = '; '.join(warning_messages)
 
+    # Validate that the sequences are in a valid genbank format
+    for seq in out_sequences:
+        read_dsrecord_from_json(seq)
+
     return {'sequences': out_sequences, 'sources': out_sources}
 
 
@@ -206,22 +211,20 @@ async def read_from_file(
 # directly the object.
 
 
-def repository_id_http_error_handler(exception: HTTPError, source: RepositoryIdSource):
+def handle_repository_errors(exception: Exception, repository_name: str) -> None:
+    """
+    Centralized error handler for repository requests.
+    Re-raises HTTPException as-is, converts ConnectError to HTTPException with 504 status.
+    """
+    if isinstance(exception, HTTPException):
+        raise
+    elif isinstance(exception, ConnectError):
+        raise HTTPException(504, f'Unable to connect to {repository_name}: {exception}')
+    else:  # pragma: no cover
+        import traceback
 
-    if exception.code == 500:  # pragma: no cover
-        raise HTTPException(
-            503, f'{source.repository_name} returned: {exception} - {source.repository_name} might be down'
-        )
-    elif exception.code == 400 or exception.code == 404:
-        raise HTTPException(
-            404,
-            f'{source.repository_name} returned: {exception} - Likely you inserted a wrong {source.repository_name} id',
-        )
-    elif exception.code == 403:
-        raise HTTPException(
-            403,
-            f'Request to {source.repository_name} is not allowed. Please check that the URL is whitelisted.',
-        )
+        traceback.print_exc()
+        raise HTTPException(500, f'Unexpected error: {exception}')
 
 
 # Redirect to the right repository
@@ -244,36 +247,46 @@ def repository_id_http_error_handler(exception: HTTPError, source: RepositoryIdS
 )
 async def get_from_repository_id(
     source: (
-        RepositoryIdSource
-        | AddgeneIdSource
+        AddgeneIdSource
         | BenchlingUrlSource
         | SnapGenePlasmidSource
         | EuroscarfSource
         | WekWikGeneIdSource
         | SEVASource
         | OpenDNACollectionsSource
+        | NCBISequenceSource
     ),
 ):
-    return RedirectResponse(f'/repository_id/{source.repository_name}', status_code=307)
+    mapping_dict = {
+        'AddgeneIdSource': 'addgene',
+        'BenchlingUrlSource': 'benchling',
+        'SnapGenePlasmidSource': 'snapgene',
+        'EuroscarfSource': 'euroscarf',
+        'WekWikGeneIdSource': 'wekwikgene',
+        'SEVASource': 'seva',
+        'OpenDNACollectionsSource': 'open_dna_collections',
+        'NCBISequenceSource': 'genbank',
+    }
+    return RedirectResponse(f'/repository_id/{mapping_dict[source.type]}', status_code=307)
 
 
 @router.post(
     '/repository_id/genbank',
     response_model=create_model(
-        'RepositoryIdResponse', sources=(list[RepositoryIdSource], ...), sequences=(list[TextFileSequence], ...)
+        'RepositoryIdResponse', sources=(list[NCBISequenceSource], ...), sequences=(list[TextFileSequence], ...)
     ),
 )
-async def get_from_repository_id_genbank(source: RepositoryIdSource):
+async def get_from_repository_id_genbank(source: NCBISequenceSource):
     try:
         # This request already fails if the sequence does not exist
         seq_length = await ncbi_requests.get_sequence_length_from_sequence_accession(source.repository_id)
-        if seq_length > 100000:
-            raise HTTPException(400, 'sequence is too long (max 100000 bp)')
+        if seq_length > settings.NCBI_MAX_SEQUENCE_LENGTH:
+            raise HTTPException(400, f'sequence is too long (max {settings.NCBI_MAX_SEQUENCE_LENGTH} bp)')
         seq = await ncbi_requests.get_genbank_sequence(source.repository_id)
-    except ConnectError as exception:
-        raise HTTPException(504, f'Unable to connect to NCBI: {exception}')
+    except Exception as exception:
+        handle_repository_errors(exception, 'NCBI')
 
-    return {'sequences': [format_sequence_genbank(seq, source.output_name)], 'sources': [source.model_copy()]}
+    return format_products(source.id, [seq], None, source.output_name)
 
 
 @router.post(
@@ -284,13 +297,23 @@ async def get_from_repository_id_genbank(source: RepositoryIdSource):
 )
 async def get_from_repository_id_addgene(source: AddgeneIdSource):
     try:
-        dseq, out_source = await request_from_addgene(source)
-    except HTTPError as exception:
-        repository_id_http_error_handler(exception, source)
-    except ConnectError:
-        raise HTTPException(504, 'unable to connect to Addgene')
-
-    return {'sequences': [format_sequence_genbank(dseq, source.output_name)], 'sources': [out_source]}
+        dseq = await request_from_addgene(source.repository_id)
+    except Exception as exception:
+        handle_repository_errors(exception, 'Addgene')
+
+    return format_products(
+        source.id,
+        [dseq],
+        source if source.sequence_file_url is not None else None,
+        source.output_name,
+        wrong_completed_source_error_message=f'''
+        The provided source is not valid.
+        We found the following:
+          - repository_id: {dseq.source.repository_id}
+          - sequence_file_url: {dseq.source.sequence_file_url}
+          - addgene_sequence_type: {dseq.source.addgene_sequence_type}
+        ''',
+    )
 
 
 @router.post(
@@ -301,12 +324,21 @@ async def get_from_repository_id_addgene(source: AddgeneIdSource):
 )
 async def get_from_repository_id_wekwikgene(source: WekWikGeneIdSource):
     try:
-        dseq, out_source = await request_from_wekwikgene(source)
-    except HTTPError as exception:
-        repository_id_http_error_handler(exception, source)
-    except ConnectError:
-        raise HTTPException(504, 'unable to connect to WekWikGene')
-    return {'sequences': [format_sequence_genbank(dseq, source.output_name)], 'sources': [out_source]}
+        dseq = await request_from_wekwikgene(source.repository_id)
+    except Exception as exception:
+        handle_repository_errors(exception, 'WeKwikGene')
+    return format_products(
+        source.id,
+        [dseq],
+        source if source.sequence_file_url is not None else None,
+        source.output_name,
+        wrong_completed_source_error_message=f'''
+        The provided source is not valid.
+        We found the following:
+          - repository_id: {dseq.source.repository_id}
+          - sequence_file_url: {dseq.source.sequence_file_url}
+        ''',
+    )
 
 
 @router.post(
@@ -319,13 +351,10 @@ async def get_from_benchling_url(
     source: Annotated[BenchlingUrlSource, Body(openapi_examples=request_examples.benchling_url_examples)]
 ):
     try:
-        dseqs = await get_sequences_from_file_url(source.repository_id)
-        return {
-            'sequences': [format_sequence_genbank(s, source.output_name) for s in dseqs],
-            'sources': [source for s in dseqs],
-        }
-    except HTTPError as exception:
-        repository_id_http_error_handler(exception, source)
+        dseq = await get_sequence_from_benchling_url(source.repository_id)
+        return format_products(source.id, [dseq], None, source.output_name)
+    except Exception as exception:
+        handle_repository_errors(exception, 'Benchling')
 
 
 @router.post(
@@ -339,17 +368,10 @@ async def get_from_repository_id_snapgene(
 ):
     try:
         plasmid_set, plasmid_name = source.repository_id.split('/')
-        url = f'https://www.snapgene.com/local/fetch.php?set={plasmid_set}&plasmid={plasmid_name}'
-        dseq = await get_sequence_from_snapgene_url(url)
-        # Unless a name is provided, we use the plasmid name from snapgene
-        if source.output_name is None:
-            source.output_name = plasmid_name
-        return {
-            'sequences': [format_sequence_genbank(dseq, source.output_name)],
-            'sources': [source],
-        }
-    except HTTPError as exception:
-        repository_id_http_error_handler(exception, source)
+        seq = await request_from_snapgene(plasmid_set, plasmid_name)
+        return format_products(source.id, [seq], None, source.output_name)
+    except Exception as exception:
+        handle_repository_errors(exception, 'Snapgene')
 
 
 @router.post(
@@ -365,12 +387,9 @@ async def get_from_repository_id_euroscarf(source: EuroscarfSource):
     """
     try:
         dseq = await get_sequence_from_euroscarf_url(source.repository_id)
-        # Sometimes the files do not contain correct topology information, so we loop them
-        if not dseq.circular:
-            dseq = dseq.looped()
-        return {'sequences': [format_sequence_genbank(dseq, source.output_name)], 'sources': [source]}
-    except HTTPError as exception:
-        repository_id_http_error_handler(exception, source)
+        return format_products(source.id, [dseq], None, source.output_name)
+    except Exception as exception:
+        handle_repository_errors(exception, 'Euroscarf')
 
 
 @router.post(
@@ -381,10 +400,21 @@ async def get_from_repository_id_euroscarf(source: EuroscarfSource):
 )
 async def get_from_repository_id_igem(source: IGEMSource):
     try:
-        dseq = (await get_sequences_from_file_url(source.sequence_file_url))[0]
-        return {'sequences': [format_sequence_genbank(dseq, source.output_name)], 'sources': [source]}
-    except HTTPError as exception:
-        repository_id_http_error_handler(exception, source)
+        dseq = await get_sequence_from_iGEM2024(*source.repository_id.split('-'))
+        return format_products(
+            source.id,
+            [dseq],
+            source if source.sequence_file_url is not None else None,
+            source.output_name,
+            wrong_completed_source_error_message=f'''
+            The provided source is not valid.
+            We found the following:
+              - repository_id: {source.repository_id}
+              - sequence_file_url: {dseq.source.sequence_file_url}
+            ''',
+        )
+    except Exception as exception:
+        handle_repository_errors(exception, 'iGEM')
 
 
 @router.post(
@@ -397,10 +427,23 @@ async def get_from_repository_id_igem(source: IGEMSource):
 )
 async def get_from_repository_id_open_dna_collections(source: OpenDNACollectionsSource):
     try:
-        dseq = (await get_sequences_from_file_url(source.sequence_file_url))[0]
-        return {'sequences': [format_sequence_genbank(dseq, source.output_name)], 'sources': [source]}
-    except HTTPError as exception:
-        repository_id_http_error_handler(exception, source)
+        collection_name, plasmid_id = source.repository_id.split('/')
+        dseq = await get_sequence_from_openDNA_collections(collection_name, plasmid_id)
+        return format_products(
+            source.id,
+            [dseq],
+            source if source.sequence_file_url is not None else None,
+            source.output_name,
+            wrong_completed_source_error_message=f'''
+            The provided source is not valid.
+            We found the following:
+              - collection_name: {collection_name}
+              - plasmid_id: {plasmid_id}
+              - sequence_file_url: {dseq.source.sequence_file_url}
+            ''',
+        )
+    except Exception as exception:
+        handle_repository_errors(exception, 'OpenDNA Collections')
 
 
 @router.post(
@@ -414,39 +457,30 @@ async def genome_coordinates(
 ):
 
     # Validate that coordinates make sense
-    ncbi_requests.validate_coordinates_pre_request(source.start, source.end, source.strand)
+    try:
+        location_str = SequenceLocationStr(source.coordinates)
+        location = location_str.to_biopython_location()
+        start, end, strand = location_str.get_ncbi_format_coordinates()
+    except Exception as e:
+        raise HTTPException(422, f'Invalid coordinates: {e}') from e
 
-    # Source includes a locus tag in annotated assembly
+    if len(location) > settings.NCBI_MAX_SEQUENCE_LENGTH:
+        raise HTTPException(400, f'sequence is too long (max {settings.NCBI_MAX_SEQUENCE_LENGTH} bp)')
+
+    if source.locus_tag is not None and source.assembly_accession is None:
+        raise HTTPException(422, 'assembly_accession is required if locus_tag is set')
 
+    # Source includes a locus tag in annotated assembly
     async def validate_locus_task():
         if source.locus_tag is not None:
-
-            if source.assembly_accession is None:
-                raise HTTPException(422, 'assembly_accession is required if locus_tag is set')
-
-            annotation = await ncbi_requests.get_annotation_from_locus_tag(source.locus_tag, source.assembly_accession)
-            gene_range = annotation['genomic_regions'][0]['gene_range']['range'][0]
-            gene_strand = 1 if gene_range['orientation'] == 'plus' else -1
-
-            # This field will not be present in all cases, but should be there in reference genomes
-            if source.gene_id is not None:
-                if 'gene_id' not in annotation:
-                    raise HTTPException(400, 'gene_id is set, but not found in the annotation')
-                if source.gene_id != int(annotation['gene_id']):
-                    raise HTTPException(400, 'gene_id does not match the locus_tag')
-            elif 'gene_id' in annotation:
-                source.gene_id = int(annotation['gene_id'])
-
-            # The gene should fall within the range (range might be bigger if bases were requested upstream or downstream)
-            if (
-                int(gene_range['begin']) < source.start
-                or int(gene_range['end']) > source.end
-                or gene_strand != source.strand
-            ):
-                raise HTTPException(
-                    400,
-                    f'wrong coordinates, expected to fall within {source.start}, {source.end} on strand: {source.strand}',
-                )
+            return await ncbi_requests.validate_locus_tag(
+                source.locus_tag,
+                source.assembly_accession,
+                source.gene_id,
+                start,
+                end,
+                strand,
+            )
 
     async def validate_assembly_task():
         if source.assembly_accession is not None:
@@ -454,23 +488,26 @@ async def genome_coordinates(
             sequence_accessions = await ncbi_requests.get_sequence_accessions_from_assembly_accession(
                 source.assembly_accession
             )
-            if source.sequence_accession not in sequence_accessions:
+            if source.repository_id not in sequence_accessions:
                 raise HTTPException(
                     400,
-                    f'Sequence accession {source.sequence_accession} not contained in assembly accession {source.assembly_accession}, which contains accessions: {", ".join(sequence_accessions)}',
+                    f'Sequence accession {source.repository_id} not contained in assembly accession {source.assembly_accession}, which contains accessions: {", ".join(sequence_accessions)}',
                 )
 
     async def get_sequence_task():
-        return await ncbi_requests.get_genbank_sequence(
-            source.sequence_accession, source.start, source.end, source.strand
-        )
+        return await ncbi_requests.get_genbank_sequence(source.repository_id, start, end, strand)
 
     tasks = [validate_locus_task(), validate_assembly_task(), get_sequence_task()]
 
-    _, _, seq = await asyncio.gather(*tasks)
+    try:
+        gene_id, _, seq = await asyncio.gather(*tasks)
+    except Exception as exception:
+        handle_repository_errors(exception, 'NCBI')
+
+    source.gene_id = gene_id
 
     # NCBI does not complain for coordinates that fall out of the sequence, so we have to check here
-    if len(seq) != source.end - source.start + 1:
+    if len(seq) != len(location):
         raise HTTPException(400, 'coordinates fall outside the sequence')
 
     return {'sequences': [format_sequence_genbank(seq, source.output_name)], 'sources': [source.model_copy()]}
@@ -487,11 +524,19 @@ async def get_from_repository_id_seva(source: SEVASource):
     Return the sequence from a plasmid in SEVA.
     """
     try:
-        dseq, source = await get_seva_plasmid(source)
-        return {'sequences': [format_sequence_genbank(dseq, source.output_name)], 'sources': [source]}
-    except HTTPError as exception:
-        repository_id_http_error_handler(exception, source)
-    except ConnectError:
-        raise HTTPException(504, 'unable to connect to SEVA')
+        dseq = await get_seva_plasmid(source.repository_id)
     except Exception as exception:
-        raise HTTPException(400, f'Error parsing file: {exception}')
+        handle_repository_errors(exception, 'SEVA')
+
+    return format_products(
+        source.id,
+        [dseq],
+        source if source.sequence_file_url is not None else None,
+        source.output_name,
+        wrong_completed_source_error_message=f'''
+        The provided source is not valid.
+        We found the following:
+          - repository_id: {dseq.source.repository_id}
+          - sequence_file_url: {dseq.source.sequence_file_url}
+        ''',
+    )

opencloning/endpoints/no_assembly.py

@@ -2,14 +2,15 @@ from fastapi import Query, HTTPException
 from pydna.dseqrecord import Dseqrecord
 from pydantic import create_model, Field
 from typing import Annotated
-from Bio.Restriction import RestrictionBatch
+
+from opencloning.endpoints.endpoint_utils import format_products, parse_restriction_enzymes
+from opencloning.temp_functions import get_enzymes_from_source
 
 from ..dna_functions import (
     format_sequence_genbank,
     read_dsrecord_from_json,
-    get_invalid_enzyme_names,
 )
-from ..pydantic_models import (
+from opencloning_linkml.datamodel import (
     RestrictionEnzymeDigestionSource,
     TextFileSequence,
     PolymeraseExtensionSource,
@@ -33,54 +34,37 @@ async def restriction(
     sequences: Annotated[list[TextFileSequence], Field(min_length=1, max_length=1)],
     restriction_enzymes: Annotated[list[str], Query(default_factory=list)],
 ):
+    completed_source = source if (source.left_edge is not None or source.right_edge is not None) else None
     # There should be 1 or 2 enzymes in the request if the source does not have cuts
-    if source.left_edge is None and source.right_edge is None:
-        if len(restriction_enzymes) < 1 or len(restriction_enzymes) > 2:
+    if completed_source is None:
+        enzymes = parse_restriction_enzymes(restriction_enzymes)
+        if len(enzymes) not in [1, 2]:
             raise HTTPException(422, 'There should be 1 or 2 restriction enzymes in the request.')
     else:
         if len(restriction_enzymes) != 0:
             raise HTTPException(422, 'There should be no restriction enzymes in the request if source is populated.')
-        restriction_enzymes = source.get_enzymes()
-
-    # TODO: this could be moved to the class
-    invalid_enzymes = get_invalid_enzyme_names(restriction_enzymes)
-    if len(invalid_enzymes):
-        raise HTTPException(404, 'These enzymes do not exist: ' + ', '.join(invalid_enzymes))
-    enzymes = RestrictionBatch(first=[e for e in restriction_enzymes if e is not None])
+        enzymes = parse_restriction_enzymes(get_enzymes_from_source(completed_source))
 
     seqr = read_dsrecord_from_json(sequences[0])
-    # TODO: return error if the id of the sequence does not correspond
 
     cutsites = seqr.seq.get_cutsites(*enzymes)
-    cutsite_pairs = seqr.seq.get_cutsite_pairs(cutsites)
-    sources = [
-        RestrictionEnzymeDigestionSource.from_cutsites(*p, [{'sequence': sequences[0].id}], source.id)
-        for p in cutsite_pairs
-    ]
-
-    all_enzymes = set(enzyme for s in sources for enzyme in s.get_enzymes())
-    enzymes_not_cutting = set(restriction_enzymes) - set(all_enzymes)
+    cutting_enzymes = set(e for _, e in cutsites if e is not None)
+    enzymes_not_cutting = set(enzymes) - set(cutting_enzymes)
     if len(enzymes_not_cutting):
-        raise HTTPException(400, 'These enzymes do not cut: ' + ', '.join(enzymes_not_cutting))
+        raise HTTPException(400, 'These enzymes do not cut: ' + ', '.join(map(str, enzymes_not_cutting)))
 
     try:
-        # If the output is known
-        if source.left_edge is not None or source.right_edge is not None:
-
-            for i, s in enumerate(sources):
-                if s == source:
-                    return {
-                        'sequences': [format_sequence_genbank(seqr.apply_cut(*cutsite_pairs[i]), source.output_name)],
-                        'sources': [s],
-                    }
-
-            raise HTTPException(400, 'Invalid restriction enzyme pair.')
-
-        products = [format_sequence_genbank(seqr.apply_cut(*p), source.output_name) for p in cutsite_pairs]
-
-        return {'sequences': products, 'sources': sources}
+        products = seqr.cut(*enzymes)
     except ValueError as e:
-        raise HTTPException(400, str(e))
+        raise HTTPException(400, *e.args)
+
+    return format_products(
+        source.id,
+        products,
+        completed_source,
+        source.output_name,
+        wrong_completed_source_error_message='Invalid restriction enzyme pair.',
+    )
 
 
 @router.post(
@@ -102,7 +86,7 @@ async def polymerase_extension(
     if dseq.circular:
         raise HTTPException(400, 'The sequence must be linear.')
 
-    if dseq.seq.ovhg == dseq.seq.watson_ovhg() == 0:
+    if dseq.seq.ovhg == dseq.seq.watson_ovhg == 0:
         raise HTTPException(400, 'The sequence must have an overhang.')
 
     out_sequence = Dseqrecord(dseq.seq.fill_in(), features=dseq.features)