How to use the autoprotocol.harness.run function in autoprotocol

protocol.seal("destination_plate")

    #gibson reaction
    protocol.thermocycle("destination_plate", [
        {"cycles": 1, "steps": [
            {"temperature": "50:celsius", "duration": params["gibson_reaction_time"]},
        ]},
        {"cycles": 1, "steps": [
            {"temperature": "8:celsius", "duration": "300:second"},

        ]},
    ])

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(gibson)

protocol.distribute(params.kinase_mix_loc.set_volume("47:microliter"), kinased_wells, params.kinase_MM_volume)

    protocol.transfer(oligo_wells, kinased_wells, params.conc_oligo_volume, mix_after = True)

    protocol.seal("kinased_oligo_plate")

    protocol.thermocycle("kinased_oligo_plate",
    [{"cycles": 1, "steps": [
        {"temperature": "37:celsius", "duration": params.kinase_time},
        ]}
    ])

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(kunkel_kinase)

standard_start += 1

    start = 0
    end = 3
    for sample in protein_samples.wells:
        for i in range(start, end):
            protocol.transfer(sample, sample_wells[i], "2:microliter", mix_after=True)
        start += 3
        end += 3

    protocol.absorbance(refs.bradford_plate, wells_to_measure,
        "595:nanometer", dataref="bradford")

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(bradford)

]},
        {"cycles": 1, "steps":[
            {"temperature": "16:celsius", "duration": "5:minute"},
        ]},
        {"cycles": 49, "steps": [
            {"temperature": "50:celsius", "duration": "10:minute"},
            {"temperature": "80:celsius", "duration": "5:minute"},
        ]},
        {"cycles": 1, "steps": [
            {"temperature": "12:celsius", "duration": "10:minute"},
        ]},
    ])

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(golden_braid)

{"temperature": params.annealing_temp,
                 "duration": params.annealing_time},
                {"temperature": params.extension_temp,
                 "duration": params.extension_time}
                ]
        },
            {"cycles": 1,
                "steps": [
                {"temperature": "72:celsius", "duration":"2:minute"}]
            }
    ])


if __name__ == '__main__':
    from autoprotocol.harness import run
    run(genotyping)

'''
    params = make_dottable_dict(params)
    refs = params.refs

    reactions = refs["reaction_plate"].wells_from(params.reaction_start, params.kunkel_number, columnwise = True)

    for reaction in reactions:
        protocol.transfer(params.polymerize_MM_loc, reaction, params.polymerize_MM_vol, mix_after=True)

    protocol.seal("reaction_plate")

    protocol.incubate("reaction_plate", "ambient", "1.5:hour")

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(kunkel_polymerize)

protocol.seal("destination_plate")

    protocol.thermocycle("destination_plate", [
        {"cycles": 1, "steps": [
            {"temperature": params.digestion_temp, "duration": params.digestion_time},
        ]},
        {"cycles": 1, "steps": [
            {"temperature": params.deactivation_temp, "duration": params.deactivation_time},

        ]},
    ])

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(restriction_digest)

dilute_wells = refs.diluted_oligo_plate.wells_from(params.dilution_start,
                                        len(params.combos), columnwise = True)
    protocol.distribute(params.water.set_volume("1500:microliter"), dilute_wells, params.water_vol,
                        allow_carryover = True)
    oligos = params.kinased_oligos.wells

    for idx,combo in enumerate(params.combos):
        for i in combo:
            olig = oligos[i-1]
            protocol.transfer(olig,dilute_wells.wells[idx],params.oligo_vol,
                                mix_after = True)

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(kunkel_dilute)

refs = make_dottable_dict(params.refs)

    reaction_wells = refs["reaction_plate"].wells_from(0,len(params.oligos), columnwise=True)

    protocol.distribute(params.ssDNA_mix_loc,reaction_wells, params.ssDNA_mix_vol)

    for oligo,reaction in zip(params.oligos,reaction_wells.wells):
        protocol.transfer(oligo,reaction,params.oligo_vol,mix_after=True)

    protocol.seal("reaction_plate")

    protocol.thermocycle_ramp("reaction_plate","95:celsius", "25:celsius", "60:minute", step_duration="4:minute")

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(kunkel_anneal)

kunkel_kinase(protocol, params)

    protocol.unseal("kinased_oligo_plate")

    kunkel_dilute(protocol, params)

    kunkel_anneal(protocol, params)

    protocol.unseal("reaction_plate")

    kunkel_polymerize(protocol, params)

if __name__ == '__main__':
    from autoprotocol.harness import run
    run(kunkel_complete)