opencloning 0.3.8__py3-none-any.whl → 0.4.3__py3-none-any.whl

opencloning/app_settings.py

@@ -43,6 +43,7 @@ default_allowed_urls = [
     'https://assets.opencloning.org/annotated-igem-distribution',
     'http://www.euroscarf.de/',
     'https://wekwikgene.wllsb.edu.cn',
+    'http://bahlerweb.cs.ucl.ac.uk',
 ]
 
 if os.environ.get('ALLOWED_EXTERNAL_URLS') is not None:

opencloning/batch_cloning/EBIC/example.py

@@ -4,7 +4,7 @@ from primer3 import bindings
 import json
 from fastapi import UploadFile, Response
 
-from ...pydantic_models import (
+from opencloning.pydantic_models import (
     GenomeCoordinatesSource,
     TextFileSequence,
     PrimerModel,
@@ -13,10 +13,10 @@ from ...pydantic_models import (
     BaseCloningStrategy,
     HomologousRecombinationSource,
 )
-from .primer_design_settings import amanda_settings
-from ...endpoints.external_import import genome_coordinates, read_from_file
-from ...endpoints.assembly import pcr, restriction_and_ligation, homologous_recombination
-from ...dna_functions import read_dsrecord_from_json
+from opencloning.batch_cloning.EBIC.primer_design_settings import amanda_settings
+from opencloning.endpoints.external_import import genome_coordinates, read_from_file
+from opencloning.endpoints.assembly import pcr, restriction_and_ligation, homologous_recombination
+from opencloning.dna_functions import read_dsrecord_from_json
 
 # Settings for design
 padding = 1000
@@ -123,7 +123,9 @@ async def main():
 
     with open(os.path.join(os.path.dirname(__file__), 'barcode.gb'), 'rb') as f:
         dummy_resp = Response()
-        resp = await read_from_file(dummy_resp, UploadFile(file=f, filename='barcode.gb'), None, None, True, 'barcode')
+        resp = await read_from_file(
+            dummy_resp, UploadFile(file=f, filename='barcode.gb'), None, None, True, 'barcode', None, None
+        )
 
     barcode_source = resp['sources'][0]
     barcode_seq: TextFileSequence = resp['sequences'][0]
@@ -132,7 +134,14 @@ async def main():
     with open(os.path.join(os.path.dirname(__file__), 'common_plasmid.gb'), 'rb') as f:
         dummy_resp = Response()
         resp = await read_from_file(
-            dummy_resp, UploadFile(file=f, filename='common_plasmid.gb'), None, None, True, 'common_plasmid'
+            dummy_resp,
+            UploadFile(file=f, filename='common_plasmid.gb'),
+            None,
+            None,
+            True,
+            'common_plasmid',
+            None,
+            None,
         )
 
     common_plasmid_source = resp['sources'][0]
@@ -151,9 +160,7 @@ async def main():
     resp = await homologous_recombination(homologous_recombination_source, [locus_seq, golgen_gate_product], 17)
 
     multi_site_sources = [
-        i
-        for i, s in enumerate(resp['sources'])
-        if all(join.left_location != join.right_location for join in s.assembly)
+        i for i, s in enumerate(resp['sources']) if all(join.left_location != join.right_location for join in s.input)
     ]
     if len(multi_site_sources) > 1:
         raise ValueError('Multiple insertions possible')

opencloning/batch_cloning/pombe/pombe_clone.py

@@ -1,7 +1,7 @@
 import os
-from ...endpoints.external_import import genome_coordinates, get_from_repository_id_addgene, read_from_file
-from ...endpoints.assembly import pcr, homologous_recombination
-from ...pydantic_models import (
+from opencloning.endpoints.external_import import genome_coordinates, get_from_repository_id_addgene, read_from_file
+from opencloning.endpoints.assembly import pcr, homologous_recombination
+from opencloning.pydantic_models import (
     GenomeCoordinatesSource,
     TextFileSequence,
     AddgeneIdSource,
@@ -12,7 +12,7 @@ from ...pydantic_models import (
     UploadedFileSource,
 )
 
-from ...ncbi_requests import get_annotations_from_query
+from opencloning.ncbi_requests import get_annotations_from_query
 import asyncio
 import json
 from Bio import SeqIO
@@ -28,8 +28,8 @@ async def main(
     checking_primers = list(SeqIO.parse(os.path.join(output_dir, 'checking_primers.fa'), 'fasta'))
     primer_records = primer_records[:3] + checking_primers[1:] + primer_records[3:] + checking_primers[:1]
     primers = []
-    for i, primer in enumerate(primer_records):
-        primers.append(PrimerModel(sequence=str(primer.seq), id=i + 1, name=primer.id))
+    for primer in primer_records:
+        primers.append(PrimerModel(sequence=str(primer.seq), id=0, name=primer.id))
 
     # Get genome region =====================================================================
     annotations = await get_annotations_from_query(gene, assembly_accession)
@@ -51,7 +51,7 @@ async def main(
     orientation = 1 if gene_range['orientation'] == 'plus' else -1
 
     source = GenomeCoordinatesSource(
-        id=1,
+        id=0,
         start=start - padding,
         end=end + padding,
         strand=orientation,
@@ -63,89 +63,81 @@ async def main(
     )
     locus = await genome_coordinates(source)
 
+    cloning_strategy = BaseCloningStrategy(
+        sequences=[],
+        sources=[],
+        primers=[],
+        description=f'Cloning strategy for deleting the gene {gene} using PCR and homologous recombination',
+    )
+    for primer in primers:
+        cloning_strategy.add_primer(primer)
     locus_seq: TextFileSequence = TextFileSequence.model_validate(locus['sequences'][0])
-    locus_seq.id = 2
     locus_source: GenomeCoordinatesSource = GenomeCoordinatesSource.model_validate(locus['sources'][0])
-    locus_source.output = 2
+    cloning_strategy.add_source_and_sequence(locus_source, locus_seq)
 
     # Get plasmid sequence =================s================================================================
     if not isinstance(plasmid, str):
         if plasmid.filename.endswith('.fa') or plasmid.filename.endswith('.fasta'):
-            resp = await read_from_file(plasmid, None, None, True, None)
+            resp = await read_from_file(plasmid, None, None, True, None, None, None)
         else:
-            resp = await read_from_file(plasmid, None, None, None, None)
-        resp['sources'][0].id = 3
+            resp = await read_from_file(plasmid, None, None, None, None, None, None)
         # Verify that plasmid is circular
         if not pydna_parse(resp['sequences'][0].file_content)[0].circular:
             raise ValueError('Plasmid is not circular')
         plasmid_source: UploadedFileSource = UploadedFileSource.model_validate(resp['sources'][0])
-        plasmid_source.output = 4
     else:
         addgene_source = AddgeneIdSource(
-            id=3,
+            id=0,
             repository_id=plasmid,
             repository_name='addgene',
         )
         resp = await get_from_repository_id_addgene(addgene_source)
         plasmid_source: AddgeneIdSource = AddgeneIdSource.model_validate(resp['sources'][0])
-        plasmid_source.output = 4
 
     plasmid_seq: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][0])
-    plasmid_seq.id = 4
+    cloning_strategy.add_source_and_sequence(plasmid_source, plasmid_seq)
 
     # PCR ================================================================================================
-    pcr_source = PCRSource(id=5, output_name='amplified_marker')
-    resp = await pcr(pcr_source, [plasmid_seq], [primers[0], primers[1]], 20, 0)
+    pcr_source = PCRSource(id=0, output_name='amplified_marker')
+    resp = await pcr(pcr_source, [plasmid_seq], [primers[0], primers[1]], 15, 0)
 
     pcr_product: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][0])
-    pcr_product.id = 6
     pcr_source: PCRSource = PCRSource.model_validate(resp['sources'][0])
-    pcr_source.output = 6
+    cloning_strategy.add_source_and_sequence(pcr_source, pcr_product)
 
     # Homologous recombination ========================================================================
-    hrec_source = HomologousRecombinationSource(id=7, output_name='deletion_allele')
+    hrec_source = HomologousRecombinationSource(id=0, output_name='deletion_allele')
     resp = await homologous_recombination(hrec_source, [locus_seq, pcr_product], 50)
 
     hrec_product: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][0])
-    hrec_product.id = 8
     hrec_source: HomologousRecombinationSource = HomologousRecombinationSource.model_validate(resp['sources'][0])
-    hrec_source.output = 8
+    cloning_strategy.add_source_and_sequence(hrec_source, hrec_product)
 
     # Checking pcr 1 ======================================================================================
-    check_pcr_source_left = PCRSource(id=9, output_name='check_pcr_left')
-    resp = await pcr(check_pcr_source_left, [hrec_product], [primers[2], primers[3]], 20, 0)
+    check_pcr_source_left = PCRSource(id=0, output_name='check_pcr_left')
+    resp = await pcr(check_pcr_source_left, [hrec_product], [primers[2], primers[3]], 15, 0)
 
     check_pcr_product_left: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][0])
-    check_pcr_product_left.id = 10
     check_pcr_source_left: PCRSource = PCRSource.model_validate(resp['sources'][0])
-    check_pcr_source_left.output = 10
+    cloning_strategy.add_source_and_sequence(check_pcr_source_left, check_pcr_product_left)
 
     # Checking pcr 2 ======================================================================================
-    check_pcr_source_right = PCRSource(id=11, output_name='check_pcr_right')
-    resp = await pcr(check_pcr_source_right, [hrec_product], [primers[4], primers[5]], 20, 0)
+    check_pcr_source_right = PCRSource(id=0, output_name='check_pcr_right')
+    resp = await pcr(check_pcr_source_right, [hrec_product], [primers[4], primers[5]], 15, 0)
 
     check_pcr_product_right: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][0])
-    check_pcr_product_right.id = 12
     check_pcr_source_right: PCRSource = PCRSource.model_validate(resp['sources'][0])
-    check_pcr_source_right.output = 12
-
-    sources = [locus_source, plasmid_source, pcr_source, hrec_source, check_pcr_source_left, check_pcr_source_right]
-    sequences = [locus_seq, plasmid_seq, pcr_product, hrec_product, check_pcr_product_left, check_pcr_product_right]
+    cloning_strategy.add_source_and_sequence(check_pcr_source_right, check_pcr_product_right)
 
-    cloning_strategy = {
-        'sources': [s.model_dump() for s in sources],
-        'sequences': [s.model_dump() for s in sequences],
-        'primers': [p.model_dump() for p in primers],
-        'description': f'Cloning strategy for deleting the gene {gene} using PCR and homologous recombination',
-    }
-
-    BaseCloningStrategy.model_validate(cloning_strategy)
+    cloning_strategy.description = (
+        f'Cloning strategy for deleting the gene {gene} using PCR and homologous recombination'
+    )
 
     if not os.path.exists(os.path.join(output_dir, gene)):
         os.makedirs(os.path.join(output_dir, gene))
 
     with open(os.path.join(output_dir, gene, 'cloning_strategy.json'), 'w') as f:
-        json.dump(cloning_strategy, f, indent=2)
+        json.dump(cloning_strategy.model_dump(), f, indent=2)
 
 
 if __name__ == '__main__':

opencloning/batch_cloning/pombe/pombe_summary.py

@@ -1,4 +1,4 @@
-from ...pydantic_models import BaseCloningStrategy, PrimerModel, PCRSource
+from ...pydantic_models import BaseCloningStrategy, PrimerModel, PCRSource, HomologousRecombinationSource
 from pydna.parsers import parse as pydna_parse
 import os
 import json
@@ -16,11 +16,11 @@ chromosomes = {
 
 def find_primer_aligned_sequence(pcr_sources: list[PCRSource], primer: PrimerModel) -> str:
     for source in pcr_sources:
-        if source.assembly[0].sequence == primer.id:
-            loc = source.assembly[0].right_location
+        if source.input[0].sequence == primer.id:
+            loc = source.input[0].right_location
             return str(primer.sequence[loc.start : loc.end])
-        if source.assembly[-1].sequence == primer.id:
-            loc = source.assembly[-1].left_location
+        if source.input[-1].sequence == primer.id:
+            loc = source.input[-1].left_location
             return str(reverse_complement(primer.sequence)[loc.start : loc.end])
     raise ValueError(f"Primer {primer.id} not found in any PCR source")
 
@@ -30,12 +30,16 @@ def process_folder(working_dir: str):
         strategy = BaseCloningStrategy.model_validate(json.load(f))
 
     pcr_sources = [s for s in strategy.sources if s.type == 'PCRSource']
+    # We do this to have action to .end and .start
+    pcr_sources = [PCRSource.model_validate(s.model_dump()) for s in pcr_sources]
     locus_source = next(s for s in strategy.sources if s.type == 'GenomeCoordinatesSource')
     hrec_source = next(s for s in strategy.sources if s.type == 'HomologousRecombinationSource')
+    # We do this to have action to .end and .start
+    hrec_source: HomologousRecombinationSource = HomologousRecombinationSource.model_validate(hrec_source.model_dump())
 
     chromosome = chromosomes[locus_source.sequence_accession]
-    insertion_start = locus_source.start + hrec_source.assembly[0].right_location.end
-    insertion_end = locus_source.start + hrec_source.assembly[-1].left_location.start
+    insertion_start = locus_source.start + hrec_source.input[0].right_location.end
+    insertion_end = locus_source.start + hrec_source.input[-1].left_location.start
 
     # Write out the sequences in genbank format and extract some relevant info
     sequences = [pydna_parse(sequence.file_content)[0] for sequence in strategy.sequences]

opencloning/batch_cloning/ziqiang_et_al2024/__init__.py

@@ -77,21 +77,17 @@ async def ziqiang_et_al2024_post(
     primers = design_primers(protospacers)
 
     with open(os.path.join(os.path.dirname(__file__), 'ziqiang_et_al2024.json'), 'r') as f:
-        template = BaseCloningStrategy.model_validate(json.load(f))
-
-    max_primer_id = max([primer.id for primer in template.primers], default=0)
+        cloning_strategy = BaseCloningStrategy.model_validate(json.load(f))
 
     for i, primer in enumerate(primers):
-        max_primer_id += 1
         orientation = 'rvs' if i % 2 == 0 else 'fwd'
-        template.primers.append(
-            PrimerModel(id=max_primer_id, name=f"protospacer_{i // 2 + 1}_{orientation}", sequence=primer)
-        )
+        cloning_strategy.add_primer(PrimerModel(id=0, name=f"protospacer_{i // 2 + 1}_{orientation}", sequence=primer))
 
-    primer_ids_for_pcrs = [3, *[p.id for p in template.primers[-len(primers) :]], 12]
-    next_node_id = max([s.id for s in template.sequences] + [s.id for s in template.sources]) + 1
+    fwd_primer3 = next(p for p in cloning_strategy.primers if p.name == 'Fw-Primer3')
+    rvs_primer12 = next(p for p in cloning_strategy.primers if p.name == 'Rev-Primer12')
+    primer_ids_for_pcrs = [fwd_primer3.id, *[p.id for p in cloning_strategy.primers[-len(primers) :]], rvs_primer12.id]
 
-    template_sequence = next(s for s in template.sequences if s.id == 18)
+    template_sequence = next(s for s in cloning_strategy.sequences if s.id == 9)
     for i, (fwd_primer_id, rvs_primer_id) in enumerate(zip(primer_ids_for_pcrs[::2], primer_ids_for_pcrs[1::2])):
         if i == 0:
             name = 'start_ps1'
@@ -100,80 +96,56 @@ async def ziqiang_et_al2024_post(
         else:
             name = f'end_ps{i}_start_ps{i + 1}'
 
-        pcr_source = PCRSource(id=next_node_id, output_name=name)
-        fwd_primer = next(p for p in template.primers if p.id == fwd_primer_id)
-        rvs_primer = next(p for p in template.primers if p.id == rvs_primer_id)
+        pcr_source = PCRSource(id=0, output_name=name)
+        fwd_primer = next(p for p in cloning_strategy.primers if p.id == fwd_primer_id)
+        rvs_primer = next(p for p in cloning_strategy.primers if p.id == rvs_primer_id)
 
-        next_node_id += 1
-        resp = await pcr(pcr_source, [template_sequence], [fwd_primer, rvs_primer], 14, 0)
+        resp = await pcr(pcr_source, [template_sequence], [fwd_primer, rvs_primer], 7, 0)
         pcr_product: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][0])
-        pcr_product.id = next_node_id
         pcr_source: PCRSource = PCRSource.model_validate(resp['sources'][0])
-        pcr_source.output = next_node_id
-
-        template.sequences.append(pcr_product)
-        template.sources.append(pcr_source)
-
-        next_node_id += 1
+        cloning_strategy.add_source_and_sequence(pcr_source, pcr_product)
 
     # Find all PCR products
     # (we use type instead of isinstance because the BaseCloningStrategy does not
     #  have the newer source models with extra methods)
-    pcr_product_ids = [s.output for s in template.sources if s.type == 'PCRSource']
+    pcr_product_ids = [s.id for s in cloning_strategy.sources if s.type == 'PCRSource']
 
     # Make all input of a Golden gate assembly
     golden_gate_source = RestrictionAndLigationSource(
-        id=next_node_id, output_name='golden_gate_assembly', restriction_enzymes=['BsaI'], input=pcr_product_ids
+        id=0, output_name='golden_gate_assembly', restriction_enzymes=['BsaI']
     )
 
-    next_node_id += 1
     # Make them
-    input_sequences = [next(s for s in template.sequences if s.id == p) for p in pcr_product_ids]
+    input_sequences = [next(s for s in cloning_strategy.sequences if s.id == p) for p in pcr_product_ids]
     resp = await restriction_and_ligation(golden_gate_source, input_sequences, False, False)
     golden_gate_product: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][0])
-    golden_gate_product.id = next_node_id
     golden_gate_source: RestrictionAndLigationSource = RestrictionAndLigationSource.model_validate(resp['sources'][0])
-    golden_gate_source.output = next_node_id
-    next_node_id += 1
+    cloning_strategy.add_source_and_sequence(golden_gate_source, golden_gate_product)
 
-    template.sequences.append(golden_gate_product)
-    template.sources.append(golden_gate_source)
-
-    bp_target = next(s for s in template.sequences if s.id == 12)
-    gateway_source = GatewaySource(id=next_node_id, output_name='entry_clone', reaction_type='BP', greedy=False)
-    next_node_id += 1
+    bp_target = next(s for s in cloning_strategy.sequences if s.id == 6)
+    gateway_source = GatewaySource(id=0, output_name='entry_clone', reaction_type='BP', greedy=False)
     resp = await gateway(gateway_source, [golden_gate_product, bp_target], circular_only=True, only_multi_site=True)
     gateway_product: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][0])
-    gateway_product.id = next_node_id
     gateway_source: GatewaySource = GatewaySource.model_validate(resp['sources'][0])
-    gateway_source.output = next_node_id
-    next_node_id += 1
-
-    template.sequences.append(gateway_product)
-    template.sources.append(gateway_source)
+    cloning_strategy.add_source_and_sequence(gateway_source, gateway_product)
 
     if until_bp:
         # Delete sources and sequences left
-        ids2delete = list(range(5, 11))
-        template.sources = [s for s in template.sources if s.id not in ids2delete]
-        template.sequences = [s for s in template.sequences if s.id not in ids2delete]
-        return template
+        ids2delete = list(range(3, 6))
+        cloning_strategy.sources = [s for s in cloning_strategy.sources if s.id not in ids2delete]
+        cloning_strategy.sequences = [s for s in cloning_strategy.sequences if s.id not in ids2delete]
+        return cloning_strategy
 
     # Now we want to do a Gateway with everything, so we need to find all sequences that are not input of anything
-    all_input_ids = sum([s.input for s in template.sources], [])
-    sequences_to_clone = [s for s in template.sequences if s.id not in all_input_ids]
+    all_inputs = sum([s.input for s in cloning_strategy.sources], [])
+    all_input_ids = [s.sequence for s in all_inputs]
+    sequences_to_clone = [s for s in cloning_strategy.sequences if s.id not in all_input_ids]
 
-    gateway_source = GatewaySource(id=next_node_id, output_name='expression_clone', reaction_type='LR', greedy=False)
-    next_node_id += 1
+    gateway_source = GatewaySource(id=0, output_name='expression_clone', reaction_type='LR', greedy=False)
     resp = await gateway(gateway_source, sequences_to_clone, circular_only=True, only_multi_site=True)
     index_of_product = next(i for i, s in enumerate(resp['sequences']) if '/label="Cas9"' in s.file_content)
     expression_clone: TextFileSequence = TextFileSequence.model_validate(resp['sequences'][index_of_product])
-    expression_clone.id = next_node_id
     gateway_source: GatewaySource = GatewaySource.model_validate(resp['sources'][index_of_product])
-    gateway_source.output = next_node_id
-    next_node_id += 1
-
-    template.sequences.append(expression_clone)
-    template.sources.append(gateway_source)
+    cloning_strategy.add_source_and_sequence(gateway_source, expression_clone)
 
-    return template
+    return cloning_strategy