Metadata-Version: 2.1
Name: synbio
Version: 0.2.1
Summary: Synbio design and build library
Home-page: UNKNOWN
Author: JJTimmons
Author-email: jtimmons@latticeautomation.com
License: UNKNOWN
Description: # synbio
        
        `synbio` is a library for designing and assembling DNA. Users can design plasmids or libraries and export multi-step build protocols. Input SeqRecords; output assembly SeqRecords, protocols, plate maps, and robotic picklists.
        
        ## Installation
        
        ```bash
        pip3 install synbio
        ```
        
        ## Models
        
        Designed to have a minimalist API, `synbio` only expects the user to define their `Design` and `Protocol` (list of steps). Several protocols are pre-defined.
        
        - `SeqRecord` - [BioPython](https://biopython.org/)
        - `Design`
          - `Plasmid` - single list of SeqRecords to concatenate
          - `Combinatorial` - list of bins for combinatorial assembly
        
        ## Example
        
        In the example below, the user specifies a combinatorial library design. Each list (`record_bin`) appended to the design is another bin of `SeqRecords` to try concatenating with all other `SeqRecords` in adjacent bins.
        
        Behind the scenes, `synbio` is filtering all combinations of `SeqRecords` from the design that will circularize into valid plasmids (via [circuits in a graph](https://bmcbioinformatics.biomedcentral.com/articles/10.1186/s12859-015-0544-x/figures/1)). After running the `protocol`, users can export plate maps (`to_csv()`), composite plasmids (`to_fasta()`, `to_genbank()`), and assembly instructions (`to_txt()`, `to_picklists()`).
        
        ```python
        """Example of a Combinatorial Golden Gate assembly with steps and output."""
        
        from Bio.SeqIO import parse
        
        from synbio import Combinatorial, Protocol
        from synbio.composite import GoldenGate
        
        # create a combinatorial library design from multiple "bins"
        design = Combinatorial()
        records = parse("./moclo_parts.fa", "fasta")
        for type in ["promoter", "RBS", "CDS", "terminator"]:
            record_bin = [r for r in records if any(f.type == type for f in r.features)]
            design.append(record_bin)  # add a new cominatorial bin
        
        # create a protocol using Golden Gate as the sole composite step and run
        protocol = Protocol(name="Combinatorial Golden Gate", design=design)
        protocol.add(GoldenGate())
        protocol.run()
        
        # export all the output plasmids to a multi-FASTA
        protocol.to_fasta("composite_parts.fasta")
        
        # export plate layouts
        protocol.to_csv("plate_layouts.csv")
        
        # export human protocol
        protocol.to_txt("protocol.txt")
        
        # export a hamilton picklist
        protocol.to_picklists("robotic_picklist.gwl", platform="tecan")
        ```
        
        _composite_parts.fasta_
        
        ```txt
        >J23100_AB|B0032m_BC|C0012m_CD|B0015_DE|DVK_AE
        GGAGTTGACGGCTAGCTCAGTCCTAGGTACAGTGCTAGCTACTAGAGTCACACAGGAAAG
        TACTAAATGATGGTGAATGTGAAACCAGTAACGTTATACGATGTCGCAGAGTATGCCGGT
        ...
        ```
        
        _combinatorial_moclo.csv_
        
        ```csv
        Setup PCR plate with (volumes) shown:
        Plate 1,1,2,3,4,5,6,7,8,9,10,11,12
        A,B0015_DE (4),C0080_CD (18),R0010_AB (54),water (36)
        B,B0015_DE (160),DVK_AE (160),cre_CD (18),water (156)
        ...
        ```
        
        _protocol.txt_
        
        ```txt
        Combinatorial GoldenGate
        1. Setup PCR plate with (volumes) shown:
        	1.1. Dilute plasmid DNA to 75 ng/µL in 'water'
        	1.2. Create 'assembly-mix' from 1:1 T4 Ligase Buffer (10X) and NEB Golden Gate Assembly Mix
        ...
        ```
        
        _robotic_picklist.gwl_
        
        ```txt
        A;Plate:2;;;15;;2.0;;;
        D;Plate:3;;;80;;2.0;;;
        W;;;;;;;;;
        ...
        ```
        
        ## Alternatives
        
        This is a non-exhaustive list. Contact me for a comparison of these libraries/platforms.
        
        - [Aquarium](https://www.aquarium.bio/) is an extensive library/application for LIMS, protocol definition/execution, and workflow design.
        - [Autoprotocol](https://github.com/autoprotocol/autoprotocol-python) is a specification standard for experiments in the life sciences.
        - [BioBricks](https://github.com/liaupm/BioBlocks) is a general focus, web-based editor for describing experiments in Biology.
        - [Biocoder](https://jbioleng.biomedcentral.com/articles/10.1186/1754-1611-4-13) is a C++ library with _extensive_ protocol definition capabilities.
        - [Plateo](https://github.com/Edinburgh-Genome-Foundry/Plateo) is a python library for planning, running and checking laboratory experiments. Great for parsing and exporting plates and picklists form multiple formats.
        - [pydna](https://github.com/BjornFJohansson/pydna) is a python DNA assembly simulation library with a human-readable description of cloning and assembly strategies.
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
