xnat

#!/usr/bin/python

# Copyright 2011 Christian Haselgrove
# Licensed under the BSD License: http://www.opensource.org/licenses/bsd-license.php

import sys
import os
import getopt
import getpass
import pyxnat

project_attributes = ('secondary_ID', 
                      'name', 
                      'keywords', 
                      'alias', 
                      'pi_firstname', 
                      'pi_lastname', 
                      'xnat:projectData/meta/last_modified', 
                      'xnat:projectData/meta/insert_date')

subject_attributes = ('group', 
                      'src', 
                      'pi_firstname', 
                      'pi_lastname', 
                      'dob', 
                      'yob', 
                      'age', 
                      'gender', 
                      'handedness', 
                      'last_modified', 
                      'insert_date', 
                      'insert_user')

experiment_attributes = ('visit_id', 
                         'date', 
                         'time', 
                         'pi_firstname', 
                         'pi_lastname', 
                         'validation_method', 
                         'validation_status', 
                         'validation_date', 
                         'validation_notes', 
                         'last_modified', 
                         'insert_date', 
                         'last_modified', 
                         'insert_date', 
                         'insert_user')

image_session_attributes = ('scanner', 
                            'dcmAccessionNumber', 
                            'dcmPatientId', 
                            'dcmPatientName', 
                            'session_type', 
                            'modality', 
                            'UID')

mr_session_attributes = ()

pet_session_attributes = ()

scan_attributes = ('type', 
                   'UID', 
                   'quality', 
                   'condition', 
                   'series_description', 
                   'scanner', 
                   'modality', 
                   'frames', 
                   'last_modified', 
                   'insert_date', 
                   'insert_user')

mr_scan_attributes = ()

pet_scan_attributes = ()

reconstruction_attributes = ('type', 
                             'baseScanType', 
                             'xnat:reconstructedImageData/meta/last_modified', 
                             'xnat:reconstructedImageData/meta/insert_date')

assessor_attributes = ('visit_id', 
                       'date', 
                       'time', 
                       'pi_firstname', 
                       'pi_lastname', 
                       'validation_method', 
                       'validation_status', 
                       'validation_date', 
                       'last_modified', 
                       'insert_date', 
                       'insert_user')

def report_error(msg):
    sys.stderr.write('%s: %s\n' % (progname, msg))
    sys.stderr.write('run %s with no arguments for usage\n' % progname)
    return

def print_table(rows, indent=''):
    if len(rows) == 0:
        return
    n_cols = len(rows[0])
    widths = []
    for i in xrange(n_cols):
        widths.append(max([ len(str(el[i])) for el in rows ]))
    for row in rows:
        parts = [ str(row[i]).ljust(widths[i]) for i in xrange(n_cols) ]
        print indent + '  '.join(parts)
    return

def add_attributes(info, object, attr_names):
    attr_values = object.attrs.mget(attr_names)
    info.extend(zip(attr_names, attr_values))
    return

def add_provenance(info, object):
    provenance = object.provenance.get()
    for (i, p) in enumerate(provenance):
        for (key, value) in p.iteritems():
            info.append(('provenance-%d-%s' % (i, key), value))
    return

def add_resources(info, resources, label):
    for r in resources:
        n_files = len([ f for f in r.files() ])
        if r.label():
            value = '%s (%d): %s' % (r.id(), n_files, r.label())
        else:
            value = '%s (%d)' % (r.id(), n_files)
        info.append((label, value))
    return

def get_project(project_id):
    project = interface.select.project(project_id)
    if not project.exists():
        msg = '%s: project %s not found\n' % (progname, project_id)
        sys.stderr.write(msg)
        raise ValueError
    return project

def get_subject(project_id, subject_id):
    project = get_project(project_id)
    subject = project.subject(subject_id)
    if not subject.exists():
        fmt = '%s: subject %s for project %s not found\n'
        sys.stderr.write(fmt % (progname, subject_id, project_id))
        raise ValueError
    return subject

def get_experiment(project_id, subject_id, experiment_id):
    subject = get_subject(project_id, subject_id)
    experiment = subject.experiment(experiment_id)
    if not experiment.exists():
        fmt = '%s: experiment %s for subject %s not found\n'
        sys.stderr.write(fmt % (progname, experiment_id, subject_id))
        raise ValueError
    return experiment

def get_scan(project_id, subject_id, experiment_id, scan_id):
    experiment = get_experiment(project_id, subject_id, experiment_id)
    scan = experiment.scan(scan_id)
    if not scan.exists():
        fmt = '%s: scan %s for experiment %s not found\n'
        sys.stderr.write(fmt % (progname, scan_id, experiment_id))
        raise ValueError
    return scan

def get_reconstruction(project_id, 
                       subject_id, 
                       experiment_id, 
                       reconstruction_id):
    experiment = get_experiment(project_id, subject_id, experiment_id)
    reconstruction = experiment.reconstruction(reconstruction_id)
    if not reconstruction.exists():
        fmt = '%s: reconstruction %s for experiment %s not found\n'
        sys.stderr.write(fmt % (progname, reconstruction_id, experiment_id))
        raise ValueError
    return reconstruction

def get_assessor(project_id, subject_id, experiment_id, assessor_id):
    experiment = get_experiment(project_id, subject_id, experiment_id)
    assessor = experiment.assessor(assessor_id)
    if not assessor.exists():
        fmt = '%s: assessor %s for experiment %s not found\n'
        sys.stderr.write(fmt % (progname, assessor_id, experiment_id))
        raise ValueError
    return assessor

def dump_projects():
    info = []
    for p in interface.select.projects():
        info.append(p.attrs.mget(('ID', 'secondary_ID')))
    print_table(info)
    return True

def dump_project(project, xml_flag):
    if xml_flag:
        print project.get()
    else:
        info = []
        info.append(('ID', project.id()))
        info.append(('label', project.label()))
        info.append(('datatype', project.datatype()))
        info.append(('accessibility', project.accessibility()))
        for m in project.members():
            info.append(('member', m))
        for o in project.owners():
            info.append(('owner', o))
        for u in project.users():
            info.append(('user', u))
        for c in project.collaborators():
            info.append(('collaborator', c))
        info.append(('current_arc', project.current_arc()))
        info.append(('prearchive_code', project.prearchive_code()))
        info.append(('quarantine_code', project.quarantine_code()))
        add_resources(info, project.resources(), 'resource')
        for s in project.subjects():
            info.append(('subject', s.id()))
        add_attributes(info, project, project_attributes)
        print_table(info)
    return

def dump_subject(subject, xml_flag):
    if xml_flag:
        print subject.get()
    else:
        info = []
        info.append(('datatype', subject.datatype()))
        info.append(('ID', subject.id()))
        info.append(('label', subject.label()))
        info.append(('project', subject.parent().id()))
        for s in subject.shares():
            info.append(('share', s.id()))
        for e in subject.experiments():
            info.append(('experiment', e.id()))
        add_resources(info, subject.resources(), 'resource')
        add_attributes(info, subject, subject_attributes)
        print_table(info)
    return

def dump_experiment(experiment, xml_flag):
    if xml_flag:
        print experiment.get()
    else:
        info = []
        info.append(('ID', experiment.id()))
        info.append(('label', experiment.label()))
        info.append(('datatype', experiment.datatype()))
        info.append(('subject', experiment.parent().id()))
        for a in experiment.assessors():
            info.append(('assessor', a.id()))
        for r in experiment.reconstructions():
            info.append(('reconstruction', r.id()))
        add_resources(info, experiment.resources(), 'resource')
        for s in experiment.scans():
            info.append(('scan', s.id()))
        for s in experiment.shares():
            info.append(('share', s.id()))
        add_attributes(info, experiment, experiment_attributes)
        if experiment.datatype() == 'xnat:mrSessionData':
            add_attributes(info, experiment, image_session_attributes)
            add_attributes(info, experiment, mr_session_attributes)
        if experiment.datatype() == 'xnat:petSessionData':
            add_attributes(info, experiment, image_session_attributes)
            add_attributes(info, experiment, pet_session_attributes)
        print_table(info)
    return

def dump_scan(scan, xml_flag):
    if xml_flag:
        print scan.get()
    else:
        info = []
        info.append(('ID', scan.id()))
        info.append(('label', scan.label()))
        info.append(('datatype', scan.datatype()))
        info.append(('experiment', scan.parent().id()))
        add_resources(info, scan.resources(), 'resource')
        add_attributes(info, scan, scan_attributes)
        if scan.datatype() == 'xnat:mrScanData':
            add_attributes(info, scan, mr_scan_attributes)
        if scan.datatype() == 'xnat:petScanData':
            add_attributes(info, scan, pet_scan_attributes)
        print_table(info)
    return

def dump_reconstruction(reconstruction, xml_flag):
    if xml_flag:
        print reconstruction.get()
    else:
        info = []
        info.append(('ID', reconstruction.id()))
        info.append(('datatype', reconstruction.datatype()))
        info.append(('label', reconstruction.label()))
        info.append(('experiment', reconstruction.parent().id()))
        add_resources(info, reconstruction.in_resources(), 'in_resource')
        add_resources(info, reconstruction.out_resources(), 'out_resource')
        add_attributes(info, reconstruction, reconstruction_attributes)
        add_provenance(info, reconstruction)
        print_table(info)
    return

def dump_assessor(assessor, xml_flag):
    if xml_flag:
        print assessor.get()
    else:
        info = []
        info.append(('ID', assessor.id()))
        info.append(('datatype', assessor.datatype()))
        info.append(('label', assessor.label()))
        info.append(('experiment', assessor.parent().id()))
        add_resources(info, assessor.in_resources(), 'in_resource')
        add_resources(info, assessor.out_resources(), 'out_resource')
        for s in assessor.shares():
            info.append(('share', s.id()))
        add_attributes(info, assessor, assessor_attributes)
        add_provenance(info, assessor)
        print_table(info)
    return

def dump_resource(resource):
    info = []
    info.append(('id', resource.id()))
    info.append(('label', resource.label()))
    for f in resource.files():
        info.append(('%s-id' % f.id(), f.id()))
        info.append(('%s-label' % f.id(), f.label()))
        info.append(('%s-format' % f.id(), f.format()))
        info.append(('%s-content' % f.id(), f.content()))
        info.append(('%s-size' % f.id(), f.size()))
    print_table(info)
    return True

progname = os.path.basename(sys.argv[0])

try:
    host = os.environ['XNAT_URI']
except KeyError:
    host = None

try:
    user_name = os.environ['XNAT_USER']
except KeyError:
    user_name = None

try:
    password = os.environ['XNAT_PASSWORD']
except KeyError:
    password = None

if len(sys.argv) == 1:
    print
    print 'usage: %s [options] <command> [command arguments]' % progname
    print
    print 'call an XNAT REST service'
    print
    print 'options are:'
    print
    print '    -n -- no authentication'
    print '    -h <host>'
    print '    -u <user name>'
    print '    -p <password>'
    print
    print 'option values may be given by environment variables:'
    print
    if host is None:
        print '    host: XNAT_URI'
    else:
        print '    host: XNAT_URI (set to %s)' % host
    if user_name is None:
        print '    user name: XNAT_USER'
    else:
        print '    user name: XNAT_USER (set to %s)' % user_name
    if password is None:
        print '    password: XNAT_PASSWORD'
    else:
        print '    password: XNAT_PASSWORD (currently set)'
    print
    print '%s will prompt for a missing user name, password, or host' % progname
    print
    print 'commands are:'
    print
    print '    projects'
    print '    project [-x|--xml] <project>'
    print '    subject [-x|--xml] <project> <subject>'
    print '    experiment [-x|--xml] <project> <subject> <experiment>'
    print '    scan [-x|--xml] <project> <subject> <experiment> <scan>'
    print '    reconstruction [-x|--xml] <project> <subject> <experiment> <reconstruction>'
    print '    assessor [-x|--xml] <project> <subject> <experiment> <assessor>'
    print
    print '    project_resource <project> <resource>'
    print '    subject_resource <project> <subject> <resource>'
    print '    experiment_resource <project> <subject> <experiment> <resource>'
    print '    scan_resource <project> <subject> <experiment> <scan> <resource>'
    print '    reconstruction_resource <project> <subject> <experiment> <reconstruction> <resource>'
    print '    assessor_resource <project> <subject> <experiment> <assessor> <resource>'
    print
    sys.exit(1)

try:
    (opts, args) = getopt.getopt(sys.argv[1:], 'h:u:p:n')
except getopt.error, data:
    report_error(data)
    sys.exit(1)

if len(args) < 1:
    report_error('no command given')
    sys.exit(1)

auth_flag = True

for (option, value) in opts:
    if option == '-h':
        host = value
    if option == '-u':
        user_name = value
    if option == '-p':
        password = value
    if option == '-n':
        auth_flag = False

if host is None:
    sys.stdout.write('Host: ')
    sys.stdout.flush()
    host = sys.stdin.readline().strip()

if auth_flag:
    if user_name is None:
        sys.stdout.write('User name: ')
        sys.stdout.flush()
        user_name = sys.stdin.readline().strip()
    if password is None:
        password = getpass.getpass()

host = host.rstrip('/')

command = args.pop(0)

if auth_flag:
    interface = pyxnat.Interface(server=host, 
                                 user=user_name, 
                                 password=password)
else:
    interface = pyxnat.Interface(server=host, anonymous=True)

if command == 'projects':
    if not dump_projects():
        sys.exit(1)
elif command == 'project':
    xml_flag = False
    try:
        (options, args2) = getopt.getopt(args, 'x', 'xml')
    except getopt.error, data:
        report_error('"project" %s' % str(data))
        sys.exit(1)
    for (option, value) in options:
        if option in ('-x', '--xml'):
            xml_flag = True
    if not args2:
        report_error('no project given')
        sys.exit(1)
    try:
        project = get_project(args2[0])
    except ValueError:
        sys.exit(1)
    dump_project(project, xml_flag)
elif command == 'subject':
    xml_flag = False
    try:
        (options, args2) = getopt.getopt(args, 'x', 'xml')
    except getopt.error, data:
        report_error('"subject" %s' % str(data))
        sys.exit(1)
    for (option, value) in options:
        if option in ('-x', '--xml'):
            xml_flag = True
    if len(args2) < 2:
        report_error('not enough arguments to "subject"')
        sys.exit(1)
    try:
        subject = get_subject(args2[0], args2[1])
    except ValueError:
        sys.exit(1)
    dump_subject(subject, xml_flag)
elif command == 'experiment':
    xml_flag = False
    try:
        (options, args2) = getopt.getopt(args, 'x', 'xml')
    except getopt.error, data:
        report_error('"experiment" %s' % str(data))
        sys.exit(1)
    for (option, value) in options:
        if option in ('-x', '--xml'):
            xml_flag = True
    if len(args2) < 3:
        report_error('not enough arguments to "experiment"')
        sys.exit(1)
    try:
        experiment = get_experiment(args2[0], args2[1], args2[2])
    except ValueError:
        sys.exit(1)
    dump_experiment(experiment, xml_flag)
elif command == 'scan':
    xml_flag = False
    try:
        (options, args2) = getopt.getopt(args, 'x', 'xml')
    except getopt.error, data:
        report_error('"scan" %s' % str(data))
        sys.exit(1)
    for (option, value) in options:
        if option in ('-x', '--xml'):
            xml_flag = True
    if len(args2) < 4:
        report_error('not enough arguments to "scan"')
        sys.exit(1)
    try:
        scan = get_scan(args2[0], args2[1], args2[2], args2[3])
    except:
        sys.exit(1)
    dump_scan(scan, xml_flag)
elif command == 'reconstruction':
    xml_flag = False
    try:
        (options, args2) = getopt.getopt(args, 'x', 'xml')
    except getopt.error, data:
        report_error('"reconstruction" %s' % str(data))
        sys.exit(1)
    for (option, value) in options:
        if option in ('-x', '--xml'):
            xml_flag = True
    if len(args2) < 4:
        report_error('not enough arguments to "reconstruction"')
        sys.exit(1)
    try:
        reconstruction = get_reconstruction(args2[0], args2[1], args2[2], args2[3])
    except ValueError:
        sys.exit(1)
    dump_reconstruction(reconstruction, xml_flag)
elif command == 'assessor':
    xml_flag = False
    try:
        (options, args2) = getopt.getopt(args, 'x', 'xml')
    except getopt.error, data:
        report_error('"assessor" %s' % str(data))
        sys.exit(1)
    for (option, value) in options:
        if option in ('-x', '--xml'):
            xml_flag = True
    if len(args2) < 4:
        report_error('not enough arguments to "assessor"')
        sys.exit(1)
    try:
        assessor = get_assessor(args2[0], args2[1], args2[2], args2[3])
    except ValueError:
        sys.exit(1)
    dump_assessor(assessor, xml_flag)
elif command == 'project_resource':
    if len(args) < 2:
        report_error('not enough arguments to "project_resource"')
        sys.exit(1)
    try:
        project = get_project(args[0])
    except ValueError:
        sys.exit(1)
    r = project.resource(args[1])
    if not r.exists():
        fmt = '%s: resource %s for project %s not found\n'
        sys.stderr.write(fmt % (progname, args[1], args[0]))
        sys.exit(1)
    dump_resource(r)
elif command == 'subject_resource':
    if len(args) < 3:
        report_error('not enough arguments to "subject_resource"')
        sys.exit(1)
    try:
        subject = get_subject(args[0], args[1])
    except ValueError:
        sys.exit(1)
    r = subject.resource(args[2])
    if not r.exists():
        fmt = '%s: resource %s for subject %s not found\n'
        sys.stderr.write(fmt % (progname, args[2], args[1]))
        sys.exit(1)
    dump_resource(r)
elif command == 'experiment_resource':
    if len(args) < 4:
        report_error('not enough arguments to "experiment_resource"')
        sys.exit(1)
    try:
        experiment = get_experiment(args[0], args[1], args[2])
    except ValueError:
        sys.exit(1)
    r = experiment.resource(args[3])
    if not r.exists():
        fmt = '%s: resource %s for experiment %s not found\n'
        sys.stderr.write(fmt % (progname, args[3], args[2]))
        sys.exit(1)
    dump_resource(r)
elif command == 'scan_resource':
    if len(args) < 4:
        report_error('not enough arguments to "scan_resource"')
        sys.exit(1)
    try:
        scan = get_scan(args[0], args[1], args[2], args[3])
    except ValueError:
        sys.exit(1)
    r = scan.resource(args[4])
    if not r.exists():
        fmt = '%s: resource %s for scan %s not found\n'
        sys.stderr.write(fmt % (progname, args[4], args[3]))
        sys.exit(1)
    dump_resource(r)
elif command == 'reconstruction_resource':
    if len(args) < 5:
        report_error('not enough arguments to "reconstruction_resource"')
        sys.exit(1)
    try:
        reconstruction = get_reconstruction(args[0], args[1], args[2], args[3])
    except ValueError:
        sys.exit(1)
    r = reconstruction.in_resource(args[4])
    if not r.exists():
        r = reconstruction.out_resource(args[4])
    if not r.exists():
        fmt = '%s: resource %s for reconstruction %s not found\n'
        sys.stderr.write(fmt % (progname, args[4], args[3]))
        sys.exit(1)
    dump_resource(r)
elif command == 'assessor_resource':
    if len(args) < 5:
        report_error('not enough arguments to "assessor_resource"')
        sys.exit(1)
    try:
        assessor = get_assessor(args[0], args[1], args[2], args[3])
    except ValueError:
        sys.exit(1)
    r = assessor.in_resource(args[4])
    if not r.exists():
        r = assessor.out_resource(args[4])
    if not r.exists():
        fmt = '%s: resource %s for assessor %s not found\n'
        sys.stderr.write(fmt % (progname, args[4], args[3]))
        sys.exit(1)
    dump_resource(r)
else:
    report_error('unknown command \"%s\"\n' % command)
    sys.exit(1)

sys.exit(0)

# eof