def main():
logging.basicConfig(format=('%(asctime)s:%(funcName)s'
':%(levelname)s:%(message)s'))
parser = ArgSchemaParser(args=sys.argv[1:],
schema_type=InputSchema,
output_schema_type=OutputSchema)
args = preprocess_input_args(parser.args)
output = run_gaze_mapping(pupil_parameters=args["pupil_params"],
cr_parameters=args["cr_params"],
eye_parameters=args["eye_params"],
monitor_position=args["monitor_position"],
monitor_rotations=args["monitor_rotations"],
camera_position=args["camera_position"],
camera_rotations=args["camera_rotations"],
led_position=args["led_position"],
eye_radius_cm=args["eye_radius_cm"],
cm_per_pixel=args["cm_per_pixel"])
output["synced_frame_timestamps_sec"] = load_sync_file_timings(args["session_sync_file"],
args["pupil_params"].shape[0],
parser.args["truncate_timestamps"])
write_gaze_mapping_output_to_h5(args["output_file"], output)
module_output = {"screen_mapping_file": str(args["output_file"])}
write_or_print_outputs(module_output, parser)
def main():
logging.basicConfig(
format='%(asctime)s - %(process)s - %(levelname)s - %(message)s')
args = sys.argv[1:]
try:
parser = argschema.ArgSchemaParser(
args=args,
schema_type=InputSchema,
output_schema_type=OutputSchema,
)
logging.info('Input successfully parsed')
except marshmallow.exceptions.ValidationError as err:
logging.error('Parsing failure')
print(err)
raise err
try:
output = write_behavior_nwb(parser.args['session_data'],
parser.args['output_path'])
logging.info('File successfully created')
except Exception as err:
logging.error('NWB write failure')
print(err)
raise err
write_or_print_outputs(output, parser)
def main():
logging.basicConfig(
format='%(asctime)s - %(process)s - %(levelname)s - %(message)s')
# TODO replace with argschema implementation of multisource parser
remaining_args = sys.argv[1:]
input_data = {}
if '--get_inputs_from_lims' in sys.argv:
lims_parser = argparse.ArgumentParser(add_help=False)
lims_parser.add_argument('--host', type=str, default='http://lims2')
lims_parser.add_argument('--job_queue', type=str, default=None)
lims_parser.add_argument('--strategy', type=str, default=None)
lims_parser.add_argument('--image_series_id', type=int, default=None)
lims_parser.add_argument('--output_root', type=str, default=None)
lims_args, remaining_args = lims_parser.parse_known_args(
remaining_args)
remaining_args = [item for item in remaining_args if
item != '--get_inputs_from_lims']
input_data = get_inputs_from_lims(**lims_args.__dict__)
parser = argschema.ArgSchemaParser(
args=remaining_args,
input_data=input_data,
schema_type=InputParameters,
output_schema_type=OutputParameters,
)
output = run_grid(parser.args)
write_or_print_outputs(output, parser)
def main():
logging.basicConfig(format=('%(asctime)s:%(funcName)s'
':%(levelname)s:%(message)s'))
parser = optional_lims_inputs(sys.argv, InputParameters, OutputParameters,
get_inputs_from_lims)
output = run_csd(parser.args)
write_or_print_outputs(output, parser)
def main():
logging.basicConfig(
format="%(asctime)s - %(process)s - %(levelname)s - %(message)s")
parser = optional_lims_inputs(sys.argv, InputSchema, OutputSchema,
get_inputs_from_lims)
output = write_ecephys_nwb(**parser.args)
write_or_print_outputs(output, parser)
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:
write_or_print_outputs(data=output, parser=mod)
barrier()
def main():
logging.basicConfig(format=('%(asctime)s:%(funcName)s'
':%(levelname)s:%(message)s'))
parser = ArgSchemaParser(args=sys.argv[1:],
schema_type=InputSchema,
output_schema_type=OutputSchema)
args = repackage_input_args(parser.args)
# TODO: Some ellipses.h5 files have the 'cr' key as complex type instead of
# float. For now, when loading ellipses.h5 files, always coerce to float
# but this should eventually be resolved upstream...
pupil_params = pd.read_hdf(args['input_file'], key="pupil").astype(float)
cr_params = pd.read_hdf(args['input_file'], key="cr").astype(float)
eye_params = pd.read_hdf(args['input_file'], key="eye").astype(float)
num_frames_match = ((pupil_params.shape[0] == cr_params.shape[0])
and (cr_params.shape[0] == eye_params.shape[0]))
if not num_frames_match:
raise RuntimeError("The number of frames for ellipse fits don't "
"match when they should: "
f"pupil_params ({pupil_params.shape[0]}), "
f"cr_params ({cr_params.shape[0]}), "
f"eye_params ({eye_params.shape[0]}).")
output = run_gaze_mapping(pupil_parameters=pupil_params,
cr_parameters=cr_params,
eye_parameters=eye_params,
monitor_position=args["monitor_position"],
monitor_rotations=args["monitor_rotations"],
camera_position=args["camera_position"],
camera_rotations=args["camera_rotations"],
led_position=args["led_position"],
eye_radius_cm=args["eye_radius_cm"],
cm_per_pixel=args["cm_per_pixel"])
# Add synchronized frame times
frame_times = get_synchronized_camera_frame_times(
args["session_sync_file"])
if (pupil_params.shape[0] != len(frame_times)):
raise RuntimeError("The number of camera sync pulses in the "
f"sync file ({len(frame_times)}) do not match "
"with the number of eye tracking frames "
f"({pupil_params.shape[0]})!!!")
output["synced_frame_timestamps_sec"] = frame_times
write_gaze_mapping_output_to_h5(args["output_file"], output)
module_output = {"screen_mapping_file": str(args["output_file"])}
write_or_print_outputs(module_output, parser)
def main():
logging.basicConfig(
format='%(asctime)s - %(process)s - %(levelname)s - %(message)s')
remaining_args = sys.argv[1:]
input_data = {}
if '--get_inputs_from_lims' in sys.argv:
lims_parser = argparse.ArgumentParser(add_help=False)
lims_parser.add_argument('--host', type=str, default='http://lims2')
lims_parser.add_argument('--job_queue',
type=str,
default='OPHYS_EXTRACT_TRACES_QUEUE')
lims_parser.add_argument('--strategy',
type=str,
default='ExtractTracesStrategy')
lims_parser.add_argument('--ophys_experiment_id',
type=int,
default=None)
lims_parser.add_argument('--output_root', type=str, default=None)
lims_args, remaining_args = lims_parser.parse_known_args(
remaining_args)
remaining_args = [
item for item in remaining_args if item != '--get_inputs_from_lims'
]
input_data = get_inputs_from_lims(**lims_args.__dict__)
try:
parser = argschema.ArgSchemaParser(
args=remaining_args,
input_data=input_data,
schema_type=InputSchema,
output_schema_type=OutputSchema,
)
except marshmallow.exceptions.ValidationError as err:
print(input_data)
raise
output = extract_traces(**parser.args)
write_or_print_outputs(output, parser)
def main():
mod = ArgSchemaParserPlus(schema_type=InputParameters,
output_schema_type=OutputSchema)
output = build_stimulus_table(**mod.args)
write_or_print_outputs(data=output, parser=mod)
copy_file_entry(file_entry['source'],
file_entry['destination'],
use_rsync,
make_parent_dirs,
chmod=chmod)
if hasher_cls is not None:
hashes = compare(file_entry['source'], file_entry['destination'],
hasher_cls, raise_if_comparison_fails)
if hashes is not None:
record['source_hash'] = [int(ii) for ii in hashes[0]]
record['destination_hash'] = [int(ii) for ii in hashes[1]]
output.append(record)
return {'files': output}
if __name__ == '__main__':
logging.basicConfig(
format='%(asctime)s - %(process)s - %(levelname)s - %(message)s')
parser = argschema.ArgSchemaParser(
schema_type=InputSchema,
output_schema_type=OutputSchema,
)
output = main(**parser.args)
write_or_print_outputs(output, parser)
def main():
mod = ArgSchemaParserPlus(schema_type=InputParameters,
output_schema_type=OutputParameters)
output = subsample(mod.args)
write_or_print_outputs(data=output, parser=mod)
velocities = extract_running_speeds(
frame_times=frame_times,
dx_deg=dx_deg,
vsig=vsig,
vin=vin,
wheel_radius=wheel_radius,
subject_position=subject_position,
use_median_duration=use_median_duration)
raw_data = pd.DataFrame({
"vsig": vsig,
"vin": vin,
"frame_time": frame_times,
"dx": dx_deg
})
store = pd.HDFStore(output_path)
store.put("running_speed", velocities)
store.put("raw_data", raw_data)
store.close()
return {"output_path": output_path}
if __name__ == "__main__":
mod = ArgSchemaParserPlus(schema_type=InputParameters,
output_schema_type=OutputParameters)
output = main(**mod.args)
write_or_print_outputs(data=output, parser=mod)
