Py clone (#96)

Add cloning and fragmentation to python. Definitely should work to improve this over time, but this is good enough to get out there.

Author: Koeng101

README.md

@@ -76,6 +76,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+- Adds cloning and recursion functions to python. [#96](https://github.com/Koeng101/dnadesign/pull/96)
 - Adds recursive fragmentation. [#92](https://github.com/Koeng101/dnadesign/pull/92)
 - Updated megamash documentation to be more specific. [#91](https://github.com/Koeng101/dnadesign/pull/91)
 - Adds automatic python documentation generation. [#88](https://github.com/Koeng101/dnadesign/pull/88)

lib/clone/example_test.go

@@ -5,7 +5,6 @@ import (
 	"log"
 
 	"github.com/koeng101/dnadesign/lib/clone"
-	"github.com/koeng101/dnadesign/lib/seqhash"
 )
 
 func ExampleGoldenGate() {
@@ -24,6 +23,6 @@ func ExampleGoldenGate() {
 		log.Fatalf("Failed to GoldenGate. Got error: %s", err)
 	}
 
-	fmt.Println(seqhash.RotateSequence(plasmid))
-	// Output: AAAAAAAGGATCTCAAGAAGGCCTACTATTAGCAACAACGATCCTTTGATCTTTTCTACGGGGTCTGACGCTCAGTGGAACGAAAACTCACGTTAAGGGATTTTGGTCATGAGATTATCAAAAAGGATCTTCACCTAGATCCTTTTAAATTAAAAATGAAGTTTTAAATCAATCTAAAGTATATATGAGTAAACTTGGTCTGACAGTTACCAATGCTTAATCAGTGAGGCACCTATCTCAGCGATCTGTCTATTTCGTTCATCCATAGTTGCCTGACTCCCCGTCGTGTAGATAACTACGATACGGGAGGGCTTACCATCTGGCCCCAGTGCTGCAATGATACCGCGAGAACCACGCTCACCGGCTCCAGATTTATCAGCAATAAACCAGCCAGCCGGAAGGGCCGAGCGCAGAAGTGGTCCTGCAACTTTATCCGCCTCCATCCAGTCTATTAATTGTTGCCGGGAAGCTAGAGTAAGTAGTTCGCCAGTTAATAGTTTGCGCAACGTTGTTGCCATTGCTACAGGCATCGTGGTGTCACGCTCGTCGTTTGGTATGGCTTCATTCAGCTCCGGTTCCCAACGATCAAGGCGAGTTACATGATCCCCCATGTTGTGCAAAAAAGCGGTTAGCTCCTTCGGTCCTCCGATCGTTGTCAGAAGTAAGTTGGCCGCAGTGTTATCACTCATGGTTATGGCAGCACTGCATAATTCTCTTACTGTCATGCCATCCGTAAGATGCTTTTCTGTGACTGGTGAGTACTCAACCAAGTCATTCTGAGAATAGTGTATGCGGCGACCGAGTTGCTCTTGCCCGGCGTCAATACGGGATAATACCGCGCCACATAGCAGAACTTTAAAAGTGCTCATCATTGGAAAACGTTCTTCGGGGCGAAAACTCTCAAGGATCTTACCGCTGTTGAGATCCAGTTCGATGTAACCCACTCGTGCACCCAACTGATCTTCAGCATCTTTTACTTTCACCAGCGTTTCTGGGTGAGCAAAAACAGGAAGGCAAAATGCCGCAAAAAAGGGAATAAGGGCGACACGGAAATGTTGAATACTCATACTCTTCCTTTTTCAATATTATTGAAGCATTTATCAGGGTTATTGTCTCATGAGCGGATACATATTTGAATGTATTTAGAAAAATAAACAAATAGGGGTTCCGCGCACCTGCACCAGTCAGTAAAACGACGGCCAGTAGTCAAAAGCCTCCGACCGGAGGCTTTTGACTTGGTTCAGGTGGAGTGGGAGAAACACGTGGCAAACATTCCGGTCTCAAATGGAAAAGAGCAACGAAACCAACGGCTACCTTGACAGCGCTCAAGCCGGCCCTGCAGCTGGCCCGGGCGCTCCGGGTACCGCCGCGGGTCGTGCACGTCGTTGCGCGGGCTTCCTGCGGCGCCAAGCGCTGGTGCTGCTCACGGTGTCTGGTGTTCTGGCAGGCGCCGGTTTGGGCGCGGCACTGCGTGGGCTCAGCCTGAGCCGCACCCAGGTCACCTACCTGGCCTTCCCCGGCGAGATGCTGCTCCGCATGCTGCGCATGATCATCCTGCCGCTGGTGGTCTGCAGCCTGGTGTCGGGCGCCGCCTCCCTCGATGCCAGCTGCCTCGGGCGTCTGGGCGGTATCGCTGTCGCCTACTTTGGCCTCACCACACTGAGTGCCTCGGCGCTCGCCGTGGCCTTGGCGTTCATCATCAAGCCAGGATCCGGTGCGCAGACCCTTCAGTCCAGCGACCTGGGGCTGGAGGACTCGGGGCCTCCTCCTGTCCCCAAAGAAACGGTGGACTCTTTCCTCGACCTGGCCAGAAACCTGTTTCCCTCCAATCTTGTGGTTGCAGCTTTCCGTACGTATGCAACCGATTATAAAGTCGTGACCCAGAACAGCAGCTCTGGAAATGTAACCCATGAAAAGATCCCCATAGGCACTGAGATAGAAGGGATGAACATTTTAGGATTGGTCCTGTTTGCTCTGGTGTTAGGAGTGGCCTTAAAGAAACTAGGCTCCGAAGGAGAGGACCTCATCCGTTTCTTCAATTCCCTCAACGAGGCGACGATGGTGCTGGTGTCCTGGATTATGTGGTACGTACCTGTGGGCATCATGTTCCTTGTTGGAAGCAAGATCGTGGAAATGAAAGACATCATCGTGCTGGTGACCAGCCTGGGGAAATACATCTTCGCATCTATATTGGGCCACGTCATTCATGGTGGTATCGTCCTGCCGCTGATTTATTTTGTTTTCACACGAAAAAACCCATTCAGATTCCTCCTGGGCCTCCTCGCCCCATTTGCGACAGCATTTGCTACGTGCTCCAGCTCAGCGACCCTTCCCTCTATGATGAAGTGCATTGAAGAGAACAATGGTGTGGACAAGAGGATCTCCAGGTTTATTCTCCCCATCGGGGCCACCGTGAACATGGACGGAGCAGCCATCTTCCAGTGTGTGGCCGCGGTGTTCATTGCGCAACTCAACAACGTAGAGCTCAACGCAGGACAGATTTTCACCATTCTAGTGACTGCCACAGCGTCCAGTGTTGGAGCAGCAGGCGTGCCAGCTGGAGGGGTCCTCACCATTGCCATTATCCTGGAGGCCATTGGGCTGCCTACTCATGATCTGCCTCTGATCCTGGCTGTGGACTGGATTGTGGACCGGACCACCACGGTGGTGAATGTGGAAGGGGATGCCCTGGGTGCAGGCATTCTCCACCACCTGAATCAGAAGGCAACAAAGAAAGGCGAGCAGGAACTTGCTGAGGTGAAAGTGGAAGCCATCCCCAACTGCAAGTCTGAGGAGGAAACCTCGCCCCTGGTGACACACCAGAACCCCGCTGGCCCCGTGGCCAGTGCCCCAGAACTGGAATCCAAGGAGTCGGTTCTGTGAAGAGCTTAGAGACCGACGACTGCCTAAGGACATTCGCTGAGGTGTCAATCGTCGGAGCCGCTGAGCAATAACTAGCATAACCCCTTGGGGCCTCTAAACGGGTCTTGAGGGGTTTTTTGCATGGTCATAGCTGTTTCCTGAGAGCTTGGCAGGTGATGACACACATTAACAAATTTCGTGAGGAGTCTCCAGAAGAATGCCATTAATTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCTCAAGTCAGAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCTCCCTCGTGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCGCTTTCTCATAGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAGACACGACTTATCGCCACTGGCAGCAGCCACTGGTAACAGGATTAGCAGAGCGAGGTATGTAGGCGGTGCTACAGAGTTCTTGAAGTGGTGGCCTAACTACGGCTACACTAGAAGAACAGTATTTGGTATCTGCGCTCTGCTGAAGCCAGTTACCTTCGGAAAAAGAGTTGGTAGCTCTTGATCCGGCAAACAAACCACCGCTGGTAGCGGTGGTTTTTTTGTTTGCAAGCAGCAGATTACGCGCAG
+	fmt.Println(plasmid)
+	// Output: GGAGAAACACGTGGCAAACATTCCGGTCTCAAATGGAAAAGAGCAACGAAACCAACGGCTACCTTGACAGCGCTCAAGCCGGCCCTGCAGCTGGCCCGGGCGCTCCGGGTACCGCCGCGGGTCGTGCACGTCGTTGCGCGGGCTTCCTGCGGCGCCAAGCGCTGGTGCTGCTCACGGTGTCTGGTGTTCTGGCAGGCGCCGGTTTGGGCGCGGCACTGCGTGGGCTCAGCCTGAGCCGCACCCAGGTCACCTACCTGGCCTTCCCCGGCGAGATGCTGCTCCGCATGCTGCGCATGATCATCCTGCCGCTGGTGGTCTGCAGCCTGGTGTCGGGCGCCGCCTCCCTCGATGCCAGCTGCCTCGGGCGTCTGGGCGGTATCGCTGTCGCCTACTTTGGCCTCACCACACTGAGTGCCTCGGCGCTCGCCGTGGCCTTGGCGTTCATCATCAAGCCAGGATCCGGTGCGCAGACCCTTCAGTCCAGCGACCTGGGGCTGGAGGACTCGGGGCCTCCTCCTGTCCCCAAAGAAACGGTGGACTCTTTCCTCGACCTGGCCAGAAACCTGTTTCCCTCCAATCTTGTGGTTGCAGCTTTCCGTACGTATGCAACCGATTATAAAGTCGTGACCCAGAACAGCAGCTCTGGAAATGTAACCCATGAAAAGATCCCCATAGGCACTGAGATAGAAGGGATGAACATTTTAGGATTGGTCCTGTTTGCTCTGGTGTTAGGAGTGGCCTTAAAGAAACTAGGCTCCGAAGGAGAGGACCTCATCCGTTTCTTCAATTCCCTCAACGAGGCGACGATGGTGCTGGTGTCCTGGATTATGTGGTACGTACCTGTGGGCATCATGTTCCTTGTTGGAAGCAAGATCGTGGAAATGAAAGACATCATCGTGCTGGTGACCAGCCTGGGGAAATACATCTTCGCATCTATATTGGGCCACGTCATTCATGGTGGTATCGTCCTGCCGCTGATTTATTTTGTTTTCACACGAAAAAACCCATTCAGATTCCTCCTGGGCCTCCTCGCCCCATTTGCGACAGCATTTGCTACGTGCTCCAGCTCAGCGACCCTTCCCTCTATGATGAAGTGCATTGAAGAGAACAATGGTGTGGACAAGAGGATCTCCAGGTTTATTCTCCCCATCGGGGCCACCGTGAACATGGACGGAGCAGCCATCTTCCAGTGTGTGGCCGCGGTGTTCATTGCGCAACTCAACAACGTAGAGCTCAACGCAGGACAGATTTTCACCATTCTAGTGACTGCCACAGCGTCCAGTGTTGGAGCAGCAGGCGTGCCAGCTGGAGGGGTCCTCACCATTGCCATTATCCTGGAGGCCATTGGGCTGCCTACTCATGATCTGCCTCTGATCCTGGCTGTGGACTGGATTGTGGACCGGACCACCACGGTGGTGAATGTGGAAGGGGATGCCCTGGGTGCAGGCATTCTCCACCACCTGAATCAGAAGGCAACAAAGAAAGGCGAGCAGGAACTTGCTGAGGTGAAAGTGGAAGCCATCCCCAACTGCAAGTCTGAGGAGGAAACCTCGCCCCTGGTGACACACCAGAACCCCGCTGGCCCCGTGGCCAGTGCCCCAGAACTGGAATCCAAGGAGTCGGTTCTGTGAAGAGCTTAGAGACCGACGACTGCCTAAGGACATTCGCTGAGGTGTCAATCGTCGGAGCCGCTGAGCAATAACTAGCATAACCCCTTGGGGCCTCTAAACGGGTCTTGAGGGGTTTTTTGCATGGTCATAGCTGTTTCCTGAGAGCTTGGCAGGTGATGACACACATTAACAAATTTCGTGAGGAGTCTCCAGAAGAATGCCATTAATTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCTCAAGTCAGAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCTCCCTCGTGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCGCTTTCTCATAGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAGACACGACTTATCGCCACTGGCAGCAGCCACTGGTAACAGGATTAGCAGAGCGAGGTATGTAGGCGGTGCTACAGAGTTCTTGAAGTGGTGGCCTAACTACGGCTACACTAGAAGAACAGTATTTGGTATCTGCGCTCTGCTGAAGCCAGTTACCTTCGGAAAAAGAGTTGGTAGCTCTTGATCCGGCAAACAAACCACCGCTGGTAGCGGTGGTTTTTTTGTTTGCAAGCAGCAGATTACGCGCAGAAAAAAAGGATCTCAAGAAGGCCTACTATTAGCAACAACGATCCTTTGATCTTTTCTACGGGGTCTGACGCTCAGTGGAACGAAAACTCACGTTAAGGGATTTTGGTCATGAGATTATCAAAAAGGATCTTCACCTAGATCCTTTTAAATTAAAAATGAAGTTTTAAATCAATCTAAAGTATATATGAGTAAACTTGGTCTGACAGTTACCAATGCTTAATCAGTGAGGCACCTATCTCAGCGATCTGTCTATTTCGTTCATCCATAGTTGCCTGACTCCCCGTCGTGTAGATAACTACGATACGGGAGGGCTTACCATCTGGCCCCAGTGCTGCAATGATACCGCGAGAACCACGCTCACCGGCTCCAGATTTATCAGCAATAAACCAGCCAGCCGGAAGGGCCGAGCGCAGAAGTGGTCCTGCAACTTTATCCGCCTCCATCCAGTCTATTAATTGTTGCCGGGAAGCTAGAGTAAGTAGTTCGCCAGTTAATAGTTTGCGCAACGTTGTTGCCATTGCTACAGGCATCGTGGTGTCACGCTCGTCGTTTGGTATGGCTTCATTCAGCTCCGGTTCCCAACGATCAAGGCGAGTTACATGATCCCCCATGTTGTGCAAAAAAGCGGTTAGCTCCTTCGGTCCTCCGATCGTTGTCAGAAGTAAGTTGGCCGCAGTGTTATCACTCATGGTTATGGCAGCACTGCATAATTCTCTTACTGTCATGCCATCCGTAAGATGCTTTTCTGTGACTGGTGAGTACTCAACCAAGTCATTCTGAGAATAGTGTATGCGGCGACCGAGTTGCTCTTGCCCGGCGTCAATACGGGATAATACCGCGCCACATAGCAGAACTTTAAAAGTGCTCATCATTGGAAAACGTTCTTCGGGGCGAAAACTCTCAAGGATCTTACCGCTGTTGAGATCCAGTTCGATGTAACCCACTCGTGCACCCAACTGATCTTCAGCATCTTTTACTTTCACCAGCGTTTCTGGGTGAGCAAAAACAGGAAGGCAAAATGCCGCAAAAAAGGGAATAAGGGCGACACGGAAATGTTGAATACTCATACTCTTCCTTTTTCAATATTATTGAAGCATTTATCAGGGTTATTGTCTCATGAGCGGATACATATTTGAATGTATTTAGAAAAATAAACAAATAGGGGTTCCGCGCACCTGCACCAGTCAGTAAAACGACGGCCAGTAGTCAAAAGCCTCCGACCGGAGGCTTTTGACTTGGTTCAGGTGGAGTG
 }

py/dnadesign/clone.py

@@ -0,0 +1,69 @@
+from typing import List, Optional
+from .cffi_bindings import ffi, lib
+
+class Part:
+    def __init__(self, sequence: str, circular: bool):
+        self.sequence = sequence
+        self.circular = circular
+
+class Fragment:
+    def __init__(self, sequence: str, forward_overhang: str, reverse_overhang: str):
+        self.sequence = sequence
+        self.forward_overhang = forward_overhang
+        self.reverse_overhang = reverse_overhang
+
+def _create_c_string(python_string: str):
+    return ffi.new("char[]", python_string.encode('utf-8'))
+
+def _create_c_part(part: Part):
+    return {"sequence": _create_c_string(part.sequence), "circular": ffi.cast("int", int(part.circular))}
+
+def _create_c_fragment(fragment: Fragment):
+    return {
+        "sequence": _create_c_string(fragment.sequence),
+        "forward_overhang": _create_c_string(fragment.forward_overhang),
+        "reverse_overhang": _create_c_string(fragment.reverse_overhang)
+    }
+
+def _fragment_from_c(c_fragment):
+    return Fragment(
+        ffi.string(c_fragment.sequence).decode('utf-8'),
+        ffi.string(c_fragment.forward_overhang).decode('utf-8'),
+        ffi.string(c_fragment.reverse_overhang).decode('utf-8')
+    )
+
+def cut_with_enzyme_by_name(part: Part, directional: bool, name: str, methylated: bool) -> List[Fragment]:
+    c_part = ffi.new("Part*", _create_c_part(part))
+    c_name = _create_c_string(name)
+    c_directional = ffi.cast("int", int(directional))
+    c_methylated = ffi.cast("int", int(methylated))
+
+    result = lib.CutWithEnzymeByName(c_part[0], c_directional, c_name, c_methylated)
+    if result.error != ffi.NULL:
+        raise Exception(ffi.string(result.error).decode('utf-8'))
+    
+    fragments = [_fragment_from_c(result.fragments[i]) for i in range(result.size)]
+    return fragments
+
+def ligate(fragments: List[Fragment], circular: bool) -> str:
+    c_fragments = ffi.new("Fragment[]", [_create_c_fragment(f) for f in fragments])
+    c_fragment_count = ffi.cast("int", len(fragments))
+    c_circular = ffi.cast("int", int(circular))
+
+    result = lib.Ligate(c_fragments, c_fragment_count, c_circular)
+    if result.error != ffi.NULL:
+        raise Exception(ffi.string(result.error).decode('utf-8'))
+    
+    return ffi.string(result.ligation).decode('utf-8')
+
+def golden_gate(sequences: List[Part], cutting_enzyme_name: str, methylated: bool) -> str:
+    c_parts = ffi.new("Part[]", [_create_c_part(part) for part in sequences])
+    c_sequence_count = ffi.cast("int", len(sequences))
+    c_cutting_enzyme_name = _create_c_string(cutting_enzyme_name)
+    c_methylated = ffi.cast("int", int(methylated))
+
+    result = lib.GoldenGate(c_parts, c_sequence_count, c_cutting_enzyme_name, c_methylated)
+    if result.error != ffi.NULL:
+        raise Exception(ffi.string(result.error).decode('utf-8'))
+    
+    return ffi.string(result.ligation).decode('utf-8')

py/dnadesign/definitions.h

@@ -137,3 +137,79 @@ typedef struct {
 
 GenbankResult ParseGenbankFromCFile(void* cfile);
 GenbankResult ParseGenbankFromCString(char* cstring);
+
+// Part, Fragment, and Assembly definitions
+typedef struct {
+    char* sequence;
+    int circular;
+} Part;
+
+typedef struct {
+    char* sequence;
+    char* forward_overhang;
+    char* reverse_overhang;
+} Fragment;
+
+typedef struct {
+    char* sequence;
+    char** fragments;
+    int fragmentCount;
+    double efficiency;
+    void* subAssemblies;
+    int subAssemblyCount;
+} Assembly;
+
+// New struct definitions for function outputs
+typedef struct {
+    Fragment* fragments;
+    int size;
+    char* error;
+} FragmentResult;
+
+typedef struct {
+    char* ligation;
+    int* ligationPattern;
+    int ligationPatternSize;
+    char* error;
+} LigationResult;
+
+typedef struct {
+    char** overhangs;
+    double* efficiencies;
+    int size;
+    char* error;
+} OverhangResult;
+
+typedef struct {
+    char** fragments;
+    int size;
+    double efficiency;
+    char* error;
+} FragmentSequenceResult;
+
+typedef struct {
+    Assembly* assembly;
+    char* error;
+} RecursiveFragmentSequenceResult;
+
+// Function declarations
+FragmentResult CutWithEnzymeByName(Part part, int directional, char* name,
+                                   int methylated);
+LigationResult Ligate(Fragment* fragments, int fragmentCount, int circular);
+LigationResult GoldenGate(Part* sequences, int sequenceCount,
+                          char* cuttingEnzymeName, int methylated);
+double SetEfficiency(char** overhangs, int overhangCount);
+OverhangResult NextOverhangs(char** currentOverhangs, int overhangCount);
+char* NextOverhang(char** currentOverhangs, int overhangCount);
+FragmentSequenceResult FragmentSequence(char* sequence, int minFragmentSize,
+                                        int maxFragmentSize,
+                                        char** excludeOverhangs,
+                                        int excludeOverhangCount);
+FragmentSequenceResult FragmentSequenceWithOverhangs(
+    char* sequence, int minFragmentSize, int maxFragmentSize,
+    char** excludeOverhangs, int excludeOverhangCount, char** includeOverhangs,
+    int includeOverhangCount);
+RecursiveFragmentSequenceResult RecursiveFragmentSequence(
+    char* sequence, int maxCodingSizeOligo, int* assemblyPattern,
+    int patternCount, char** excludeOverhangs, int excludeCount,
+    char** includeOverhangs, int includeCount);

py/dnadesign/fragment.py

@@ -0,0 +1,90 @@
+from typing import List, Tuple
+from .cffi_bindings import ffi, lib
+
+class Assembly:
+    def __init__(self, sequence: str, fragments: List[str], efficiency: float, sub_assemblies: List['Assembly']):
+        self.sequence = sequence
+        self.fragments = fragments
+        self.efficiency = efficiency
+        self.sub_assemblies = sub_assemblies
+
+def _create_c_string_array(python_strings: List[str]):
+    c_strings = [ffi.new("char[]", s.encode('utf-8')) for s in python_strings]
+    c_array = ffi.new("char *[]", c_strings)
+    return c_array, c_strings  # Return c_strings to keep them alive
+
+def _c_string_array_to_python(c_array, size):
+    return [ffi.string(c_array[i]).decode('utf-8') for i in range(size)]
+
+def set_efficiency(overhangs: List[str]) -> float:
+    c_overhangs, _ = _create_c_string_array(overhangs)
+    return lib.SetEfficiency(c_overhangs, len(overhangs))
+
+def next_overhangs(current_overhangs: List[str]) -> Tuple[List[str], List[float]]:
+    c_overhangs, _ = _create_c_string_array(current_overhangs)
+    result = lib.NextOverhangs(c_overhangs, len(current_overhangs))
+    
+    if result.error != ffi.NULL:
+        raise Exception(ffi.string(result.error).decode('utf-8'))
+    
+    overhangs = _c_string_array_to_python(result.overhangs, result.size)
+    efficiencies = [result.efficiencies[i] for i in range(result.size)]
+    return overhangs, efficiencies
+
+def next_overhang(current_overhangs: List[str]) -> str:
+    c_overhangs, _ = _create_c_string_array(current_overhangs)
+    result = lib.NextOverhang(c_overhangs, len(current_overhangs))
+    return ffi.string(result).decode('utf-8')
+
+def fragment(sequence: str, min_fragment_size: int, max_fragment_size: int, exclude_overhangs: List[str]) -> Tuple[List[str], float, str]:
+    c_sequence = ffi.new("char[]", sequence.encode('utf-8'))
+    c_exclude_overhangs, _ = _create_c_string_array(exclude_overhangs)
+    
+    result = lib.FragmentSequence(c_sequence, min_fragment_size, max_fragment_size, c_exclude_overhangs, len(exclude_overhangs))
+    
+    if result.error != ffi.NULL:
+        error = ffi.string(result.error).decode('utf-8')
+        return [], 0.0, error
+    
+    fragments = _c_string_array_to_python(result.fragments, result.size)
+    return fragments, result.efficiency, None
+
+def fragment_with_overhangs(sequence: str, min_fragment_size: int, max_fragment_size: int, 
+                            exclude_overhangs: List[str], include_overhangs: List[str]) -> Tuple[List[str], float, str]:
+    c_sequence = ffi.new("char[]", sequence.encode('utf-8'))
+    c_exclude_overhangs, _ = _create_c_string_array(exclude_overhangs)
+    c_include_overhangs, _ = _create_c_string_array(include_overhangs)
+    
+    result = lib.FragmentSequenceWithOverhangs(c_sequence, min_fragment_size, max_fragment_size, 
+                                               c_exclude_overhangs, len(exclude_overhangs),
+                                               c_include_overhangs, len(include_overhangs))
+    
+    if result.error != ffi.NULL:
+        error = ffi.string(result.error).decode('utf-8')
+        return [], 0.0, error
+    
+    fragments = _c_string_array_to_python(result.fragments, result.size)
+    return fragments, result.efficiency, None
+
+def _assembly_from_c(c_assembly) -> Assembly:
+    sequence = ffi.string(c_assembly.sequence).decode('utf-8')
+    fragments = _c_string_array_to_python(c_assembly.fragments, c_assembly.fragmentCount)
+    efficiency = c_assembly.efficiency
+    sub_assemblies = [_assembly_from_c(c_assembly.subAssemblies[i]) for i in range(c_assembly.subAssemblyCount)]
+    return Assembly(sequence, fragments, efficiency, sub_assemblies)
+
+def recursive_fragment(sequence: str, max_coding_size_oligo: int, assembly_pattern: List[int],
+                       exclude_overhangs: List[str], include_overhangs: List[str]) -> Assembly:
+    c_sequence = ffi.new("char[]", sequence.encode('utf-8'))
+    c_assembly_pattern = ffi.new("int[]", assembly_pattern)
+    c_exclude_overhangs, _ = _create_c_string_array(exclude_overhangs)
+    c_include_overhangs, _ = _create_c_string_array(include_overhangs)
+    
+    result = lib.RecursiveFragmentSequence(c_sequence, max_coding_size_oligo, c_assembly_pattern, len(assembly_pattern),
+                                           c_exclude_overhangs, len(exclude_overhangs),
+                                           c_include_overhangs, len(include_overhangs))
+    
+    if result.error != ffi.NULL:
+        raise Exception(ffi.string(result.error).decode('utf-8'))
+    
+    return _assembly_from_c(result.assembly)