def parameters(cls):
sid_enum = cls._DB_CONNECTOR.distinct(PROBE_EXPERIMENTS_COLLECTION,
SAMPLE_ID)
rid_enum = cls._DB_CONNECTOR.distinct(PROBE_EXPERIMENTS_COLLECTION,
RUN_ID)
pid_enum = cls._DB_CONNECTOR.distinct(PROBE_EXPERIMENTS_COLLECTION,
PROBE_ID)
date_enum = cls._DB_CONNECTOR.distinct(PROBE_EXPERIMENTS_COLLECTION,
DATE)
date_enum = map(lambda x: x.strftime("%Y_%m_%d"), date_enum)
parameters = [
ParameterFactory.format(),
ParameterFactory.lc_string(SAMPLE_ID,
"Genomic DNA Sample ID(s).",
required=False,
allow_multiple=True,
enum=sid_enum),
ParameterFactory.lc_string(RUN_ID, "Run ID(s).",
required=False,
allow_multiple=True,
enum=rid_enum),
ParameterFactory.lc_string(PROBE_ID, "Probe ID(s).",
required=False,
allow_multiple=True,
enum=pid_enum),
ParameterFactory.date(required=False, enum=date_enum)
]
return parameters
def parameters(cls):
parameters = [
ParameterFactory.format(),
ParameterFactory.sequence_names(required=True),
ParameterFactory.sequences(required=True),
]
return parameters
def parameters(cls):
cls.refresh_parameter = ParameterFactory.boolean("refresh",
"Refresh available " \
"run reports.",
default_value=False)
cls.cart_sn_parameter = ParameterFactory.cartridge_sn()
cls.start_date = DateParameter("start",
"Start date of the form YYYY_MM_DD.",
allow_multiple=False,
required=False)
cls.end_date = DateParameter("end",
"End date of the form YYYY_MM_DD.",
allow_multiple=False,
required=False)
cls.uuid_parameter = ParameterFactory.uuid(required=False,
allow_multiple=False)
parameters = [
cls.cart_sn_parameter,
cls.refresh_parameter,
cls.start_date,
cls.end_date,
cls.uuid_parameter,
ParameterFactory.format(),
]
return parameters
def parameters(cls):
cls.uuids_param = ParameterFactory.uuid(required=False)
parameters = [
cls.uuids_param,
ParameterFactory.format(),
]
return parameters
def parameters(cls):
cls.ac_method = ParameterFactory.ac_method(AC_METHOD,
AC_METHOD_DESCRIPTION)
parameters = [
cls.ac_method,
ParameterFactory.format(),
]
return parameters
def parameters(cls):
parameters = [
ParameterFactory.format(),
ParameterFactory.snpsearch_name(required=True),
ParameterFactory.chromosome_num(required=True),
ParameterFactory.chromosome_start(required=True),
ParameterFactory.chromosome_stop(required=True),
]
return parameters
def parameters(cls):
cls.refresh_parameter = ParameterFactory.boolean("refresh",
"Refresh available dyes.",
default_value=False)
parameters = [
cls.refresh_parameter,
ParameterFactory.format(),
]
return parameters
def parameters(cls):
cls._file_param = ParameterFactory.file("Probe metadata file.")
cls._app_param = ParameterFactory.lc_string(
APPLICATION, "Case-insensitive application (e.g. Oncopanel).")
parameters = [
cls._file_param,
cls._app_param,
]
return parameters
def parameters(cls):
cls.filenames_parameter = ParameterFactory.filenames()
cls.report_uuid_parameter = ParameterFactory.uuid(allow_multiple=False)
parameters = [
cls.filenames_parameter,
cls.report_uuid_parameter,
ParameterFactory.format(),
]
return parameters
def parameters(cls):
cls.dataset_parameter = ParameterFactory.pa_data_source()
cls.report_uuid_parameter = ParameterFactory.uuid(allow_multiple=False)
parameters = [
cls.dataset_parameter,
cls.report_uuid_parameter,
ParameterFactory.format(),
]
return parameters
def parameters(cls):
cls.tags_parameter = ParameterFactory.tags("Run report tags.")
cls.report_uuid_parameter = ParameterFactory.uuid(allow_multiple=False)
parameters = [
cls.tags_parameter,
cls.report_uuid_parameter,
ParameterFactory.format(),
]
return parameters
def parameters(cls):
cls.archives_param = ParameterFactory.archive()
cls.job_name_param = ParameterFactory.lc_string(JOB_NAME, "Unique "\
"name to give this "
"job.")
parameters = [
cls.archives_param,
cls.job_name_param,
]
return parameters
def process_request(cls, params_dict):
snp_search_name = params_dict[ParameterFactory.snpsearch_name(required=True)]
chromosome_num = params_dict[ParameterFactory.chromosome_num(required=True)]
start_pos = params_dict[ParameterFactory.chromosome_start(required=True)]
stop_pos = params_dict[ParameterFactory.chromosome_stop(required=True)]
data = list()
ncbi_snps = snps_in_interval_multiple(snp_search_name, chromosome_num, start_pos, stop_pos)
for snp in ncbi_snps:
data.append(snp)
columns = ['search_name', 'rs', 'chromosome', 'loc', 'ref', 'alt', 'validated']
return data, columns, None
def parameters(cls):
parameters = [
ParameterFactory.file_uuid(PROBES, PROBES_COLLECTION),
ParameterFactory.file_uuid(TARGETS, TARGETS_COLLECTION),
ParameterFactory.boolean("absorb", "Check for absorbed probes."),
ParameterFactory.integer("num",
"Minimum number of probes for a target.",
default=3,
minimum=1),
ParameterFactory.lc_string(JOB_NAME,
"Unique name to give this job.")
]
return parameters
def parameters(cls):
pid_enum = cls._DB_CONNECTOR.distinct(PROBE_METADATA_COLLECTION,
PROBE_ID)
parameters = [
ParameterFactory.format(),
ParameterFactory.lc_string(PROBE_ID,
"Probe ID(s).",
required=False,
allow_multiple=True,
enum=pid_enum),
]
return parameters
def parameters(cls):
cls._file_param = ParameterFactory.file("Experiment results file.")
cls._sid_param = ParameterFactory.lc_string(SAMPLE_ID,
"Genomic DNA Sample ID.")
cls._rid_param = ParameterFactory.lc_string(RUN_ID, "Run ID.")
cls._date_param = ParameterFactory.date()
parameters = [
cls._file_param,
cls._sid_param,
cls._rid_param,
cls._date_param,
]
return parameters
def parameters(cls):
cls.pa_data_src_param = ParameterFactory.pa_data_source()
cls.dyes_param = ParameterFactory.dyes()
cls.device_param = ParameterFactory.device()
cls.major_param = ParameterFactory.integer(MAJOR, "Major dye " \
"profile version",
minimum=0)
cls.minor_param = ParameterFactory.integer(MINOR, "Minor dye " \
"profile version",
minimum=0)
cls.job_name_param = ParameterFactory.lc_string(JOB_NAME, "Unique "\
"name to give this "
"job.")
cls.offset = ParameterFactory.integer(OFFSETS, "Offset used " \
"to infer a dye model. The inference will offset the dye profiles " \
"in a range of (-<offset>,<offset>] to determine the optimal " \
"offset.", default=abs(DEFAULT_OFFSETS[0]), minimum=1)
cls.use_iid_param = ParameterFactory.boolean(USE_IID, "Use IID Peak " \
"Detection.",
default_value=False)
parameters = [
cls.pa_data_src_param,
cls.dyes_param,
cls.device_param,
cls.major_param,
cls.minor_param,
cls.job_name_param,
cls.offset,
cls.use_iid_param,
]
return parameters
def parameters(cls):
cls._file_param = ParameterFactory.file("Image stack tgz file.")
cls._exp_defs_param = ParameterFactory.experiment_definition()
cls._name_param = ParameterFactory.cs_string(
NAME, "Unique name to give this image stack.")
cls._short_desc_param = ParameterFactory.cs_string(
DESCRIPTION, "Short description of image stack.")
parameters = [
cls._file_param,
cls._exp_defs_param,
cls._name_param,
cls._short_desc_param,
]
return parameters
def parameters(cls):
cls._dyes_metrics = ParameterFactory.dye_metrics()
cls._drop_ave_diameter = ParameterFactory.float(
DROP_AVE_DIAMETER,
'Float specifying average drop diameter',
required=True)
cls._drop_std_diameter = ParameterFactory.float(
DROP_STD_DIAMETER,
'Float specifying drop diameter standard deviation',
required=True)
parameters = [
cls._drop_ave_diameter, cls._dyes_metrics, cls._drop_std_diameter
]
return parameters
def process_request(cls, params_dict):
probes_file_uuid = params_dict[ParameterFactory.file_uuid(
"probes", PROBES_COLLECTION)][0]
targets_file_uuid = params_dict[ParameterFactory.file_uuid(
"targets", TARGETS_COLLECTION)][0]
absorb = params_dict[ParameterFactory.boolean(
"absorb", "Check for absorbed probes.")][0]
num = params_dict[ParameterFactory.integer(
"num",
"Minimum number of probes for a target.",
default=3,
minimum=1)][0]
job_name = params_dict[ParameterFactory.lc_string(
JOB_NAME, "Unique name to give this job.")][0]
json_response = {
PROBES: probes_file_uuid,
TARGETS: targets_file_uuid,
ABSORB: absorb,
NUM: num,
UUID: str(uuid4()),
STATUS: JOB_STATUS.submitted, # @UndefinedVariable
JOB_NAME: job_name,
DATESTAMP: datetime.today(),
}
http_status_code = 200
if job_name in cls._DB_CONNECTOR.distinct(VALIDATION_COLLECTION,
JOB_NAME):
http_status_code = 403
else:
try:
probes_path = cls._DB_CONNECTOR.find_one(
PROBES_COLLECTION, UUID, probes_file_uuid)[FILEPATH]
targets_path = cls._DB_CONNECTOR.find_one(
TARGETS_COLLECTION, UUID, targets_file_uuid)[FILEPATH]
#ADD VALIDATOR JOB TO QUEUE
cls._DB_CONNECTOR.insert(VALIDATION_COLLECTION,
[json_response])
del json_response[ID]
except:
APP_LOGGER.exception(traceback.format_exc())
json_response[ERROR] = str(sys.exc_info()[1])
http_status_code = 500
return make_clean_response(json_response, http_status_code)
def _parse_query_params(cls, query_params):
'''
Valid query_params are defined by parameters(). However, a user can
supply parameters not contained in this list. Therefore, invalid
parameters are discarded and a params_dict is populated only with those
parameters that are valid. Since format is a special required input
parameter for every API function, it is parsed and returned separately.
Note that each parameter parses its own arguments. This allows it to
set a default when the parameter isn't included in the API call, as well
as format the input appropriately (string, float, int, date, etc.).
'''
params_dict = dict()
_format = FORMATS.json # @UndefinedVariable
parameters = cls.parameters()
for parameter in parameters:
# Path parameters are parsed in _handle_path_fields()
if not parameter.is_path():
# query_params is a default_dict(list), so it returns an empty
# list if this parameter was not provided - parse_args must
# be called on every parameter to set its default value if one
# exists.
args = parameter.parse_args(
query_params[parameter.alias.lower()])
if args:
if parameter == ParameterFactory.format():
_format = args[0]
else:
params_dict[parameter] = args
return (params_dict, _format)
def parameters(cls):
cls._exp_defs_param = ParameterFactory.experiment_definition()
parameters = [
cls._exp_defs_param,
]
return parameters
def parameters(cls):
cls._file_param = ParameterFactory.file('Image stack tgz file.')
cls._stack_type_param = ParameterFactory.mon_camera_type(
STACK_TYPE, 'Monitor Camera Number')
cls._name_param = ParameterFactory.cs_string(
NAME, 'Unique name to give this image stack.')
cls._short_desc_param = ParameterFactory.cs_string(
DESCRIPTION, 'Short description of image stack.')
parameters = [
cls._file_param,
cls._stack_type_param,
cls._name_param,
cls._short_desc_param,
]
return parameters
def parameters(cls):
cls.job_uuid_param = ParameterFactory.job_uuid(SA_ASSAY_CALLER_COLLECTION)
cls.job_name_param = ParameterFactory.lc_string(JOB_NAME, JOB_NAME_DESC)
cls.exp_defs_param = ParameterFactory.experiment_definition()
cls.req_drops_param = ParameterFactory.integer(REQUIRED_DROPS,
REQ_DROPS_DESCRIPTION,
required=True, default=0,
minimum=0)
parameters = [
cls.job_uuid_param,
cls.job_name_param,
cls.exp_defs_param,
cls.req_drops_param,
]
return parameters
def parameters(cls):
cls.job_uuid = ParameterFactory.job_uuid(PA_PROCESS_COLLECTION)
parameters = [
cls.job_uuid,
]
return parameters
def process_request(cls, params_dict):
response = {}
http_status_code = 200
targets_uuids = params_dict[ParameterFactory.uuid()]
criteria = {UUID: {"$in": targets_uuids}}
records = cls._DB_CONNECTOR.find(PROBES_COLLECTION, criteria, {ID:0})
response["deleted"] = {}
if len(records) > 0:
# Record records
for record in records:
response["deleted"][record[UUID]] = record
# Delete records from database
result = cls._DB_CONNECTOR.remove(PROBES_COLLECTION, criteria)
# Delete files from disk only if removal from DB was successful
if result and result['n'] == len(response["deleted"]):
for _,record in response["deleted"].iteritems():
os.remove(record[FILEPATH])
else:
del response["deleted"]
raise Exception("Error deleting records from the database: %s" % result)
else:
http_status_code = 404
return response, http_status_code
def process_request(cls, params_dict):
sequences = params_dict[ParameterFactory.sequences(required=True)]
sequence_names = params_dict[ParameterFactory.sequence_names(
required=True)]
# Every sequence must have an accompanying name
if len(sequences) != len(sequence_names):
return (None, None, None)
data = list()
for i, sequence in enumerate(sequences):
melting_temp = cls._IDT_CLIENT.get_melting_temp(sequence)
data.append({
"Name": sequence_names[i],
"Sequence": sequence,
"Tm": melting_temp.tm
})
columns = ["Name", "Sequence", "Tm"]
return (data, columns, None)
def parameters(cls):
cls._probes_param = ParameterFactory.file_uuid(PROBES,
PROBES_COLLECTION)
cls._targets_param = ParameterFactory.file_uuid(
TARGETS, TARGETS_COLLECTION)
cls._strict_param = ParameterFactory.integer(STRICT, "Restrict " \
"each probe to this number of bases from the 3' end of its " \
"sequence (0 to use entire probe)", default=0, minimum=0)
cls._job_name_param = ParameterFactory.cs_string(JOB_NAME,
"Unique name to " \
"give this job.")
parameters = [
cls._probes_param,
cls._targets_param,
cls._strict_param,
cls._job_name_param,
]
return parameters
def parameters(cls):
cls._name_param = ParameterFactory.cs_string(
NAME, 'Unique name to give this image stack.')
cls._ham_imgs_param = ParameterFactory.available_stacks(
HAM_NAME, 'Existing ham image stack.', HAM)
cls._mon1_imgs_param = ParameterFactory.available_stacks(
MON1_NAME, 'Existing monitor camera 1 image stack.', MONITOR1)
cls._mon2_imgs_param = ParameterFactory.available_stacks(
MON2_NAME, 'Existing monitor camera 2 image stack.', MONITOR2)
cls._short_desc_param = ParameterFactory.cs_string(
DESCRIPTION, 'Short description of image stack.')
parameters = [
cls._name_param,
cls._ham_imgs_param,
cls._mon1_imgs_param,
cls._mon2_imgs_param,
cls._short_desc_param,
]
return parameters
def parameters(cls):
rid_enum = cls._DB_CONNECTOR.distinct(PROBE_EXPERIMENTS_COLLECTION,
RUN_ID)
cls._rid_param = ParameterFactory.lc_string(RUN_ID,
"Run ID.",
required=True,
allow_multiple=True,
enum=rid_enum)
parameters = [
cls._rid_param,
]
return parameters
