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