def main(): """Main entry point for running sg-prototype.""" mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) output = {} # YOUR STUFF GOES HERE output.update({"input_parameters": mod.args}) if "output_json" in mod.args: mod.output(output) else: print(mod.get_output_json(output))
def test_bad_output(tmpdir): file_out = tmpdir.join('test_output_bad.json') input_parameters = {'output_json': str(file_out)} mod = ArgSchemaParser(input_data=input_parameters, output_schema_type=MyOutputSchema, args=[]) M = [[5, 5], [7, 2]] Mnp = np.array(M) output = {"a": "example", "b": "not a number", "M": Mnp} with pytest.raises(mm.ValidationError): mod.output(output)
def test_output_unvalidated(tmpdir): file_out = tmpdir.join('test_output_unvalidated.json') input_parameters = {'output_json': str(file_out)} mod = ArgSchemaParser(input_data=input_parameters, args=[]) output = { "a": "example", } mod.output(output) with open(str(file_out), 'r') as fp: actual_output = json.load(fp) assert actual_output == output
def main(): """Main entry point for running AllenSDK Eye Tracking.""" try: mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) istream = CvInputStream(mod.args["input_source"]) ostream = setup_annotation( istream.frame_shape, **mod.args.get("annotation", DEFAULT_ANNOTATION)) qc_params = mod.args.get("qc", {}) generate_plots = qc_params.get("generate_plots", EyeTracker.DEFAULT_GENERATE_QC_OUTPUT) tracker = EyeTracker(istream, ostream, mod.args.get("starburst", {}), mod.args.get("ransac", {}), mod.args["pupil_bounding_box"], mod.args["cr_bounding_box"], generate_plots, **mod.args.get("eye_params", {})) cr_params, pupil_params, cr_err, pupil_err = tracker.process_stream( start=mod.args.get("start_frame", 0), stop=mod.args.get("stop_frame", None), step=mod.args.get("frame_step", 1)) output = write_output(mod.args["output_dir"], cr_params, pupil_params, tracker.mean_frame) pupil_intensity = None if tracker.adaptive_pupil: pupil_intensity = tracker.pupil_colors if generate_plots: write_QC_output(tracker.annotator, cr_params, pupil_params, cr_err, pupil_err, tracker.mean_frame, pupil_intensity=pupil_intensity, **mod.args) output["input_parameters"] = mod.args if "output_json" in mod.args: mod.output(output, indent=1) else: print(json.dumps(mod.get_output_json(output), indent=1)) except marshmallow.ValidationError as e: print(e) argparser = schema_argparser(InputParameters()) argparser.print_usage()
def main(): from ._schemas import InputParameters, OutputParameters mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) output = calculate_quality_metrics(mod.args) output.update({"input_parameters": mod.args}) if "output_json" in mod.args: mod.output(output, indent=2) else: print(mod.get_output_json(output))
def main(): from ._schemas import InputParameters, OutputParameters mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) # output = calculate_stimulus_metrics_ondisk(mod.args) output = calculate_stimulus_metrics_gather(mod.args) if MPI_rank == 0: output.update({"input_parameters": mod.args}) if "output_json" in mod.args: mod.output(output, indent=2) else: log_info(mod.get_output_json(output)) barrier()
def main(): from ._schemas import InputParameters, OutputParameters mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) output = classify_noise_templates(mod.args) output.update({"input_parameters": mod.args}) if "output_json" in mod.args: mod.output(output, indent=2) else: print(mod.get_output_json(output))
def main(): from ._schemas import InputParameters, OutputParameters """Main entry point:""" mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) output = get_psth_events(mod.args) output.update({"input_parameters": mod.args}) if "output_json" in mod.args: mod.output(output, indent=2) else: print(mod.get_output_json(output))
def test_output(tmpdir): file_out = tmpdir.join('test_output.json') input_parameters = {'output_json': str(file_out)} mod = ArgSchemaParser(input_data=input_parameters, output_schema_type=MyOutputSchema, args=[]) M = [[5, 5], [7, 2]] Mnp = np.array(M) output = {"a": "example", "M": Mnp} expected_output = {"a": "example", "b": 5, "M": M} mod.output(output) with open(str(file_out), 'r') as fp: actual_output = json.load(fp) assert actual_output == expected_output
def main(): from ._schemas import InputParameters, OutputParameters mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) output = run_automerging(mod.args) output.update({"input_parameters": mod.args}) if "output_json" in mod.args: mod.output(output, indent=2) else: print(mod.get_output_json(output))
def main(): from ._schemas import InputParameters, OutputParameters """Main entry point:""" mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) if mod.args['tPrime_helper_params']['tPrime_3A']: output = call_TPrime_3A(mod.args) else: output = call_TPrime(mod.args) output.update({"input_parameters": mod.args}) if "output_json" in mod.args: mod.output(output, indent=2) else: print(mod.get_output_json(output))
def main(): parser = ArgSchemaParser( schema_type=InputParameters, output_schema_type=OutputParameters ) inputs_record = cp.deepcopy(parser.args) logging.getLogger().setLevel(inputs_record.pop("log_level")) inputs_record.pop("input_json", None) inputs_record.pop("output_json", None) output_table_path = inputs_record.pop("output_table_path", None) output = {} output.update({"inputs": parser.args}) output.update({"results": extract_multiple(**inputs_record)}) parser.output(output)
def main(): """Main entry point for running AllenSDK Eye Tracking.""" try: mod = ArgSchemaParser(schema_type=InputParameters, output_schema_type=OutputParameters) starburst_args = get_starburst_args(mod.args["starburst"]) istream = CvInputStream(mod.args["input_source"]) im_shape = istream.frame_shape ostream = setup_annotation(im_shape, **mod.args["annotation"]) tracker = EyeTracker(im_shape, istream, ostream, starburst_args, mod.args["ransac"], mod.args["pupil_bounding_box"], mod.args["cr_bounding_box"], mod.args["qc"]["generate_plots"], **mod.args["eye_params"]) pupil_parameters, cr_parameters = tracker.process_stream( start=mod.args.get("start_frame", 0), stop=mod.args.get("stop_frame", None), step=mod.args.get("frame_step", 1)) output = write_output(mod.args["output_dir"], cr_parameters, pupil_parameters, tracker.mean_frame) if mod.args["qc"]["generate_plots"]: write_QC_output(tracker.annotator, cr_parameters, pupil_parameters, tracker.mean_frame, **mod.args) output["input_parameters"] = mod.args if "output_json" in mod.args: mod.output(output, indent=1) else: print(json.dumps(mod.get_output_json(output), indent=1)) except marshmallow.ValidationError as e: print(e) argparser = schema_argparser(InputParameters()) argparser.print_usage()
def main(): parser = ArgSchemaParser(schema_type=PiaWmStreamlineSchema, output_schema_type=OutputParameters) args = cp.deepcopy(parser.args) logging.getLogger().setLevel(args.pop("log_level")) output_dir = args.pop('output_dir') depth_field, gradient_field, translation = run_streamlines(**args) # save results to file depth_field_file = os.path.join(output_dir, 'depth_field.nc') gradient_field_file = os.path.join(output_dir, 'gradient_field.nc') depth_field.to_netcdf(depth_field_file) gradient_field.to_netcdf(gradient_field_file) output = { 'inputs': parser.args, 'translation': translation, 'depth_field_file': depth_field_file, 'gradient_field_file': gradient_field_file, } parser.output(output)
def main(): mod = ArgSchemaParser(schema_type=ApplyAffineSchema, output_schema_type=OutputParameters) args = mod.args if 'affine_dict' in args: affine_transform = AffineTransform.from_dict(args['affine_dict']) elif 'affine_list' in args: affine_transform = AffineTransform.from_list(args['affine_list']) else: raise ValueError('must provide either an affine_dict or affine_list') morph_in = morphology_from_swc(args['input_swc']) morph_out = affine_transform.transform_morphology(morph_in) morphology_to_swc(morph_out, args['output_swc']) output = { 'inputs': args, 'transformed_swc': args['output_swc'], } mod.output(output)
def main(): mod = ArgSchemaParser(schema_type=InputSchema, output_schema_type=OutputSchema) if mod.args['test_mode']: global volume_to_h5, volume_to_tif volume_to_h5 = mock_h5 volume_to_tif = mock_tif h5_opts = {} if mod.args['compression_level']: h5_opts = {"compression": "gzip", "compression_opts": mod.args['compression_level']} stack_tifs = set() ready_to_archive = set() session_storage = mod.args["storage_directory"] output = {"column_stacks": [], "file_metadata": []} experiments = [] z_outs = {} for plane_group in mod.args["plane_groups"]: column_stack = plane_group.get("column_z_stack_tif", None) if column_stack: ready_to_archive.add(column_stack) if column_stack not in stack_tifs: try: out, meta = convert_column( column_stack, session_storage, plane_group["ophys_experiments"][0], **h5_opts ) output["column_stacks"].append(out) output["file_metadata"].append(meta) except ValueError as e: # don't break on failed column stack conversion logging.error(e) stack_tifs.add(column_stack) for exp in plane_group["ophys_experiments"]: localz = plane_group["local_z_stack_tif"] ready_to_archive.add(localz) out, meta = split_z(localz, exp, **h5_opts) if localz not in stack_tifs: output["file_metadata"].append(meta) stack_tifs.add(localz) experiments.append(exp) z_outs[exp["experiment_id"]] = out surf_outs, surf_meta = split_image(mod.args["surface_tif"], experiments, "surface") depth_outs, depth_meta = split_image(mod.args["depths_tif"], experiments, "depth") ts_outs, ts_meta = split_timeseries(mod.args["timeseries_tif"], experiments, **h5_opts) output["file_metadata"].extend([surf_meta, depth_meta, ts_meta]) exp_out = [] for exp in experiments: eid = exp["experiment_id"] sync_stride = ts_outs[eid].pop("sync_stride") sync_offset = ts_outs[eid].pop("sync_offset") exp_data = {"experiment_id": eid, "local_z_stack": z_outs[eid], "surface_2p": surf_outs[eid], "depth_2p": depth_outs[eid], "timeseries": ts_outs[eid], "sync_offset": sync_offset, "sync_stride": sync_stride} exp_out.append(exp_data) output["experiment_output"] = exp_out ready_to_archive.add(mod.args["surface_tif"]) ready_to_archive.add(mod.args["depths_tif"]) ready_to_archive.add(mod.args["timeseries_tif"]) output["ready_to_archive"] = list(ready_to_archive) mod.output(output, indent=1)
# this defines a default dictionary that will be used if input_json is not specified example_input = { "inc": { "name": "from_dictionary", "increment": 5, "array": [0, 2, 5], "write_output": True }, "output_json": "output_dictionary.json" } # here is my ArgSchemaParser that processes my inputs mod = ArgSchemaParser(input_data=example_input, schema_type=MyParameters, output_schema_type=MyOutputParams) # pull out the inc section of the parameters inc_params = mod.args['inc'] # do my simple addition of the parameters inc_array = inc_params['array'] + inc_params['increment'] # define the output dictionary output = {'name': inc_params['name'], 'inc_array': inc_array} # if the parameters are set as such write the output if inc_params['write_output']: mod.output(output) pp.pprint(mod.args)