Dict[str, CoRegistrationData]:\\n with open(filename, \\\"r\\\") as json_file:\\n data = json.load(json_file)\\n co_reg_data = {}\\n for index, data in data.items():\\n co_reg_data[index] = CoRegistrationData(\\n name=str(data['name']),\\n target_w=int(data['target_w']),\\n target_h=int(data['target_h']),\\n transform_matrix=np.array(data['transform_matrix']),\\n moving_img_name=str(data['moving_img_name'])\\n )\\n return co_reg_data\",\n \"def create_cris_data_dict(df, filename, outdir):\\n json_dict = {}\\n for key in df.keys():\\n if key != 'participant_id':\\n json_dict[key] = {'Units': key.split()[-1]}\\n else:\\n json_dict[key] = {'Description': 'OpenNeuro ID of the subject.'}\\n with open(outdir.joinpath(filename + '.json'), \\\"w\\\") as f:\\n json.dump(json_dict, f, indent=4)\",\n \"def __init__(self, image_set, root_path, data_path, category='all', task='detection'):\\n super(coco, self).__init__('COCO', image_set, root_path, data_path)\\n self.root_path = root_path\\n self.data_path = data_path\\n self.category = category\\n self.task = task\\n self.name = self.name + '_' + category\\n # deal with data name\\n view_map = {'minival2014': 'val2014',\\n 'valminusminival2014': 'val2014'}\\n self.data_name = view_map[image_set] if image_set in view_map else image_set\",\n \"def get_dataset(data_name: str = 'wnut_17', label_to_id: dict = None, allow_update: bool=True):\\n label_to_id = dict() if label_to_id is None else label_to_id\\n data_path = os.path.join(CACHE_DIR, data_name)\\n\\n def decode_file(file_name, _label_to_id: dict):\\n inputs, labels = [], []\\n with open(os.path.join(data_path, file_name), 'r') as f:\\n sentence, entity = [], []\\n for n, line in enumerate(f):\\n line = line.strip()\\n if len(line) == 0 or line.startswith(\\\"-DOCSTART-\\\"):\\n if len(sentence) != 0:\\n assert len(sentence) == len(entity)\\n inputs.append(sentence)\\n labels.append(entity)\\n sentence, entity = [], []\\n else:\\n ls = line.split()\\n if len(ls) < 2:\\n continue\\n sentence.append(ls[0])\\n # Examples could have no label for mode = \\\"test\\\"\\n tag = 'O' if len(ls) < 2 else ls[-1]\\n if tag not in _label_to_id.keys():\\n assert allow_update\\n _label_to_id[tag] = len(_label_to_id)\\n entity.append(_label_to_id[tag])\\n return _label_to_id, {\\\"data\\\": inputs, \\\"label\\\": labels}\\n\\n if data_name == 'conll_2003':\\n if not os.path.exists(data_path):\\n os.makedirs(data_path, exist_ok=True)\\n os.system('git clone https://github.com/mohammadKhalifa/xlm-roberta-ner')\\n os.system('mv ./xlm-roberta-ner/data/coNLL-2003/* {}/'.format(data_path))\\n os.system('rm -rf ./xlm-roberta-ner')\\n files = ['train.txt', 'valid.txt', 'test.txt']\\n elif data_name == 'wnut_17':\\n if not os.path.exists(data_path):\\n os.makedirs(data_path, exist_ok=True)\\n os.system(\\\"curl -L 'https://github.com/leondz/emerging_entities_17/raw/master/wnut17train.conll' | tr '\\\\t' ' ' > {}/train.txt.tmp\\\".format(data_path))\\n os.system(\\\"curl -L 'https://github.com/leondz/emerging_entities_17/raw/master/emerging.dev.conll' | tr '\\\\t' ' ' > {}/dev.txt.tmp\\\".format(data_path))\\n os.system(\\\"curl -L 'https://raw.githubusercontent.com/leondz/emerging_entities_17/master/emerging.test.annotated' | tr '\\\\t' ' ' > {}/test.txt.tmp\\\".format(data_path))\\n files = ['train.txt.tmp', 'dev.txt.tmp', 'test.txt.tmp']\\n elif data_name in ['wiki-ja-500', 'wiki-news-ja-1000']:\\n if not os.path.exists(data_path):\\n os.makedirs(data_path, exist_ok=True)\\n os.system('git clone https://github.com/Hironsan/IOB2Corpus')\\n if data_name == 'wiki-ja-500':\\n os.system('mv ./IOB2Corpus/hironsan.txt {}/tmp.txt'.format(data_path))\\n else:\\n os.system('mv ./IOB2Corpus/ja.wikipedia.conll {}/tmp.txt'.format(data_path))\\n os.system('rm -rf ./IOB2Corpus')\\n label_to_id, data = decode_file('tmp.txt', dict())\\n split(data['data'], data['label'], data_path, label_to_id)\\n os.system('rm -rf {}/tmp.txt'.format(data_path))\\n files = ['train.txt', 'valid.txt', 'test.txt']\\n else:\\n raise ValueError('unknown dataset: %s' % data_name)\\n\\n data_split = dict()\\n for name, filepath in zip(['train', 'valid', 'test'], files):\\n label_to_id, data_dict = decode_file(filepath, _label_to_id=label_to_id)\\n data_split[name] = data_dict\\n LOGGER.info('dataset {}/{}: {} entries'.format(data_name, filepath, len(data_dict['data'])))\\n if allow_update:\\n return data_split, label_to_id\\n else:\\n return data_split\",\n \"def load_demo():\\n\\tprint(\\\"\\\"\\\"\\n\\tBreast Cancer Wisconsin dataset. It contains a total of 569 samples of tumor and malignant cells. \\n\\tData labeled 1 corresponds to malignant cells, while data labeled 0 corresponds to benign cells. \\n\\tThe 30 characteristics contain real values obtained from images of cell nuclei. For more information:\\n\\n\\t\\t\\thttp://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(diagnostic)\\n\\n\\n\\tThe returned value is a dictionary where 'x_data' are the predictor variables, 'y_data' the class \\n\\tlabels and 'features' the name of the characteristics.\\n\\t\\\"\\\"\\\")\\n\\tpath = '/'.join(os.path.abspath(pywinEA.__file__).split('/')[:-1])\\n\\t\\n\\tdata = pd.read_csv(path+'/dataset/data/BreastCancerWisconsin.csv', index_col=0)\\n\\tx_data = data.iloc[:, 1:].values\\n\\ty_data = data.iloc[:, 0].values\\n\\tfeatures = data.columns[1:].values\\n\\n\\t# Transform labels\\n\\ty_data[np.where(y_data == 'M')] = 1\\n\\ty_data[np.where(y_data == 'B')] = 0\\n\\ty_data = y_data.astype(int)\\n\\n\\treturn {'x_data': x_data, 'y_data': y_data, 'features': features}\",\n \"def load_ccs9():\\n ccs9 = pd.read_csv(pkg_resources.resource_filename(__name__,'$dxref 2015.csv'))\\n ccs9 = ccs9.reset_index()\\n for col in ccs9.columns:\\n ccs9.loc[:,col]=ccs9[col].str.strip('\\\\'')\\n ccs9.columns=ccs9.iloc[0,:]\\n ccs9 = ccs9.iloc[1:,:]\\n ccs9 = ccs9.replace(r'^\\\\s*$', np.nan, regex=True)\\n ccs9 = ccs9.loc[ccs9['ICD-9-CM CODE'].notnull(),:]\\n ccs9.loc[:,'ICD-9-CM CODE'] = ccs9['ICD-9-CM CODE'].str.replace(' ','')\\n ccs9.loc[:,'CCS CATEGORY'] = ccs9['CCS CATEGORY'].str.replace(' ','')\\n ccs9 = ccs9.iloc[:,0:4] \\n ccs9_labels = pd.read_csv(pkg_resources.resource_filename(__name__,'dxlabel 2015.csv'))\\n ccs9 = ccs9.merge(ccs9_labels,how='left',left_on='CCS CATEGORY',right_on='CCS DIAGNOSIS CATEGORIES')\\n ccs9.drop('CCS CATEGORY DESCRIPTION',axis=1,inplace=True)\\n ccs9.drop('CCS DIAGNOSIS CATEGORIES',axis=1,inplace=True)\\n ccs9.columns = [i.replace('CCS DIAGNOSIS CATEGORIES LABELS','CCS CATEGORY DESCRIPTION') for i in ccs9.columns]\\n return ccs9\",\n \"def main(root_dir):\\n # load annotations\\n print('Loading instances and annotations...')\\n captions_file = json.load(open('{}/annotations/captions_train2017.json'.format(root_dir), 'r'))\\n categories_file = json.load(open('{}/annotations/instances_train2017.json'.format(root_dir), 'r'))\\n print('Done.')\\n\\n # group categories by image\\n image_categories = group_categories(categories_file)\\n\\n # group captions by image\\n image_captions = group_captions(captions_file['annotations'])\\n\\n # get filename of each image\\n image_file = get_filename(captions_file['images'])\\n\\n # assign each category an id.\\n # we are not using the default ids given in the dataset because\\n # the id ranges are not continuous.\\n category_id, id_category = map_category_id(categories_file['categories'])\\n \\n # save parsed coco dataset\\n save_dataset(image_categories, image_captions, image_file, category_id, id_category, root_dir)\",\n \"def load_nir_alcohol():\\n\\n # loading matlab data set\\n raw_data = sio.loadmat(__data_set_path)\\n\\n # ----------------\\n\\n # getting all variable/features labels\\n var_labels_all = raw_data['var_labels_all'].tolist()\\n\\n # getting spectra labels\\n var_labels_spectra = [int(l) for l in var_labels_all[3:]]\\n\\n # getting properties labels\\n var_labels_properties = var_labels_all[:3]\\n\\n # ----------------\\n\\n # getting all data (train-new-msc)\\n data_all = raw_data['data_all']\\n\\n # getting spectra data\\n data_spectra = data_all[:, 3:]\\n\\n # getting properties data\\n data_properties = data_all[:, :3]\\n\\n # ----------------\\n\\n obj_labels_train = raw_data['obj_labels_train'].tolist()\\n data_train = data_spectra[:27, :]\\n other_cols_train = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[:27, :].T)}\\n\\n ds_train = utils.build_data_set(data_train, obj_labels_train, var_labels_spectra, extra_cols=other_cols_train)\\n\\n # ----------------\\n\\n obj_labels_new = raw_data['obj_labels_new'].tolist()\\n data_new = data_spectra[27:40, :]\\n other_cols_new = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[27:40, :].T)}\\n\\n ds_new = utils.build_data_set(data_new, obj_labels_new, var_labels_spectra, extra_cols=other_cols_new)\\n\\n # ----------------\\n\\n obj_labels_msc = raw_data['obj_labels_mscorrected'].tolist()\\n data_msc = data_spectra[40:, :]\\n other_cols_msc = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[40:, :].T)}\\n\\n ds_msc = utils.build_data_set(data_msc, obj_labels_msc, var_labels_spectra, extra_cols=other_cols_msc)\\n\\n # ----------------\\n\\n # training/validation data sets and labels\\n data_sets = [ds_train, ds_new, ds_msc]\\n labels = ['train', 'new', 'msc']\\n\\n # actually building the joint data set\\n ds = pd.concat(data_sets, keys=labels)\\n\\n # returning the final data set\\n return ds\",\n \"def getCoaddDatasetName(self):\\n warpType = self.config.warpType\\n suffix = \\\"\\\" if warpType == \\\"direct\\\" else warpType[0].upper() + warpType[1:]\\n return self.config.coaddName + \\\"Coadd\\\" + suffix\",\n \"def dataio_prep(hparams):\\n\\n # Define audio pipeline\\n @sb.utils.data_pipeline.takes(\\\"wav\\\")\\n @sb.utils.data_pipeline.provides(\\\"sig\\\")\\n def audio_pipeline(wav):\\n \\\"\\\"\\\"Load the signal, and pass it and its length to the corruption class.\\n This is done on the CPU in the `collate_fn`.\\\"\\\"\\\"\\n sig = sb.dataio.dataio.read_audio(wav)\\n return sig\\n\\n # Initialization of the label encoder. The label encoder assignes to each\\n # of the observed label a unique index (e.g, 'spk01': 0, 'spk02': 1, ..)\\n label_encoder = sb.dataio.encoder.CategoricalEncoder()\\n\\n # Define label pipeline:\\n @sb.utils.data_pipeline.takes(\\\"emo\\\")\\n @sb.utils.data_pipeline.provides(\\\"emo\\\", \\\"emo_encoded\\\")\\n def label_pipeline(emo):\\n yield emo\\n emo_encoded = label_encoder.encode_label_torch(emo)\\n yield emo_encoded\\n\\n # Define datasets. We also connect the dataset with the data processing\\n # functions defined above.\\n datasets = {}\\n for dataset in [\\\"train\\\", \\\"valid\\\", \\\"test\\\"]:\\n datasets[dataset] = sb.dataio.dataset.DynamicItemDataset.from_json(\\n json_path=hparams[f\\\"{dataset}_annotation\\\"],\\n replacements={\\\"data_root\\\": hparams[\\\"data_folder\\\"]},\\n dynamic_items=[audio_pipeline, label_pipeline],\\n output_keys=[\\\"id\\\", \\\"sig\\\", \\\"emo_encoded\\\"],\\n )\\n # Load or compute the label encoder (with multi-GPU DDP support)\\n # Please, take a look into the lab_enc_file to see the label to index\\n # mappinng.\\n\\n lab_enc_file = os.path.join(hparams[\\\"save_folder\\\"], \\\"label_encoder.txt\\\")\\n label_encoder.load_or_create(\\n path=lab_enc_file,\\n from_didatasets=[datasets[\\\"train\\\"]],\\n output_key=\\\"emo\\\",\\n )\\n\\n return datasets\",\n \"def _convert_to_rdf(self):\\n\\n job_result = {}\\n\\n # Add \\\"/\\\" at the end of data_namespace if not present.\\n vocabulary_namespace = self._namespace_vocabspace_validator(self.vocabulary_namespace)\\n data_namespace = self._namespace_vocabspace_validator(self.data_namespace) + self.datasetid + \\\"/\\\"\\n # Vocabulary prefix\\n vocabulary_namespace_prefix = \\\"losdv\\\"\\n # Data namespace prefix\\n data_namespace_prefix = \\\"losdd\\\"\\n\\n # read from json-stat from a url\\n source_json = self._get_content()\\n _cleanString = self._cleanString\\n _prefix_build_concept = self._prefix_build_concept\\n\\n def conversion_for_old_jstat_version():\\n\\n scheme = [\\n '@prefix qb: <http://purl.org/linked-data/cube#> .'\\n '\\\\n@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .'\\n '\\\\n@prefix skos: <http://www.w3.org/2004/02/skos/core#> .'\\n '\\\\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .'\\n '\\\\n@prefix prov: <http://www.w3.org/ns/prov#> .'\\n '\\\\n@prefix dc: <http://purl.org/dc/elements/1.1/> .'\\n '\\\\n@prefix ' + vocabulary_namespace_prefix + ': <' + vocabulary_namespace + '> .\\\\n@prefix '\\n + data_namespace_prefix + ': <' + data_namespace + '> .',\\n '\\\\n@prefix ' + data_namespace_prefix + 'schm: <' + data_namespace + 'conceptscheme/> .']\\n\\n code_list = ['#CODELIST\\\\n\\\\n']\\n observations = ['#OBSERVATIONS\\\\n\\\\n']\\n\\n dataset_label = source_json['dataset']['label']\\n dataset_source = source_json['dataset']['source']\\n dataset_updated = source_json['dataset']['updated']\\n dimensions = source_json['dataset']['dimension']\\n\\n # Building prefix\\n\\n for data_field_nm in dimensions['id']:\\n scheme.append('\\\\n@prefix ' + data_namespace_prefix + _cleanString(\\n data_field_nm) + 'cpt: <' + data_namespace + 'concept/' + _cleanString(data_field_nm) + '/> .')\\n\\n scheme.append('\\\\n\\\\n#SCHEME\\\\n\\\\n')\\n dataset_values = source_json['dataset']['value']\\n n1 = len(dimensions['id'])\\n\\n # Scheme: Individual terms\\n\\n try:\\n\\n for data_field_nm in dimensions['id']:\\n scheme.append('' + vocabulary_namespace_prefix + ':' + _cleanString(\\n data_field_nm) + ' a qb:ComponentProperty, qb:DimensionProperty ;\\\\n\\\\trdfs:label \\\"' + data_field_nm + '\\\" ;\\\\n\\\\trdfs:range xsd:string .\\\\n\\\\n')\\n\\n scheme.append(\\n '' + vocabulary_namespace_prefix + ':value a qb:ComponentProperty, qb:MeasureProperty ;\\\\n\\\\trdfs:label \\\"value\\\" ;\\\\n\\\\trdfs:range xsd:float .\\\\n\\\\n')\\n\\n # Scheme: DSD\\n\\n scheme.append('' + data_namespace_prefix + ':' + self._cleanString(\\n dataset_label) + '_dsd a qb:DataStructureDefinition ;\\\\n\\\\tqb:component\\\\n\\\\t\\\\t'\\n '[ a qb:ComponentSpecification ;\\\\n\\\\t\\\\t qb:codeList ' +\\n data_namespace_prefix + 'schm:measureType ; \\\\n\\\\t\\\\t qb:dimension qb:measureType ;'\\n '\\\\n\\\\t\\\\t qb:order 1 \\\\n\\\\t] ;\\\\n\\\\tqb:component [ qb:measure ' +\\n vocabulary_namespace_prefix + ':value ] ;\\\\n\\\\t')\\n\\n for index, data_field_nm in enumerate(dimensions['id']):\\n scheme.append(\\n 'qb:component\\\\n\\\\t\\\\t[ a qb:ComponentSpecification ;\\\\n\\\\t\\\\t qb:codeList ' + data_namespace_prefix +\\n 'schm:' + self._cleanString(\\n data_field_nm) + ' ;\\\\n\\\\t\\\\t qb:dimension ' + vocabulary_namespace_prefix + ':' + _cleanString(\\n data_field_nm) + ' ;\\\\n\\\\t\\\\t qb:order ' + str(index + 2) + ' \\\\n\\\\t\\\\t] ')\\n\\n if index == (n1 - 1):\\n scheme.append('\\\\n.\\\\n\\\\n')\\n else:\\n scheme.append(';\\\\n\\\\t')\\n\\n # Scheme: Dataset\\n\\n scheme.append('' + data_namespace_prefix + ':' + _cleanString(dataset_label) +\\n '_dataset a qb:DataSet ;\\\\n\\\\tqb:structure ' + data_namespace_prefix + ':' +\\n _cleanString(dataset_label) + '_dsd ;\\\\n\\\\trdfs:label \\\"' + \\\\\\n dataset_label + '\\\" ; \\\\n\\\\tprov:generatedAtTime \\\"' + dataset_updated\\n + '\\\"^^xsd:dateTime ;\\\\n\\\\tdc:creator \\\"' + dataset_source + '\\\" .\\\\n\\\\n')\\n\\n # Generating Codelist\\n\\n # Codelist: Conceptscheme\\n\\n for index, data_field_nm in enumerate(dimensions['id']):\\n code_list.append('' + data_namespace_prefix + 'schm:' +\\n _cleanString(data_field_nm) + ' a skos:ConceptScheme ;\\\\n\\\\t')\\n\\n skos_members = []\\n for k in dimensions[data_field_nm]['category']['index'].keys():\\n concept = dimensions[data_field_nm]['category']['label'][k]\\n\\n skos_members.append(\\n 'skos:member ' + _prefix_build_concept(data_namespace_prefix, data_field_nm) + _cleanString(\\n concept) + ' ')\\n\\n code_list.append(';\\\\n\\\\t'.join(skos_members) + '.\\\\n\\\\n')\\n\\n # Codelist: Concepts\\n\\n for data_field_nm in dimensions['id']:\\n\\n for k in dimensions[data_field_nm]['category']['index'].keys():\\n concept = dimensions[data_field_nm]['category']['label'][k]\\n code_list.append(\\n '' + self._prefix_build_concept(data_namespace_prefix, data_field_nm) + self._cleanString(concept) +\\n ' a skos:Concept ;\\\\n\\\\trdfs:label \\\"' + concept + '\\\" .\\\\n\\\\n')\\n\\n # Generating Observations\\n\\n all_term = []\\n\\n for data_field_nm in dimensions['id']:\\n labels = []\\n\\n for k in dimensions[data_field_nm]['category']['index'].keys():\\n concept = dimensions[data_field_nm]['category']['label'][k]\\n labels.append(self._cleanString(concept))\\n\\n all_term.append(labels)\\n\\n size = dimensions['size']\\n total_size = 1\\n tracker = []\\n\\n for s in size:\\n tracker.append(0)\\n total_size *= s\\n\\n track_size = len(tracker)\\n\\n # Observations: creating each\\n\\n for t in range(total_size):\\n observations.append(data_namespace_prefix + ':' + str(\\n uuid.uuid4()) + ' a qb:Observation ;\\\\n\\\\tqb:dataSet ' + data_namespace_prefix + ':' +\\n _cleanString(dataset_label) + '_dataset ;\\\\n\\\\tqb:measureType ' +\\n vocabulary_namespace_prefix + ':value ;\\\\n\\\\t')\\n\\n for index, data_field_nm in enumerate(dimensions['id']):\\n observations.append('' + vocabulary_namespace_prefix + ':' + _cleanString(data_field_nm) + ' ')\\n observations.append(\\n '' + _prefix_build_concept(data_namespace_prefix, data_field_nm) + all_term[index][\\n tracker[index]] + ' ;\\\\n\\\\t')\\n\\n tracker[track_size - 1] += 1\\n\\n for i in range(track_size - 1, -1, -1):\\n if i != 0:\\n if tracker[i] > size[i] - 1:\\n tracker[i] = 0\\n tracker[i - 1] += 1\\n else:\\n if tracker[i] > size[i] - 1:\\n tracker[i] = 0\\n\\n observations.append('qb:measureType ' + vocabulary_namespace_prefix + ':value ;\\\\n\\\\t' +\\n vocabulary_namespace_prefix + ':value \\\"' +\\n str(dataset_values[t]) + '\\\"^^xsd:float\\\\n . \\\\n\\\\n')\\n\\n except Exception as e:\\n traceback.print_exc(file=sys.stdout)\\n logger.error(\\\"Errort status code - Mssg: {}\\\".format(str(e)))\\n job_result['status'] = 500\\n job_result['Error'] = str(e)\\n job_result['version'] = \\\"old\\\"\\n job_result['ErrorMessage'] = \\\"Something went wrong in the parsing json-stat to rdf. \\\" \\\\\\n \\\"Please ensure json stat in required format\\\"\\n\\n return job_result\\n\\n rdf_content = []\\n rdf_content.extend(scheme)\\n rdf_content.extend(code_list)\\n rdf_content.extend(observations)\\n job_result['status'] = 200\\n job_result['Error'] = \\\"None\\\"\\n job_result['version'] = \\\"old\\\"\\n job_result['SuccessMessage'] = \\\"RDF file is successfully created\\\"\\n job_result['rdf_content'] = \\\"\\\".join(rdf_content)\\n\\n return job_result\\n\\n def conversion_for_new_jstat_version():\\n\\n scheme = [\\n '@prefix qb: <http://purl.org/linked-data/cube#> .'\\n '\\\\n@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .'\\n '\\\\n@prefix skos: <http://www.w3.org/2004/02/skos/core#> .'\\n '\\\\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .'\\n '\\\\n@prefix prov: <http://www.w3.org/ns/prov#> .'\\n '\\\\n@prefix dc: <http://purl.org/dc/elements/1.1/> .'\\n '\\\\n@prefix ' + vocabulary_namespace_prefix + ': <' + vocabulary_namespace + '> .\\\\n@prefix '\\n + data_namespace_prefix + ': <' + data_namespace + '> .',\\n '\\\\n@prefix ' + data_namespace_prefix + 'schm: <' + data_namespace + 'conceptscheme/> .']\\n\\n code_list = ['#CODELIST\\\\n\\\\n']\\n observations = ['#OBSERVATIONS\\\\n\\\\n']\\n\\n dataset_label = source_json['label']\\n dataset_source = source_json['source']\\n dataset_updated = source_json['updated']\\n dimensions = source_json['dimension']\\n dataset_values = source_json['value']\\n field_nms = source_json['id']\\n\\n #### Building prefix\\n\\n for data_field_nm in field_nms:\\n scheme.append('\\\\n@prefix ' + data_namespace_prefix + _cleanString(\\n data_field_nm) + 'cpt: <' + data_namespace + 'concept/' + _cleanString(data_field_nm) + '/> .')\\n\\n scheme.append('\\\\n\\\\n#SCHEME\\\\n\\\\n')\\n\\n # Generating Scheme\\n\\n unit_index = source_json['id'].index('Units')\\n n1 = len(field_nms)\\n\\n try:\\n\\n # Scheme: Individual terms\\n\\n for data_field_nm in field_nms:\\n scheme.append('' + vocabulary_namespace_prefix + ':' + _cleanString(\\n data_field_nm) + ' a qb:ComponentProperty, qb:DimensionProperty ;\\\\n\\\\trdfs:label \\\"' + data_field_nm + '\\\" ;\\\\n\\\\trdfs:range xsd:string .\\\\n\\\\n')\\n\\n scheme.append(\\n '' + vocabulary_namespace_prefix + ':value a qb:ComponentProperty, qb:MeasureProperty ;'\\n '\\\\n\\\\trdfs:label \\\"value\\\" ;\\\\n\\\\trdfs:range xsd:float .\\\\n\\\\n')\\n\\n # Scheme: DSD\\n\\n scheme.append('' + data_namespace_prefix + ':' + _cleanString(\\n dataset_label) + '_dsd a qb:DataStructureDefinition ;\\\\n\\\\tqb:component\\\\n\\\\t\\\\t'\\n '[ a qb:ComponentSpecification ;\\\\n\\\\t\\\\t qb:codeList ' +\\n data_namespace_prefix + 'schm:measureType ; \\\\n\\\\t\\\\t qb:dimension qb:measureType ;'\\n '\\\\n\\\\t\\\\t qb:order 1 \\\\n\\\\t] ;\\\\n\\\\tqb:component [ qb:measure ' +\\n vocabulary_namespace_prefix + ':value ] ;\\\\n\\\\t')\\n\\n for index, data_field_nm in enumerate(field_nms):\\n if data_field_nm != 'Units':\\n scheme.append('qb:component\\\\n\\\\t\\\\t[ a qb:ComponentSpecification ;\\\\n\\\\t\\\\t qb:codeList '\\n + data_namespace_prefix + 'schm:' + _cleanString(data_field_nm) +\\n ' ;\\\\n\\\\t\\\\t qb:dimension ' + vocabulary_namespace_prefix + ':' +\\n _cleanString(data_field_nm) + ' ;\\\\n\\\\t\\\\t qb:order ' + str(\\n index + 2) + ' \\\\n\\\\t\\\\t] ')\\n if index == n1 - 1:\\n scheme.append('\\\\n.\\\\n\\\\n')\\n else:\\n scheme.append(';\\\\n\\\\t')\\n\\n # Scheme: Dataset\\n\\n scheme.append('' + data_namespace_prefix + ':' + _cleanString(dataset_label) +\\n '_dataset a qb:DataSet ;\\\\n\\\\tqb:structure ' + data_namespace_prefix + ':' +\\n _cleanString(dataset_label) + '_dsd ;\\\\n\\\\trdfs:label \\\"' + \\\\\\n dataset_label + '\\\" ; \\\\n\\\\tprov:generatedAtTime \\\"' + dataset_updated\\n + '\\\"^^xsd:dateTime ;\\\\n\\\\tdc:creator \\\"' + dataset_source + '\\\" .\\\\n\\\\n')\\n\\n # Generating Code list\\n\\n # Code list: Conceptscheme\\n\\n for data_field_nm in field_nms:\\n if data_field_nm != 'Units':\\n code_list.append('' + data_namespace_prefix + 'schm:' +\\n _cleanString(data_field_nm) + ' a skos:ConceptScheme ;\\\\n\\\\t')\\n\\n skos_members = []\\n for k in dimensions[data_field_nm]['category']['index'].keys():\\n concept = dimensions[data_field_nm]['category']['label'][k]\\n # print(concept)\\n\\n skos_members.append(\\n 'skos:member ' + _prefix_build_concept(data_namespace_prefix,\\n data_field_nm) + _cleanString(\\n concept) + ' ')\\n\\n code_list.append(';\\\\n\\\\t'.join(skos_members) + '.\\\\n\\\\n')\\n\\n # Code list: Concepts\\n\\n for data_field_nm in field_nms:\\n if data_field_nm != 'Units':\\n\\n for k in dimensions[data_field_nm]['category']['index'].keys():\\n concept = dimensions[data_field_nm]['category']['label'][k]\\n code_list.append(\\n '' + _prefix_build_concept(data_namespace_prefix, data_field_nm) + _cleanString(\\n concept) +\\n ' a skos:Concept ;\\\\n\\\\trdfs:label \\\"' + concept + '\\\" .\\\\n\\\\n')\\n\\n # Generating Observations\\n\\n all_term = []\\n for data_field_nm in field_nms:\\n if data_field_nm != 'Units':\\n labels = []\\n for k in dimensions[data_field_nm]['category']['index'].keys():\\n concept = dimensions[data_field_nm]['category']['label'][k]\\n labels.append(self._cleanString(concept))\\n\\n all_term.append(labels)\\n\\n size = source_json['size']\\n del size[unit_index]\\n total_size = 1\\n tracker = []\\n\\n for s in size:\\n tracker.append(0)\\n total_size *= s\\n\\n track_size = len(tracker)\\n\\n # Observations: creating each\\n\\n for t in range(total_size):\\n observations.append(data_namespace_prefix + ':' + str(\\n uuid.uuid4()) + ' a qb:Observation ;\\\\n\\\\tqb:dataSet ' + data_namespace_prefix + ':' +\\n _cleanString(dataset_label) + '_dataset ;\\\\n\\\\tqb:measureType ' +\\n vocabulary_namespace_prefix + ':value ;\\\\n\\\\t')\\n\\n cnt_all = 0\\n\\n for data_field_nm in field_nms:\\n\\n if data_field_nm != 'Units':\\n observations.append('' + vocabulary_namespace_prefix + ':'\\n + self._cleanString(data_field_nm) + ' ')\\n observations.append('' + self._prefix_build_concept(data_namespace_prefix, data_field_nm) +\\n all_term[cnt_all][tracker[cnt_all]] + ' ;\\\\n\\\\t')\\n cnt_all += 1\\n\\n tracker[track_size - 1] += 1\\n\\n for i in range(track_size - 1, -1, -1):\\n if i != 0:\\n if tracker[i] > size[i] - 1:\\n tracker[i] = 0\\n tracker[i - 1] += 1\\n else:\\n if tracker[i] > size[i] - 1:\\n tracker[i] = 0\\n\\n observations.append('qb:measureType ' + vocabulary_namespace_prefix + ':value ;\\\\n\\\\t' +\\n vocabulary_namespace_prefix + ':value \\\"' +\\n str(dataset_values[t]) + '\\\"^^xsd:float\\\\n . \\\\n\\\\n')\\n\\n except Exception as e:\\n traceback.print_exc(file=sys.stdout)\\n logger.error(\\\"Errort status code - Mssg: {}\\\".format(str(e)))\\n job_result['status'] = 500\\n job_result['Error'] = str(e)\\n job_result['version'] = \\\"New\\\"\\n job_result['Message'] = \\\"Something went wrong in parsing the json-stat to RDF\\\"\\n\\n return job_result\\n\\n rdf_content = []\\n rdf_content.extend(scheme)\\n rdf_content.extend(code_list)\\n rdf_content.extend(observations)\\n job_result['status'] = 200\\n job_result['Error'] = \\\"None\\\"\\n job_result['version'] = \\\"New\\\"\\n job_result['SuccessMessage'] = \\\"RDF file is successfully created\\\"\\n job_result['rdf_content'] = \\\"\\\".join(rdf_content)\\n\\n return job_result\\n\\n # Check for the version of the json-stat file\\n\\n if \\\"version\\\" in source_json.keys():\\n return conversion_for_new_jstat_version()\\n else:\\n return conversion_for_old_jstat_version()\",\n \"def initialize_data(self , station = '', datasets = {} ):\\n \\n self.datasets = datasets\\n self.datasets_keys = datasets.keys()\\n self.station = station\\n \\n data = {} # container for the data of each dataset\\n source_configuration = {} # container for the source_configuration of each dataset\\n \\n\\n \\n \\\"\\\"\\\" Looping over the datasets \\\"\\\"\\\"\\n logging.info('*** Reading and Initializing the data from the netCDF files ')\\n \\n \\n for k,v in datasets.items() :\\n logging.info(' Initialising the dataset: *** %s ' , k )\\n data[k] = {} \\n data['cdm_tables'] = {} \\n \\n ### alternative with xarray \\n #ds = xr.load_dataset(v) \\n #observations_table = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \\n \\n ### alternative with netCDF4\\n #ds = nc.Dataset(v) \\n #data[k]['dateindex'] = ds.variables['dateindex'][0,:] # storing the dateindex \\n \\n ###for h5py but cant extract date time units !!!\\n ds = h5py.File(v , driver=\\\"core\\\" ) \\n data[k]['df'] = ds # storing the entire file \\n try: \\n data[k]['source_file'] = ds['source_configuration']['source_file'][0]\\n except:\\n data[k]['source_file'] = str(v) # temp fix \\n \\n #data[k]['product_code'] = ds['source_configuration']['product_code'][0] \\n #data[k]['recordtimestamp'] = ds['recordtimestamp'].value\\n #data[k]['recordindex'] = ds['recordindex'].value \\n #ds.close() \\n logging.debug('Reading the file with h5py ')\\n \\n \\n # add here appending datasets for the case of ncar_w and ncar_t \\n \\n \\n self.data = data\\n self.make_dataframe()\\n ds.close()\\n \\n \\\"\\\"\\\" Reading the header_table, station_configuration, source_configuration \\\"\\\"\\\"\\n for k,v in datasets.items() : \\n \\n #d = xr.open_dataset(v , engine = 'h5netcdf' ) \\n #data[k]['recordtimestamp'] = d['recordtimestamp'].values\\n #data[k]['recordindex'] = d['recordindex'].values \\n \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'station_configuration') \\n data[k]['station_configuration'] = d.to_dataframe() \\n #data[k]['station_configuration'] = d ### USELESS ? \\n logging.debug('Done with %s station_configuration' , str(k) )\\n \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'header_table') \\n logging.debug('Loading the header_table') \\n if 'header_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\\n self.attributes['header_table'] = {}\\n for var in d.variables:\\n self.attributes['header_table'][var] = {}\\n self.attributes['header_table'][var]['description'] = d[var].description\\n self.attributes['header_table'][var]['external_table'] = d[var].external_table \\n data[k]['header_table'] = d.to_dataframe() \\n logging.debug('Done with %s ' , k )\\n \\n logging.info(\\\"*** Loading the observations_table (might take time) %s\\\" , k ) \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \\n \\n if 'observations_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\\n self.attributes['observations_table'] = {}\\n for var in d.variables:\\n self.attributes['observations_table'][var] = {}\\n self.attributes['observations_table'][var]['description'] = d[var].description\\n self.attributes['observations_table'][var]['external_table'] = d[var].external_table\\n \\n \\n logging.info(\\\"*** Loading the source configuration %s\\\" , k ) \\n try: \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'source_configuration')\\n d = d.isel(hdrlen=[0])\\n data[k]['source_configuration'] = d.to_dataframe() ### USELESS ? \\n logging.debug('Done with %s source_configuration' , k )\\n except: \\n data[k]['source_configuration']= pd.DataFrame(np.array( [ [ self.data[k]['source_file'] ] ] ) , columns=['source_file'] ) \\n \\n if k == 'era5_1': # reading the whole era5_1 feedback (including reanalysis)\\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'era5fb') \\n data[k]['era5fb'] = d.to_dataframe() \\n logging.debug('Done with %s era5 feedback ', k )\\n \\n \\\"\\\"\\\" Reading the CDM tables that do not depend on specific stations or observations (fixed values), for the first file only \\\"\\\"\\\" \\n if list(datasets.keys()).index(k) == 0 :\\n for t in [ 'crs' , 'observed_variable', 'units' , 'z_coordinate_type' , 'station_type']: \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = t) \\n #data['cdm_tables'][t] = d.to_dataframe() ### USELESS ?\\n data['cdm_tables'][t] = d \\n \\n d.close() \\n ds.close()\\n\\n \\\"\\\"\\\" Reading the name of the original source file \\\"\\\"\\\"\\n source_configuration[k] = {} \\n source_configuration[k]['source_file'] = [ c for c in v.split('/') if '.nc' in c][0]\\n\\n \\n \\\"\\\"\\\" Storing the station configurations \\\"\\\"\\\" \\n self.source_configuration = source_configuration \\n \\n \\\"\\\"\\\" Making all date_times \\\"\\\"\\\" \\n self.make_all_datetime()\\n \\n \\n \\\"\\\"\\\" feedback columns \\\"\\\"\\\"\\n if 'era5_1' in list (self.data.keys() ):\\n self.fb_columns = list(self.data['era5_1']['era5fb'].columns ) \\n else:\\n self.fb_columns = ['empty']\",\n \"def main():\\n with open(IMAGEPATH_LIST_PATH, \\\"rt\\\") as imagepath_list_handle:\\n imagepath_list = [line.strip() for line in imagepath_list_handle.readlines()]\\n\\n object_detector = ObjectDetector(MODEL_PATH)\\n\\n dataset_json = []\\n for imagepath in imagepath_list:\\n image = scipy.misc.imread(imagepath)\\n detections = object_detector.run(image)\\n\\n detections_json = {\\\"path\\\": imagepath, \\\"detections\\\": [det.to_dict() for det in detections]}\\n dataset_json.append(detections_json)\\n\\n with open(DATASET_PATH, \\\"wt\\\") as json_handle:\\n json.dump(dataset_json, json_handle, sort_keys=True, indent=4)\",\n \"def __init__(self, dataset):\\n\\n self.input_names = ['CORCON_nv_lwc_vcol',\\n 'CORCON_nv_lwc_icol',\\n 'CORCON_nv_lwc_vref',\\n 'CORCON_nv_lwc_iref',\\n 'CORCON_nv_twc_vcol',\\n 'CORCON_nv_twc_icol',\\n 'CORCON_nv_twc_vref',\\n 'CORCON_nv_twc_iref',\\n 'TAS_RVSM',\\n 'IAS_RVSM',\\n 'PS_RVSM',\\n 'WOW_IND',\\n 'CLWCIREF', 'CLWCVREF', 'CLWCICOL', 'CLWCVCOL',\\n 'CTWCIREF', 'CTWCVREF', 'CTWCICOL', 'CTWCVCOL',\\n 'CALNVTWC',\\n 'CALNVLWC1',\\n 'CALNVLWC2',\\n 'CALNVL']\\n\\n self.outputs = [parameter('NV_TWC_U',\\n units='gram m-3',\\n frequency=64,\\n long_name='Uncorrected total condensed water content from the Nevzorov probe'),\\n parameter('NV_LWC1_U',\\n units='gram m-3',\\n frequency=64,\\n long_name='Uncorrected liquid water content from the Nevzorov probe (1st collector)',\\n standard_name='mass_concentration_of_liquid_water_in_air'),\\n parameter('NV_LWC2_U',\\n units='gram m-3',\\n frequency=64,\\n long_name='Uncorrected liquid water content from the Nevzorov probe (2nd collector)',\\n standard_name='mass_concentration_of_liquid_water_in_air'),\\n parameter('NV_TWC_C',\\n units='gram m-3',\\n frequency=64,\\n long_name='Corrected total condensed water content from the Nevzorov probe'),\\n parameter('NV_LWC1_C',\\n units='gram m-3',\\n frequency=64,\\n long_name='Corrected liquid water content from the Nevzorov probe (1st collector)',\\n standard_name='mass_concentration_of_liquid_water_in_air'),\\n parameter('NV_LWC2_C',\\n units='gram m-3',\\n frequency=64,\\n long_name='Corrected liquid water content from the Nevzorov probe (2nd collector)',\\n standard_name='mass_concentration_of_liquid_water_in_air'),\\n parameter('NV_TWC_P',\\n units='W',\\n frequency=64,\\n long_name='TWC collector power'),\\n parameter('NV_LWC1_P',\\n units='W',\\n frequency=64,\\n long_name='LWC1 collector power'),\\n parameter('NV_LWC2_P',\\n units='W',\\n frequency=64,\\n long_name='LWC2 collector power'),\\n parameter('NV_REF_P',\\n units='W',\\n frequency=64,\\n long_name='Reference power')]\\n\\n self.version = 1.00\\n cal_base.__init__(self, dataset)\",\n \"def convert_pixel_map_COCO_type(element: np.ndarray) -> Dict:\\n p = maskUtils.encode(np.asfortranarray(element).astype(np.uint8))\\n return p\",\n \"def load_cci9():\\n cci9 = pd.read_csv(pkg_resources.resource_filename(__name__,'cci2015.csv'),skiprows=1)\\n cci9.columns = [i.strip('\\\\'') for i in cci9.columns]\\n \\n for col in cci9.columns:\\n cci9.loc[:,col] = cci9[col].str.strip('\\\\'')\\n cci9 = cci9.replace(r'^\\\\s*$', np.nan, regex=True)\\n cci9.columns=[i.replace('CATEGORY DESCRIPTION','CHRONIC') for i in cci9.columns]\\n\\n dict_bodysystem=[\\n ('1' ,'Infectious and parasitic disease'),\\n ('2' ,'Neoplasms'),\\n ('3' ,'Endocrine, nutritional, and metabolic diseases and immunity disorders'),\\n ('4' ,'Diseases of blood and blood-forming organs'),\\n ('5' ,'Mental disorders'),\\n ('6' ,'Diseases of the nervous system and sense organs'),\\n ('7' ,'Diseases of the circulatory system'),\\n ('8' ,'Diseases of the respiratory system'),\\n ('9' ,'Diseases of the digestive system'),\\n ('10','Diseases of the genitourinary system'),\\n ('11','Complications of pregnancy, childbirth, and the puerperium'),\\n ('12','Diseases of the skin and subcutaneous tissue'),\\n ('13','Diseases of the musculoskeletal system'),\\n ('14','Congenital anomalies'),\\n ('15','Certain conditions originating in the perinatal period'),\\n ('16','Symptoms, signs, and ill-defined conditions'),\\n ('17','Injury and poisoning'),\\n ('18','Factors influencing health status and contact with health service'),\\n ]\\n \\n cci9 = cci9.merge(pd.DataFrame(dict_bodysystem,columns=['BODY SYSTEM','BODY SYSTEM DESCRIPTION']),how='left',on='BODY SYSTEM')\\n \\n cci9.loc[:,'ICD-9-CM CODE'] = cci9['ICD-9-CM CODE'].str.replace(' ','')\\n \\n return cci9\",\n \"def load_cci10():\\n \\n cci10 = pd.read_csv(pkg_resources.resource_filename(__name__,'cci_icd10cm_2019_1.csv'))\\n \\n cci10.columns = [i.strip('\\\\'') for i in cci10.columns]\\n \\n for col in cci10.columns:\\n cci10.loc[:,col] = cci10[col].str.strip('\\\\'')\\n cci10 = cci10.replace(r'^\\\\s*$', np.nan, regex=True)\\n cci10.columns = [i.replace('CHRONIC INDICATOR','CHRONIC') for i in cci10.columns]\\n \\n dict_bodysystem = [\\n ('1','Infectious and parasitic disease'),\\n ('2','Neoplasms'),\\n ('3','Endocrine, nutritional, and metabolic diseases and immunity disorders'),\\n ('4','Diseases of blood and blood-forming organs'),\\n ('5','Mental disorders'),\\n ('6','Diseases of the nervous system and sense organs'),\\n ('7','Diseases of the circulatory system'),\\n ('8','Diseases of the respiratory system'),\\n ('9','Diseases of the digestive system'),\\n ('10','Diseases of the genitourinary system'),\\n ('11','Complications of pregnancy, childbirth, and the puerperium'),\\n ('12','Diseases of the skin and subcutaneous tissue'),\\n ('13','Diseases of the musculoskeletal system'),\\n ('14','Congenital anomalies'),\\n ('15','Certain conditions originating in the perinatal period'),\\n ('16','Symptoms, signs, and ill-defined conditions'),\\n ('17','Injury and poisoning'),\\n ('18','Factors influencing health status and contact with health services'),\\n ]\\n \\n cci10 = cci10.merge(pd.DataFrame(dict_bodysystem,columns=['BODY SYSTEM','BODY SYSTEM DESCRIPTION']),how='left',on='BODY SYSTEM')\\n \\n cci10.loc[:,'ICD-10-CM CODE'] = cci10['ICD-10-CM CODE'].str.replace(' ','')\\n \\n return cci10\",\n \"def characterize_object(obj_name, obj_data):\\n if isinstance(obj_data, h5py.Dataset):\\n summary['shapes'][obj_name] = obj_data.shape\\n # note that this will break if the hdf5 file contains non-numeric datasets\\n summary['sums'][obj_name] = obj_data[...].sum()\\n print(\\\"dataset %s version = %s\\\" % (obj_name, hdf5_file.get_version(obj_name)))\",\n \"def generate_dataset():\\n if not os.path.exists(\\\"../data/COVID-19/COVID-19.npy\\\"):\\n print(\\\"Processing Training Data.\\\")\\n training_data = get_training_data('../data/COVID-19/train')\\n print(\\\"Processing Test Data.\\\")\\n test_data = get_training_data('../data/COVID-19/test')\\n\\n x_train, y_train, x_test, y_test = [], [], [], []\\n\\n for feature, label in training_data:\\n x_train.append(feature)\\n y_train.append(label)\\n\\n for feature, label in test_data:\\n x_test.append(feature)\\n y_test.append(label)\\n\\n # Normalize the data\\n x_train = np.array(x_train) / 255\\n x_test = np.array(x_test) / 255\\n\\n # resize data for deep learning\\n x_train = x_train.reshape(-1, 3, img_size, img_size)\\n y_train = np.array(y_train)\\n x_test = x_test.reshape(-1, 3, img_size, img_size)\\n y_test = np.array(y_test)\\n\\n # With data augmentation to prevent overfitting and handling the imbalance in dataset\\n dataset = {\\\"x_train\\\": x_train, \\\"y_train\\\": y_train, \\\"x_test\\\": x_test, \\\"y_test\\\": y_test}\\n np.save(\\\"../data/COVID-19/COVID-19.npy\\\", dataset)\\n else:\\n dataset = np.load(\\\"../data/COVID-19/COVID-19.npy\\\", allow_pickle=True).item()\\n x_train, y_train, x_test, y_test = dataset[\\\"x_train\\\"], dataset[\\\"y_train\\\"], dataset[\\\"x_test\\\"], dataset[\\\"y_test\\\"]\\n\\n x_train_tensor = torch.from_numpy(x_train)\\n x_train_tensor = x_train_tensor.type(torch.FloatTensor)\\n y_train_tensor = torch.from_numpy(y_train)\\n y_train_tensor = y_train_tensor.type(torch.LongTensor)\\n x_test_tensor = torch.from_numpy(x_test)\\n x_test_tensor = x_test_tensor.type(torch.FloatTensor)\\n y_test_tensor = torch.from_numpy(y_test)\\n y_test_tensor = y_test_tensor.type(torch.LongTensor)\\n\\n train_dataset = TensorDataset(x_train_tensor, y_train_tensor)\\n test_dataset = TensorDataset(x_test_tensor, y_test_tensor)\\n\\n return train_dataset, test_dataset\",\n \"def make_odb_header(odbfile, dataset):\\n \\n header = 'headers/' + dataset + '_header.dat'\\n \\n if not os.path.isfile ( header ):\\n print(' Creating the header file for the dataset: ', dataset )\\n if dataset in ('era5_1','era5_2'):\\n \\n odbfile = odbfile.replace('.gz','')\\n else:\\n odbfile = odbfile.replace('.gz','').replace('.conv._','.conv.')\\n \\n rdata=subprocess.check_output([\\\"odb\\\",\\\"header\\\", odbfile ])\\n \\n with open( header , 'wb' ) as f:\\n f.write(rdata) \\n \\n f = open(header , 'rb')\\n rdata=f.read()\\n rdata=rdata.decode('utf-8').split('\\\\n') \\n \\n else:\\n f = open(header , 'rb')\\n rdata=f.read()\\n rdata=rdata.decode('utf-8').split('\\\\n')\\n #print(' Done reading the existing header file for the dataset: ', dataset )\\n \\n columns, kinds, tdict =[] , [] , {} \\n \\n for r in rdata[2:-2]:\\n try:\\n \\n if r[:6]=='Header':\\n break\\n else: \\n columns.append(r.split('name: ')[1].split(',')[0])\\n kinds.append(r.split('type: ')[1].split(',')[0])\\n if kinds[-1]=='REAL':\\n tdict[columns[-1]]=numpy.float32\\n elif 'INTEGER' in kinds[-1] or 'BITFIELD' in kinds[-1]:\\n #print(columns[-1])\\n if columns[-1]=='sonde_type@conv' or columns[-1]=='station_type@conv':\\n tdict[columns[-1]]=numpy.float32\\n else: \\n tdict[columns[-1]]=numpy.int32\\n else:\\n tdict[columns[-1]]=numpy.dtype('S') # dict containng column name and type\\n \\n except IndexError:\\n pass \\n \\n \\\"\\\"\\\" This is done otherwise for the era5 databases (1759,1761,3188) the tdict has different length than the columns list.\\n So the following call alldict=pd.read_csv(f,delimiter='\\\\t', usecols=columns, quoting=3,comment='#', skipinitialspace=True, dtype=tdict) breaks \\\"\\\"\\\" \\n for t in tdict.keys():\\n if t not in columns:\\n #print(\\\"Removing non appearing fb column: \\\" , c) \\n del tdict[t]\\n \\n \\\"\\\"\\\" These values must be removed rom the fb, since they have NULL values and it creates problem with \\n alldict=pd.read_csv(f,delimiter='\\\\t', usecols=columns, quoting=3,comment='#', skipinitialspace=True, dtype=tdict) \\\"\\\"\\\" \\n \\n if dataset in [\\\"era5_1759\\\", \\\"era5_1761\\\", \\\"era5_3188\\\"]:\\n remove = ['sonde_type@conv' , \\\"eda_spread@errstat\\\", \\\"bias_volatility@body\\\" , \\\"timeseries_index@conv\\\"]\\n for c in remove:\\n #print(\\\"Removing wrong fb column: \\\" , c)\\n try:\\n columns.remove(c)\\n del tdict[c]\\n except:\\n pass\\n return columns, kinds, tdict\",\n \"def _load_obcfile(casename=None): \\n\\n data={}\\n\\n if casename==None:\\n print('_load_obcfile requires a filename to load.')\\n return\\n try:\\n fp=open(casename+'_obc.dat','r')\\n except IOError:\\n print('_load_obcfile: invalid case name.')\\n return data\\n\\n obc_str=fp.readline().split('=')\\n obc_num=int(obc_str[1])\\n t_data1=np.genfromtxt(casename+'_obc.dat',skip_header=1)\\n fp.close()\\n\\n data['obcf_num']=obc_num\\n data['obcf_numbers']=t_data1[:,0]\\n data['obcf_nodes']=t_data1[:,1]\\n data['obcf_value']=t_data1[:,2]\\n\\n \\n return data\",\n \"def read_cbf_file(inputfilename):\\n \\n \\n with open(inputfilename, 'rb') as fid:\\n BD = np.fromfile(fid, np.float64)\\n \\n # https://www.mathworks.com/help/matlab/ref/fwrite.html\\n # https://www.mathworks.com/help/matlab/numeric-types.html\\n \\n k=0;\\n # Static data (100 places)\\n SD=BD[k:k+100]\\n k=k+100\\n # Priors (50 places)\\n PR=BD[k:k+50];\\n k=k+50;\\n # Priorunc (50 places)\\n PRU=BD[k:k+50]\\n k=k+50 \\n \\n # O. Priors (50 places)\\n OPR=BD[k:k+50]\\n k=k+50\\n # O. Priorunc (50 places)\\n OPRU=BD[k:k+50]\\n k=k+50\\n \\n CBF = {}\\n CBF['PARPRIORS'] = np.expand_dims(PR,axis=1)\\n CBF['PARPRIORUNC'] = np.expand_dims(PRU,axis=1)\\n CBF=read_other_obs_constraints(CBF,OPR,OPRU)\\n \\n CBF['ID'] = SD[0] # ID (not used)\\n CBF['LAT'] = SD[1] # Latitude\\n CBF['nodays'] = int(SD[2]) # Number of days\\n CBF['nomet'] = int(SD[3])\\n CBF['noobs'] =int(SD[4])\\n CBF['EDC'] = SD[5]\\n CBF['EDCDIAG'] = SD[6]\\n# CBF = {'PARPRIORS':np.expand_dims(PR,axis=1), \\n# 'PARPRIORUNC':np.expand_dims(PRU,axis=1), \\n# 'OTHERPRIORS':np.expand_dims(OPR,axis=1), #\\n# 'OTHERPRIORSUNC':np.expand_dims(OPRU,axis=1),\\n# 'ID':SD[0], # ID (not used)\\n# 'LAT':SD[1], # Latitude\\n# 'nodays':int(SD[2]), # Number of days\\n# 'nomet':int(SD[3]), \\n# 'noobs':int(SD[4]),\\n# 'EDC':SD[5],\\n# 'EDCDIAG':SD[6],\\n# 'gppabs':SD[7],\\n# 'rc_random_search':SD[10]==1,\\n# 'nbe_annual_unc':SD[13],\\n# 'etiav':SD[14],\\n# 'nbe_seasonal_unc':SD[15]}\\n \\n #MCMC start searching EDCs from anywhere (1) or from prescribed starting\\n #point(0). this is outdated - consider deleting\\n CBF['rc_random_search'] = SD[10]==1\\n \\n #NEE IAV options\\n CBF=read_obs_uncertainty_fields(CBF,SD,OPRU)\\n \\n \\n TEMPDATA=BD[k:k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']].reshape(CBF['nodays'],\\n (CBF['nomet']+CBF['noobs']))\\n #All met data\\n CBF['MET'] = TEMPDATA[0:CBF['nodays'],0:CBF['nomet']] # Add in new meteorology here\\n# CBF['OBS'] = TEMPDATA[0:CBF['nodays'],CBF['nomet']:]\\n CBFOBS = TEMPDATA[0:CBF['nodays'],CBF['nomet']:]\\n CBF=define_cbf_obs_fields(CBF,CBFOBS)\\n \\n #Removing redundant fields\\n# CBF=rmfield(CBF,'noobs');\\n# # CBF=rmfield(CBF,'nomet');\\n# # CBF=rmfield(CBF,'nodays');\\n \\n \\n # Read prescribed mean meteorology\\n \\n if len(BD) - (k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']) == CBF['nomet'] + CBF['noobs']:\\n \\n kmmet= k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']\\n CBF['mmet'] = BD[kmmet:kmmet+CBF['nomet']]\\n \\n \\n #Retaining \\\"OTHERPRIORS\\\" for now\\n CBF['RAW'] = {}\\n CBF['RAW']['OTHERPRIORS']=OPR;\\n CBF['RAW']['OTHERPRIORSUNC']=OPRU;\\n CBF['RAW']['info']='Raw inputs/outputs as stored in CBF binary structure';\\n CBF['RAW']['details']='For completeness & development purpose only; When re-writing CBF to file, these are over-written by CBF.OBS, etc.';\\n\\n \\n \\n \\n \\n return CBF\\n #disp(sprintf('CHECK: .cbf file \\\"%s\\\" successfully read into matlab.',filename)) \",\n \"def main() -> Dict[int, int]:\\n # DOCUMENTS DIRECTORY\\n # Path of the directory that contains the .txt documents. One .txt document by company. IT NEEDS TO BE \\\"/data\\\" when you upload it in data challenge platform. For test in local, you can modifiy to match your data path.\\n if dev:\\n documents_directory = \\\"../example_dataset/data\\\"\\n else: \\n documents_directory = \\\"/data\\\"\\n\\n path_to_files: List[str] = [os.path.join(documents_directory, file) for file in os.listdir(documents_directory)]\\n assert len(path_to_files) == 10 # 10 files in documents directory\\n path_to_files.sort() # Sort list of path file by alphabetical order to match ground truth annotations order : IT IS ESSENTIAL.\\n\\n # INITIALIZATION OF YOUR OBJECTS\\n data_model = FormDataModel.from_json_file(\\n os.path.join(os.path.dirname(__file__), \\\"resources\\\", \\\"data-model.json\\\")\\n )\\n country_referential = CountryReferential.from_csv(\\n os.path.join(os.path.dirname(__file__), \\\"resources\\\", \\\"countries_code.csv\\\")\\n )\\n form_company_filling = FormCompanyFilling([\\n BasicExtractor(\\n question_ids=NOT_COUNTRY_QUESTIONS_NUMBERS,\\n form_data_model=data_model,\\n ),\\n BasicCountryExtractor(\\n question_ids=COUNTRY_QUESTIONS_NUMBERS,\\n form_data_model=data_model,\\n country_code_referential=country_referential,\\n\\n )\\n ])\\n\\n # COMPUTE PREDICTION BY FILE (ie company)\\n print(\\\"##################################\\\")\\n print(\\\"RUNNING PREDICTION\\\")\\n results: Dict[int, int] = {}\\n start_time = time.time()\\n for i, path in enumerate(path_to_files):\\n start = time.time()\\n print(f\\\"File : {path}\\\")\\n with open(path, \\\"r\\\") as input_file:\\n text = input_file.read()\\n print(\\\"... Encoding ...\\\")\\n start_encoding = time.time()\\n embeddings = model.encode(prepare_sentences(text))\\n # embeddings = []\\n print(\\\"Successfully encoded\\\")\\n print(\\\"Encoding time : \\\", time.time() - start_encoding)\\n\\n form_company_response = form_company_filling.fill(text, embeddings, model)\\n form_company_response.sort_by_question_id() # ESSENTIAL : Sort the response by question number for each company\\n for answer in form_company_response.answers:\\n question_number = answer.question_id + i * 22 # ESSENTIAL : each company has 22 questions. Each question_number in results should be unique\\n results[question_number] = answer.answer_id\\n # gc.collect()\\n print(\\\"File time :\\\", time.time()-start, '\\\\n')\\n # CHECK FORMAT RESULTS IS DATACHALLENGE PLATFORM COMPATIBLE\\n assert len(results) == len(path_to_files) * (len(COUNTRY_QUESTIONS_NUMBERS) + len(NOT_COUNTRY_QUESTIONS_NUMBERS))\\n assert set(list(results.keys())) == {i for i in range(1,221)}\\n print(\\\"Full Time\\\", time.time()-start_time)\\n return results\",\n \"def convert(data):\\n NODES, EDGES = {}, {}\\n\\n for duid, entity in data['entity'].iteritems():\\n if entity['entityType'] == 'Trigger':\\n continue\\n if Node.add(duid, NODES):\\n NODES[duid].Label = entity['entityText']\\n NODES[duid].source = entity['source']\\n NODES[duid].json = json.dumps(entity)\\n\\n for duid, relation in data['relation'].iteritems():\\n duid = relation['duid']\\n sn, tn = None, None\\n if relation['source'] == 'miRTex':\\n sn, tn = tm.mirtex.cytoscape_relation_args(relation)\\n # elif relation['source'] == 'RLIMS-P':\\n # sn, tn = tm.rlims.cytoscape_relation_args(relation)\\n if sn not in NODES or tn not in NODES:\\n continue\\n if Edge.add(duid, sn, tn, relation['relationType'], EDGES):\\n EDGES[duid].json = json.dumps(relation)\\n\\n return dump_network(NODES, EDGES)\",\n \"def load_coco(self, dataset_dir, subset, year=DEFAULT_DATASET_YEAR, class_ids=None, class_names=None,\\n class_map=None, return_coco=False, auto_download=False):\\n\\n if auto_download is True:\\n self.auto_download(dataset_dir, subset, year)\\n\\n coco = COCO(\\\"{}/annotations/instances_{}{}.json\\\".format(dataset_dir, subset, year))\\n if subset == \\\"minival\\\" or subset == \\\"valminusminival\\\":\\n subset = \\\"val\\\"\\n image_dir = \\\"{}/{}{}\\\".format(dataset_dir, subset, year)\\n\\n # Select class_ids from class_names:\\n if class_names:\\n class_ids = sorted(coco.getCatIds(catNms=class_names))\\n\\n # Load all classes or a subset?\\n if not class_ids:\\n # All classes\\n class_ids = sorted(coco.getCatIds())\\n\\n # All images or a subset?\\n if class_ids:\\n image_ids = []\\n for id in class_ids:\\n imgs = [] # list of images to add to image_ids\\n # Select at most COCO_IMAGES_PER_OBJECT and select only the images\\n # that have at most COCO_MAX_NUM_MASK_PER_IMAGE masks inside them:\\n for imgid in list(coco.getImgIds(catIds=[id])):\\n if len(imgs) >= COCO_IMAGES_PER_OBJECT:\\n break\\n if len(coco.loadAnns(coco.getAnnIds(imgIds=[imgid], catIds=class_ids, iscrowd=None))) <= COCO_MAX_NUM_MASK_PER_IMAGE:\\n imgs.append(imgid)\\n image_ids.extend(imgs)\\n #image_ids.extend(list(coco.getImgIds(catIds=[id]))[:COCO_IMAGES_PER_OBJECT])\\n # Remove duplicates\\n image_ids = list(set(image_ids))\\n else:\\n # All images\\n image_ids = list(coco.imgs.keys())\\n\\n # Add classes\\n for i in class_ids:\\n self.add_class(\\\"coco\\\", i, coco.loadCats(i)[0][\\\"name\\\"])\\n\\n # Add images\\n for i in image_ids:\\n #print(len(coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None))))\\n self.add_image(\\n \\\"coco\\\", image_id=i,\\n path=os.path.join(image_dir, coco.imgs[i]['file_name']),\\n width=coco.imgs[i][\\\"width\\\"],\\n height=coco.imgs[i][\\\"height\\\"],\\n annotations=coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None)))\\n if return_coco:\\n return coco\",\n \"def coco_metrics(pred_data, anno_json, config):\\n from pycocotools.coco import COCO\\n from pycocotools.cocoeval import COCOeval\\n num_classes = config.num_classes\\n\\n #Classes need to train or test.\\n val_cls = config.classes\\n val_cls_dict = {}\\n for i, cls in enumerate(val_cls):\\n val_cls_dict[i] = cls\\n coco_gt = COCO(anno_json)\\n classs_dict = {}\\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\\n for cat in cat_ids:\\n classs_dict[cat[\\\"name\\\"]] = cat[\\\"id\\\"]\\n\\n predictions = []\\n img_ids = []\\n\\n for sample in pred_data:\\n pred_boxes = sample['boxes']\\n box_scores = sample['box_scores']\\n img_id = sample['img_id']\\n h, w = sample['image_shape']\\n\\n final_boxes = []\\n final_label = []\\n final_score = []\\n img_ids.append(img_id)\\n\\n for c in range(1, num_classes):\\n class_box_scores = box_scores[:, c]\\n score_mask = class_box_scores > config.min_score\\n class_box_scores = class_box_scores[score_mask]\\n class_boxes = pred_boxes[score_mask] * [h, w, h, w]\\n\\n if score_mask.any():\\n nms_index = apply_nms(class_boxes, class_box_scores, config.nms_threshold, config.max_boxes)\\n class_boxes = class_boxes[nms_index]\\n class_box_scores = class_box_scores[nms_index]\\n\\n final_boxes += class_boxes.tolist()\\n final_score += class_box_scores.tolist()\\n final_label += [classs_dict[val_cls_dict[c]]] * len(class_box_scores)\\n\\n for loc, label, score in zip(final_boxes, final_label, final_score):\\n res = {}\\n res['image_id'] = img_id\\n res['bbox'] = [loc[1], loc[0], loc[3] - loc[1], loc[2] - loc[0]]\\n res['score'] = score\\n res['category_id'] = label\\n predictions.append(res)\\n if not os.path.exists('./eval_out'):\\n os.makedirs('./eval_out')\\n with open('./eval_out/predictions.json', 'w') as f:\\n json.dump(predictions, f)\\n\\n coco_dt = coco_gt.loadRes('./eval_out/predictions.json')\\n E = COCOeval(coco_gt, coco_dt, iouType='bbox')\\n E.params.imgIds = img_ids\\n E.evaluate()\\n E.accumulate()\\n E.summarize()\\n return E.stats[0]\",\n \"def mscoco_read_json(file_path):\\n print(\\\"Reading mscoco raw data .. \\\")\\n print(\\\" data path: %s\\\" % file_path)\\n with open(file_path, \\\"r\\\") as fd:\\n data = json.load(fd)\\n\\n print(\\\"%d sentences in total\\\" % len(data[\\\"annotations\\\"]))\\n \\n # aggregate all sentences of the same images\\n image_idx = set([d[\\\"image_id\\\"] for d in data[\\\"annotations\\\"]])\\n paraphrases = {}\\n for im in image_idx: paraphrases[im] = []\\n for d in tqdm(data[\\\"annotations\\\"]):\\n im = d[\\\"image_id\\\"]\\n sent = d[\\\"caption\\\"]\\n paraphrases[im].append(sent)\\n\\n sentence_sets = [paraphrases[im] for im in paraphrases]\\n\\n return sentence_sets\",\n \"def __init__(self, data_array, cui2name):\\n\\t\\tassert isinstance(data_array, xr.DataArray), 'Constructor requires xr.DataArray.'\\n\\n\\t\\tself.data_array = data_array\\n\\t\\tself.data = self.data_array.values\\n\\t\\tself.sources = self.data_array.source.values\\n\\t\\tself.targets = self.data_array.target.values\\n\\t\\tself.metrics = self.data_array.metric.values\\n\\t\\tself.metapaths = self.data_array.metapath.values\\n\\n\\t\\t# Fetch the verbose names\\n\\t\\t#int_rf_df = pd.read_csv('data/impd_cogn_sources.tsv', delimiter='\\\\t')\\n\\t\\t#cui2name = {cui:name for cui, name in zip(int_rf_df.identifier, int_rf_df.name)} \\n\\t\\tself.source_names = np.array([cui2name[source] for source in self.sources])\",\n \"def decode_coco_detection_example(example, input_range=None):\\n image = tf.image.convert_image_dtype(example['image'], dtype=tf.float32)\\n\\n ### normalize\\n if input_range:\\n image = image * (input_range[1] - input_range[0]) + input_range[0]\\n else:\\n mean_rgb = tf.constant(MEAN_RGB, shape=[1, 1, 3], dtype=tf.float32)\\n std_rgb = tf.constant(STDDEV_RGB, shape=[1, 1, 3], dtype=tf.float32)\\n image = (image - mean_rgb) / std_rgb\\n\\n boxes = decode_boxes(example['objects']['bbox'], tf.shape(image)[0:2])\\n\\n target = {\\n 'area': example['objects']['area'],\\n 'boxes': boxes,\\n 'objects/id': example['objects']['id'],\\n 'is_crowd': example['objects']['is_crowd'],\\n 'labels': example['objects']['label'] + 1, # 0'th class is padding.\\n }\\n\\n # Filters objects to exclude degenerate boxes.\\n keep = tf.where(tf.logical_and(boxes[:, 2] > boxes[:, 0],\\n boxes[:, 3] > boxes[:, 1]))[:, 0]\\n target_kept = {k: tf.gather(v, keep) for k, v in target.items()}\\n target_kept = target\\n\\n target_kept['orig_size'] = tf.cast(tf.shape(image)[0:2], dtype=tf.int32)\\n target_kept['size'] = tf.identity(target_kept['orig_size'])\\n target_kept['image/id'] = example['image/id']\\n\\n return {\\n 'inputs': image,\\n 'label': target_kept,\\n }\",\n \"def load_kiba_dataset():\\n trainn_fold = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'folds', 'train_fold_setting1.txt')))\\n train_fold = []\\n for e in zip(*trainn_fold):\\n for ee in e:\\n train_fold.extend(ee)\\n #train_fold = [ee for e in trainn_fold for ee in e]\\n test_fold = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'folds', 'test_fold_setting1.txt')))\\n ligands = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'ligands_can.txt')),\\n object_pairs_hook=OrderedDict)\\n proteins = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'proteins.txt')),\\n object_pairs_hook=OrderedDict)\\n \\n affinity = pickle.load(open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'Y'), \\n 'rb'), encoding='latin1')\\n smiles_lst, protein_lst = [], []\\n\\n for k in ligands.keys():\\n smiles = ligands[k]\\n smiles_lst.append(smiles)\\n for k in proteins.keys():\\n protein_lst.append(proteins[k])\\n\\n affinity = np.asarray(affinity)\\n \\n os.makedirs(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'processed'), exist_ok=True)\\n train_test_dataset = []\\n for split in ['train', 'test']:\\n split_dir = os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'processed', split)\\n os.makedirs(split_dir, exist_ok=True)\\n fold = train_fold if split == 'train' else test_fold\\n rows, cols = np.where(np.isnan(affinity) == False)\\n rows, cols = rows[fold], cols[fold]\\n \\n data_lst = [[] for _ in range(1)]\\n for idx in range(len(rows)):\\n data = {}\\n data['smiles'] = smiles_lst[rows[idx]]\\n data['protein'] = protein_lst[cols[idx]]\\n af = affinity[rows[idx], cols[idx]]\\n data['aff'] = af\\n\\n data_lst[idx % 1].append(data)\\n random.shuffle(data_lst)\\n train_test_dataset.append(data_lst[0])\\n return train_test_dataset\",\n \"def _get_metadata(dataset, path_to_cdf):\\n metadata = []\\n cdf = cdflib.CDF(path_to_cdf)\\n if dataset=='SOHO_ERNE-HED_L2-1MIN' or dataset=='SOHO_ERNE-LED_L2-1MIN':\\n if dataset=='SOHO_ERNE-HED_L2-1MIN':\\n m = 'H'\\n if dataset=='SOHO_ERNE-LED_L2-1MIN':\\n m = 'L'\\n metadata = {'He_E_label': cdf.varget('He_E_label')[0],\\n 'He_energy': cdf.varget('He_energy'),\\n 'He_energy_delta': cdf.varget('He_energy_delta'),\\n f'A{m}_LABL': cdf.varattsget(f'A{m}')['LABLAXIS'],\\n f'A{m}_UNITS': cdf.varattsget(f'A{m}')['UNITS'],\\n f'A{m}_FILLVAL': cdf.varattsget(f'A{m}')['FILLVAL'],\\n 'P_E_label': cdf.varget('P_E_label')[0],\\n 'P_energy': cdf.varget('P_energy'),\\n 'P_energy_delta': cdf.varget('P_energy_delta'),\\n f'P{m}_LABL': cdf.varattsget(f'P{m}')['LABLAXIS'],\\n f'P{m}_UNITS': cdf.varattsget(f'P{m}')['UNITS'],\\n f'P{m}_FILLVAL': cdf.varattsget(f'P{m}')['FILLVAL'],\\n }\\n\\n channels_dict_df_He = pd.DataFrame(cdf.varget('He_E_label')[0], columns=['ch_strings'])\\n channels_dict_df_He['lower_E'] = cdf.varget(\\\"He_energy\\\")-cdf.varget(\\\"He_energy_delta\\\")\\n channels_dict_df_He['upper_E'] = cdf.varget(\\\"He_energy\\\")+cdf.varget(\\\"He_energy_delta\\\")\\n channels_dict_df_He['DE'] = cdf.varget(\\\"He_energy_delta\\\")\\n # channels_dict_df_He['mean_E'] = np.sqrt(channels_dict_df_He['upper_E'] * channels_dict_df_He['lower_E'])\\n channels_dict_df_He['mean_E'] = cdf.varget(\\\"He_energy\\\")\\n\\n channels_dict_df_p = pd.DataFrame(cdf.varget('P_E_label')[0], columns=['ch_strings'])\\n channels_dict_df_p['lower_E'] = cdf.varget(\\\"P_energy\\\")-cdf.varget(\\\"P_energy_delta\\\")\\n channels_dict_df_p['upper_E'] = cdf.varget(\\\"P_energy\\\")+cdf.varget(\\\"P_energy_delta\\\")\\n channels_dict_df_p['DE'] = cdf.varget(\\\"P_energy_delta\\\")\\n # channels_dict_df_p['mean_E'] = np.sqrt(channels_dict_df_p['upper_E'] * channels_dict_df_p['lower_E'])\\n channels_dict_df_p['mean_E'] = cdf.varget(\\\"P_energy\\\")\\n\\n metadata.update({'channels_dict_df_He': channels_dict_df_He})\\n metadata.update({'channels_dict_df_p': channels_dict_df_p})\\n return metadata\",\n \"def test_graph_from_dataset(self):\\n\\n dataset_dict = {\\n \\\"id\\\": \\\"dct:identifier\\\",\\n \\\"notes\\\": \\\"dct:description\\\",\\n \\\"title\\\": \\\"dct:title\\\",\\n\\n \\\"url\\\": \\\"dcat:landingPage\\\",\\n \\\"version\\\": \\\"owl:versionInfo\\\",\\n \\\"metadata_created\\\": \\\"2017-07-06T13:08:40\\\",\\n \\\"metadata_modified\\\": \\\"2017-07-06T13:08:41\\\",\\n \\\"license_id\\\": \\\"nocheck\\\",\\n\\n \\\"groups\\\": [{\\\"name\\\": \\\"GRUPPEA\\\"},\\n {\\\"name\\\": \\\"GRUPPEB\\\"}\\n ],\\n \\\"tags\\\": [{\\\"name\\\":\\\"dcat:keyword\\\"},\\n {\\\"name\\\": \\\"tagB\\\"}\\n ],\\n\\n \\\"author\\\": \\\"nocheck\\\",\\n \\\"author_email\\\": \\\"nocheck\\\",\\n\\n \\\"maintainer\\\": \\\"nocheck\\\",\\n \\\"maintainer_email\\\": \\\"nocheck\\\",\\n\\n \\\"extras\\\": self.transform_to_key_value({\\n \\\"contributorID\\\": [\\\"dcatde:contributorID\\\"],\\n \\\"qualityProcessURI\\\": \\\"dcatde:qualityProcessURI\\\",\\n \\\"documentation\\\": \\\"foaf:page\\\",\\n \\\"frequency\\\": \\\"dct:accrualPeriodicity\\\",\\n \\\"version_notes\\\": \\\"adms:versionNotes\\\",\\n \\\"dcat_type\\\": \\\"dct:type\\\",\\n\\n \\\"author_url\\\": \\\"nocheck\\\",\\n\\n \\\"maintainer_url\\\": \\\"nocheck\\\",\\n \\\"maintainer_tel\\\": \\\"nocheck\\\",\\n 'maintainer_street': \\\"nocheck\\\",\\n 'maintainer_city': \\\"nocheck\\\",\\n 'maintainer_zip': \\\"nocheck\\\",\\n 'maintainer_country': \\\"nocheck\\\",\\n\\n \\\"publisher_name\\\": \\\"nocheck\\\",\\n \\\"publisher_email\\\": \\\"nocheck\\\",\\n \\\"publisher_url\\\": \\\"nocheck\\\",\\n\\n \\\"originator_name\\\": \\\"nocheck\\\",\\n \\\"originator_email\\\": \\\"nocheck\\\",\\n \\\"originator_url\\\": \\\"nocheck\\\",\\n\\n \\\"contributor_name\\\": \\\"nocheck\\\",\\n \\\"contributor_email\\\": \\\"nocheck\\\",\\n \\\"contributor_url\\\": \\\"nocheck\\\",\\n\\n \\\"access_rights\\\": \\\"dct:accessRights\\\",\\n \\\"provenance\\\": \\\"dct:provenance\\\",\\n \\\"politicalGeocodingLevelURI\\\": \\\"dcatde:politicalGeocodingLevelURI\\\",\\n \\\"politicalGeocodingURI\\\": [\\\"dcatde:politicalGeocodingURI\\\"],\\n \\\"geocodingText\\\": [\\\"dcatde:geocodingText\\\"],\\n \\\"legalbasisText\\\": [\\\"dcatde:legalbasisText\\\"],\\n\\n \\\"temporal_start\\\": \\\"2017-07-06T13:08:40\\\",\\n \\\"temporal_end\\\": \\\"2017-07-06T13:08:41\\\",\\n\\n \\\"spatial\\\": \\\"{\\\\\\\"type\\\\\\\":\\\\\\\"Polygon\\\\\\\",\\\\\\\"coordinates\\\\\\\":[[[8.852920532226562,\\\"+\\n \\\"47.97245599240245],[9.133758544921875,47.97245599240245],\\\"+\\n \\\"[9.133758544921875,48.17249666038475],[8.852920532226562,\\\"+\\n \\\"48.17249666038475],[8.852920532226562,47.97245599240245]]]}\\\",\\n\\n \\\"language\\\": [\\\"dct:language\\\"],\\n \\\"conforms_to\\\": [\\\"dct:conformsTo\\\"],\\n \\\"alternate_identifier\\\" : [\\\"adms:identifier\\\"],\\n \\\"used_datasets\\\": [\\\"dct:relation\\\", \\\"bla\\\"],\\n \\\"has_version\\\": [\\\"dct:hasVersion\\\"],\\n \\\"is_version_of\\\": [\\\"dct:isVersionOf\\\"]\\n }),\\n \\\"resources\\\": [{\\n \\\"id\\\": \\\"id\\\",\\n \\\"name\\\": \\\"dct:title\\\",\\n \\\"description\\\": \\\"dct:description\\\",\\n \\\"url\\\": \\\"dcat:accessURL\\\",\\n \\\"format:\\\": \\\"dct:format\\\",\\n \\\"mimetype\\\": \\\"dcat:mediaType\\\",\\n \\\"size\\\": 10,\\n \\\"hash\\\": 24,\\n\\n \\\"extras\\\": self.transform_to_key_value({\\n \\\"issued\\\": \\\"dct:issued\\\",\\n \\\"modified\\\": \\\"dct:modified\\\",\\n \\\"documentation\\\": \\\"foaf:page\\\",\\n \\\"download_url\\\": \\\"dcat:downloadURL\\\",\\n \\\"plannedAvailability\\\": \\\"dcatde:plannedAvailability\\\",\\n \\\"licenseAttributionByText\\\": \\\"dcatde:licenseAttributionByText\\\",\\n\\n \\\"license\\\": \\\"dct:license\\\",\\n \\\"rights\\\": \\\"dct:rights\\\",\\n \\\"status\\\": \\\"adms:status\\\",\\n\\n \\\"language\\\": [\\\"dct:language\\\"],\\n \\\"conforms_to\\\": [\\\"dct:conformsTo\\\"],\\n })\\n }]\\n }\\n\\n dataset_ref = URIRef(\\\"http://testuri/\\\")\\n\\n dcat = EuropeanDCATAPProfile(self.graph, False)\\n dcat.graph_from_dataset(dataset_dict, dataset_ref)\\n\\n dcatde = DCATdeProfile(self.graph, False)\\n dcatde.graph_from_dataset(dataset_dict, dataset_ref)\\n\\n\\n # Assert structure of graph - basic values\\n extras = dataset_dict[\\\"extras\\\"]\\n\\n for key in dataset_dict:\\n self.check_simple_items(dataset_dict, dataset_ref, key)\\n\\n for key in extras:\\n self.check_simple_items(dataset_dict, dataset_ref, key)\\n\\n # issued, modified\\n self.assertEqual(len(list(self.graph.objects(dataset_ref, self.DCT.issued))), 1,\\n \\\"dct:issued not found\\\")\\n self.assertEqual(len(list(self.graph.objects(dataset_ref, self.DCT.modified))), 1,\\n \\\"dct:modified not found\\\")\\n\\n # groups, tags\\n self.assert_list(dataset_ref, self.DCAT.theme,\\n [self.dcat_theme_prefix + x[\\\"name\\\"] for x in dataset_dict[\\\"groups\\\"]])\\n self.assert_list(dataset_ref, self.DCAT.keyword,\\n [x[\\\"name\\\"] for x in dataset_dict[\\\"tags\\\"]])\\n\\n # author, maintainer, originator, contributor, publisher\\n self.assert_contact_info(dataset_ref, self.DCATDE.originator)\\n self.assert_contact_info(dataset_ref, self.DCATDE.maintainer)\\n self.assert_contact_info(dataset_ref, self.DCT.contributor)\\n self.assert_contact_info(dataset_ref, self.DCT.creator)\\n self.assert_contact_info(dataset_ref, self.DCT.publisher)\\n\\n # contactPoint\\n contact_point = next(self.graph.objects(dataset_ref, self.DCAT.contactPoint))\\n vcard_attrs = [\\n self.VCARD.fn, self.VCARD.hasEmail, self.VCARD.hasURL,\\n self.VCARD.hasTelephone, self.VCARD.hasStreetAddress,\\n self.VCARD.hasLocality, self.VCARD.hasCountryName,\\n self.VCARD.hasPostalCode\\n ]\\n for v_attr in vcard_attrs:\\n self.assertEqual(len(list(self.graph.objects(contact_point, v_attr))), 1,\\n self.DCAT.contactPoint + str(v_attr) + \\\" not found\\\")\\n\\n # temporal\\n temporal = list(self.graph.objects(dataset_ref, self.DCT.temporal))[0]\\n self.assertEqual(len(list(self.graph.objects(temporal, self.SCHEMA.startDate))), 1,\\n self.SCHEMA.startDate + \\\" not found\\\")\\n self.assertEqual(len(list(self.graph.objects(temporal, self.SCHEMA.endDate))), 1,\\n self.SCHEMA.endDate + \\\" not found\\\")\\n\\n # spatial\\n for spatial in list(self.graph.objects(dataset_ref, self.DCT.spatial)):\\n geonodes = len(list(self.graph.objects(spatial, self.LOCN.geometry)))\\n adminnodes = len(list(self.graph.objects(spatial, self.LOCN.adminUnitL2)))\\n if geonodes > 0:\\n self.assertEqual(geonodes, 2, self.LOCN.geometry + \\\" not present, 2x\\\")\\n elif adminnodes > 0:\\n self.assertEqual(adminnodes, 1, self.LOCN.adminUnitL2 + \\\" not present\\\")\\n else:\\n self.fail(\\\"No valid spatial blocks found.\\\")\\n\\n # lists in extras\\n self.assert_list(dataset_ref, self.DCT.language,\\n self.get_value_from_extras(extras, \\\"language\\\"))\\n self.assert_list(dataset_ref, self.DCT.conformsTo,\\n self.get_value_from_extras(extras, \\\"conforms_to\\\"))\\n self.assert_list(dataset_ref, self.ADMS.identifier,\\n self.get_value_from_extras(extras, \\\"alternate_identifier\\\"))\\n self.assert_list(dataset_ref, self.DCT.relation,\\n self.get_value_from_extras(extras, \\\"used_datasets\\\"))\\n self.assert_list(dataset_ref, self.DCT.hasVersion,\\n self.get_value_from_extras(extras, \\\"has_version\\\"))\\n self.assert_list(dataset_ref, self.DCT.isVersionOf,\\n self.get_value_from_extras(extras, \\\"is_version_of\\\"))\\n self.assert_list(dataset_ref, self.DCATDE.politicalGeocodingURI,\\n self.get_value_from_extras(extras, \\\"politicalGeocodingURI\\\"))\\n self.assert_list(dataset_ref, self.DCATDE.geocodingText,\\n self.get_value_from_extras(extras, \\\"geocodingText\\\"))\\n self.assert_list(dataset_ref, self.DCATDE.legalbasisText,\\n self.get_value_from_extras(extras, \\\"legalbasisText\\\"))\\n self.assert_list(dataset_ref, self.DCATDE.contributorID,\\n self.get_value_from_extras(extras, \\\"contributorID\\\"))\\n\\n # resources\\n resource = dataset_dict[\\\"resources\\\"][0]\\n resource_ref = list(self.graph.objects(dataset_ref, self.DCAT.distribution))[0]\\n resource_extras = resource[\\\"extras\\\"]\\n\\n for key in resource:\\n self.check_simple_items(resource, resource_ref, key)\\n\\n for key in resource_extras:\\n self.check_simple_items(resource, resource_ref, key)\\n\\n # size\\n self.assertEqual(len(list(self.graph.objects(resource_ref, self.DCAT.byteSize))), 1,\\n self.DCAT.byteSize + \\\" not found\\\")\\n\\n # hash\\n self.assertEqual(len(list(self.graph.objects(resource_ref, self.SPDX.checksum))), 1,\\n self.SPDX.checksum + \\\" not found\\\")\\n\\n # lists\\n self.assert_list(resource_ref, self.DCT.language,\\n self.get_value_from_extras(resource_extras, \\\"language\\\"))\\n self.assert_list(resource_ref, self.DCT.conformsTo,\\n self.get_value_from_extras(resource_extras, \\\"conforms_to\\\"))\",\n \"def try8():\\n path = '/Users/mayankkejriwal/datasets/companies/'\\n gt_file = path+'GT.json'\\n infile = codecs.open(gt_file, 'r', 'utf-8')\\n obj = json.load(infile)\\n print obj\\n infile.close()\",\n \"def process_coco(coco_file_path: str) -> (list, dict):\\n coco_dict = load_json(coco_file_path)\\n\\n # rearrange coco file for better annotation reach\\n images = list()\\n for image in coco_dict[\\\"images\\\"]:\\n image_annotations = list()\\n for annotation in coco_dict[\\\"annotations\\\"]:\\n if image[\\\"id\\\"] == annotation[\\\"image_id\\\"]:\\n image_annotations.append(annotation)\\n image[\\\"annotations\\\"] = image_annotations\\n images.append(image)\\n\\n return images, coco_dict[\\\"categories\\\"]\",\n \"def test_make_legacy_dataset_from_numpy():\\n current_dir = os.path.dirname(os.path.abspath(__file__))\\n # legacy_dataset is a dataset in the legacy format kept around for testing purposes.\\n data_dir = os.path.join(current_dir, \\\"legacy_dataset\\\")\\n dataset = dc.data.DiskDataset(data_dir)\\n assert dataset.legacy_metadata\\n assert len(dataset.metadata_df.columns) == 4\\n assert list(dataset.metadata_df.columns) == ['ids', 'X', 'y', 'w']\\n\\n # Test constructor reload works for legacy format\\n dataset2 = dc.data.DiskDataset(dataset.data_dir)\\n assert dataset2.legacy_metadata\\n assert len(dataset2.metadata_df.columns) == 4\\n assert list(dataset2.metadata_df.columns) == ['ids', 'X', 'y', 'w']\",\n \"def load_citation(dataset_str=\\\"cora\\\", normalization=\\\"AugNormAdj\\\", cuda=True,task_type = \\\"full\\\"):\\n names = ['x', 'y', 'tx', 'ty', 'allx', 'ally', 'graph']\\n objects = []\\n\\n for i in range(len(names)):\\n with open(\\\"data/ind.{}.{}\\\".format(dataset_str.lower(), names[i]), 'rb') as f:\\n if sys.version_info > (3, 0):\\n objects.append(pkl.load(f, encoding='latin1'))\\n else:\\n objects.append(pkl.load(f))\\n\\n x, y, tx, ty, allx, ally, graph = tuple(objects)\\n test_idx_reorder = parse_index_file(\\\"data/ind.{}.test.index\\\".format(dataset_str))\\n test_idx_range = np.sort(test_idx_reorder)\\n\\n if dataset_str == 'citeseer':\\n # Fix citeseer dataset (there are some isolated nodes in the graph)\\n # Find isolated nodes, add them as zero-vecs into the right position\\n test_idx_range_full = range(min(test_idx_reorder), max(test_idx_reorder)+1)\\n tx_extended = sp.lil_matrix((len(test_idx_range_full), x.shape[1]))\\n tx_extended[test_idx_range-min(test_idx_range), :] = tx\\n tx = tx_extended\\n ty_extended = np.zeros((len(test_idx_range_full), y.shape[1]))\\n ty_extended[test_idx_range-min(test_idx_range), :] = ty\\n ty = ty_extended\\n\\n features = sp.vstack((allx, tx)).tolil()\\n features[test_idx_reorder, :] = features[test_idx_range, :]\\n adj = nx.adjacency_matrix(nx.from_dict_of_lists(graph))\\n adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)\\n adj_origin = adj\\n labels = np.vstack((ally, ty))\\n labels[test_idx_reorder, :] = labels[test_idx_range, :]\\n\\n\\n\\n if task_type == \\\"full\\\":\\n print(\\\"Load full supervised task.\\\")\\n # supervised setting\\n idx_test = test_idx_range.tolist()\\n idx_train = range(len(ally) - 500)\\n idx_val = range(len(ally) - 500, len(ally))\\n elif task_type == \\\"semi\\\":\\n print(\\\"Load semi-supervised task.\\\")\\n # semi-supervised setting\\n idx_test = test_idx_range.tolist()\\n idx_train = range(len(y))\\n idx_val = range(len(y), len(y) + 500)\\n\\n\\n adj, features = preprocess_citation(adj, features, normalization)\\n\\n features = torch.FloatTensor(np.array(features.todense())).float()\\n labels = np.argmax(labels, axis=1)\\n labels = torch.LongTensor(labels)\\n adj = sparse_mx_to_torch_sparse_tensor(adj).float()\\n adj_origin = torch.LongTensor(np.array(adj_origin.todense()))\\n idx_train = torch.LongTensor(idx_train)\\n idx_val = torch.LongTensor(idx_val)\\n idx_test = torch.LongTensor(idx_test)\\n if cuda:\\n features = features.cuda()\\n adj = adj.cuda() \\n labels = labels.cuda()\\n idx_train = idx_train.cuda()\\n idx_val = idx_val.cuda()\\n idx_test = idx_test.cuda()\\n adj_origin = adj_origin.cuda()\\n\\n return adj, features, labels, idx_train, idx_val, idx_test,adj_origin\",\n \"def Reconstruct_COVID_data(COVID_data):\\r\\n COVID_data_reconstructed = {}\\r\\n COVID_data_reconstructed['_Country'] = COVID_data['_Country']\\r\\n \\r\\n Countries_list = list(COVID_data.keys())[1:]\\r\\n \\r\\n for Country in Countries_list: # For each country...\\r\\n COVID_data_single_country = list(COVID_data[Country].values()) # Extract the matrix containing the data and transpose it. That way, each element of a single list in the array corresponds to one column (see help of Main_script) and it makes it easier to navigate through each column and recontruct the missing elements\\r\\n T_COVID_data_single_country = list(map(list, zip(*COVID_data_single_country)))\\r\\n \\r\\n for Column_inc in range(len(T_COVID_data_single_country)): # For each column...\\r\\n Column = T_COVID_data_single_country[Column_inc]\\r\\n Max_column_inc = len(Column) - 1\\r\\n \\r\\n Row_inc = 0\\r\\n while Column[Row_inc] == None and Row_inc < Max_column_inc: # Recontructing missing data at the beginning is impossible so we just skip the first rows with a None in them\\r\\n Row_inc += 1\\r\\n \\r\\n \\r\\n if None in Column: # If a None is in the list (meaning there are bits of data missing)...\\r\\n while Row_inc < Max_column_inc: # Not including this line could prompt an index error\\r\\n if Column[Row_inc] == None: # When a None in encoutered...\\r\\n None_interval_start = Row_inc # Recording when the segments of None starts and ends\\r\\n \\r\\n while Column[Row_inc] == None and Row_inc < Max_column_inc:\\r\\n Row_inc += 1\\r\\n \\r\\n None_interval_end = Row_inc - 1\\r\\n Interpolation_interval_length = None_interval_end - None_interval_start + 2\\r\\n \\r\\n if Row_inc < Max_column_inc: # Reconstruction of the segment by linear interpolation : Y = mX + b with m = (Y_max - Y_min) / (X_max - X_min)\\r\\n m = (Column[None_interval_end + 1] - Column[None_interval_start - 1]) / Interpolation_interval_length\\r\\n b = Column[None_interval_start - 1]\\r\\n \\r\\n for Row_inc in range(None_interval_start, Row_inc):\\r\\n T_COVID_data_single_country[Column_inc][Row_inc] = m * (Row_inc - None_interval_start + 1) + b\\r\\n \\r\\n else: # In the case the None segment goes on until the end, the last known value is just copied\\r\\n for Row_inc in range(None_interval_start, Row_inc + 1):\\r\\n T_COVID_data_single_country[Column_inc][Row_inc] = T_COVID_data_single_country[Column_inc][None_interval_start - 1]\\r\\n \\r\\n Row_inc += 1\\r\\n \\r\\n COVID_data_single_country_reconstructed = list(map(list, zip(*T_COVID_data_single_country))) # Retranspose the matrix to get the reconstruted data in the correct format\\r\\n \\r\\n Date_list_country = list(COVID_data[Country].keys()) # Add the reconstructed data to the appropriate dictionnary\\r\\n COVID_data_reconstructed[Country] = {}\\r\\n for Date_inc in range(len(Date_list_country)):\\r\\n Date = Date_list_country[Date_inc]\\r\\n COVID_data_reconstructed[Country][Date] = COVID_data_single_country_reconstructed[Date_inc]\\r\\n \\r\\n return COVID_data_reconstructed\",\n \"def load_data():\\n # Dictionary mapping image names to labels\\n image_name_to_label = dict()\\n\\n # Store labels associated with image names\\n notifier.send(\\\" Reading metadata...\\\")\\n with open(\\\"data/metadata.csv\\\") as file: # Original dataset\\n # Use images for normal, virus (unknown type), COVID-19, SARS\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n if row[\\\"Label\\\"].lower() == \\\"normal\\\":\\n label = 2\\n elif row[\\\"Label_2_Virus_category\\\"].lower() == \\\"covid-19\\\":\\n label = 0\\n elif row[\\\"Label_1_Virus_category\\\"].lower() == \\\"virus\\\":\\n label = 1\\n else:\\n continue\\n image_name_to_label[row[\\\"X_ray_image_name\\\"]] = label\\n with open(\\\"data/metadata2.csv\\\") as file: # GitHub dataset\\n # Use COVID-19, SARS\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n if row[\\\"filename\\\"] in image_name_to_label: # Image already added\\n continue\\n if \\\"covid-19\\\" in row[\\\"finding\\\"].lower():\\n label = 0\\n elif row[\\\"finding\\\"].lower() == \\\"sars\\\":\\n label = 1\\n else:\\n continue\\n image_name_to_label[row[\\\"filename\\\"]] = label\\n with open(\\\"data/metadata_COVID-19.csv\\\") as file: # Additional COVID-19 images\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n name = \\\"COVID-19/\\\" + row[\\\"FILE NAME\\\"] + \\\".\\\" + row[\\\"FORMAT\\\"]\\n image_name_to_label[name.lower().replace(\\\" \\\", \\\"\\\")] = 0\\n with open(\\\"data/metadata_ViralPneumonia.csv\\\") as file: # Additional virus images\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n name = \\\"ViralPneumonia/\\\" + row[\\\"FILE NAME\\\"].replace(\\\"-\\\", \\\"(\\\") + \\\").\\\" + row[\\\"FORMAT\\\"]\\n image_name_to_label[name.lower().replace(\\\" \\\", \\\"\\\")] = 1\\n with open(\\\"data/metadata_Normal.csv\\\") as file: # Additional normal images\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n name = \\\"Normal/\\\" + row[\\\"FILE NAME\\\"].replace(\\\"-\\\", \\\"(\\\") + \\\").\\\" + row[\\\"FORMAT\\\"]\\n image_name_to_label[name.lower().replace(\\\" \\\", \\\"\\\")] = 2\\n\\n notifier.send(\\\" Loading images...\\\")\\n images, labels = load_images(image_name_to_label)\\n\\n notifier.send(\\\" Splitting data...\\\")\\n return split_data(images, labels)\",\n \"def get_e_coli_core_config():\\n package_path = get_package_path()\\n metabolism_file = os.path.join(package_path, 'bigg_models', 'e_coli_core.json')\\n return {'model_path': metabolism_file}\",\n \"def load_data():\\n\\t\\t# load the data\\n\\t\\tDATPATH = \\\"../data/\\\"\\n\\t\\t#fnino = DATPATH + \\\"nino3.csv\\\" # 1871-2000\\n\\t\\tfnino = DATPATH + \\\"tas_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_nino3_tseries.csv\\\" # 1871-2016\\n\\t\\t#fnino = DATPATH + \\\"nino34.long.data\\\"\\n\\t\\t#nc_data_nino3 = netCDF4.Dataset(fnino)\\n\\t\\t#nino3_load = nc_data_nino3.variables['tas'][:]\\n\\t\\t#dnino = nino3_load.flatten()\\n\\n\\t\\tdnino = np.genfromtxt(fnino, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t#fismr = DATPATH + \\\"ismr.csv\\\" # 1871-2000\\n\\t\\t#fismr = DATPATH + \\\"psl_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_1_india_goswami_2002_tseries.csv\\\" # 1871-2016\\n\\t\\tfismr = DATPATH + \\\"pr_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_goswami_india_tseries.csv\\\" # 1871-2016\\n\\t\\tdismr = np.genfromtxt(fismr, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t#fvolc = DATPATH + \\\"robock.txt\\\" # 1871-2000\\n\\t\\tfvolc = DATPATH + \\\"sigl.txt\\\" # 1871-2016\\n\\t\\tdvolc = np.genfromtxt(fvolc, delimiter=\\\",\\\", dtype=float).flatten()\\n\\n\\t\\tfvolc_source = DATPATH + \\\"volc_source_850_1850.csv\\\" # 1871-2016\\n\\t\\tdvolc_source = np.genfromtxt(fvolc_source, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t# simple check for data consistency\\n\\t\\tassert dnino.shape == dismr.shape, \\\"Data sets are unequal!\\\"\\n\\t\\tassert int(dismr.shape[0]/12) == dvolc.shape[0], \\\"Data sets are unequal\\\"\\n\\t\\treturn dnino, dismr, dvolc, dvolc_source\",\n \"def infer_confidence_map(DATA_DIR=DATA_DIR, SAVE_ROOT=SAVE_ROOT, FILE_LIST=FILE_LIST,\\n DS_NAME=DS_NAME, MODEL_DIR=MODEL_DIR ,LOAD_EPOCH=LOAD_EPOCH, extra_save_name=None ):\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--gpu', type=int, default=GPU)\\n parser.add_argument('--model_dir', type=str, default=MODEL_DIR)\\n parser.add_argument('--data_dir', type=str, default=DATA_DIR)\\n parser.add_argument('--save_root', type=str, default=SAVE_ROOT)\\n parser.add_argument('--load_epoch', type=int, default=LOAD_EPOCH)\\n parser.add_argument('--ds_name', type=str, default=DS_NAME)\\n parser.add_argument('--patch_size', type=str, default=PATCH_SIZE)\\n parser.add_argument('--file_list', type=str, default=FILE_LIST)\\n parser.add_argument('--compute_iou', dest='iou_eval', action='store_true')\\n parser.add_argument('--no_compute_iou', dest='iou_eval', action='store_false')\\n parser.set_defaults(iou_eval=False)\\n super_args = parser.parse_args()\\n\\n # device, _ = misc_utils.set_gpu(super_args.gpu)\\n device = 'cuda:{}'.format(super_args.gpu)\\n\\n\\n def load_func_ct_tiles(data_dir, file_list=super_args.file_list, class_names=['panel', ]):\\n if file_list:\\n if not os.path.isfile(file_list):\\n make_file_list(data_dir)\\n with open(file_list, 'r') as f:\\n rgb_files = f.read().splitlines()\\n else:\\n from glob import glob\\n rgb_files = natsorted(glob(os.path.join(data_dir, '*.jpg')))\\n lbl_files = [None] * len(rgb_files)\\n assert len(rgb_files) == len(lbl_files)\\n return rgb_files, lbl_files\\n\\n # # make file list for this\\n # if not os.path.exists(FILE_LIST):\\n # make_file_list(DATA_DIR, 'png')\\n \\n # make file list for this\\n if not os.path.exists(FILE_LIST):\\n make_file_list(DATA_DIR)\\n\\n # init model\\n args = network_io.load_config(super_args.model_dir)\\n model = network_io.create_model(args)\\n if LOAD_EPOCH:\\n args['trainer']['epochs'] = super_args.load_epoch\\n ckpt_dir = os.path.join(\\n super_args.model_dir, 'epoch-{}.pth.tar'.format(args['trainer']['epochs']))\\n network_utils.load(model, ckpt_dir)\\n print('Loaded from {}'.format(ckpt_dir))\\n model.to(device)\\n model.eval()\\n\\n # eval on dataset\\n if os.path.exists(os.path.join('/home/wh145/mrs/data/stats/custom', '{}.npy'.format(DS_NAME))):\\n mean, std = np.load(os.path.join(\\n '/home/wh145/mrs/data/stats/custom', '{}.npy'.format(DS_NAME)))\\n print('Use {} mean and std stats: {}'.format(DS_NAME, (mean, std)))\\n else:\\n mean = (0.485, 0.456, 0.406)\\n std = (0.229, 0.224, 0.225)\\n print('Use default (imagenet) mean and std stats: {}'.format((mean, std)))\\n\\n tsfm_valid = A.Compose([\\n A.Normalize(mean=mean, std=std),\\n ToTensorV2(),\\n ])\\n if extra_save_name is None:\\n save_dir = os.path.join(super_args.save_root, os.path.basename(\\n network_utils.unique_model_name(args)))\\n else:\\n save_dir = os.path.join(super_args.save_root, extra_save_name)\\n evaluator = eval_utils.Evaluator(\\n super_args.ds_name, super_args.data_dir, tsfm_valid, device, load_func=load_func_ct_tiles)\\n # evaluator.evaluate(model, PATCHS_SIZE, 2*model.lbl_margin,\\n # pred_dir=save_dir, report_dir=save_dir)\\n evaluator.infer(model=model, patch_size=PATCH_SIZE, overlap=2*model.lbl_margin,\\n pred_dir=save_dir, save_conf=True)\\n\\n if super_args.iou_eval:\\n # calculate tile-wise IOU\\n with open(super_args.file_list, 'r') as fp:\\n tile_list = [os.path.basename(s).split('.')[0] for s in fp.readlines()]\\n\\n print(\\n tile_wise_validation(\\n super_args.data_dir, save_dir, tile_list, min_conf=0.5, min_area=0,\\n gt_max=1, conf_max=255, gt_postfix='.png', conf_postfix='_conf.png'\\n )\\n )\\n # Ben's comment here\",\n \"def __init__(self, out_dir = 'output' ):\\n\\n self.data = {} # will contain the data for each different dataset \\n self.datasets = '' # will contain the input datasets (original dictionary)\\n self.datasets_keys = '' # will contain the input datasets names only (i.e. keys of the datasets dictionary)\\n #self.datasets_all = ['era5_2_2'] # all possibly available datasets \\n\\n self.unique_dates = {} \\n self.attributes = {} # will keep the original attributes from the CDM tables, read from the netCDF files \\n self.id_string_length = 14 # fixed length for record_id and observation_id values \\n self.out_dir = out_dir \\n self.variable_types = {}\\n self.observation_ids_merged = { 'igra2':b'3' , \\n 'ncar':b'4', \\n 'bufr':b'5', \\n 'era5_1':b'1' , \\n 'era5_2':b'2', \\n 'era5_1759' :b'6' , \\n 'era5_1761':b'7' , \\n 'era5_3188' :b'8' } # values used to convert original record_id to the merged record_id, see method merge_all_data \\n\\n logging.info('*** Initialising the Merging procedure ***' ) \\n #self.era5b_columns = [] # stores the columns of the era5fb \\n self.standard_cdm = [ 'crs' , 'observed_variable', 'units' , 'z_coordinate_type' , 'station_type', 'station_configuration_codes'] \\n self.slice_size = 3000\\n self.index_offset = 0 # will be replaced when running \\n self.hour_time_delta = 60 * 60 * 2 # decide up to which time shift records are considered identical \\n \\n \\n self.only_std_plevels = False # set to True to store only standard pressure level data \\n self.std_plevs = [1000, 2000, 3000, 5000, 7000, 10000, 15000, 20000, 25000, 30000, 40000, 50000, 70000, 85000, 92500, 100000]\",\n \"def load_data(tetrode_number=TETRODE_NUMBER):\\n print(\\\"Loading data...\\\")\\n X_train, X_valid, X_test, y_train_labels, y_valid_labels, y_test_labels = formatData(tetrode_number,BASENAME,CONV)\\n print(\\\"Done!\\\")\\n\\n X_train = X_train.reshape(X_train.shape[0],1,X_train.shape[1],X_train.shape[2])\\n X_valid = X_valid.reshape(X_valid.shape[0],1,X_valid.shape[1],X_valid.shape[2])\\n X_test = X_test.reshape(X_test.shape[0],1,X_test.shape[1],X_test.shape[2])\\n\\n\\n y_train = X_train\\n y_valid = X_valid\\n y_test = X_test\\n\\n r={}\\n for x,y in zip(X_test,y_test_labels):\\n # print(\\\"x: {}\\\".format(x))\\n # print(\\\"y: {}\\\".format(y))\\n _y = list(y)\\n if int(_y.index(1.0)) not in r:\\n r[int(_y.index(1.0))]=[x]\\n else:\\n r[int(_y.index(1.0))].append(x)\\n\\n for key in r:\\n r[key] = np.asarray(r[key])\\n\\n\\n return dict(\\n X_train=X_train,\\n y_train=y_train,\\n X_valid=X_valid,\\n y_valid=y_valid,\\n X_test=X_test,\\n y_test=y_test,\\n labeled_test=r,\\n caswells_dim = y_train_labels.shape[-1],\\n num_examples_train=X_train.shape[0],\\n num_examples_valid=X_valid.shape[0],\\n num_examples_test=X_test.shape[0],\\n input_shape=X_train.shape,\\n output_dim=y_train.shape[-1],\\n )\",\n \"def read_microsoft_aec_data(synthetic_dataset_filepath):\\n\\n synthetic_csv = join(synthetic_dataset_filepath, 'meta.csv')\\n\\n data = {}\\n data_train = {}\\n data_test = {}\\n\\n is_farend_nonlinear = {'train': {1: [], 0: []}, 'test': {1: [], 0: []}}\\n is_farend_noisy = {'train': {1: [], 0: []}, 'test': {1: [], 0: []}}\\n is_nearend_noisy = {'train': {1: [], 0: []}, 'test': {1: [], 0: []}}\\n\\n df = pandas.read_csv(synthetic_csv)\\n for _, row in df.iterrows():\\n\\n fileid = row['fileid']\\n data[fileid] = {}\\n data[fileid]['ser'] = row['ser']\\n data[fileid]['is_farend_nonlinear'] = row['is_farend_nonlinear']\\n data[fileid]['is_farend_noisy'] = row['is_farend_noisy']\\n data[fileid]['is_nearend_noisy'] = row['is_nearend_noisy']\\n data[fileid]['split'] = row['split']\\n data[fileid]['fileid'] = row['fileid']\\n data[fileid]['nearend_scale'] = row['nearend_scale']\\n\\n # Add the absolute path of the echo, far-end, near-end, and clean near-end\\n data[fileid]['echo_path'] = join(synthetic_dataset_filepath,\\n 'echo_signal/echo_fileid_' + str(fileid) + '.wav')\\n data[fileid]['farend_speech_path'] = join(synthetic_dataset_filepath,\\n 'farend_speech/farend_speech_fileid_' + str(fileid) + '.wav')\\n data[fileid]['nearend_mic_path'] = join(synthetic_dataset_filepath,\\n 'nearend_mic_signal/nearend_mic_fileid_' + str(fileid) + '.wav')\\n data[fileid]['nearend_speech_path'] = join(synthetic_dataset_filepath,\\n 'nearend_speech/nearend_speech_fileid_' + str(fileid) + '.wav')\\n\\n # Dictionary train/test -> nonlinear -> file id\\n is_farend_nonlinear[row['split']\\n ][row['is_farend_nonlinear']].append(fileid)\\n is_farend_noisy[row['split']][row['is_farend_noisy']].append(fileid)\\n is_nearend_noisy[row['split']][row['is_nearend_noisy']].append(fileid)\\n\\n if row['split'] == 'test':\\n data_test[fileid] = data[fileid]\\n else:\\n data_train[fileid] = data[fileid]\\n\\n return data, data_train, data_test, is_farend_nonlinear, is_farend_noisy, is_nearend_noisy\",\n \"def label_to_coco_label(self, label):\\n\\t\\t\\treturn self.coco_labels[label]\",\n \"def noaa20cr(self):\\n if os.path.exists('./data/noaa20cr.zarr'):\\n return './data/noaa20cr.zarr'\\n return self.gcs.get_mapper(os.path.join(self.bucket, 'noaa20cr.zarr'))\",\n \"def label_to_coco_label(self, label):\\n\\t\\treturn self.coco_labels[label]\",\n \"def data():\\n\\n run_type = 'standardised'\\n sr = 48000\\n train_perc = 0.9\\n\\n if sr == 48000:\\n time_dimension = 282\\n if sr == 44100:\\n time_dimension = 259\\n\\n x_train, y_train, x_test, y_test = essential.compile_dataset(run_type, sr)\\n\\n # reshape for CNN input\\n x_train = np.array([x.reshape((128, time_dimension, 1)) for x in x_train])\\n x_test = np.array([x.reshape((128, time_dimension, 1)) for x in x_test])\\n\\n # encoded \\n encoder = LabelEncoder()\\n encoder.fit(y_train)\\n encoder.fit(y_test)\\n y_train = encoder.transform(y_train)\\n y_test = encoder.transform(y_test)\\n\\n return x_train, y_train, x_test, y_test\",\n \"def test_to_json_stat_types(self):\\n\\n results = pyjstat.from_json_stat(self.oecd_datasets)\\n json_data = json.loads(pyjstat.to_json_stat(results),\\n object_pairs_hook=OrderedDict)\\n self.assertTrue(json_data[0][\\\"dataset1\\\"][\\\"dimension\\\"]\\n [\\\"OECD countries,EU15 and total\\\"][\\\"category\\\"][\\\"index\\\"]\\n [\\\"Spain\\\"] == 28)\\n self.assertTrue(type(json_data[0][\\\"dataset1\\\"][\\\"dimension\\\"]\\n [\\\"OECD countries,EU15 and total\\\"][\\\"category\\\"][\\\"index\\\"]\\n [\\\"Spain\\\"]) is int)\\n self.assertTrue(json_data[0][\\\"dataset1\\\"][\\\"dimension\\\"]\\n [\\\"OECD countries,EU15 and total\\\"][\\\"category\\\"][\\\"label\\\"]\\n [\\\"France\\\"] == \\\"France\\\")\\n self.assertTrue(type(json_data[0][\\\"dataset1\\\"][\\\"dimension\\\"]\\n [\\\"OECD countries,EU15 and total\\\"][\\\"category\\\"][\\\"label\\\"]\\n [\\\"France\\\"]) is unicode)\\n self.assertTrue(json_data[0][\\\"dataset1\\\"][\\\"dimension\\\"]\\n [\\\"2003-2014\\\"][\\\"category\\\"][\\\"index\\\"]\\n [\\\"2005\\\"] == 2)\\n self.assertTrue(json_data[0][\\\"dataset1\\\"][\\\"dimension\\\"]\\n [\\\"2003-2014\\\"][\\\"category\\\"][\\\"label\\\"]\\n [\\\"2005\\\"] == \\\"2005\\\")\\n self.assertTrue(type(json_data[0][\\\"dataset1\\\"][\\\"dimension\\\"]\\n [\\\"2003-2014\\\"][\\\"category\\\"][\\\"index\\\"]\\n [\\\"2005\\\"]) is int)\\n self.assertTrue(type(json_data[0][\\\"dataset1\\\"][\\\"dimension\\\"]\\n [\\\"2003-2014\\\"][\\\"category\\\"][\\\"label\\\"]\\n [\\\"2005\\\"]) is unicode)\",\n \"def load_davis_dataset():\\n trainn_fold = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'folds', 'train_fold_setting1.txt')))\\n train_fold = []\\n for e in zip(*trainn_fold):\\n for ee in e:\\n train_fold.append(ee)\\n #train_fold = [ee for e in trainn_fold for ee in e]\\n test_fold = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'folds', 'test_fold_setting1.txt')))\\n ligands = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'ligands_can.txt')),\\n object_pairs_hook=OrderedDict)\\n proteins = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'proteins.txt')),\\n object_pairs_hook=OrderedDict)\\n \\n affinity = pickle.load(open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'Y'), \\n 'rb'), encoding='latin1')\\n smiles_lst, protein_lst = [], []\\n\\n for k in ligands.keys():\\n smiles = ligands[k]\\n smiles_lst.append(smiles)\\n for k in proteins.keys():\\n protein_lst.append(proteins[k])\\n\\n affinity = [-np.log10(y / 1e9) for y in affinity]\\n affinity = np.asarray(affinity)\\n \\n os.makedirs(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'processed'), exist_ok=True)\\n train_test_dataset = []\\n for split in ['train', 'test']:\\n split_dir = os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'processed', split)\\n os.makedirs(split_dir, exist_ok=True)\\n fold = train_fold if split == 'train' else test_fold\\n rows, cols = np.where(np.isnan(affinity) == False)\\n rows, cols = rows[fold], cols[fold]\\n \\n data_lst = [[] for _ in range(1)]\\n for idx in range(len(rows)):\\n data = {}\\n data['smiles'] = smiles_lst[rows[idx]]\\n data['protein'] = protein_lst[cols[idx]]\\n af = affinity[rows[idx], cols[idx]]\\n data['aff'] = af\\n\\n data_lst[idx % 1].append(data)\\n random.shuffle(data_lst)\\n train_test_dataset.append(data_lst[0])\\n return train_test_dataset\",\n \"def load_waifu2x_json(self, data: list):\\n self.conv1.load_waifu2x_json(data[0])\\n self.conv2.load_waifu2x_json(data[1])\\n self.conv3.load_waifu2x_json(data[2])\\n self.conv4.load_waifu2x_json(data[3])\\n self.conv5.load_waifu2x_json(data[4])\\n self.conv6.load_waifu2x_json(data[5])\\n self.conv7.load_waifu2x_json(data[6])\",\n \"def main(version: str, data_root: str,\\n split_name: str, output_dir: str, config_name: str = 'predict_2020_icra.json') -> None:\\n\\n print('Dataset dir:', data_root)\\n nusc = NuScenes(version=version, dataroot=data_root)\\n helper = PredictHelper(nusc)\\n dataset = get_prediction_challenge_split(split_name, data_root)\\n config = load_prediction_config(helper, config_name)\\n\\n oracle = PhysicsOracle(config.seconds, helper)\\n cv_heading = ConstantVelocityHeading(config.seconds, helper)\\n covernet = CoverNetBaseline(config.seconds, helper)\\n\\n cv_preds = []\\n oracle_preds = []\\n covernet_preds = []\\n for idx, token in enumerate(tqdm(dataset)):\\n # if idx > 20:\\n # break\\n\\n cv_preds.append(cv_heading(token).serialize())\\n oracle_preds.append(oracle(token).serialize())\\n covernet_preds.append(covernet(token).serialize()) # The slowest one, by far\\n\\n json.dump(cv_preds, open(os.path.join(output_dir, \\\"cv_preds.json\\\"), \\\"w\\\"))\\n json.dump(oracle_preds, open(os.path.join(output_dir, \\\"oracle_preds.json\\\"), \\\"w\\\"))\\n json.dump(covernet_preds, open(os.path.join(output_dir, \\\"covernet_preds.json\\\"), \\\"w\\\"))\",\n \"def df_to_cdm(cdm, cdmd, out_dir, dataset, dic_obstab_attributes, fn): \\n \\n #station_id_fails = open('station_id_fail.log' , 'a') \\n #station_id_ok = open('station_id_correct.log' , 'a')\\n \\n t=time.time()\\n if not False: \\n # era5 analysis feedback is read from compressed netcdf files era5.conv._?????.nc.gz in $RSCRATCH/era5/odbs/1\\n \\\"\\\"\\\" Reading the odb and convert to xarray \\\"\\\"\\\" \\n if 'bufr' in dataset :\\n df, stations_id= bufr_to_dataframe(fn) # fdbs: the xarray converted from the pandas dataframe \\n \\n elif 'ncar' in dataset:\\n df, stations_id = uadb_ascii_to_dataframe(fn)\\n \\n elif 'igra2' in dataset:\\n df, stations_id = igra2_ascii_to_dataframe(fn)\\n \\n else:\\n #print('Unidentified file is: ', fn)\\n raise ValueError('Cannot identify the type of file to be analized!!! ')\\n \\n station_configuration_retrieved = get_station_configuration_f( stations_id, cdm['station_configuration'] ) \\n #primary_id = station_configuration_retrieved['primary_id'].values[0].decode('utf-8') \\n try:\\n primary_id = station_configuration_retrieved['primary_id'].values[0].decode('utf-8')\\n except:\\n #print('CANT FIND STATION PRIMARY ID ')\\n out =open(dataset + \\\"_wrong_ids.txt\\\" , 'a+')\\n out.write(fn + '\\\\n')\\n \\n primary_id = '-1'\\n \\n fno, source_file = initialize_output(fn, output_dir, primary_id, dataset) \\n #if primary_id == 'uknown_primary':\\n # return \\n \\n \\\"\\\"\\\" Casting the original variable types to appropriate numpy types \\\"\\\"\\\" \\n #df = convert_variable_type(df) # ->think this is overly complicated. \\n df = convert_variable_type_n(df)\\n #df = df.replace( -2147483648 , np.nan ) \\n \\n \\n \\\"\\\"\\\" Extract the unique indices of each date observation, one for only dates, one for date_time (i.e. record index). \\n Converts the time variables in seconds since 1900-01-01 00:00:00 \\\"\\\"\\\" \\n di=xr.Dataset() \\n \\n \\n if 'igra2' in dataset:\\n releasetime_toseconds = datetime_toseconds( df['report_timestamp'] ) \\n df['report_timestamp'] = releasetime_toseconds # will fill the header_table TODO see if it improves by replacing values with dictionaries in pandas \\n \\n record_timestamp_seconds = datetime_toseconds( df['record_timestamp'] ) # will fill the header_table TODO see if it improves by replacing values with dictionaries in pandas \\n df['record_timestamp'] = record_timestamp_seconds # replacing with seconds from 1900-01-01 00:00:00 \\n\\n indices, day, counts = make_datetime_indices( df['iday'].values ) #only date information\\n di['dateindex'] = ( { 'dateindex' : day.shape } , indices ) \\n \\n indices, date_times , counts = make_datetime_indices( df['record_timestamp'].values ) #date_time plus indices \\n di['recordindex'] = ( {'recordindex' : indices.shape }, indices )\\n di['recordtimestamp'] = ( {'recordtimestamp' : date_times.shape }, date_times )\\n\\n di['recordtimestamp'].attrs['units']='seconds since 1900-01-01 00:00:00'\\n\\n di.to_netcdf( fno, format='netCDF4', engine='h5netcdf', mode='w' )\\n \\n \\n \\n \\\"\\\"\\\" Storing the variable encodings \\\"\\\"\\\"\\n fbencodings={}\\n for d,v in df.items(): \\n if v.dtype==numpy.dtype('float64'):\\n fbencodings[d]={'dtype':numpy.dtype('float32'), 'compression': 'gzip'} \\n \\n elif v.dtype==numpy.dtype('float32'):\\n fbencodings[d]={'dtype':numpy.dtype('float32'), 'compression': 'gzip'} \\n \\n elif v.dtype==numpy.dtype('int32'):\\n fbencodings[d]={'dtype':numpy.dtype('int32'), 'compression': 'gzip'} \\n \\n elif v.dtype==numpy.dtype('int64'):\\n fbencodings[d]={'dtype':numpy.dtype('int64'), 'compression': 'gzip'} \\n \\n elif type(v.values[0])==bytes:\\n fbencodings[d]={'compression': 'gzip', 'chunksizes': ( min( [10000,v.shape[0] ] ), 10 ) }#,'chunksizes':(10000,10)\\n else:\\n fbencodings[d]={'compression': 'gzip'}\\n fbencodings['index']={'compression': 'gzip'}\\n \\n \\n #write_dict_h5(fno, df, 'era5fb', fbencodings, var_selection=[],mode='a')\\n dcols=[]\\n for d in df.columns:\\n if d not in ['date@hdr','time@hdr','statid@hdr','vertco_reference_1@body','varno@body', 'lon@hdr','lat@hdr','seqno@hdr',\\n 'obsvalue@body','fg_depar@body','an_depar@body','biascorr@body','sonde_type@conv', 'record_timestamp' , 'report_timestamp',\\n 'observation_id', 'report_id' , 'units' , 'vertco_type@body' ] :\\n \\n dcols.append(d)\\n df.drop(columns=dcols,inplace=True)\\n \\n groups={}\\n groupencodings={}\\n for k in cdmd.keys(): # loop over all the table definitions \\n if k in ('observations_table'):\\n pass #groups[k]=pd.DataFrame()\\n else:\\n groups[k]=xr.Dataset() # create an xarray\\n groupencodings[k]={} # create a dict of group econding\\n \\n for i in range(len(cdmd[k])):\\n d=cdmd[k].iloc[i] \\n \\n \\\"\\\"\\\" Filling the observations_table \\\"\\\"\\\"\\n if k in ('observations_table'):\\n groups[k]=pd.DataFrame() # creating dataframes that will be written to netcdf via h5py methods by the write_dict_h5() method \\n \\n try: \\n groups[k][d.element_name]= fromfb_l(df, di._variables, cdmfb_noodb[d.element_name], ttrans(d.kind,kinds=okinds)) \\n except KeyError:\\n x=numpy.zeros( df['record_timestamp'].shape[0], dtype=numpy.dtype(ttrans(d.kind,kinds=okinds) ) )\\n x.fill(numpy.nan)\\n groups[k][d.element_name]=x\\n\\n \\n elif k in ('header_table'):\\n if d.element_name == 'report_timestamp':\\n groups[k][d.element_name]= ( {'hdrlen':di['recordindex'].shape[0]} , np.take(df[d.element_name], di['recordindex'] ) )\\n groups[k][d.element_name].attrs['units'] = 'seconds since 1900-01-01 00:00:00'\\n elif d.element_name == 'record_timestamp':\\n groups[k][d.element_name]= ( {'hdrlen':di['recordindex'].shape[0]} , np.take(df[d.element_name], di['recordindex'] ) )\\n groups[k][d.element_name].attrs['units'] = 'seconds since 1900-01-01 00:00:00' \\n else:\\n try:\\n \\n if d.element_name not in station_configuration_retrieved.columns: # variables might be from the df (input file) or from the retrieved station configuration \\n \\n try: \\n # groups[k][d.element_name] = ({'hdrlen':di['recordindex'].shape[0]}, hdrfromfb(df,di._variables, cdmfb[d.element_name],ttrans(d.kind,kinds=gkinds) ) )\\n groups[k][d.element_name]= (di['recordindex'].shape[0], hdrfromfb(df, di._variables, cdmfb_noodb[d.element_name], ttrans(d.kind,kinds=gkinds) ) )\\n except: \\n x=numpy.zeros(di['recordindex'].shape[0], dtype=numpy.dtype(ttrans(d.kind,kinds=gkinds)))\\n x.fill(numpy.nan)\\n groups[k][d.element_name]=({'hdrlen':di['recordindex'].shape[0]},x) \\n \\n else: \\n x=numpy.zeros(di['recordindex'].shape[0], dtype=numpy.dtype(ttrans(d.kind,kinds=gkinds)))\\n x.fill( station_configuration_retrieved[d.element_name].values[0] )\\n groups[k][d.element_name]= ({'hdrlen':di['recordindex'].shape[0]},x) \\n except: # in case I cannot retrieve the station configuration file \\n try: \\n groups[k][d.element_name]=(di['recordindex'].shape[0], hdrfromfb(df, di._variables, cdmfb_noodb[d.element_name], ttrans(d.kind,kinds=gkinds) ) )\\n except: \\n x=numpy.zeros(di['recordindex'].shape[0], dtype=numpy.dtype(ttrans(d.kind,kinds=gkinds)))\\n x.fill(numpy.nan)\\n groups[k][d.element_name]=({'hdrlen':di['recordindex'].shape[0]},x) \\n \\n elif k in ('station_configuration'): # station_configurationt contains info of all the stations, so this extracts only the one line for the wanted station with the numpy.where\\n try: # case when the station+conf cannot be retrieved \\n if d.element_name in station_configuration_retrieved.columns: \\n groups[k][d.element_name]=({'hdrlen': 1}, np.full( 1 , station_configuration_retrieved[d.element_name].values[0] ) )\\n except:\\n pass\\n \\n elif k in ('source_configuration'): # storing the source configuration info, e.g. original file name, \\n if d.element_name=='source_file':\\n # groups[k][d.element_name] = ( {'hdrlen':fbds.variables['date@hdr'].shape[0] } , np.full( fbds.variables['date@hdr'].shape[0] , source_file ) ) \\n groups[k][d.element_name] = ( {'hdrlen': 1 }, np.full( 1 , source_file) )\\n else:\\n try: \\n groups[k][d.element_name] = ( {'hdrlen': 1 }, np.full( 1 , np.nan) ) # element_name is the netcdf variable name, which is the column name of the cdm table k \\n except KeyError:\\n pass\\n\\n else : # this is the case where the cdm tables DO exist\\n try: \\n groups[k][d.element_name]=({k+'_len':len(cdm[k])}, cdm[k][d.element_name].values) # element_name is the netcdf variable name, which is the column name of the cdm table k \\n except KeyError:\\n pass\\n \\n \\n \\\"\\\"\\\" Tryin to add attributes, e.g. description and external tables \\\"\\\"\\\" \\n try:\\n groups[k][d.element_name].attrs['external_table']=d.external_table # defining variable attributes that point to other tables (3rd and 4th columns)\\n groups[k][d.element_name].attrs['description']=d.description # it faisl when trying with the observations_table \\n except:\\n pass\\n \\n try: \\n if type(groups[k][d.element_name].values[0])==str:\\n s=groups[k][d.element_name].values.shape\\n groupencodings[k][d.element_name]={'dtype':numpy.dtype('S80'),'compression': 'gzip','chunksizes':(min(100000,s[0]),80)}\\n else:\\n groupencodings[k][d.element_name]={'compression': 'gzip'}\\n \\n if k in ('observations_table'):\\n write_dict_h5(fno, groups[k], k, groupencodings[k], var_selection=[],mode='a', attrs= dic_obstab_attributes )\\n \\n except:\\n #print('bad:',k,d.element_name)\\n pass\\n \\n for k in groups.keys(): \\n if k not in ('observations_table') : \\n groups[k].to_netcdf(fno,format='netCDF4',engine='h5netcdf',encoding=groupencodings[k],group=k,mode='a') #\\n \\n del df\\n \\n return 0\",\n \"def load_icd_to_ccw(path):\\n with open(path) as f:\\n data = json.load(f)\\n print('len(ccw_codes):', len(data))\\n name_id = {x: str(i) for i, x in enumerate(data.keys())}\\n id_name = {v: k for k, v in name_id.items()}\\n n_dx = 0\\n icd_ccwid = {}\\n icd_ccwname = {}\\n icddot_ccwid = {}\\n for name, dx in data.items():\\n n_dx += len(dx)\\n for icd in dx:\\n icd_no_dot = icd.strip().replace('.', '')\\n if icd_no_dot: # != ''\\n icd_ccwid[icd_no_dot] = name_id.get(name)\\n icd_ccwname[icd_no_dot] = name\\n icddot_ccwid[icd] = name_id.get(name)\\n data_info = (name_id, id_name, data)\\n return icd_ccwid, icd_ccwname, data_info\",\n \"def prepare_cityscapes_data(seed=1, percent=30.0, version=2017):\\n def _save_anno(name, images, annotations):\\n \\\"\\\"\\\"Save annotation\\n \\\"\\\"\\\"\\n print('>> Processing data {}.json saved ({} images {} annotations)'.format(\\n name, len(images), len(annotations)))\\n new_anno = {}\\n new_anno['images'] = images\\n new_anno['annotations'] = annotations\\n new_anno['categories'] = anno['categories']\\n\\n with open(\\n '{root}/{save_name}.json'.format(\\n save_name=name, root=DATA_DIR),\\n 'w') as f:\\n json.dump(new_anno, f)\\n print('>> Data {}.json saved ({} images {} annotations)'.format(\\n name, len(images), len(annotations)))\\n\\n np.random.seed(seed)\\n \\n anno = json.load(open(os.path.join(DATA_DIR, 'instancesonly_filtered_gtFine_train.json')))\\n\\n image_list = anno['images']\\n labeled_tot = int(percent / 100. * len(image_list))\\n #labeled_ind = np.random.choice(range(len(image_list)), size=labeled_tot)\\n labeled_ind = np.arange(len(image_list))\\n np.random.shuffle(labeled_ind)\\n labeled_ind = labeled_ind[0:labeled_tot]\\n\\n labeled_id = []\\n labeled_images = []\\n unlabeled_images = []\\n labeled_ind = set(labeled_ind)\\n for i in range(len(image_list)):\\n if i in labeled_ind:\\n labeled_images.append(image_list[i])\\n labeled_id.append(image_list[i]['id'])\\n else:\\n unlabeled_images.append(image_list[i])\\n\\n # get all annotations of labeled images\\n labeled_id = set(labeled_id)\\n labeled_annotations = []\\n unlabeled_annotations = []\\n for an in anno['annotations']:\\n if an['image_id'] in labeled_id:\\n labeled_annotations.append(an)\\n else:\\n unlabeled_annotations.append(an)\\n\\n # save labeled and unlabeled\\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}'.format(\\n version=version, seed=seed, tot=int(percent))\\n _save_anno(save_name, labeled_images, labeled_annotations)\\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}-unlabeled'.format(\\n version=version, seed=seed, tot=int(percent))\\n _save_anno(save_name, unlabeled_images, unlabeled_annotations)\",\n \"def _raw_to_dict(self, force_c1=False, force_units=False, np_out=True):\\n\\n self.update_geometry()\\n molrec = {}\\n\\n if self.name() not in ['', 'default']:\\n molrec['name'] = self.name()\\n\\n if force_units == 'Bohr':\\n molrec['units'] = 'Bohr'\\n elif force_units == 'Angstrom':\\n molrec['units'] = 'Angstrom'\\n else:\\n units = self.units()\\n molrec['units'] = units\\n if units == 'Angstrom' and abs(self.input_units_to_au() * psi_bohr2angstroms - 1.) > 1.e-6:\\n molrec['input_units_to_au'] = self.input_units_to_au()\\n\\n molrec['fix_com'] = self.com_fixed()\\n molrec['fix_orientation'] = self.orientation_fixed()\\n if force_c1:\\n molrec['fix_symmetry'] = 'c1'\\n elif self.symmetry_from_input():\\n molrec['fix_symmetry'] = self.symmetry_from_input()\\n\\n # if self.has_zmatrix:\\n # moldict['zmat'] = self.zmat\\n # TODO zmat, geometry_variables\\n\\n nat = self.natom()\\n geom = np.array(self.geometry()) # [a0]\\n if molrec['units'] == 'Angstrom':\\n geom *= psi_bohr2angstroms #self.input_units_to_au()\\n molrec['geom'] = geom.reshape((-1))\\n\\n molrec['elea'] = np.array([self.mass_number(at) for at in range(nat)])\\n molrec['elez'] = np.array([el2z[self.symbol(at).upper()] for at in range(nat)])\\n molrec['elem'] = np.array([self.symbol(at).capitalize() for at in range(nat)])\\n molrec['mass'] = np.array([self.mass(at) for at in range(nat)])\\n molrec['real'] = np.array([bool(self.Z(at)) for at in range(nat)])\\n molrec['elbl'] = np.array([self.label(at)[len(self.symbol(at)):].lower() for at in range(nat)])\\n\\n fragments = [x[:] for x in self.get_fragments()]\\n fragment_charges = [float(f) for f in self.get_fragment_charges()]\\n fragment_multiplicities = [m for m in self.get_fragment_multiplicities()]\\n\\n # do trimming not performed in Molecule class b/c fragment_* member data never directly exposed\\n for ifr, fr in reversed(list(enumerate(self.get_fragment_types()))):\\n if fr == 'Ghost':\\n fragment_charges[ifr] = 0.\\n fragment_multiplicities[ifr] = 1\\n elif fr == 'Absent':\\n del fragment_charges[ifr]\\n del fragment_multiplicities[ifr]\\n # readjust atom indices for subsequent fragments\\n renum = fragments[ifr][0]\\n for iffr, ffr in enumerate(fragments):\\n if iffr <= ifr:\\n continue\\n lenfr = ffr[1] - ffr[0]\\n fragments[iffr] = [renum, renum + lenfr]\\n renum += lenfr\\n del fragments[ifr]\\n\\n molrec['fragment_separators'] = [int(f[0]) for f in fragments[1:]] # np.int --> int\\n molrec['fragment_charges'] = fragment_charges\\n molrec['fragment_multiplicities'] = fragment_multiplicities\\n\\n molrec['molecular_charge'] = float(self.molecular_charge())\\n molrec['molecular_multiplicity'] = self.multiplicity()\\n\\n # * mass number (elea) untouched by qcdb.Molecule/psi4.core.Molecule and\\n # likely to be array of -1s, so let from_arrays fill in the values and\\n # (1) don't complain about the difference and\\n # (2) return the from_arrays filled-in values\\n # * from.arrays is expecting speclabel \\\"Co_userlbl\\\" for elbl, but we're\\n # sending \\\"_userlbl\\\", hence speclabel=False\\n forgive = ['elea']\\n\\n # * from_arrays and comparison lines below are quite unnecessary to\\n # to_dict, but is included as a check. in practice, only fills in mass\\n # numbers and heals user chgmult.\\n try:\\n validated_molrec = molparse.from_arrays(speclabel=False, verbose=0, domain='qm', **molrec)\\n except ValidationError as err:\\n # * this can legitimately happen if total chg or mult has been set\\n # independently b/c fragment chg/mult not reset. so try again.\\n print('Have you been meddling with chgmult?')\\n molrec['fragment_charges'] = [None] * len(fragments)\\n molrec['fragment_multiplicities'] = [None] * len(fragments)\\n validated_molrec = molparse.from_arrays(speclabel=False, verbose=0, domain='qm', **molrec)\\n forgive.append('fragment_charges')\\n forgive.append('fragment_multiplicities')\\n compare_molrecs(validated_molrec, molrec, 6, 'to_dict', forgive=forgive, verbose=0)\\n\\n if not np_out:\\n validated_molrec = unnp(validated_molrec)\\n\\n return validated_molrec\",\n \"def make_dataframe(self):\\n logging.info('*** Creating the dataframes from the source files ' )\\n \\n for k in self.datasets_keys:\\n #for k in ['igra2' , 'ncar']:\\n \\n logging.info('*** Creating the dataframe for the dataset: %s ' , k ) \\n \\n p_levels = self.data[k]['df']['observations_table']['z_coordinate'][:]\\n logging.debug(' Loaded the z_coordinate')\\n \\n z_type = self.data[k]['df']['observations_table']['z_coordinate_type'][:]\\n logging.debug(' Loaded the z_coordinate_type')\\n \\n obs_variable = self.data[k]['df']['observations_table']['observed_variable'][:]\\n logging.debug(' Loaded the observed_variable')\\n \\n obs_values = self.data[k]['df']['observations_table']['observation_value'][:]\\n logging.debug(' Loaded the observation_value')\\n \\n observation_id = self.data[k]['df']['observations_table']['observation_id'][:]\\n logging.debug(' Loaded the observation_id')\\n \\n units = self.data[k]['df']['observations_table']['units'][:].astype(int)\\n logging.debug(' Loaded the units') \\n \\n report_id = self.data[k]['df']['observations_table']['report_id'][:] \\n logging.debug(' Loaded the report_id')\\n \\n date_time = self.data[k]['df']['observations_table']['date_time'][:]\\n logging.debug(' Loaded the date_time (deltas)')\\n \\n lat , lon = self.data[k]['df']['observations_table']['latitude'][:] , self.data[k]['df']['observations_table']['longitude'][:]\\n logging.debug(' Loaded the lat,lon ')\\n \\n \\n self.obs_table_columns = list(self.data[k]['df']['observations_table'].keys() )\\n \\n self.data[k]['df'].close()\\n \\n \\\"\\\"\\\" Creating a dataframe \\\"\\\"\\\"\\n columns = ['date_time', 'z_coordinate' , 'z_coordinate_type', 'observed_variable' , 'observation_value' , 'report_id' , 'observation_id' , 'latitude' , 'longitude', 'units']\\n logging.info(' Loaded the data, creating dataframe ')\\n \\n df = pd.DataFrame( list(zip( date_time, p_levels, z_type, obs_variable , obs_values, report_id, observation_id , lat , lon, units ) ) , columns = columns ) \\n \\n \\n \\\"\\\"\\\" Storing the dataframe \\\"\\\"\\\" ### try using xarrays ??? \\n logging.debug('Storing the DF ' ) \\n self.data[k]['dataframe'] = df\\n \\n logging.debug(' PD dataframe created !!! ')\",\n \"def make_dataset(dataset_name):\\n return {\\n\\n 'duc': DUCDataset(),\\n\\n 'icsi-asr': ICSIASRDataset(),\\n 'icsi-ht': ICSIHumanTranscriptDataset(),\\n\\n 'inspec-train': InspectTrainingDataset(),\\n 'inspec-val': InspectValidationDataset(),\\n 'inspec-test': InspectTestDataset(),\\n\\n 'nus': NUSDataset()\\n\\n }[dataset_name]\",\n \"def nc_to_hdf5_mudis(dataset, config):\\n np.warnings.filterwarnings('ignore')\\n\\n date = datetime.datetime.strptime(dataset.recorddate,\\n '%d.%m.%Y') # read date from dateset\\n date_name = datetime.datetime.strftime(date,\\n '%Y%m%d') # convert date to YYYYMMDD format\\n config['date'] = date_name\\n\\n # Create the directory to save the results\\n path = config['str_dir'] + '/radiance/{}/data/'.format(config['date'])\\n os.makedirs(os.path.dirname(path), exist_ok=True)\\n\\n # Read time of the file (correct time)\\n time = datetime.datetime.strptime(dataset.recordtime, '%H:%M:%S.')\\n time = datetime.datetime.time(time)\\n\\n # convert time to datetime format\\n datetime_name = datetime.datetime.combine(date, time)\\n new_name = datetime.datetime.strftime(datetime_name, '%Y%m%d_%H%M%S')\\n\\n # radiance = dataset.variables['data'][:].reshape(113, 1281)\\n # wavelength_axis = dataset.variables['xAxis'][:]\\n\\n # Create a file in the disk\\n with h5py.File(config['str_dir'] + '/radiance/{}/data/{}.h5'.format(\\n config['date'], new_name), 'w') as datos:\\n\\n if not list(datos.items()):\\n # Create two datasets(use only one time)\\n datos.create_dataset('/data',\\n data=dataset['data'][:].reshape(113, 1281),\\n dtype='f4')\\n # datos.create_dataset('/skymap', data=skymap, dtype='f4')\\n else:\\n del datos['data']\\n # del datos['skymap']\\n print('data deleted and corrected')\\n datos.create_dataset('/data', data=data, dtype='f4')\\n # datos.create_dataset('/skymap', data=skymap, dtype='f4')\\n\\n # Add attributes to datasets\\n datos['data'].attrs['time'] = str(time)\\n datos['data'].attrs['Exposure'] = dataset.exposuretime\\n datos['data'].attrs['NumAver'] = dataset.AVERAGED\\n datos['data'].attrs['CCDTemp'] = dataset.detectortemperature\\n datos['data'].attrs['NumSingMes'] = dataset.noofaccumulations\\n # datos['data'].attrs['ElectrTemp'] = dataset.\\n datos['data'].attrs['Latitude'] = '52.39N'\\n datos['data'].attrs['Longitude'] = '9.7E'\\n datos['data'].attrs['Altitude'] = '65 AMSL'\\n\\n chn = np.arange(1, 114)\\n datos.create_dataset('/channel', data=chn, dtype=np.float32)\\n datos.create_dataset('/wavelength', data=dataset['xAxis'][:])\\n\\n datos['data'].dims.create_scale(datos['channel'], 'channel')\\n datos['data'].dims[0].attach_scale(datos['channel'])\\n datos['data'].dims[0].label = 'channel'\\n datos['data'].dims[1].label = 'wavelength'\\n\\n # datos['skymap'].dims[0].label = 'channel'\\n # datos['skymap'].dims[1].label = 'Azimuth, Zenith'\\n\\n datos.close()\",\n \"def main():\\n datasets = {}\\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\\\"Processing datasets and fitting base models\\\"):\\n logger.info(f\\\"processing dataset {dataset_name}\\\")\\n clusters_path: Optional[str] = None\\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_clusters.json\\\")\\n train_pairs_path = None\\n val_pairs_path = None\\n test_pairs_path = None\\n else:\\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"train_pairs.csv\\\")\\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"val_pairs.csv\\\")\\n if not os.path.exists(val_pairs_path):\\n val_pairs_path = None\\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"test_pairs.csv\\\")\\n\\n logger.info(f\\\"loading dataset {dataset_name}\\\")\\n anddata = ANDData(\\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_signatures.json\\\"),\\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_papers.json\\\"),\\n name=dataset_name,\\n mode=\\\"train\\\",\\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_specter.pickle\\\"),\\n clusters=clusters_path,\\n block_type=BLOCK_TYPE,\\n train_pairs=train_pairs_path,\\n val_pairs=val_pairs_path,\\n test_pairs=test_pairs_path,\\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\\n val_pairs_size=N_VAL_TEST_SIZE,\\n test_pairs_size=N_VAL_TEST_SIZE,\\n preprocess=True,\\n )\\n\\n logger.info(f\\\"featurizing {dataset_name}\\\")\\n train, val, test = featurize(\\n anddata,\\n FEATURIZER_INFO,\\n n_jobs=N_JOBS,\\n use_cache=True,\\n chunk_size=100,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\\n nan_value=NAN_VALUE,\\n )\\n X_train, y_train, nameless_X_train = train\\n X_val, y_val, nameless_X_val = val\\n X_test, y_test, nameless_X_test = test\\n\\n dataset = {}\\n dataset[\\\"anddata\\\"] = anddata\\n dataset[\\\"X_train\\\"] = X_train\\n dataset[\\\"y_train\\\"] = y_train\\n dataset[\\\"X_val\\\"] = X_val\\n dataset[\\\"y_val\\\"] = y_val\\n dataset[\\\"X_test\\\"] = X_test\\n dataset[\\\"y_test\\\"] = y_test\\n dataset[\\\"nameless_X_train\\\"] = nameless_X_train\\n dataset[\\\"nameless_X_val\\\"] = nameless_X_val\\n dataset[\\\"nameless_X_test\\\"] = nameless_X_test\\n dataset[\\\"name\\\"] = anddata.name\\n datasets[dataset_name] = dataset\\n\\n anddatas = [\\n datasets[dataset_name][\\\"anddata\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in PAIRWISE_ONLY_DATASETS\\n ]\\n\\n X_train = np.vstack([datasets[dataset_name][\\\"X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n y_train = np.hstack([datasets[dataset_name][\\\"y_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n X_val = np.vstack(\\n [datasets[dataset_name][\\\"X_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n y_val = np.hstack(\\n [datasets[dataset_name][\\\"y_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n\\n nameless_X_train = np.vstack([datasets[dataset_name][\\\"nameless_X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n nameless_X_val = np.vstack(\\n [\\n datasets[dataset_name][\\\"nameless_X_val\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in {\\\"augmented\\\"}\\n ]\\n )\\n\\n logger.info(\\\"fitting pairwise\\\")\\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\\n union_classifier.fit(X_train, y_train, X_val, y_val)\\n\\n nameless_union_classifier = None\\n if USE_NAMELESS_MODEL:\\n logger.info(\\\"nameless fitting pairwise for \\\" + str(SOURCE_DATASET_NAMES))\\n nameless_union_classifier = PairwiseModeler(\\n n_iter=N_ITER,\\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\\n )\\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\\n logger.info(\\\"nameless pairwise fit for \\\" + str(SOURCE_DATASET_NAMES))\\n\\n logger.info(\\\"fitting clusterer for\\\")\\n union_clusterer = Clusterer(\\n FEATURIZER_INFO,\\n union_classifier.classifier,\\n cluster_model=FastCluster(),\\n search_space=search_space,\\n n_jobs=N_JOBS,\\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\\n )\\n union_clusterer.fit(anddatas)\\n print(\\n \\\"best clustering parameters:\\\",\\n union_clusterer.best_params,\\n )\\n\\n models = {}\\n models[\\\"clusterer\\\"] = union_clusterer\\n\\n with open(\\n f\\\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\\\",\\n \\\"wb\\\",\\n ) as _pickle_file:\\n pickle.dump(models, _pickle_file)\\n logger.info(\\\"Done.\\\")\",\n \"def update_model(path_to_data, path_to_model):\\r\\n # Open the annotation files.\\r\\n with open(path_to_data + r'\\\\coco_annotation.json') as f:\\r\\n coco_d = json.load(f)\\r\\n # Get the categories.\\r\\n categories = []\\r\\n for cat in coco_d['categories']:\\r\\n categories.append(cat['name'])\\r\\n\\r\\n # Register the new data.\\r\\n register_coco_instances(\\\"coco_update\\\", {}, path_to_data + r\\\"\\\\coco_annotation.json\\\", path_to_data)\\r\\n MetadataCatalog.get(\\\"meta_update\\\").set(thing_classes=categories)\\r\\n # MetadataCatalog.get(\\\"meta_update\\\").set(thing_classes=[\\\"Bad\\\", \\\"Good\\\"], thing_colors=[(172, 0, 0), (229, 0, 0)])\\r\\n\\r\\n # Set the parameters.\\r\\n cfg = get_cfg()\\r\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\\\"))\\r\\n cfg.DATASETS.TRAIN = (\\\"coco_update\\\",)\\r\\n cfg.OUTPUT_DIR = path_to_model\\r\\n cfg.DATASETS.TEST = ()\\r\\n cfg.DATALOADER.NUM_WORKERS = 2\\r\\n cfg.MODEL.DEVICE = 'cpu'\\r\\n cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, \\\"model_final.pth\\\")\\r\\n cfg.SOLVER.IMS_PER_BATCH = 1\\r\\n cfg.SOLVER.BASE_LR = 0.00025\\r\\n cfg.SOLVER.MAX_ITER = 400\\r\\n cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 10\\r\\n cfg.MODEL.ROI_HEADS.NUM_CLASSES = len(categories)\\r\\n\\r\\n # Update the model.\\r\\n trainer = DefaultTrainer(cfg)\\r\\n trainer.resume_or_load(resume=False)\\r\\n trainer.train()\",\n \"def _info(self) -> tfds.core.DatasetInfo:\\n features = {\\n # sequence of [RGB, depth] images\\n \\\"image\\\": tfds.features.Sequence(\\n tfds.features.Image(shape=(600, 800, 3)), length=2,\\n ),\\n # sequence of image features for [RGB, depth]\\n \\\"images\\\": tfds.features.Sequence(\\n tfds.features.FeaturesDict(\\n {\\n \\\"file_name\\\": tfds.features.Text(),\\n \\\"height\\\": tf.int64,\\n \\\"width\\\": tf.int64,\\n \\\"id\\\": tf.int64,\\n },\\n ),\\n length=2,\\n ),\\n # both modalities share the same categories\\n \\\"categories\\\": tfds.features.Sequence(\\n tfds.features.FeaturesDict(\\n {\\n \\\"id\\\": tf.int64, # {'pedstrian':1, 'vehicles':2, 'trafficlight':3, 'patch':4}\\n \\\"name\\\": tfds.features.Text(),\\n }\\n )\\n ),\\n # both modalities share the same objects\\n \\\"objects\\\": tfds.features.Sequence(\\n {\\n \\\"id\\\": tf.int64,\\n \\\"image_id\\\": tf.int64,\\n \\\"area\\\": tf.int64, # un-normalized area\\n \\\"boxes\\\": tfds.features.BBoxFeature(), # normalized bounding box [ymin, xmin, ymax, xmax]\\n \\\"labels\\\": tfds.features.ClassLabel(num_classes=5),\\n \\\"is_crowd\\\": tf.bool,\\n }\\n ),\\n # these data only apply to the \\\"green screen patch\\\" objects, which both modalities share\\n \\\"patch_metadata\\\": tfds.features.FeaturesDict(\\n {\\n \\\"gs_coords\\\": tfds.features.Sequence(\\n tfds.features.Tensor(\\n shape=[2], dtype=tf.int64\\n ), # green screen vertices in (x,y)\\n length=4, # always rectangle shape\\n ),\\n \\\"cc_ground_truth\\\": tfds.features.Tensor(\\n shape=[24, 3], dtype=tf.float32\\n ), # colorchecker color ground truth\\n \\\"cc_scene\\\": tfds.features.Tensor(\\n shape=[24, 3], dtype=tf.float32\\n ), # colorchecker colors in a scene\\n # binarized segmentation mask of patch.\\n # mask[x,y] == 1 indicates patch pixel; 0 otherwise\\n \\\"mask\\\": tfds.features.Tensor(shape=[600, 800, 3], dtype=tf.uint8),\\n \\\"shape\\\": tfds.features.Text(),\\n }\\n ),\\n }\\n\\n return tfds.core.DatasetInfo(\\n builder=self,\\n description=_DESCRIPTION,\\n features=tfds.features.FeaturesDict(features),\\n citation=_CITATION,\\n )\",\n \"def merge_coco_annotations(anno_file_list, save_dir, pre_fixs, keep_cls=13):\\n annos = mmcv.load(anno_file_list[0])\\n categories =[info for info in annos['categories'] if info['id'] == keep_cls]\\n info = annos['info']\\n licenses = annos['licenses']\\n del annos\\n\\n new_coco_annotations = {}\\n new_annotations = []\\n new_images = []\\n image_idx_offset = 0\\n anno_idx_offset = 0\\n for file_i, file_path in tqdm(enumerate(anno_file_list), total=len(anno_file_list)):\\n annos = mmcv.load(file_path)\\n cur_images = annos['images']\\n cur_annotations = annos['annotations']\\n for img_info in cur_images: # loop through image_infos\\n img_info['id'] += image_idx_offset\\n img_info['file_name'] = os.path.join(pre_fixs[file_i], img_info['file_name'])\\n new_images.append(img_info)\\n for anno_info in cur_annotations: # loop through boxes\\n anno_info['id'] += anno_idx_offset\\n anno_info['image_id'] += image_idx_offset\\n cat_id = keep_cls if anno_info['category_id'] == keep_cls else 15\\n anno_info['category_id'] = cat_id\\n new_annotations.append(anno_info)\\n\\n image_idx_offset += len(cur_images)\\n anno_idx_offset += len(cur_annotations)\\n\\n new_coco_annotations['info'] = info\\n new_coco_annotations['licenses'] = licenses\\n new_coco_annotations['categories'] = categories\\n new_coco_annotations['annotations'] = new_annotations\\n new_coco_annotations['images'] = new_images\\n\\n print('convert done\\\\nsaving coco annotations')\\n mmcv.dump(new_coco_annotations, save_dir)\\n print('all done!')\",\n \"def create_dataset_dict(dataset: str, all_data_dict: dict) -> dict:\\n\\n return {\\n 'branch_comments_embedded_text_df': all_data_dict[dataset][f'branch_comments_embedded_text_df'],\\n 'branch_comments_features_df': all_data_dict[dataset][f'branch_comments_features_df'],\\n 'branch_comments_user_profiles_df': all_data_dict[dataset][f'branch_comments_user_profiles_df'],\\n 'branch_submission_dict': all_data_dict[dataset][f'branch_submission_dict'],\\n 'submission_data_dict': all_data_dict[dataset][f'submission_data_dict'],\\n 'branch_deltas_data_dict': all_data_dict[dataset][f'branch_deltas_data_dict'],\\n 'branches_lengths_list': all_data_dict[dataset][f'branches_lengths_list'],\\n 'len_df': all_data_dict[dataset]['len_df']\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7177033","0.6570015","0.6285049","0.6221178","0.611349","0.6035911","0.57440627","0.5730883","0.55947363","0.5550295","0.55144775","0.55096453","0.5449006","0.54164267","0.54066616","0.5378364","0.5358252","0.53523004","0.5315025","0.53006166","0.52751917","0.52599084","0.5252502","0.5243089","0.52422625","0.52382267","0.52332723","0.51955414","0.51893556","0.5188074","0.5180327","0.51510614","0.5133625","0.5123209","0.51189053","0.51085836","0.5096402","0.50855505","0.5076382","0.50698453","0.50609493","0.50564456","0.5054036","0.5034961","0.5033961","0.50266635","0.5024288","0.50228155","0.50150955","0.50133526","0.50126374","0.50060457","0.5002489","0.49817988","0.49731982","0.49583542","0.4952396","0.49313256","0.49190736","0.4918561","0.49175924","0.49153927","0.4912753","0.49072006","0.4902035","0.49010774","0.4895797","0.48916045","0.48910144","0.48879376","0.48781306","0.4866957","0.4862119","0.48558533","0.48408082","0.48394704","0.48371738","0.48312485","0.48175615","0.4816929","0.48156166","0.4804166","0.48010725","0.47981948","0.47901267","0.47866932","0.47843868","0.47800732","0.47778484","0.47720557","0.47664922","0.47653154","0.47576448","0.4754369","0.4745958","0.474592","0.47274458","0.47269487","0.4724094","0.4721283"],"string":"[\n \"0.7177033\",\n \"0.6570015\",\n \"0.6285049\",\n \"0.6221178\",\n \"0.611349\",\n \"0.6035911\",\n \"0.57440627\",\n \"0.5730883\",\n \"0.55947363\",\n \"0.5550295\",\n \"0.55144775\",\n \"0.55096453\",\n \"0.5449006\",\n \"0.54164267\",\n \"0.54066616\",\n \"0.5378364\",\n \"0.5358252\",\n \"0.53523004\",\n \"0.5315025\",\n \"0.53006166\",\n \"0.52751917\",\n \"0.52599084\",\n \"0.5252502\",\n \"0.5243089\",\n \"0.52422625\",\n \"0.52382267\",\n \"0.52332723\",\n \"0.51955414\",\n \"0.51893556\",\n \"0.5188074\",\n \"0.5180327\",\n \"0.51510614\",\n \"0.5133625\",\n \"0.5123209\",\n \"0.51189053\",\n \"0.51085836\",\n \"0.5096402\",\n \"0.50855505\",\n \"0.5076382\",\n \"0.50698453\",\n \"0.50609493\",\n \"0.50564456\",\n \"0.5054036\",\n \"0.5034961\",\n \"0.5033961\",\n \"0.50266635\",\n \"0.5024288\",\n \"0.50228155\",\n \"0.50150955\",\n \"0.50133526\",\n \"0.50126374\",\n \"0.50060457\",\n \"0.5002489\",\n \"0.49817988\",\n \"0.49731982\",\n \"0.49583542\",\n \"0.4952396\",\n \"0.49313256\",\n \"0.49190736\",\n \"0.4918561\",\n \"0.49175924\",\n \"0.49153927\",\n \"0.4912753\",\n \"0.49072006\",\n \"0.4902035\",\n \"0.49010774\",\n \"0.4895797\",\n \"0.48916045\",\n \"0.48910144\",\n \"0.48879376\",\n \"0.48781306\",\n \"0.4866957\",\n \"0.4862119\",\n \"0.48558533\",\n \"0.48408082\",\n \"0.48394704\",\n \"0.48371738\",\n \"0.48312485\",\n \"0.48175615\",\n \"0.4816929\",\n \"0.48156166\",\n \"0.4804166\",\n \"0.48010725\",\n \"0.47981948\",\n \"0.47901267\",\n \"0.47866932\",\n \"0.47843868\",\n \"0.47800732\",\n \"0.47778484\",\n \"0.47720557\",\n \"0.47664922\",\n \"0.47653154\",\n \"0.47576448\",\n \"0.4754369\",\n \"0.4745958\",\n \"0.474592\",\n \"0.47274458\",\n \"0.47269487\",\n \"0.4724094\",\n \"0.4721283\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56904554"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":77681,"cells":{"query":{"kind":"string","value":"Register a new strategy for generating data for specific string \"format\"."},"document":{"kind":"string","value":"def register_string_format(name: str, strategy: st.SearchStrategy) -> None:\n if not isinstance(name, str):\n raise TypeError(f\"name must be of type {str}, not {type(name)}\")\n if not isinstance(strategy, st.SearchStrategy):\n raise TypeError(f\"strategy must be of type {st.SearchStrategy}, not {type(strategy)}\")\n\n STRING_FORMATS[name] = strategy"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def register_data_format(format_name,parser):\n\n data_format_parser[format_name] = parser","def register_str_format(\n tag: Tag, conformer: Optional[Conformer] = None\n) -> Callable[[ValidatorFn], ValidatorFn]:\n\n def create_str_format(f: ValidatorFn) -> ValidatorFn:\n with _STR_FORMAT_LOCK:\n _STR_FORMATS[tag] = StrFormat(f, conformer=conformer)\n return f\n\n return create_str_format","def register_format(recipe):\n afr = AFMFormatRecipe(recipe)\n formats_available.append(afr)\n # suffix\n if afr.suffix not in formats_by_suffix:\n formats_by_suffix[afr.suffix] = []\n formats_by_suffix[afr.suffix].append(afr)\n # mode\n if afr.mode not in formats_by_mode:\n formats_by_mode[afr.mode] = []\n formats_by_mode[afr.mode].append(afr)\n # supported extensions\n if afr.suffix not in supported_extensions: # avoid duplucates\n supported_extensions.append(afr.suffix)\n supported_extensions.sort()","def Register(self, name, fn):\n name = normalizeStr(name)\n Logger.Debug(\"Registering Formatter:\", name)\n self._formatters[name] = fn","def register_filename_format(format_name,parser):\n if format_name == \"ALL\":\n raise ValueError(\"filename format code ALL is reserved\")\n\n filename_format_parser[format_name] = parser","def __init__(self, format_string):\r\n if not isinstance(format_string, Compatibility.string):\r\n raise TypeError('format_string should be a string, instead got %s' % type(format_string))\r\n self._re_pattern, self._applicators = self._preprocess_format_string(format_string)\r\n self._re = re.compile(self._re_pattern)","def register(\n self, name='', magic=(), patterns=(),\n funcwrapper=lambda _:_\n ):\n\n def _decorator(converter):\n if not name:\n raise ValueError('No registration name given')\n if name in self._names:\n raise ValueError(f'Registration name `{name}` already in use for {self._names[name]}')\n if not isinstance(magic, (list, tuple)):\n raise TypeError('Registration parameter `magic` must be list or tuple')\n if not isinstance(patterns, (list, tuple)):\n raise TypeError('Registration parameter `patterns` must be list or tuple')\n converter.format = name\n self._names[name] = converter\n ## magic signatures\n for sequence in magic:\n self._magic.append((Magic(sequence), converter))\n # sort the magic registry long to short to manage conflicts\n self._magic = list(sorted(\n self._magic,\n key=lambda _i:len(_i[0]), reverse=True\n )\n )\n ## glob patterns\n for pattern in (*patterns, f'*.{name}'):\n self._patterns.append((to_pattern(pattern), converter))\n return funcwrapper(converter)\n\n return _decorator","def register_output_format(name):\n\n def check_decorator(fn):\n _output_format_map[name] = fn\n\n def wrapper(*args, **kwargs):\n return fn(*args, **kwargs)\n\n return wrapper\n\n return check_decorator","def register(self, format, serfunc):\n if not isinstance(serfunc, func):\n raise TypeError(\"Serializer.register(): serfunc is not a function: \"+\n str(func))\n self._map[format] = serfunc","def assign_format(self):\n if self.is_output or self.is_req_output:\n if self.pname in self.tool_data[self.tool_name]['output_fmt']:\n return self.tool_data[self.tool_name]['output_fmt'][self.pname]\n elif self.pname in self.gen_out_fmt:\n return self.gen_out_fmt[self.pname]\n elif self.is_input:\n if self.pname in self.tool_data[self.tool_name]['input_fmt']:\n print(self.tool_data[self.tool_name])\n return self.tool_data[self.tool_name]['input_fmt'][self.pname]\n elif self.pname in self.gen_in_fmt:\n return self.gen_in_fmt[self.pname]\n else:\n # Not sure yet what this will be used for, but I think we need it.\n return ''","def register(file_format, extensions, reader, writer=None):\n register_format(\n fmt=file_format,\n ext_to_fmt=_extension_to_filetype,\n reader_map=_reader_map,\n writer_map=_writer_map,\n extensions=extensions,\n reader=reader,\n writer=writer,\n )","def register(file_format, extensions, reader, writer=None):\n register_format(\n fmt=file_format,\n ext_to_fmt=_extension_to_filetype,\n reader_map=_reader_map,\n writer_map=_writer_map,\n extensions=extensions,\n reader=reader,\n writer=writer,\n )","def register_code_name(code_name,format_name):\n if format_name not in data_format_parser:\n raise ValueError(\"unknown format_name: {:s}\".format(format_name))\n code_name_map[code_name] = format_name","def used_implementation(self, impl: str, value):","def formatLookup(format_str):\n pat = '(\\d+)([A-Z])'\n match = re.search(pat, format_str)\n #print match.group()\n \n data_len = int(match.group(1))\n data_fmt = str(match.group(2))\n np_fmt = fitsFormatLookup(data_fmt)\n np_dtype = '%i%s'%(data_len, np_fmt)\n \n return np_dtype, data_len, np_fmt","def add_formatter(config: Configurator, name: str, func: t.Callable) -> None:\n config.registry.settings.setdefault(\"pyramid_openapi3_formatters\", {})\n reg = config.registry.settings[\"pyramid_openapi3_formatters\"]\n reg[name] = func","def __new__(cls, format):\n self = super(SF_Pattern, cls).__new__(cls)\n\n if isinstance(format, bytes):\n uni_str = format.decode('ISO-8859-1') # decode to unicode\n trans_str = translate(uni_str) # translate only works with unicode\n re_fmt = trans_str.encode('ISO-8859-1') # encode back to bytes\n self._spec = _gbspec\n else:\n re_fmt = translate(format)\n self._spec = _gspec\n\n self._format = format\n self._re = cre = re.compile(re_fmt)\n\n if cre.groupindex and len(cre.groupindex) != cre.groups:\n raise RuntimeError('cannot mix mapped and unmapped specifiers')\n elif not cre.groupindex:\n self._retfunc = self._return_tuple\n self._type = tuple\n else:\n self._retfunc = self._return_dict\n self._type = dict\n\n self._casts = self._get_types()\n\n return self","def register_pattern(name, pattern_factory, override=None):\n\tif not isinstance(name, string_types):\n\t\traise TypeError(\"name:{!r} is not a string.\".format(name))\n\tif not callable(pattern_factory):\n\t\traise TypeError(\"pattern_factory:{!r} is not callable.\".format(pattern_factory))\n\tif name in _registered_patterns and not override:\n\t\traise AlreadyRegisteredError(name, _registered_patterns[name])\n\t_registered_patterns[name] = pattern_factory","def extension (formatStr):\n assert False, \"TODO:\"","def register(self, what, obj):\n # print(\"Registering pattern\", name, pattern)\n name = obj.name\n version = obj.version\n enable = obj.enable\n if enable == 'n':\n return\n\n key = Key(name, version)\n self.plugins[what][key] = obj","async def test_string_data_type(hass, mock_hub):\n register_config = {\n CONF_COUNT: 8,\n CONF_REGISTER_TYPE: CALL_TYPE_REGISTER_HOLDING,\n CONF_DATA_TYPE: DATA_TYPE_STRING,\n CONF_SCALE: 1,\n CONF_OFFSET: 0,\n CONF_PRECISION: 0,\n }\n await run_test(\n hass,\n mock_hub,\n register_config,\n SENSOR_DOMAIN,\n register_words=[0x3037, 0x2D30, 0x352D, 0x3230, 0x3230, 0x2031, 0x343A, 0x3335],\n expected=\"07-05-2020 14:35\",\n )","def formatter(question: dict):\n fmt = question.get('possibilities', {}).get('format')\n if fmt == 'date':\n return pd.to_datetime\n elif fmt == 'num':\n return lambda x: x\n else:\n raise ValueError(f\"Question format {fmt} unknown\")","def init_default_strategies() -> None:\n register_string_format(\"binary\", st.binary())\n register_string_format(\"byte\", st.binary().map(lambda x: b64encode(x).decode()))\n\n def make_basic_auth_str(item: Tuple[str, str]) -> str:\n return _basic_auth_str(*item)\n\n latin1_text = st.text(alphabet=st.characters(min_codepoint=0, max_codepoint=255))\n\n register_string_format(\"_basic_auth\", st.tuples(latin1_text, latin1_text).map(make_basic_auth_str)) # type: ignore\n register_string_format(\"_bearer_auth\", st.text().map(\"Bearer {}\".format))","def initFormat(self):\n pass","def __call__(self, format, filename):\n # turn the filename into something suitable for use in #define's\n prettyname = filename.replace(\".\", \"_\").upper()\n prettyname = prettyname.replace(\"/\", \"__\")\n prettyname = prettyname.replace(\":\", \"__\")\n prettyname = prettyname.replace(\"-\", \"__\")\n\n # try and open the file\n with open(filename, \"w\") as output:\n self.writeFuncsLut[format]( output, prettyname )","def coords_format(format):\n if format == 'galactic':\n return 'galactic'\n elif format in ['fk5','icrs']:\n return 'celestial'","def AddFormat(self, format):\n self._legacy = False\n if format:\n self._format = format","def format_to_extension(self, format):","def pattern_gen():\n pattern = \"\"\n\n return pattern","def register( self, pattern, callback ):\n self.patterns.append((pattern, callback))","def __init__(\n self,\n spacy_pipeline,\n lowercase=False,\n format: str ='gem',\n ):\n\n self.lowercase = lowercase\n self.format = format\n self.spacy_pipeline = spacy_pipeline","def get_template(self, format):\n for pattern, converter in self._patterns:\n if converter.format == format:\n template = pattern.generate('{name}')\n if template:\n return template\n return '{name}' f'.{format}'","def _handle_string(\n *, artifacts: types.ColumnArtifacts\n) -> typing.Union[String, Binary, Date, DateTime]:\n if artifacts.open_api.format in {None, \"byte\", \"password\"}:\n if artifacts.open_api.max_length is None:\n return String\n return String(length=artifacts.open_api.max_length)\n if artifacts.open_api.format == \"binary\":\n if artifacts.open_api.max_length is None:\n return Binary\n return Binary(length=artifacts.open_api.max_length)\n if artifacts.open_api.format == \"date\":\n return Date\n if artifacts.open_api.format == \"date-time\":\n return DateTime\n raise exceptions.FeatureNotImplementedError(\n f\"{artifacts.open_api.format} format for string is not supported.\"\n )","def set_quantize_strategy(self,\n new_quantize_strategy='quantize_strategy.json'):\n if self._model_format == 'pb':\n logger.warning('This function does not support pb format model.')\n return None\n\n if isinstance(new_quantize_strategy, str):\n new_quantize_strategy = common_utils.load_json(new_quantize_strategy)\n elif not isinstance(new_quantize_strategy, dict):\n logger.error(\n 'new_quantize_strategy should be filepath or dict, but found {}'\n .format(type(new_quantize_strategy)))\n\n self._quantize_strategy.update(new_quantize_strategy)","def _add_format_spec(self, fmt_name_key: str, fmt_spec : gsfmt.CellFormat):\n if not len(fmt_name_key) or not isinstance(fmt_spec, gsfmt.CellFormat):\n raise (ValueError, \"Invalid format specification data\")\n else:\n self.format_specs[fmt_name_key] = fmt_spec","def _file_format_adapter(self):\n raise NotImplementedError","def update_placeholder_formats(self, format_string, placeholder_formats):\n # Tokenize the format string and process them\n output = []\n for token in self.tokens(format_string):\n if (\n token.group(\"placeholder\")\n and (not token.group(\"format\"))\n and token.group(\"key\") in placeholder_formats\n ):\n output.append(f\"{{{token.group('key')}{placeholder_formats[token.group('key')]}}}\")\n continue\n value = token.group(0)\n output.append(value)\n return \"\".join(output)","def __format__(self, format_spec):\n if format_spec == \"polite\":\n return self.polite\n elif format_spec == \"casual\":\n return self.casual\n else:\n # Using string addition here to avoid triggering flake8-sfs\n # while still giving a meaningful self-contained example:\n raise ValueError(format_spec + \" not a format defined by Client object\")","def data_format(self, data_format):\n self._data_format = data_format","def asformat(self, format):","def strategy(self, strategy):\n\n if strategy == \"auto\":\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 0)\n elif strategy == \"cranelift\":\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 1)\n elif strategy == \"lightbeam\":\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 2)\n else:\n raise WasmtimeError(\"unknown strategy: \" + str(strategy))\n if error:\n raise WasmtimeError.__from_ptr__(error)","def add_formatter(self, fmt):\n if fmt and not isfunction(fmt):\n raise TypeError(\"custom format function must be a type of function\")\n\n if fmt and fmt.__code__.co_argcount < 2:\n raise TypeError(\"custom format function requires at least 2 arguments\")\n\n self.formatter = fmt","def add_pattern(self, name, pattern=None):\n assert isinstance(name, str) and len(name) < 32 and name.find(' ') == -1, \"name must be a string with less than 32 characters and contain no spaces\"\n assert isinstance(pattern, (list, np.ndarray, Pattern)), \"pattern must be a list or Pattern\"\n \n if not isinstance(pattern, Pattern):\n pattern = Pattern(name, multipliers=pattern, time_options=self._options.time) \n else: #elif pattern.time_options is None:\n pattern.time_options = self._options.time\n if pattern.name in self._data.keys():\n raise ValueError('Pattern name already exists')\n self[name] = pattern","def add_formatter(self, regexp, conv, userdata=None):\n if isinstance(regexp, str):\n regexp = re.compile(regexp)\n self._formatters.append([regexp, conv, userdata])","def add_format(self, key, value=None):\n if key in self.FORMAT:\n return\n self.FORMAT.append(key)\n if value is not None:\n for call in self:\n call.data.setdefault(key, value)","def initFormat(self):\n self.formatList = self.splitText(self.format)","def strategy(func):\n strategies.append(func)\n return func","def add_pattern(self, command, pattern_string):\n parts = pattern_string.split(\":\")\n if len(parts) != 2:\n raise AssertionError(\"Cannot parse '{value}' to pattern\".format(value = value))\n pattern_id = parts[0]\n pattern_values = parts[1].split(',')\n pattern = Pattern(pattern_id, pattern_values)\n self._config.add_pattern(command, pattern)","def _is_format_endpoint(pattern):\n return '?P<format>' in pattern._regex","def __init_key_value_fmts__(self):\n self.test_desc_fmt = \"{0}.description\"\n self.test_svc_name_fmt = \"{0}.svc\"\n self.test_svc_ipc_id_fmt = \"{0}.svc.{1}.ipc_id\"\n self.test_svc_rsp_code_fmt = \"{0}.svc.{1}.svc_rsp_code\"\n self.test_svc_rsp_stage_fmt = \"{0}.svc.{1}.svc_rsp_stage\"\n self.test_pre_hook_stage_fmt = \"{0}.pre_hook.stage\"\n self.test_pre_hook_script_fmt = \"{0}.pre_hook.script\"\n self.test_post_hook_stage_fmt = \"{0}.post_hook.stage\"\n self.test_post_hook_script_fmt = \"{0}.post_hook.script\"\n self.test_svc_rsp_time_delay_fmt = \"{0}.svc.{1}.rsp_time_delay\"\n\n self.test_expected_result_fmt = \"{0}.expected_result\"\n self.test_exp_api_return_fmt = \"{0}.expected_result.api_return_code\"\n self.test_exp_log_file_fmt = \"{0}.expected_result.log\"\n self.test_exp_log_fmt = \"{0}.expected_result.log.{1}\"","def __init__(self, format_url, transform_string=None):\n self.format_url = format_url\n\n if callable(transform_string):\n self.transform_string = transform_string","def set_format_by_type(self, value, format):\n self.set_render_func_by_type(value, format.format)","def register_factory(factory, from_protocol, to_protocol):\n manager = get_global_adaptation_manager()\n return manager.register_factory(factory, from_protocol, to_protocol)","def format(self, data):","def __call__(self, input_type, output_format):\n self.configure()\n return self._object_graph.provide(\\\n self._plugins[input_type][output_format])","def register_factory(factory, iface, requires, name):","def get_format(self):\n pass","def strategy(self) -> AwesomeVersionStrategy:\n return version_strategy(self.string)","def loadFeatureWriterFromString(spec):\n return _loadPluginFromString(spec, \"ufo2ft.featureWriters\", isValidFeatureWriter)","def _generate_data(phg: str = None, rng: str = None, dfs: str = None, course: int = None,\n speed: int = None, altitude: int = None, comment: str = None) -> str:\n\n data = \"\"\n if phg:\n data += phg\n elif rng:\n data += rng\n elif dfs:\n data += dfs\n elif course and speed:\n data += \"{}/{}\".format(\n str(course).zfill(3), str(speed).zfill(3)\n )\n\n if altitude:\n data += \"/A={}\".format(\n str(altitude).zfill(6)\n )\n\n if comment:\n data += comment\n\n return data","def InitStrategy(self, sname, strategy):\n\n self._string = sname\n\n self.strategy = strategy\n self.postracker = position.PositionTracker(self.strategy)","def set_format(cls,format):\n import __main__\n IP = __main__.__dict__['__IP']\n prompt = getattr(IP.outputcache,cls._prompt)\n prompt.p_template = format\n prompt.set_p_str()\n cls._format = format","def addIfMissing(self, format):\n self.setdefault(format.name, format)","def test_unsupported_format():\n formatter = TabularOutputFormatter()\n\n with pytest.raises(ValueError):\n formatter.format_name = \"foobar\"\n\n with pytest.raises(ValueError):\n formatter.format_output((), (), format_name=\"foobar\")","def format(self, *args, **kwargs):\n raise NotImplementedError()","def parser_formatter(format_class, **kwargs):\n try:\n return lambda prog: format_class(prog, **kwargs)\n except TypeError:\n return format_class","def parser_formatter(format_class, **kwargs):\n try:\n return lambda prog: format_class(prog, **kwargs)\n except TypeError:\n return format_class","def format(self, *args, **kwargs) -> String:\n pass","def test_specify_format(self):\n t = ConfigurableDatasetRequest('SomeCoolSet',\n params=dict(subjectid='45838',\n locale='eng',\n app_instance_uuid='1234'))\n\n self.assertEqual(Url('datasets/SomeCoolSet?subjectid=45838&'\n 'locale=eng&'\n 'app_instance_uuid=1234'), Url(t.url_path()))\n t = ConfigurableDatasetRequest('SomeCoolSet',\n dataset_format=\"csv\",\n params=dict(subjectid='45838',\n locale='eng',\n app_instance_uuid='1234'))\n\n self.assertEqual(Url('datasets/SomeCoolSet.csv?subjectid=45838&'\n 'locale=eng&'\n 'app_instance_uuid=1234'), Url(t.url_path()))","def training_pattern_setup(self, **overrides):\n raise NotImplementedError","def add_convertor(metadata):\n\n metadata[\"convertor\"] = make_convertor(metadata[\"name\"],\n metadata[\"datatype\"])","def register_serializer(format, serializer_module, serializers=None):\n module = importlib.import_module(serializer_module)\n if serializers is None:\n _test_serializers[format] = module\n else:\n serializers[format] = module","def set_sampling_strategy(self, namespace, sensor_name,\n strategy_and_params, persist_to_redis=False):\n req = JSONRPCRequest(\n 'set_sampling_strategy',\n [namespace, sensor_name, strategy_and_params, persist_to_redis]\n )\n result = yield self._send(req)\n self._cache_jsonrpc_request(req)\n raise tornado.gen.Return(result)","def autodetect_format(file_data):\n\n # The first header line.\n for line in file_data:\n if line != []:\n break\n\n # Sparky format.\n if line[0] == 'Assignment':\n return 'sparky'\n\n # NMRView format.\n if line == ['label', 'dataset', 'sw', 'sf']:\n return 'nmrview'\n\n # NMRPipe SeriesTab.\n if line[0] == 'REMARK' and line[1] == 'SeriesTab':\n return 'seriestab'\n\n # XEasy format.\n if line == ['No.', 'Color', 'w1', 'w2', 'ass.', 'in', 'w1', 'ass.', 'in', 'w2', 'Volume', 'Vol.', 'Err.', 'Method', 'Comment']:\n return 'xeasy'\n\n # Assume a generic format.\n return 'generic'","def make_specgrams_helper(self):\n raise NotImplementedError","def by_extension_and_format(cls, extension: str, ser_format: str):\n if cls._format_to_serializer is None:\n cls._register_subclasses()\n if ser_format == 'auto':\n serializer = cls._extension_to_serializer.get(extension.lstrip('.'))\n else:\n serializer = cls._format_to_serializer.get(ser_format)\n\n if serializer is None:\n raise InvalidExtensionOrFormat(\n 'Cannot find serializer for format: %s and extension %s' % (\n ser_format, extension))\n return serializer","def setDataFormat(self, format='yaml'):\n self.dataFormat = format;","def make_parsing_fn(data_format,\n list_size=None,\n context_feature_spec=None,\n example_feature_spec=None,\n size_feature_name=None,\n mask_feature_name=None,\n shuffle_examples=False,\n seed=None):\n kwargs = {\n \"list_size\": list_size,\n \"context_feature_spec\": context_feature_spec,\n \"example_feature_spec\": example_feature_spec,\n \"size_feature_name\": size_feature_name,\n \"mask_feature_name\": mask_feature_name,\n \"shuffle_examples\": shuffle_examples,\n \"seed\": seed\n }\n fns_dict = {\n EIE: parse_from_example_in_example,\n SEQ: parse_from_sequence_example,\n ELWC: parse_from_example_list,\n }\n if data_format in fns_dict:\n return functools.partial(fns_dict[data_format], **kwargs)\n else:\n raise ValueError(\"Format {} is not supported.\".format(data_format))","def format_sampler(val):\n return val","def register_string(self,string):\n return self.registry.register_string(string)","def register_to_converter(cls, coord_system):\n print(f\"Registering to converter for {coord_system} in {cls.__name__}\")\n def anon_reg_func(callback):\n cls.to_other_conversions[coord_system] = callback\n return callback\n return anon_reg_func","def _set_real_format(self, fmt):\n # try to use the _nomax variant if available\n if not self._max and fmt + '_nomax' in self.formats:\n self._format = self.formats[fmt + '_nomax']\n elif fmt in self.formats:\n self._format = self.formats[fmt]\n else:\n self._format = fmt\n\n self._format_line_count = self._format.count('\\n')","def format_data(self, data):","def validate_format(self):\n raise NotImplementedError()","def register_type(type_, serializer_deserializer: Tuple[Callable[[T], str], Callable[[str], T]]):\n global _transform\n if type_ not in _transform:\n _transform[type_] = serializer_deserializer\n _load_types()","async def test_parameters_as_strings(hass, mock_hub):\n register_config = {\n CONF_COUNT: 1,\n CONF_DATA_TYPE: DATA_TYPE_INT,\n CONF_SCALE: \"1.5\",\n CONF_OFFSET: \"5\",\n CONF_PRECISION: \"1\",\n }\n await run_test(\n hass,\n mock_hub,\n register_config,\n SENSOR_DOMAIN,\n register_words=[9],\n expected=\"18.5\",\n )","def _create_Data(classname, typename):\n attributes = {\"typename\": typename}\n if \"complex\" in typename:\n def format_sampler(self, val):\n \"\"\"Format surrounded by [] for the sampler.\n\n 2x space (for real and complex parts).\n \"\"\"\n if isinstance(val, int):\n return \"[%s]\" % (2 * val)\n return val\n attributes[\"format_sampler\"] = format_sampler\n globals()[classname] = type(classname, (Data,), attributes)","def string_feature(ds, feature: str, verbosity=0, dim=\"sample\", numeric_dis=True):\n t = get_annotation_table(ds, dim)\n ser = t[feature]\n dt = ser.dtype\n descript = \"\"\"\"\"\"\n\n non_null_ser = ser[ser.notnull()]\n null_flag = len(non_null_ser) < len(ser)\n levels = list(set(non_null_ser.values))\n num_levels = len(levels)\n\n if dt == pd.StringDtype():\n\n if num_levels >= 50:\n descript += f\"\"\"\nSorry, {feature} is a String feature with too many factor levels \n(n = {num_levels}) to describe, here \n\"\"\"\n\n elif num_levels < 50 and num_levels >= 2:\n descript += f\"\"\"\n{feature}: {dt} Feature\n-------------------------\n\nFactor level counts df:\n\n{non_null_ser.value_counts()}\n\n\nSome example query statements:\n------------------------------\n\n{feature} in ['{levels[0]}', '{levels[1]}', ...]\n\n{feature} not in ['{levels[0]}', '{levels[-1]}', ...]\n\n{feature} != '{levels[-2]}'\n\"\"\"\n\n else:\n descript += f\"\"\"\nThere's only a single factor level, {levels[0]}, across all samples.\n\"\"\"\n\n elif dt == pd.BooleanDtype():\n descript += f\"\"\"\n{feature}: {dt} Feature:\n---------------------------\n\nFactor level counts df:\n\n{non_null_ser.value_counts()}\n\n\nSome example query statements:\n------------------------------\n\n{feature} == True\n\n{feature} == False\n\"\"\"\n\n elif dt == pd.Int64Dtype() or dt == pd.Float64Dtype():\n if num_levels == 1:\n descript += f\"\"\"\nThere's only a single factor level, {levels[0]}, across all samples.\n\"\"\"\n\n elif (num_levels > 1) and (not numeric_dis):\n descript += f\"\"\"\n{feature}: {dt} Feature\n-------------------------\n\nFactor level counts df:\n\n{non_null_ser.value_counts()}\n\n\nSome example query statements:\n------------------------------\n\n{feature} in [{levels[0]}, {levels[1]}, ...]\n\n{feature} not in [{levels[0]}, {levels[-1]}, ...]\n\n{feature} != {levels[-2]}\n\"\"\"\n else:\n des = ser.describe()\n descript += f\"\"\"\n{feature}: {dt} Feature:\n---------------------------\n\ndistribution of numerical feature:\n\n{des}\n\nSome example query statements:\n------------------------------\n\n{feature} >= {int(des[1])}\n\n{feature} <= {int(des[1])}\n\n({feature} >= {int(des[4])}) and ({feature} <= {int(des[5])})\n\"\"\"\n\n else:\n descript += f\"\"\"\n{feature}: {dt} Feature\n-------------------------\n\nFactor level counts df:\n\n{non_null_ser.value_counts()}\n\n\nSome example query statements:\n------------------------------\n\n{feature} in ['{levels[0]}', '{levels[1]}', ...]\n\n{feature} not in ['{levels[0]}', '{levels[-1]}', ...]\n\n{feature} != '{levels[-2]}'\n\"\"\"\n\n if null_flag:\n descript += f\"\"\"\n{feature}.isnull()\n\n{feature}.notnull()\n\"\"\"\n\n return descript","def __init__(self, **kwargs):\n super(Converter, self).__init__()\n self._specfile = kwargs.get(\"specfile\", None)\n self._parsed = False\n self._columns = []\n self._offsets = []\n self._fixed_with_encoding = Encodings.default_fixedwidth_enc()\n self._included_header = False\n self._delimited_encoding = Encodings.default_delimited_enc()\n self.encoder_spec()","def _register_datasource_and_factory_method(\n cls,\n ds_type: Type[Datasource],\n factory_fn: SourceFactoryFn,\n ds_type_name: str,\n datasource_type_lookup: TypeLookup,\n ) -> str:\n method_name = f\"add_{ds_type_name}\"\n LOGGER.info(\n f\"2a. Registering {ds_type.__name__} as {ds_type_name} with {method_name}() factory\"\n )\n\n pre_existing = cls.__source_factories.get(method_name)\n if pre_existing:\n raise TypeRegistrationError(\n f\"'{ds_type_name}' - `sources.{method_name}()` factory already exists\",\n )\n\n datasource_type_lookup[ds_type] = ds_type_name\n LOGGER.info(f\"'{ds_type_name}' added to `type_lookup`\")\n cls.__source_factories[method_name] = factory_fn\n return ds_type_name","def add_pattern(self, pattern, callback):\n self.patterns.append((pattern, callback))","def GuessDateConcept(data_format):\n stripped_format = data_format.strip()\n\n if re.search('^y+$', stripped_format):\n return 'time:year'\n elif re.search('^([yM]|[^a-zA-Z0-9])+$', stripped_format):\n return 'time:month'\n elif re.search('^([yMd]|[^a-zA-Z0-9])+$', stripped_format):\n return 'time:day'\n else:\n raise DataSourceError(\n 'Can\\'t figure out time concept for format: %s' % data_format)","def format(self):\n ...","def get_exporter(format, exporters):\n\n if format in exporters:\n return exporters[format]\n if format == 'sql':\n return export_sql\n elif format == 'json':\n return export_json\n\n raise RuntimeError('Unsupported format: %s' % format)","def update_json(\n self, unformatted_path: str, strategy: str, epoch: int, iteration: int, data\n ):\n json_data = self.load_json(unformatted_path)\n json_data[strategy] = json_data.get(strategy, {})\n json_data[strategy][str(epoch)] = json_data[strategy].get(\n str(epoch), {str(epoch): {}}\n )\n json_data[strategy][str(epoch)][str(iteration)] = data\n self.dump_json(unformatted_path, json_data)","def opt_format(self, fmt):\n key = get_enum_key(fmt, FORMATTERS)\n if key is not None:\n self.conf[\"format\"] = key\n print(\"Set format %r\" % key)\n else:\n print(\"Unknown format %r\" % fmt)","def codeCfg(suffix, cfg):\n if suffix == '' or suffix == None:\n config = { 'series': 'a', 'trajectory': int(cfg) }\n else:\n config = { 'series': suffix, 'trajectory': int(cfg) }\n return '%(series)s%(trajectory)06d' % config","def __format__(self, format_specification=''):\n return super().__format__(format_specification=format_specification)","def add_pattern(self, pattern):\n self.patterns.append(pattern)","def formatter(formatter_name):\n\n def _formatter_decorator(f):\n def _formatter_wrapper(*wrapper_args, **wrapper_kwargs):\n ctx = wrapper_args[1]\n if not ctx.json and formatter_name in _formatter_functions:\n ctx.format_function = _formatter_functions[formatter_name]\n return f(*wrapper_args, **wrapper_kwargs)\n\n return _formatter_wrapper\n\n return _formatter_decorator"],"string":"[\n \"def register_data_format(format_name,parser):\\n\\n data_format_parser[format_name] = parser\",\n \"def register_str_format(\\n tag: Tag, conformer: Optional[Conformer] = None\\n) -> Callable[[ValidatorFn], ValidatorFn]:\\n\\n def create_str_format(f: ValidatorFn) -> ValidatorFn:\\n with _STR_FORMAT_LOCK:\\n _STR_FORMATS[tag] = StrFormat(f, conformer=conformer)\\n return f\\n\\n return create_str_format\",\n \"def register_format(recipe):\\n afr = AFMFormatRecipe(recipe)\\n formats_available.append(afr)\\n # suffix\\n if afr.suffix not in formats_by_suffix:\\n formats_by_suffix[afr.suffix] = []\\n formats_by_suffix[afr.suffix].append(afr)\\n # mode\\n if afr.mode not in formats_by_mode:\\n formats_by_mode[afr.mode] = []\\n formats_by_mode[afr.mode].append(afr)\\n # supported extensions\\n if afr.suffix not in supported_extensions: # avoid duplucates\\n supported_extensions.append(afr.suffix)\\n supported_extensions.sort()\",\n \"def Register(self, name, fn):\\n name = normalizeStr(name)\\n Logger.Debug(\\\"Registering Formatter:\\\", name)\\n self._formatters[name] = fn\",\n \"def register_filename_format(format_name,parser):\\n if format_name == \\\"ALL\\\":\\n raise ValueError(\\\"filename format code ALL is reserved\\\")\\n\\n filename_format_parser[format_name] = parser\",\n \"def __init__(self, format_string):\\r\\n if not isinstance(format_string, Compatibility.string):\\r\\n raise TypeError('format_string should be a string, instead got %s' % type(format_string))\\r\\n self._re_pattern, self._applicators = self._preprocess_format_string(format_string)\\r\\n self._re = re.compile(self._re_pattern)\",\n \"def register(\\n self, name='', magic=(), patterns=(),\\n funcwrapper=lambda _:_\\n ):\\n\\n def _decorator(converter):\\n if not name:\\n raise ValueError('No registration name given')\\n if name in self._names:\\n raise ValueError(f'Registration name `{name}` already in use for {self._names[name]}')\\n if not isinstance(magic, (list, tuple)):\\n raise TypeError('Registration parameter `magic` must be list or tuple')\\n if not isinstance(patterns, (list, tuple)):\\n raise TypeError('Registration parameter `patterns` must be list or tuple')\\n converter.format = name\\n self._names[name] = converter\\n ## magic signatures\\n for sequence in magic:\\n self._magic.append((Magic(sequence), converter))\\n # sort the magic registry long to short to manage conflicts\\n self._magic = list(sorted(\\n self._magic,\\n key=lambda _i:len(_i[0]), reverse=True\\n )\\n )\\n ## glob patterns\\n for pattern in (*patterns, f'*.{name}'):\\n self._patterns.append((to_pattern(pattern), converter))\\n return funcwrapper(converter)\\n\\n return _decorator\",\n \"def register_output_format(name):\\n\\n def check_decorator(fn):\\n _output_format_map[name] = fn\\n\\n def wrapper(*args, **kwargs):\\n return fn(*args, **kwargs)\\n\\n return wrapper\\n\\n return check_decorator\",\n \"def register(self, format, serfunc):\\n if not isinstance(serfunc, func):\\n raise TypeError(\\\"Serializer.register(): serfunc is not a function: \\\"+\\n str(func))\\n self._map[format] = serfunc\",\n \"def assign_format(self):\\n if self.is_output or self.is_req_output:\\n if self.pname in self.tool_data[self.tool_name]['output_fmt']:\\n return self.tool_data[self.tool_name]['output_fmt'][self.pname]\\n elif self.pname in self.gen_out_fmt:\\n return self.gen_out_fmt[self.pname]\\n elif self.is_input:\\n if self.pname in self.tool_data[self.tool_name]['input_fmt']:\\n print(self.tool_data[self.tool_name])\\n return self.tool_data[self.tool_name]['input_fmt'][self.pname]\\n elif self.pname in self.gen_in_fmt:\\n return self.gen_in_fmt[self.pname]\\n else:\\n # Not sure yet what this will be used for, but I think we need it.\\n return ''\",\n \"def register(file_format, extensions, reader, writer=None):\\n register_format(\\n fmt=file_format,\\n ext_to_fmt=_extension_to_filetype,\\n reader_map=_reader_map,\\n writer_map=_writer_map,\\n extensions=extensions,\\n reader=reader,\\n writer=writer,\\n )\",\n \"def register(file_format, extensions, reader, writer=None):\\n register_format(\\n fmt=file_format,\\n ext_to_fmt=_extension_to_filetype,\\n reader_map=_reader_map,\\n writer_map=_writer_map,\\n extensions=extensions,\\n reader=reader,\\n writer=writer,\\n )\",\n \"def register_code_name(code_name,format_name):\\n if format_name not in data_format_parser:\\n raise ValueError(\\\"unknown format_name: {:s}\\\".format(format_name))\\n code_name_map[code_name] = format_name\",\n \"def used_implementation(self, impl: str, value):\",\n \"def formatLookup(format_str):\\n pat = '(\\\\d+)([A-Z])'\\n match = re.search(pat, format_str)\\n #print match.group()\\n \\n data_len = int(match.group(1))\\n data_fmt = str(match.group(2))\\n np_fmt = fitsFormatLookup(data_fmt)\\n np_dtype = '%i%s'%(data_len, np_fmt)\\n \\n return np_dtype, data_len, np_fmt\",\n \"def add_formatter(config: Configurator, name: str, func: t.Callable) -> None:\\n config.registry.settings.setdefault(\\\"pyramid_openapi3_formatters\\\", {})\\n reg = config.registry.settings[\\\"pyramid_openapi3_formatters\\\"]\\n reg[name] = func\",\n \"def __new__(cls, format):\\n self = super(SF_Pattern, cls).__new__(cls)\\n\\n if isinstance(format, bytes):\\n uni_str = format.decode('ISO-8859-1') # decode to unicode\\n trans_str = translate(uni_str) # translate only works with unicode\\n re_fmt = trans_str.encode('ISO-8859-1') # encode back to bytes\\n self._spec = _gbspec\\n else:\\n re_fmt = translate(format)\\n self._spec = _gspec\\n\\n self._format = format\\n self._re = cre = re.compile(re_fmt)\\n\\n if cre.groupindex and len(cre.groupindex) != cre.groups:\\n raise RuntimeError('cannot mix mapped and unmapped specifiers')\\n elif not cre.groupindex:\\n self._retfunc = self._return_tuple\\n self._type = tuple\\n else:\\n self._retfunc = self._return_dict\\n self._type = dict\\n\\n self._casts = self._get_types()\\n\\n return self\",\n \"def register_pattern(name, pattern_factory, override=None):\\n\\tif not isinstance(name, string_types):\\n\\t\\traise TypeError(\\\"name:{!r} is not a string.\\\".format(name))\\n\\tif not callable(pattern_factory):\\n\\t\\traise TypeError(\\\"pattern_factory:{!r} is not callable.\\\".format(pattern_factory))\\n\\tif name in _registered_patterns and not override:\\n\\t\\traise AlreadyRegisteredError(name, _registered_patterns[name])\\n\\t_registered_patterns[name] = pattern_factory\",\n \"def extension (formatStr):\\n assert False, \\\"TODO:\\\"\",\n \"def register(self, what, obj):\\n # print(\\\"Registering pattern\\\", name, pattern)\\n name = obj.name\\n version = obj.version\\n enable = obj.enable\\n if enable == 'n':\\n return\\n\\n key = Key(name, version)\\n self.plugins[what][key] = obj\",\n \"async def test_string_data_type(hass, mock_hub):\\n register_config = {\\n CONF_COUNT: 8,\\n CONF_REGISTER_TYPE: CALL_TYPE_REGISTER_HOLDING,\\n CONF_DATA_TYPE: DATA_TYPE_STRING,\\n CONF_SCALE: 1,\\n CONF_OFFSET: 0,\\n CONF_PRECISION: 0,\\n }\\n await run_test(\\n hass,\\n mock_hub,\\n register_config,\\n SENSOR_DOMAIN,\\n register_words=[0x3037, 0x2D30, 0x352D, 0x3230, 0x3230, 0x2031, 0x343A, 0x3335],\\n expected=\\\"07-05-2020 14:35\\\",\\n )\",\n \"def formatter(question: dict):\\n fmt = question.get('possibilities', {}).get('format')\\n if fmt == 'date':\\n return pd.to_datetime\\n elif fmt == 'num':\\n return lambda x: x\\n else:\\n raise ValueError(f\\\"Question format {fmt} unknown\\\")\",\n \"def init_default_strategies() -> None:\\n register_string_format(\\\"binary\\\", st.binary())\\n register_string_format(\\\"byte\\\", st.binary().map(lambda x: b64encode(x).decode()))\\n\\n def make_basic_auth_str(item: Tuple[str, str]) -> str:\\n return _basic_auth_str(*item)\\n\\n latin1_text = st.text(alphabet=st.characters(min_codepoint=0, max_codepoint=255))\\n\\n register_string_format(\\\"_basic_auth\\\", st.tuples(latin1_text, latin1_text).map(make_basic_auth_str)) # type: ignore\\n register_string_format(\\\"_bearer_auth\\\", st.text().map(\\\"Bearer {}\\\".format))\",\n \"def initFormat(self):\\n pass\",\n \"def __call__(self, format, filename):\\n # turn the filename into something suitable for use in #define's\\n prettyname = filename.replace(\\\".\\\", \\\"_\\\").upper()\\n prettyname = prettyname.replace(\\\"/\\\", \\\"__\\\")\\n prettyname = prettyname.replace(\\\":\\\", \\\"__\\\")\\n prettyname = prettyname.replace(\\\"-\\\", \\\"__\\\")\\n\\n # try and open the file\\n with open(filename, \\\"w\\\") as output:\\n self.writeFuncsLut[format]( output, prettyname )\",\n \"def coords_format(format):\\n if format == 'galactic':\\n return 'galactic'\\n elif format in ['fk5','icrs']:\\n return 'celestial'\",\n \"def AddFormat(self, format):\\n self._legacy = False\\n if format:\\n self._format = format\",\n \"def format_to_extension(self, format):\",\n \"def pattern_gen():\\n pattern = \\\"\\\"\\n\\n return pattern\",\n \"def register( self, pattern, callback ):\\n self.patterns.append((pattern, callback))\",\n \"def __init__(\\n self,\\n spacy_pipeline,\\n lowercase=False,\\n format: str ='gem',\\n ):\\n\\n self.lowercase = lowercase\\n self.format = format\\n self.spacy_pipeline = spacy_pipeline\",\n \"def get_template(self, format):\\n for pattern, converter in self._patterns:\\n if converter.format == format:\\n template = pattern.generate('{name}')\\n if template:\\n return template\\n return '{name}' f'.{format}'\",\n \"def _handle_string(\\n *, artifacts: types.ColumnArtifacts\\n) -> typing.Union[String, Binary, Date, DateTime]:\\n if artifacts.open_api.format in {None, \\\"byte\\\", \\\"password\\\"}:\\n if artifacts.open_api.max_length is None:\\n return String\\n return String(length=artifacts.open_api.max_length)\\n if artifacts.open_api.format == \\\"binary\\\":\\n if artifacts.open_api.max_length is None:\\n return Binary\\n return Binary(length=artifacts.open_api.max_length)\\n if artifacts.open_api.format == \\\"date\\\":\\n return Date\\n if artifacts.open_api.format == \\\"date-time\\\":\\n return DateTime\\n raise exceptions.FeatureNotImplementedError(\\n f\\\"{artifacts.open_api.format} format for string is not supported.\\\"\\n )\",\n \"def set_quantize_strategy(self,\\n new_quantize_strategy='quantize_strategy.json'):\\n if self._model_format == 'pb':\\n logger.warning('This function does not support pb format model.')\\n return None\\n\\n if isinstance(new_quantize_strategy, str):\\n new_quantize_strategy = common_utils.load_json(new_quantize_strategy)\\n elif not isinstance(new_quantize_strategy, dict):\\n logger.error(\\n 'new_quantize_strategy should be filepath or dict, but found {}'\\n .format(type(new_quantize_strategy)))\\n\\n self._quantize_strategy.update(new_quantize_strategy)\",\n \"def _add_format_spec(self, fmt_name_key: str, fmt_spec : gsfmt.CellFormat):\\n if not len(fmt_name_key) or not isinstance(fmt_spec, gsfmt.CellFormat):\\n raise (ValueError, \\\"Invalid format specification data\\\")\\n else:\\n self.format_specs[fmt_name_key] = fmt_spec\",\n \"def _file_format_adapter(self):\\n raise NotImplementedError\",\n \"def update_placeholder_formats(self, format_string, placeholder_formats):\\n # Tokenize the format string and process them\\n output = []\\n for token in self.tokens(format_string):\\n if (\\n token.group(\\\"placeholder\\\")\\n and (not token.group(\\\"format\\\"))\\n and token.group(\\\"key\\\") in placeholder_formats\\n ):\\n output.append(f\\\"{{{token.group('key')}{placeholder_formats[token.group('key')]}}}\\\")\\n continue\\n value = token.group(0)\\n output.append(value)\\n return \\\"\\\".join(output)\",\n \"def __format__(self, format_spec):\\n if format_spec == \\\"polite\\\":\\n return self.polite\\n elif format_spec == \\\"casual\\\":\\n return self.casual\\n else:\\n # Using string addition here to avoid triggering flake8-sfs\\n # while still giving a meaningful self-contained example:\\n raise ValueError(format_spec + \\\" not a format defined by Client object\\\")\",\n \"def data_format(self, data_format):\\n self._data_format = data_format\",\n \"def asformat(self, format):\",\n \"def strategy(self, strategy):\\n\\n if strategy == \\\"auto\\\":\\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 0)\\n elif strategy == \\\"cranelift\\\":\\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 1)\\n elif strategy == \\\"lightbeam\\\":\\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 2)\\n else:\\n raise WasmtimeError(\\\"unknown strategy: \\\" + str(strategy))\\n if error:\\n raise WasmtimeError.__from_ptr__(error)\",\n \"def add_formatter(self, fmt):\\n if fmt and not isfunction(fmt):\\n raise TypeError(\\\"custom format function must be a type of function\\\")\\n\\n if fmt and fmt.__code__.co_argcount < 2:\\n raise TypeError(\\\"custom format function requires at least 2 arguments\\\")\\n\\n self.formatter = fmt\",\n \"def add_pattern(self, name, pattern=None):\\n assert isinstance(name, str) and len(name) < 32 and name.find(' ') == -1, \\\"name must be a string with less than 32 characters and contain no spaces\\\"\\n assert isinstance(pattern, (list, np.ndarray, Pattern)), \\\"pattern must be a list or Pattern\\\"\\n \\n if not isinstance(pattern, Pattern):\\n pattern = Pattern(name, multipliers=pattern, time_options=self._options.time) \\n else: #elif pattern.time_options is None:\\n pattern.time_options = self._options.time\\n if pattern.name in self._data.keys():\\n raise ValueError('Pattern name already exists')\\n self[name] = pattern\",\n \"def add_formatter(self, regexp, conv, userdata=None):\\n if isinstance(regexp, str):\\n regexp = re.compile(regexp)\\n self._formatters.append([regexp, conv, userdata])\",\n \"def add_format(self, key, value=None):\\n if key in self.FORMAT:\\n return\\n self.FORMAT.append(key)\\n if value is not None:\\n for call in self:\\n call.data.setdefault(key, value)\",\n \"def initFormat(self):\\n self.formatList = self.splitText(self.format)\",\n \"def strategy(func):\\n strategies.append(func)\\n return func\",\n \"def add_pattern(self, command, pattern_string):\\n parts = pattern_string.split(\\\":\\\")\\n if len(parts) != 2:\\n raise AssertionError(\\\"Cannot parse '{value}' to pattern\\\".format(value = value))\\n pattern_id = parts[0]\\n pattern_values = parts[1].split(',')\\n pattern = Pattern(pattern_id, pattern_values)\\n self._config.add_pattern(command, pattern)\",\n \"def _is_format_endpoint(pattern):\\n return '?P<format>' in pattern._regex\",\n \"def __init_key_value_fmts__(self):\\n self.test_desc_fmt = \\\"{0}.description\\\"\\n self.test_svc_name_fmt = \\\"{0}.svc\\\"\\n self.test_svc_ipc_id_fmt = \\\"{0}.svc.{1}.ipc_id\\\"\\n self.test_svc_rsp_code_fmt = \\\"{0}.svc.{1}.svc_rsp_code\\\"\\n self.test_svc_rsp_stage_fmt = \\\"{0}.svc.{1}.svc_rsp_stage\\\"\\n self.test_pre_hook_stage_fmt = \\\"{0}.pre_hook.stage\\\"\\n self.test_pre_hook_script_fmt = \\\"{0}.pre_hook.script\\\"\\n self.test_post_hook_stage_fmt = \\\"{0}.post_hook.stage\\\"\\n self.test_post_hook_script_fmt = \\\"{0}.post_hook.script\\\"\\n self.test_svc_rsp_time_delay_fmt = \\\"{0}.svc.{1}.rsp_time_delay\\\"\\n\\n self.test_expected_result_fmt = \\\"{0}.expected_result\\\"\\n self.test_exp_api_return_fmt = \\\"{0}.expected_result.api_return_code\\\"\\n self.test_exp_log_file_fmt = \\\"{0}.expected_result.log\\\"\\n self.test_exp_log_fmt = \\\"{0}.expected_result.log.{1}\\\"\",\n \"def __init__(self, format_url, transform_string=None):\\n self.format_url = format_url\\n\\n if callable(transform_string):\\n self.transform_string = transform_string\",\n \"def set_format_by_type(self, value, format):\\n self.set_render_func_by_type(value, format.format)\",\n \"def register_factory(factory, from_protocol, to_protocol):\\n manager = get_global_adaptation_manager()\\n return manager.register_factory(factory, from_protocol, to_protocol)\",\n \"def format(self, data):\",\n \"def __call__(self, input_type, output_format):\\n self.configure()\\n return self._object_graph.provide(\\\\\\n self._plugins[input_type][output_format])\",\n \"def register_factory(factory, iface, requires, name):\",\n \"def get_format(self):\\n pass\",\n \"def strategy(self) -> AwesomeVersionStrategy:\\n return version_strategy(self.string)\",\n \"def loadFeatureWriterFromString(spec):\\n return _loadPluginFromString(spec, \\\"ufo2ft.featureWriters\\\", isValidFeatureWriter)\",\n \"def _generate_data(phg: str = None, rng: str = None, dfs: str = None, course: int = None,\\n speed: int = None, altitude: int = None, comment: str = None) -> str:\\n\\n data = \\\"\\\"\\n if phg:\\n data += phg\\n elif rng:\\n data += rng\\n elif dfs:\\n data += dfs\\n elif course and speed:\\n data += \\\"{}/{}\\\".format(\\n str(course).zfill(3), str(speed).zfill(3)\\n )\\n\\n if altitude:\\n data += \\\"/A={}\\\".format(\\n str(altitude).zfill(6)\\n )\\n\\n if comment:\\n data += comment\\n\\n return data\",\n \"def InitStrategy(self, sname, strategy):\\n\\n self._string = sname\\n\\n self.strategy = strategy\\n self.postracker = position.PositionTracker(self.strategy)\",\n \"def set_format(cls,format):\\n import __main__\\n IP = __main__.__dict__['__IP']\\n prompt = getattr(IP.outputcache,cls._prompt)\\n prompt.p_template = format\\n prompt.set_p_str()\\n cls._format = format\",\n \"def addIfMissing(self, format):\\n self.setdefault(format.name, format)\",\n \"def test_unsupported_format():\\n formatter = TabularOutputFormatter()\\n\\n with pytest.raises(ValueError):\\n formatter.format_name = \\\"foobar\\\"\\n\\n with pytest.raises(ValueError):\\n formatter.format_output((), (), format_name=\\\"foobar\\\")\",\n \"def format(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def parser_formatter(format_class, **kwargs):\\n try:\\n return lambda prog: format_class(prog, **kwargs)\\n except TypeError:\\n return format_class\",\n \"def parser_formatter(format_class, **kwargs):\\n try:\\n return lambda prog: format_class(prog, **kwargs)\\n except TypeError:\\n return format_class\",\n \"def format(self, *args, **kwargs) -> String:\\n pass\",\n \"def test_specify_format(self):\\n t = ConfigurableDatasetRequest('SomeCoolSet',\\n params=dict(subjectid='45838',\\n locale='eng',\\n app_instance_uuid='1234'))\\n\\n self.assertEqual(Url('datasets/SomeCoolSet?subjectid=45838&'\\n 'locale=eng&'\\n 'app_instance_uuid=1234'), Url(t.url_path()))\\n t = ConfigurableDatasetRequest('SomeCoolSet',\\n dataset_format=\\\"csv\\\",\\n params=dict(subjectid='45838',\\n locale='eng',\\n app_instance_uuid='1234'))\\n\\n self.assertEqual(Url('datasets/SomeCoolSet.csv?subjectid=45838&'\\n 'locale=eng&'\\n 'app_instance_uuid=1234'), Url(t.url_path()))\",\n \"def training_pattern_setup(self, **overrides):\\n raise NotImplementedError\",\n \"def add_convertor(metadata):\\n\\n metadata[\\\"convertor\\\"] = make_convertor(metadata[\\\"name\\\"],\\n metadata[\\\"datatype\\\"])\",\n \"def register_serializer(format, serializer_module, serializers=None):\\n module = importlib.import_module(serializer_module)\\n if serializers is None:\\n _test_serializers[format] = module\\n else:\\n serializers[format] = module\",\n \"def set_sampling_strategy(self, namespace, sensor_name,\\n strategy_and_params, persist_to_redis=False):\\n req = JSONRPCRequest(\\n 'set_sampling_strategy',\\n [namespace, sensor_name, strategy_and_params, persist_to_redis]\\n )\\n result = yield self._send(req)\\n self._cache_jsonrpc_request(req)\\n raise tornado.gen.Return(result)\",\n \"def autodetect_format(file_data):\\n\\n # The first header line.\\n for line in file_data:\\n if line != []:\\n break\\n\\n # Sparky format.\\n if line[0] == 'Assignment':\\n return 'sparky'\\n\\n # NMRView format.\\n if line == ['label', 'dataset', 'sw', 'sf']:\\n return 'nmrview'\\n\\n # NMRPipe SeriesTab.\\n if line[0] == 'REMARK' and line[1] == 'SeriesTab':\\n return 'seriestab'\\n\\n # XEasy format.\\n if line == ['No.', 'Color', 'w1', 'w2', 'ass.', 'in', 'w1', 'ass.', 'in', 'w2', 'Volume', 'Vol.', 'Err.', 'Method', 'Comment']:\\n return 'xeasy'\\n\\n # Assume a generic format.\\n return 'generic'\",\n \"def make_specgrams_helper(self):\\n raise NotImplementedError\",\n \"def by_extension_and_format(cls, extension: str, ser_format: str):\\n if cls._format_to_serializer is None:\\n cls._register_subclasses()\\n if ser_format == 'auto':\\n serializer = cls._extension_to_serializer.get(extension.lstrip('.'))\\n else:\\n serializer = cls._format_to_serializer.get(ser_format)\\n\\n if serializer is None:\\n raise InvalidExtensionOrFormat(\\n 'Cannot find serializer for format: %s and extension %s' % (\\n ser_format, extension))\\n return serializer\",\n \"def setDataFormat(self, format='yaml'):\\n self.dataFormat = format;\",\n \"def make_parsing_fn(data_format,\\n list_size=None,\\n context_feature_spec=None,\\n example_feature_spec=None,\\n size_feature_name=None,\\n mask_feature_name=None,\\n shuffle_examples=False,\\n seed=None):\\n kwargs = {\\n \\\"list_size\\\": list_size,\\n \\\"context_feature_spec\\\": context_feature_spec,\\n \\\"example_feature_spec\\\": example_feature_spec,\\n \\\"size_feature_name\\\": size_feature_name,\\n \\\"mask_feature_name\\\": mask_feature_name,\\n \\\"shuffle_examples\\\": shuffle_examples,\\n \\\"seed\\\": seed\\n }\\n fns_dict = {\\n EIE: parse_from_example_in_example,\\n SEQ: parse_from_sequence_example,\\n ELWC: parse_from_example_list,\\n }\\n if data_format in fns_dict:\\n return functools.partial(fns_dict[data_format], **kwargs)\\n else:\\n raise ValueError(\\\"Format {} is not supported.\\\".format(data_format))\",\n \"def format_sampler(val):\\n return val\",\n \"def register_string(self,string):\\n return self.registry.register_string(string)\",\n \"def register_to_converter(cls, coord_system):\\n print(f\\\"Registering to converter for {coord_system} in {cls.__name__}\\\")\\n def anon_reg_func(callback):\\n cls.to_other_conversions[coord_system] = callback\\n return callback\\n return anon_reg_func\",\n \"def _set_real_format(self, fmt):\\n # try to use the _nomax variant if available\\n if not self._max and fmt + '_nomax' in self.formats:\\n self._format = self.formats[fmt + '_nomax']\\n elif fmt in self.formats:\\n self._format = self.formats[fmt]\\n else:\\n self._format = fmt\\n\\n self._format_line_count = self._format.count('\\\\n')\",\n \"def format_data(self, data):\",\n \"def validate_format(self):\\n raise NotImplementedError()\",\n \"def register_type(type_, serializer_deserializer: Tuple[Callable[[T], str], Callable[[str], T]]):\\n global _transform\\n if type_ not in _transform:\\n _transform[type_] = serializer_deserializer\\n _load_types()\",\n \"async def test_parameters_as_strings(hass, mock_hub):\\n register_config = {\\n CONF_COUNT: 1,\\n CONF_DATA_TYPE: DATA_TYPE_INT,\\n CONF_SCALE: \\\"1.5\\\",\\n CONF_OFFSET: \\\"5\\\",\\n CONF_PRECISION: \\\"1\\\",\\n }\\n await run_test(\\n hass,\\n mock_hub,\\n register_config,\\n SENSOR_DOMAIN,\\n register_words=[9],\\n expected=\\\"18.5\\\",\\n )\",\n \"def _create_Data(classname, typename):\\n attributes = {\\\"typename\\\": typename}\\n if \\\"complex\\\" in typename:\\n def format_sampler(self, val):\\n \\\"\\\"\\\"Format surrounded by [] for the sampler.\\n\\n 2x space (for real and complex parts).\\n \\\"\\\"\\\"\\n if isinstance(val, int):\\n return \\\"[%s]\\\" % (2 * val)\\n return val\\n attributes[\\\"format_sampler\\\"] = format_sampler\\n globals()[classname] = type(classname, (Data,), attributes)\",\n \"def string_feature(ds, feature: str, verbosity=0, dim=\\\"sample\\\", numeric_dis=True):\\n t = get_annotation_table(ds, dim)\\n ser = t[feature]\\n dt = ser.dtype\\n descript = \\\"\\\"\\\"\\\"\\\"\\\"\\n\\n non_null_ser = ser[ser.notnull()]\\n null_flag = len(non_null_ser) < len(ser)\\n levels = list(set(non_null_ser.values))\\n num_levels = len(levels)\\n\\n if dt == pd.StringDtype():\\n\\n if num_levels >= 50:\\n descript += f\\\"\\\"\\\"\\nSorry, {feature} is a String feature with too many factor levels \\n(n = {num_levels}) to describe, here \\n\\\"\\\"\\\"\\n\\n elif num_levels < 50 and num_levels >= 2:\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature\\n-------------------------\\n\\nFactor level counts df:\\n\\n{non_null_ser.value_counts()}\\n\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} in ['{levels[0]}', '{levels[1]}', ...]\\n\\n{feature} not in ['{levels[0]}', '{levels[-1]}', ...]\\n\\n{feature} != '{levels[-2]}'\\n\\\"\\\"\\\"\\n\\n else:\\n descript += f\\\"\\\"\\\"\\nThere's only a single factor level, {levels[0]}, across all samples.\\n\\\"\\\"\\\"\\n\\n elif dt == pd.BooleanDtype():\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature:\\n---------------------------\\n\\nFactor level counts df:\\n\\n{non_null_ser.value_counts()}\\n\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} == True\\n\\n{feature} == False\\n\\\"\\\"\\\"\\n\\n elif dt == pd.Int64Dtype() or dt == pd.Float64Dtype():\\n if num_levels == 1:\\n descript += f\\\"\\\"\\\"\\nThere's only a single factor level, {levels[0]}, across all samples.\\n\\\"\\\"\\\"\\n\\n elif (num_levels > 1) and (not numeric_dis):\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature\\n-------------------------\\n\\nFactor level counts df:\\n\\n{non_null_ser.value_counts()}\\n\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} in [{levels[0]}, {levels[1]}, ...]\\n\\n{feature} not in [{levels[0]}, {levels[-1]}, ...]\\n\\n{feature} != {levels[-2]}\\n\\\"\\\"\\\"\\n else:\\n des = ser.describe()\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature:\\n---------------------------\\n\\ndistribution of numerical feature:\\n\\n{des}\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} >= {int(des[1])}\\n\\n{feature} <= {int(des[1])}\\n\\n({feature} >= {int(des[4])}) and ({feature} <= {int(des[5])})\\n\\\"\\\"\\\"\\n\\n else:\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature\\n-------------------------\\n\\nFactor level counts df:\\n\\n{non_null_ser.value_counts()}\\n\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} in ['{levels[0]}', '{levels[1]}', ...]\\n\\n{feature} not in ['{levels[0]}', '{levels[-1]}', ...]\\n\\n{feature} != '{levels[-2]}'\\n\\\"\\\"\\\"\\n\\n if null_flag:\\n descript += f\\\"\\\"\\\"\\n{feature}.isnull()\\n\\n{feature}.notnull()\\n\\\"\\\"\\\"\\n\\n return descript\",\n \"def __init__(self, **kwargs):\\n super(Converter, self).__init__()\\n self._specfile = kwargs.get(\\\"specfile\\\", None)\\n self._parsed = False\\n self._columns = []\\n self._offsets = []\\n self._fixed_with_encoding = Encodings.default_fixedwidth_enc()\\n self._included_header = False\\n self._delimited_encoding = Encodings.default_delimited_enc()\\n self.encoder_spec()\",\n \"def _register_datasource_and_factory_method(\\n cls,\\n ds_type: Type[Datasource],\\n factory_fn: SourceFactoryFn,\\n ds_type_name: str,\\n datasource_type_lookup: TypeLookup,\\n ) -> str:\\n method_name = f\\\"add_{ds_type_name}\\\"\\n LOGGER.info(\\n f\\\"2a. Registering {ds_type.__name__} as {ds_type_name} with {method_name}() factory\\\"\\n )\\n\\n pre_existing = cls.__source_factories.get(method_name)\\n if pre_existing:\\n raise TypeRegistrationError(\\n f\\\"'{ds_type_name}' - `sources.{method_name}()` factory already exists\\\",\\n )\\n\\n datasource_type_lookup[ds_type] = ds_type_name\\n LOGGER.info(f\\\"'{ds_type_name}' added to `type_lookup`\\\")\\n cls.__source_factories[method_name] = factory_fn\\n return ds_type_name\",\n \"def add_pattern(self, pattern, callback):\\n self.patterns.append((pattern, callback))\",\n \"def GuessDateConcept(data_format):\\n stripped_format = data_format.strip()\\n\\n if re.search('^y+$', stripped_format):\\n return 'time:year'\\n elif re.search('^([yM]|[^a-zA-Z0-9])+$', stripped_format):\\n return 'time:month'\\n elif re.search('^([yMd]|[^a-zA-Z0-9])+$', stripped_format):\\n return 'time:day'\\n else:\\n raise DataSourceError(\\n 'Can\\\\'t figure out time concept for format: %s' % data_format)\",\n \"def format(self):\\n ...\",\n \"def get_exporter(format, exporters):\\n\\n if format in exporters:\\n return exporters[format]\\n if format == 'sql':\\n return export_sql\\n elif format == 'json':\\n return export_json\\n\\n raise RuntimeError('Unsupported format: %s' % format)\",\n \"def update_json(\\n self, unformatted_path: str, strategy: str, epoch: int, iteration: int, data\\n ):\\n json_data = self.load_json(unformatted_path)\\n json_data[strategy] = json_data.get(strategy, {})\\n json_data[strategy][str(epoch)] = json_data[strategy].get(\\n str(epoch), {str(epoch): {}}\\n )\\n json_data[strategy][str(epoch)][str(iteration)] = data\\n self.dump_json(unformatted_path, json_data)\",\n \"def opt_format(self, fmt):\\n key = get_enum_key(fmt, FORMATTERS)\\n if key is not None:\\n self.conf[\\\"format\\\"] = key\\n print(\\\"Set format %r\\\" % key)\\n else:\\n print(\\\"Unknown format %r\\\" % fmt)\",\n \"def codeCfg(suffix, cfg):\\n if suffix == '' or suffix == None:\\n config = { 'series': 'a', 'trajectory': int(cfg) }\\n else:\\n config = { 'series': suffix, 'trajectory': int(cfg) }\\n return '%(series)s%(trajectory)06d' % config\",\n \"def __format__(self, format_specification=''):\\n return super().__format__(format_specification=format_specification)\",\n \"def add_pattern(self, pattern):\\n self.patterns.append(pattern)\",\n \"def formatter(formatter_name):\\n\\n def _formatter_decorator(f):\\n def _formatter_wrapper(*wrapper_args, **wrapper_kwargs):\\n ctx = wrapper_args[1]\\n if not ctx.json and formatter_name in _formatter_functions:\\n ctx.format_function = _formatter_functions[formatter_name]\\n return f(*wrapper_args, **wrapper_kwargs)\\n\\n return _formatter_wrapper\\n\\n return _formatter_decorator\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67097753","0.56974983","0.55908847","0.55496186","0.5468228","0.5330458","0.52871567","0.5243602","0.52405083","0.51500815","0.51046956","0.51046956","0.5070095","0.4967492","0.4967349","0.49556667","0.49543664","0.49472272","0.49290946","0.49174467","0.49154463","0.48975977","0.48481756","0.48445597","0.48293704","0.482906","0.48125598","0.47840753","0.47669846","0.4763105","0.47602996","0.47552094","0.4749683","0.4730872","0.47110412","0.46916276","0.4676606","0.4673527","0.4670282","0.4669142","0.46683994","0.46642214","0.46610463","0.4659824","0.46521676","0.4631983","0.4629271","0.46291363","0.46278736","0.46269554","0.46212944","0.46146145","0.4604003","0.4595204","0.45708448","0.45578393","0.4552202","0.45504493","0.45502207","0.4537894","0.4536509","0.45215595","0.45167473","0.4516305","0.45118734","0.4497238","0.4497238","0.44888327","0.44850814","0.44825807","0.4480984","0.44773057","0.44756186","0.44724718","0.44674993","0.44665986","0.4459776","0.44568512","0.44515082","0.44398144","0.4438341","0.44377506","0.44363245","0.4433409","0.44327593","0.44282925","0.44279376","0.4424846","0.44245374","0.4421552","0.44162896","0.44152087","0.44100863","0.44013295","0.44011542","0.43992686","0.43963465","0.43957698","0.43931115","0.43888792"],"string":"[\n \"0.67097753\",\n \"0.56974983\",\n \"0.55908847\",\n \"0.55496186\",\n \"0.5468228\",\n \"0.5330458\",\n \"0.52871567\",\n \"0.5243602\",\n \"0.52405083\",\n \"0.51500815\",\n \"0.51046956\",\n \"0.51046956\",\n \"0.5070095\",\n \"0.4967492\",\n \"0.4967349\",\n \"0.49556667\",\n \"0.49543664\",\n \"0.49472272\",\n \"0.49290946\",\n \"0.49174467\",\n \"0.49154463\",\n \"0.48975977\",\n \"0.48481756\",\n \"0.48445597\",\n \"0.48293704\",\n \"0.482906\",\n \"0.48125598\",\n \"0.47840753\",\n \"0.47669846\",\n \"0.4763105\",\n \"0.47602996\",\n \"0.47552094\",\n \"0.4749683\",\n \"0.4730872\",\n \"0.47110412\",\n \"0.46916276\",\n \"0.4676606\",\n \"0.4673527\",\n \"0.4670282\",\n \"0.4669142\",\n \"0.46683994\",\n \"0.46642214\",\n \"0.46610463\",\n \"0.4659824\",\n \"0.46521676\",\n \"0.4631983\",\n \"0.4629271\",\n \"0.46291363\",\n \"0.46278736\",\n \"0.46269554\",\n \"0.46212944\",\n \"0.46146145\",\n \"0.4604003\",\n \"0.4595204\",\n \"0.45708448\",\n \"0.45578393\",\n \"0.4552202\",\n \"0.45504493\",\n \"0.45502207\",\n \"0.4537894\",\n \"0.4536509\",\n \"0.45215595\",\n \"0.45167473\",\n \"0.4516305\",\n \"0.45118734\",\n \"0.4497238\",\n \"0.4497238\",\n \"0.44888327\",\n \"0.44850814\",\n \"0.44825807\",\n \"0.4480984\",\n \"0.44773057\",\n \"0.44756186\",\n \"0.44724718\",\n \"0.44674993\",\n \"0.44665986\",\n \"0.4459776\",\n \"0.44568512\",\n \"0.44515082\",\n \"0.44398144\",\n \"0.4438341\",\n \"0.44377506\",\n \"0.44363245\",\n \"0.4433409\",\n \"0.44327593\",\n \"0.44282925\",\n \"0.44279376\",\n \"0.4424846\",\n \"0.44245374\",\n \"0.4421552\",\n \"0.44162896\",\n \"0.44152087\",\n \"0.44100863\",\n \"0.44013295\",\n \"0.44011542\",\n \"0.43992686\",\n \"0.43963465\",\n \"0.43957698\",\n \"0.43931115\",\n \"0.43888792\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7103577"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":77682,"cells":{"query":{"kind":"string","value":"Register all default \"format\" strategies."},"document":{"kind":"string","value":"def init_default_strategies() -> None:\n register_string_format(\"binary\", st.binary())\n register_string_format(\"byte\", st.binary().map(lambda x: b64encode(x).decode()))\n\n def make_basic_auth_str(item: Tuple[str, str]) -> str:\n return _basic_auth_str(*item)\n\n latin1_text = st.text(alphabet=st.characters(min_codepoint=0, max_codepoint=255))\n\n register_string_format(\"_basic_auth\", st.tuples(latin1_text, latin1_text).map(make_basic_auth_str)) # type: ignore\n register_string_format(\"_bearer_auth\", st.text().map(\"Bearer {}\".format))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def all_formats(cls):\n if cls._format_to_serializer is None:\n cls._register_subclasses()\n formats = ['auto']\n formats.extend(cls._format_to_serializer)\n return formats","def register_format(recipe):\n afr = AFMFormatRecipe(recipe)\n formats_available.append(afr)\n # suffix\n if afr.suffix not in formats_by_suffix:\n formats_by_suffix[afr.suffix] = []\n formats_by_suffix[afr.suffix].append(afr)\n # mode\n if afr.mode not in formats_by_mode:\n formats_by_mode[afr.mode] = []\n formats_by_mode[afr.mode].append(afr)\n # supported extensions\n if afr.suffix not in supported_extensions: # avoid duplucates\n supported_extensions.append(afr.suffix)\n supported_extensions.sort()","def add_formatter(config: Configurator, name: str, func: t.Callable) -> None:\n config.registry.settings.setdefault(\"pyramid_openapi3_formatters\", {})\n reg = config.registry.settings[\"pyramid_openapi3_formatters\"]\n reg[name] = func","def formats():\n return _FORMATS","def register_filename_format(format_name,parser):\n if format_name == \"ALL\":\n raise ValueError(\"filename format code ALL is reserved\")\n\n filename_format_parser[format_name] = parser","def register_data_format(format_name,parser):\n\n data_format_parser[format_name] = parser","def opt_format(self, fmt):\n key = get_enum_key(fmt, FORMATTERS)\n if key is not None:\n self.conf[\"format\"] = key\n print(\"Set format %r\" % key)\n else:\n print(\"Unknown format %r\" % fmt)","def initialize_formatter(config):\n if config.json: # pylint: disable=R1705\n return formatters.JsonFormatter()\n elif config.severity: # pylint: disable=R1705\n return formatters.SeverityFormatter(config.colored)\n return formatters.Formatter(config.colored)","def register_formatters(ipython: Any) -> None:\n html_formatter = ipython.display_formatter.formatters['text/html']\n html_formatter.for_type(etree._Element, display_xml)\n html_formatter.for_type(etree._ElementTree, display_xml)","def register_string_format(name: str, strategy: st.SearchStrategy) -> None:\n if not isinstance(name, str):\n raise TypeError(f\"name must be of type {str}, not {type(name)}\")\n if not isinstance(strategy, st.SearchStrategy):\n raise TypeError(f\"strategy must be of type {st.SearchStrategy}, not {type(strategy)}\")\n\n STRING_FORMATS[name] = strategy","def getFormats(self):\n return self.formats","def _format_default_functions(self):\n self._out_formatter = count_out_formatter_general\n self._core_characterizer = characterizer_1sh_counter\n self._f_default_names = counter_featurenames","def parser_formatter(format_class, **kwargs):\n try:\n return lambda prog: format_class(prog, **kwargs)\n except TypeError:\n return format_class","def parser_formatter(format_class, **kwargs):\n try:\n return lambda prog: format_class(prog, **kwargs)\n except TypeError:\n return format_class","def _format_default_functions(self):\n self._out_formatter = null_out_formatter\n self._f_default_names = lambda x: [0]","def _translate_fmts(self):\n fmt_info = []\n fmt_append = fmt_info.append\n \n isvalid = self._is_valid_fmt\n typlist = self._typlist\n isstrvar = self._isstrvar\n default_fmts = self._default_fmts\n \n for i, fmt in enumerate(self._fmtlist):\n fmt = fmt.strip()\n \n iscalendar = (fmt[1] == 't' or fmt[1:3] == '-t')\n \n if iscalendar or not isvalid(fmt):\n if isstrvar(i):\n wid = min(typlist[i], 10)\n fmt_append(('s', \"{{:>{}s}}\".format(wid), wid))\n continue\n else:\n fmt = default_fmts[typlist[i]]\n \n last_char = fmt[-1]\n if last_char == 's': # string\n m = STR_FMT_RE.match(fmt)\n align, _, wid = m.group(1), m.group(2), m.group(3)\n new_align = (\"<\" if align == \"-\" \n else \"^\" if align == \"~\" else \">\")\n new = \"\".join((\"{:\", new_align, wid, \"s}\"))\n fmt_append(('s', new, int(wid)))\n elif last_char == 'H' or last_char == 'L': # binary\n fmt_append((last_char, fmt, int(fmt[1:-1])))\n elif last_char == 'x': # hexadecimal\n fmt_append(('x', fmt, 21))\n elif last_char in {'f', 'g', 'e', 'c'}: # numeric\n m = NUM_FMT_RE.match(fmt)\n align, _, wid, delim, prec, type, com = (m.group(1), m.group(2), \n m.group(3), m.group(4),\n m.group(5), m.group(6),\n m.group(7))\n aln = \"<\" if align == \"-\" else \">\"\n sep = \",\" if com is not None else \"\"\n if type == \"g\" and int(prec) == 0:\n new = \"\".join((\"{:\", aln, wid, sep, type, \"}\"))\n else:\n new = \"\".join((\"{:\", aln, wid, sep, \".\", prec, type, \"}\"))\n fmt_append((type, new, int(wid), delim, com))\n \n return fmt_info","def path_formats():\n return set(path_loaders.keys())","def initFormat(self):\n pass","def asformat(self, format):","def test_logging_formatter(self):\n configure_logging()\n\n assert logging.Formatter.converter == time.gmtime\n assert logging.Formatter.default_time_format == '%Y-%m-%dT%H:%M:%S'\n assert logging.Formatter.default_msec_format == '%s.%03d'","def _file_format_adapter(self):\n raise NotImplementedError","def get_format(self):\n pass","def display_strptime_formatters():\n data = [\n [\"%a\", \"Weekday as locale's abbreviated name.\", \"Mon\"],\n [\"%A\", \"Weekday as locale's full name.\", \"Monday\"],\n [\"%w\", \"Weekday as a decimal number, where 0 is Sunday and 6 is Saturday.\", \"1\"],\n [\"%d\", \"Day of the month as a zero-padded decimal number.\", \"30\"],\n [\"%-d\", \"Day of the month as a decimal number. (Platform specific)\", \"30\"],\n [\"%b\", \"Month as locale's abbreviated name.\", \"Sep\"],\n [\"%B\", \"Month as locale's full name.\", \"September\"],\n [\"%m\", \"Month as a zero-padded decimal number.\", \"09\"],\n [\"%-m\", \"Month as a decimal number. (Platform specific)\", \"9\"],\n [\"%y\", \"Year without century as a zero-padded decimal number.\", \"13\"],\n [\"%Y\", \"Year with century as a decimal number.\", \"2013\"],\n [\"%H\", \"Hour (24-hour clock) as a zero-padded decimal number.\", \"07\"],\n [\"%-H\", \"Hour (24-hour clock) as a decimal number. (Platform specific)\", \"7\"],\n [\"%I\", \"Hour (12-hour clock) as a zero-padded decimal number.\", \"07\"],\n [\"%-I\", \"Hour (12-hour clock) as a decimal number. (Platform specific)\", \"7\"],\n [\"%p\", \"Locale's equivalent of either AM or PM.\", \"AM\"],\n [\"%M\", \"Minute as a zero-padded decimal number.\", \"06\"],\n [\"%-M\", \"Minute as a decimal number. (Platform specific)\", \"6\"],\n [\"%S\", \"Second as a zero-padded decimal number.\", \"05\"],\n [\"%-S\", \"Second as a decimal number. (Platform specific)\", \"5\"],\n [\"%f\", \"Microsecond as a decimal number, zero-padded on the left.\", \"000000\"],\n [\"%z\", \"UTC offset in the form +HHMM or -HHMM (empty string if the the object is naive).\", \"\"],\n [\"%Z\", \"Time zone name (empty string if the object is naive).\", \"\"],\n [\"%j\", \"Day of the year as a zero-padded decimal number.\", \"273\"],\n [\"%-j\", \"Day of the year as a decimal number. (Platform specific)\", \"273\"],\n [\"%U\", \"Week number of the year (Sunday as the first day of the week) as a zero padded decimal number. All days in a new year preceding the first Sunday are considered to be in week 0.\", \"39\"],\n [\"%W\", \"Week number of the year (Monday as the first day of the week) as a decimal number. All days in a new year preceding the first Monday are considered to be in week 0.\", \"39\"],\n [\"%c\", \"Locale's appropriate date and time representation.\", \"Mon Sep 30 07:06:05 2013\"],\n [\"%x\", \"Locale's appropriate date representation.\", \"09/30/13\"],\n [\"%X\", \"Locale's appropriate time representation.\", \"07:06:05\"],\n [\"%%\", \"A literal '%' character.\", \"%\"]\n ]\n\n display(HTML(\n '<table><tr>{}</tr></table>'.format(\n '</tr><tr>'.join(\n '<td>{}</td>'.format('</td><td>'.join(str(_) for _ in row)) for row in data)\n )\n ))","def register(file_format, extensions, reader, writer=None):\n register_format(\n fmt=file_format,\n ext_to_fmt=_extension_to_filetype,\n reader_map=_reader_map,\n writer_map=_writer_map,\n extensions=extensions,\n reader=reader,\n writer=writer,\n )","def register(file_format, extensions, reader, writer=None):\n register_format(\n fmt=file_format,\n ext_to_fmt=_extension_to_filetype,\n reader_map=_reader_map,\n writer_map=_writer_map,\n extensions=extensions,\n reader=reader,\n writer=writer,\n )","def available_formats() -> List[str]:\n formats = [p.stem for p in Path(TEMPLATES_PATH).glob(f'*{TEMPLATE_SUFFIX}')]\n return formats","def initFormat(self):\n self.formatList = []","def test_available_output_formats():\n assert set([\"GTiff\", \"PNG\", \"PNG_hillshade\", \"GeoJSON\"]).issubset(\n set(available_output_formats())\n )","def reset_format(self):\n ## Formatters\n self._format_setters(*self.format_set_info)\n self._format_getters(*self.format_get_info)\n self._format_joining_functions()","def available_output_formats() -> Dict:\n output_formats = {}\n for v in drivers:\n driver_ = v.load()\n if hasattr(driver_, \"METADATA\") and (driver_.METADATA[\"mode\"] in [\"w\", \"rw\"]):\n output_formats[driver_.METADATA[\"driver_name\"]] = driver_.METADATA\n return output_formats","def getopt_format(self):\n self._print_enum_opt(\"format\", FORMATTERS)","def set_format_by_type(self, value, format):\n self.set_render_func_by_type(value, format.format)","def output_formats(self) -> List[DataFormat]:\n return [DataFormat.NGEN_OUTPUT]","def default_formatter(self, data):\n return data","def register_output_format(name):\n\n def check_decorator(fn):\n _output_format_map[name] = fn\n\n def wrapper(*args, **kwargs):\n return fn(*args, **kwargs)\n\n return wrapper\n\n return check_decorator","def initFormat(self):\n self.formatList = self.splitText(self.format)","def formatter(question: dict):\n fmt = question.get('possibilities', {}).get('format')\n if fmt == 'date':\n return pd.to_datetime\n elif fmt == 'num':\n return lambda x: x\n else:\n raise ValueError(f\"Question format {fmt} unknown\")","def set_formatter(self, formatter):\n self.format = formatter","def source_formats(self):\n formats = []\n for source_path in self.source_paths:\n formats.append('{}{}'.format(\n source_path,\n self.sub_base_pod_path))\n return formats","def Register(self, name, fn):\n name = normalizeStr(name)\n Logger.Debug(\"Registering Formatter:\", name)\n self._formatters[name] = fn","def _define_formats(self, workbook):\n self.format_title = workbook.add_format({\n 'bold': True,\n 'align': 'center',\n 'font_size': 12,\n 'font': 'Arial',\n 'border': False\n })\n self.format_header = workbook.add_format({\n 'bold': True,\n 'font_size': 10,\n 'align': 'center',\n 'font': 'Arial',\n #'border': True\n })\n self.content_header = workbook.add_format({\n 'bold': False,\n 'font_size': 10,\n 'align': 'center',\n 'border': True,\n 'font': 'Arial',\n })\n self.content_header_date = workbook.add_format({\n 'bold': False,\n 'font_size': 10,\n 'border': True,\n 'align': 'center',\n 'font': 'Arial',\n })\n self.line_header = workbook.add_format({\n 'bold': True,\n 'font_size': 10,\n 'align': 'center',\n 'top': True,\n 'bottom': True,\n 'font': 'Arial',\n })\n self.line_header_light = workbook.add_format({\n 'bold': False,\n 'font_size': 10,\n 'align': 'center',\n 'text_wrap': True,\n 'font': 'Arial',\n 'valign': 'top'\n })\n self.line_header_light_date = workbook.add_format({\n 'bold': False,\n 'font_size': 10,\n 'align': 'center',\n 'font': 'Arial',\n })\n self.line_header_light_initial = workbook.add_format({\n 'italic': True,\n 'font_size': 10,\n 'align': 'center',\n 'bottom': True,\n 'font': 'Arial',\n 'valign': 'top'\n })\n self.line_header_light_ending = workbook.add_format({\n 'italic': True,\n 'font_size': 10,\n 'align': 'center',\n 'top': True,\n 'font': 'Arial',\n 'valign': 'top'\n })","def available_input_formats() -> Dict:\n input_formats = {}\n for v in drivers:\n logger.debug(\"driver found: %s\", v)\n driver_ = v.load()\n if hasattr(driver_, \"METADATA\") and (driver_.METADATA[\"mode\"] in [\"r\", \"rw\"]):\n input_formats[driver_.METADATA[\"driver_name\"]] = driver_.METADATA\n return input_formats","def format_(self):\n return self.set_format or self.default_format or self.FALLBACK_FORMAT","def format(self, *args, **kwargs):\n raise NotImplementedError()","def available_input_formats():\n input_formats = []\n # Extensions.\n for v in pkg_resources.iter_entry_points(_DRIVERS_ENTRY_POINT):\n try:\n input_formats.append(v.load().InputData.METADATA[\"driver_name\"])\n except ImportError:\n raise\n except Exception:\n pass\n return input_formats","def AddFormat(self, format):\n self._legacy = False\n if format:\n self._format = format","def define_log_pre_format_hooks(self):\n return []","def available_output_formats():\n output_formats = []\n for v in pkg_resources.iter_entry_points(_DRIVERS_ENTRY_POINT):\n try:\n output_formats.append(\n v.load().OutputData.METADATA[\"driver_name\"])\n except AttributeError:\n pass\n return output_formats","def set_default_input_format(args):\n if not args.inputFormat:\n for pname, popt in parser_opts.items():\n input_extension = os.path.splitext(args.input)[1]\n if input_extension.lower() == popt.file_extension:\n args.inputFormat = pname\n log.info(\"You didn't set an input format. Assuming %s\", args.inputFormat)\n break\n else:\n raise RuntimeError(\"Cannot determine input format. \"\n \"Must be one of {}\".format(list(parser_opts.keys())))","def _define_formats(self, workbook):\n self.format_title_main_center = workbook.add_format({\n 'bold': True,\n 'align': 'left',\n 'font_size': 14,\n 'border': True,\n 'font_name':'Arial',\n 'align': 'Center',\n 'bg_color': '#D8D7D7',\n })\n self.format_title = workbook.add_format({\n 'align': 'left',\n 'font_size': 12,\n 'border': True,\n 'font_name':'Arial',\n 'text_wrap': True\n })\n self.format_title_noborder = workbook.add_format({\n 'align': 'left',\n 'font_size': 12,\n 'border': False,\n 'font_name':'Arial'\n })\n self.format_title_noborder_bold = workbook.add_format({\n 'align': 'left',\n 'font_size': 12,\n 'bold': True,\n 'border': False,\n 'font_name':'Arial'\n })\n self.format_title_center = workbook.add_format({\n 'align': 'left',\n 'font_size': 12,\n 'border': True,\n 'align': 'Center',\n 'font_name':'Arial'\n })\n self.format_title_bold = workbook.add_format({\n 'align': 'left',\n 'font_size': 12,\n 'border': True,\n 'font_name':'Arial',\n 'bold': True,\n })\n self.format_title_center_bold = workbook.add_format({\n 'align': 'left',\n 'font_size': 12,\n 'border': True,\n 'font_name':'Arial',\n 'align': 'Center',\n 'bold': True,\n })\n self.format_title_number = workbook.add_format({\n 'align': 'right',\n 'font_size': 12,\n 'border': True,\n 'font_name':'Arial',\n 'num_format': '#,##0.00',\n })\n self.format_title_number_bold = workbook.add_format({\n 'align': 'right',\n 'font_size': 12,\n 'border': True,\n 'font_name':'Arial',\n 'num_format': '#,##0.00',\n 'bold': True,\n 'bg_color': '#D8D7D7',\n })\n \n self.format_header = workbook.add_format({\n 'bold': True,\n 'border': True,\n 'font_name':'Arial',\n 'font_size': 12,\n 'align': 'Center',\n 'bg_color': '#D8D7D7', \n })\n\n self.merge_format = workbook.add_format({\n 'bold': 1,\n 'border': 1,\n 'align': 'center',\n 'valign': 'vcenter',\n })","def format_to_extension(self, format):","def determine_format(request, serializer, default_format='application/json'):\n # First, check if they forced the format.\n if request.GET.get('format'):\n if request.GET['format'] in serializer.formats:\n return serializer.get_mime_for_format(request.GET['format'])\n \n # If callback parameter is present, use JSONP.\n if request.GET.has_key('callback'):\n return serializer.get_mime_for_format('jsonp')\n \n # Try to fallback on the Accepts header.\n if request.META.get('HTTP_ACCEPT', '*/*') != '*/*':\n formats = list(serializer.supported_formats) or []\n # Reverse the list, because mimeparse is weird like that. See also\n # https://github.com/toastdriven/django-tastypie/issues#issue/12 for\n # more information.\n formats.reverse()\n best_format = mimeparse.best_match(formats, request.META['HTTP_ACCEPT'])\n \n if best_format:\n return best_format\n \n # No valid 'Accept' header/formats. Sane default.\n return default_format","def add_formatter(self, fmt):\n if fmt and not isfunction(fmt):\n raise TypeError(\"custom format function must be a type of function\")\n\n if fmt and fmt.__code__.co_argcount < 2:\n raise TypeError(\"custom format function requires at least 2 arguments\")\n\n self.formatter = fmt","def setInputFormats(self, value):\n return self._set(inputFormats=value)","def setDateOutputFormat(self,fmt):\r\n self.datefmt_out = fmt","def load_print_formats(self, doclist):\n\t\t# TODO: Process Print Formats for $import\n\t\t# to deprecate code in print_format.py\n\t\t# if this is implemented, clear CacheItem on saving print format\n\t\tprint_formats = webnotes.conn.sql(\"\"\"\\\n\t\t\tSELECT * FROM `tabPrint Format`\n\t\t\tWHERE doc_type=%s AND docstatus<2\"\"\", doclist[0].fields.get('name'),\n\t\t\tas_dict=1)\n\t\tfor pf in print_formats:\n\t\t\tif not pf: continue\n\t\t\tprint_format_doc = webnotes.model.doc.Document('Print Format', fielddata=pf)\n\t\t\tdoclist.append(print_format_doc)","def get_format_tools(fmt: str, config: Config) -> FormatTools:\n if fmt == \"rst\":\n from . import ( # pylint: disable=cyclic-import,import-outside-toplevel\n format_rst,\n )\n\n return format_rst.RstTools(config)\n else:\n assert fmt == \"md\"\n from . import ( # pylint: disable=cyclic-import,import-outside-toplevel\n format_md,\n )\n\n return format_md.MdTools(config)","def get_formatters(self, method_string):\n formatters = self.formatter_lookup_fn(method_string)\n return formatters or get_default_formatters()","def _load_serializers(self):\n global _serializers\n serializers = {}\n for format in BUILTIN_SERIALIZERS:\n self.register_serializer(format, BUILTIN_SERIALIZERS[format], serializers)\n if hasattr(settings, \"SERIALIZATION_MODULES\"):\n for format in settings.SERIALIZATION_MODULES:\n self.register_serializer(format,\n settings.SERIALIZATION_MODULES[format],\n serializers)\n _serializers = serializers","def formatter(formatter_name):\n\n def _formatter_decorator(f):\n def _formatter_wrapper(*wrapper_args, **wrapper_kwargs):\n ctx = wrapper_args[1]\n if not ctx.json and formatter_name in _formatter_functions:\n ctx.format_function = _formatter_functions[formatter_name]\n return f(*wrapper_args, **wrapper_kwargs)\n\n return _formatter_wrapper\n\n return _formatter_decorator","def initFormat(self):\n self.html = True","def initFormat(self):\n self.html = True","def setup_fmt(self, ctx):\n ctx.implicit_errors = False","def determine_format(request, serializer, default_format='application/json'):\r\n # First, check if they forced the format.\r\n if request.GET.get('format'):\r\n if request.GET['format'] in serializer.formats:\r\n return serializer.get_mime_for_format(request.GET['format'])\r\n\r\n # Try to fallback on the Accepts header.\r\n if request.META.get('HTTP_ACCEPT', '*/*') != '*/*':\r\n formats = list(serializer.supported_formats) or []\r\n # Reverse the list, because mimeparse is weird like that. See also\r\n # https://github.com/toastdriven/django-tastypie/issues#issue/12 for\r\n # more information.\r\n formats.reverse()\r\n best_format = mimeparse.best_match(\r\n formats, request.META['HTTP_ACCEPT'])\r\n\r\n if best_format:\r\n return best_format\r\n\r\n # No valid 'Accept' header/formats. Sane default.\r\n return default_format","def register_serializer(format, serializer_module, serializers=None):\n module = importlib.import_module(serializer_module)\n if serializers is None:\n _test_serializers[format] = module\n else:\n serializers[format] = module","def set_formatter(self, enable_time=False, enable_msg_count=True):\n self.formatter = logging.Formatter(\n '{}%(name)s - %(levelname)s - %(message)s'.format(\n \"%(asctime)s - \" if enable_time else \"\",\n ))\n for handler in self.handlers:\n handler.setFormatter(self.formatter)\n return self.formatter","def formats(self):\n logger.debug(\"Get formats\")\n return self._raw_api.formats.get()","def __format__(self, *args, **kwargs): # real signature unknown\r\n pass","def _set_real_format(self, fmt):\n # try to use the _nomax variant if available\n if not self._max and fmt + '_nomax' in self.formats:\n self._format = self.formats[fmt + '_nomax']\n elif fmt in self.formats:\n self._format = self.formats[fmt]\n else:\n self._format = fmt\n\n self._format_line_count = self._format.count('\\n')","def __init__(self, fmt, datefmt=None):\n logging.Formatter.__init__(self, fmt, datefmt)","def format(self, *args, **kwargs) -> String:\n pass","def __format__(self, format_specification=''):\n return super().__format__(format_specification=format_specification)","def formats():\n if PIL_ENABLED:\n return 'BMP', 'EPS', 'GIF', 'JPEG', 'MSP', 'PCX', 'PNG', 'SVG', 'TIFF', 'XBM'\n else:\n return 'EPS', 'SVG'","def setFormat( self, fmt, style = '{' ):\n formatter = logging.Formatter( fmt, style = style )\n for handler in self.logger.handlers:\n handler.setFormatter( formatter )","def get_formats(self):\n return tuple(self._names.keys())","def GetCaptureFileFormats(self): # real signature unknown; restored from __doc__\n pass","def addIfMissing(self, format):\n self.setdefault(format.name, format)","def handler_defaults(stdout_handler=stdout_handler, stderr_handler=stderr_handler):\n\n\tfor handler in [stdout_handler, stderr_handler]:\n\t\tif handler is not None:\n\t\t\thandler.setFormatter(default_formatter)\n\n\tif stdout_handler is not None:\n\t\tstdout_handler.setLevel(default_console_level)\n\t\t# Ignore messages given to stderr.\n\t\tstdout_handler.addFilter(stdout_filter)\n\n\tif stderr_handler is not None:\n\t\tstderr_handler.setLevel(max(default_console_level + 1, logging.WARNING))","def get_import_formats(self):\n return [f for f in self.formats if f().can_import()]","def _determine_format(self, request):\n return determine_format(request, self._meta.serializer, default_format=self._meta.default_format)","def format(self):\n ...","def get_formatted_messages(formats, label, context):\r\n format_templates = {}\r\n for format in formats:\r\n # conditionally turn off autoescaping for .txt extensions in format\r\n if format.endswith(\".txt\"):\r\n context.autoescape = False\r\n format_templates[format] = render_to_string((\r\n 'notification/%s/%s' % (label, format),\r\n 'notification/%s' % format), context_instance=context)\r\n return format_templates","def test_unsupported_format():\n formatter = TabularOutputFormatter()\n\n with pytest.raises(ValueError):\n formatter.format_name = \"foobar\"\n\n with pytest.raises(ValueError):\n formatter.format_output((), (), format_name=\"foobar\")","def setup(self, formats):\n for f in formats:\n try:\n self.counters[f] += 1\n except KeyError:\n self.counters[f] = 1\n self.vim.command(f\"set efm+={f}\")","def sformatf(cls, msg, *args):\n #formats = {\"%t\": \"%d\", \"%0t\": \"%0d\"}\n #for s in formats:\n # msg = msg.replace(s, formats[s])\n #return sformatf(msg, *args)\n # TODO substitute old types %s/%d etc with {}\n #new_msg = cls.STR_RE.sub(r'{:\\1}', msg)\n #print(\"new_msg is \" + new_msg)\n for s in cls.formats:\n if s == \"%h\" or s == \"%0h\":\n msg = msg.replace(s, \"{:X}\")\n else:\n msg = msg.replace(s, \"{}\")\n return msg.format(*args)","def datetime_formats(self) -> localedata.LocaleDataDict:\n return self._data['datetime_formats']","def strfdate(self, fmt):\n pattern = r'%({})'.format(reduce(lambda x, y: '{}|{}'.format(x, y), FORMAT_MAP.keys()))\n for f in re.findall(pattern, fmt):\n fmt = fmt.replace('%{}'.format(f), FORMAT_MAP[f](self))\n return fmt","def add_formatter(self, regexp, conv, userdata=None):\n if isinstance(regexp, str):\n regexp = re.compile(regexp)\n self._formatters.append([regexp, conv, userdata])","def date_formats(self) -> localedata.LocaleDataDict:\n return self._data['date_formats']","def interval_formats(self) -> localedata.LocaleDataDict:\n return self._data['interval_formats']","def register_converters(self, converter_list):\n for converter in converter_list:\n self.register_converter(converter)","def after_init(self):\n if self.options.format.appended:\n self.error_format = self.options.format.appended[0]","def basicConfig(**kwargs):\n # Add thread safety in case someone mistakenly calls\n # basicConfig() from multiple threads\n logging._acquireLock()\n try:\n if len(logging.root.handlers) == 0:\n handlers = kwargs.pop(\"handlers\", None)\n if handlers is None:\n if \"stream\" in kwargs and \"filename\" in kwargs:\n raise ValueError(\"'stream' and 'filename' should not be \"\n \"specified together\")\n else:\n if \"stream\" in kwargs or \"filename\" in kwargs:\n raise ValueError(\"'stream' or 'filename' should not be \"\n \"specified together with 'handlers'\")\n if handlers is None:\n filename = kwargs.pop(\"filename\", None)\n mode = kwargs.pop(\"filemode\", 'a')\n if filename:\n h = logging.FileHandler(filename, mode)\n else:\n stream = kwargs.pop(\"stream\", None)\n h = logging.StreamHandler(stream)\n handlers = [h]\n dfs = kwargs.pop(\"datefmt\", None)\n style = kwargs.pop(\"style\", '%')\n if style not in _STYLES:\n raise ValueError('Style must be one of: %s' % ','.join(\n _STYLES.keys()))\n fs = kwargs.pop(\"format\", BASIC_FORMAT)\n fmt = JsonFormatter(fs, dfs, style)\n for h in handlers:\n if h.formatter is None:\n h.setFormatter(fmt)\n logging.root.addHandler(h)\n level = kwargs.pop(\"level\", None)\n if level is not None:\n logging.root.setLevel(level)\n if kwargs:\n keys = ', '.join(kwargs.keys())\n raise ValueError('Unrecognised argument(s): %s' % keys)\n finally:\n logging._releaseLock()","def get_renderers(self, request):\n if self._format_override_parameter in request.REQUEST:\n formats = request.REQUEST[self._format_override_parameter].split(',')\n renderers, seen_formats = [], set()\n for format in formats:\n if format in self._renderers_by_format and format not in seen_formats:\n renderers.extend(self._renderers_by_format[format])\n elif request.META.get('HTTP_ACCEPT'):\n accepts = self.parse_accept_header(request.META['HTTP_ACCEPT'])\n renderers = MediaType.resolve(accepts, self._renderers)\n elif self._default_format:\n renderers = self._renderers_by_format[self._default_format]\n else:\n renderers = []\n if self._force_fallback_format:\n renderers.extend(self._renderers_by_format[self._force_fallback_format])\n return renderers","def test_available_input_formats():\n assert set([\"Mapchete\", \"raster_file\", \"vector_file\"]).issubset(\n set(available_input_formats())\n )","def assign_format(self):\n if self.is_output or self.is_req_output:\n if self.pname in self.tool_data[self.tool_name]['output_fmt']:\n return self.tool_data[self.tool_name]['output_fmt'][self.pname]\n elif self.pname in self.gen_out_fmt:\n return self.gen_out_fmt[self.pname]\n elif self.is_input:\n if self.pname in self.tool_data[self.tool_name]['input_fmt']:\n print(self.tool_data[self.tool_name])\n return self.tool_data[self.tool_name]['input_fmt'][self.pname]\n elif self.pname in self.gen_in_fmt:\n return self.gen_in_fmt[self.pname]\n else:\n # Not sure yet what this will be used for, but I think we need it.\n return ''","def extension (formatStr):\n assert False, \"TODO:\"","def autodetect_format(file_data):\n\n # The first header line.\n for line in file_data:\n if line != []:\n break\n\n # Sparky format.\n if line[0] == 'Assignment':\n return 'sparky'\n\n # NMRView format.\n if line == ['label', 'dataset', 'sw', 'sf']:\n return 'nmrview'\n\n # NMRPipe SeriesTab.\n if line[0] == 'REMARK' and line[1] == 'SeriesTab':\n return 'seriestab'\n\n # XEasy format.\n if line == ['No.', 'Color', 'w1', 'w2', 'ass.', 'in', 'w1', 'ass.', 'in', 'w2', 'Volume', 'Vol.', 'Err.', 'Method', 'Comment']:\n return 'xeasy'\n\n # Assume a generic format.\n return 'generic'","def update_placeholder_formats(self, format_string, placeholder_formats):\n # Tokenize the format string and process them\n output = []\n for token in self.tokens(format_string):\n if (\n token.group(\"placeholder\")\n and (not token.group(\"format\"))\n and token.group(\"key\") in placeholder_formats\n ):\n output.append(f\"{{{token.group('key')}{placeholder_formats[token.group('key')]}}}\")\n continue\n value = token.group(0)\n output.append(value)\n return \"\".join(output)","def initDefaultChoices(self):\n return [text for text in self.formatList]"],"string":"[\n \"def all_formats(cls):\\n if cls._format_to_serializer is None:\\n cls._register_subclasses()\\n formats = ['auto']\\n formats.extend(cls._format_to_serializer)\\n return formats\",\n \"def register_format(recipe):\\n afr = AFMFormatRecipe(recipe)\\n formats_available.append(afr)\\n # suffix\\n if afr.suffix not in formats_by_suffix:\\n formats_by_suffix[afr.suffix] = []\\n formats_by_suffix[afr.suffix].append(afr)\\n # mode\\n if afr.mode not in formats_by_mode:\\n formats_by_mode[afr.mode] = []\\n formats_by_mode[afr.mode].append(afr)\\n # supported extensions\\n if afr.suffix not in supported_extensions: # avoid duplucates\\n supported_extensions.append(afr.suffix)\\n supported_extensions.sort()\",\n \"def add_formatter(config: Configurator, name: str, func: t.Callable) -> None:\\n config.registry.settings.setdefault(\\\"pyramid_openapi3_formatters\\\", {})\\n reg = config.registry.settings[\\\"pyramid_openapi3_formatters\\\"]\\n reg[name] = func\",\n \"def formats():\\n return _FORMATS\",\n \"def register_filename_format(format_name,parser):\\n if format_name == \\\"ALL\\\":\\n raise ValueError(\\\"filename format code ALL is reserved\\\")\\n\\n filename_format_parser[format_name] = parser\",\n \"def register_data_format(format_name,parser):\\n\\n data_format_parser[format_name] = parser\",\n \"def opt_format(self, fmt):\\n key = get_enum_key(fmt, FORMATTERS)\\n if key is not None:\\n self.conf[\\\"format\\\"] = key\\n print(\\\"Set format %r\\\" % key)\\n else:\\n print(\\\"Unknown format %r\\\" % fmt)\",\n \"def initialize_formatter(config):\\n if config.json: # pylint: disable=R1705\\n return formatters.JsonFormatter()\\n elif config.severity: # pylint: disable=R1705\\n return formatters.SeverityFormatter(config.colored)\\n return formatters.Formatter(config.colored)\",\n \"def register_formatters(ipython: Any) -> None:\\n html_formatter = ipython.display_formatter.formatters['text/html']\\n html_formatter.for_type(etree._Element, display_xml)\\n html_formatter.for_type(etree._ElementTree, display_xml)\",\n \"def register_string_format(name: str, strategy: st.SearchStrategy) -> None:\\n if not isinstance(name, str):\\n raise TypeError(f\\\"name must be of type {str}, not {type(name)}\\\")\\n if not isinstance(strategy, st.SearchStrategy):\\n raise TypeError(f\\\"strategy must be of type {st.SearchStrategy}, not {type(strategy)}\\\")\\n\\n STRING_FORMATS[name] = strategy\",\n \"def getFormats(self):\\n return self.formats\",\n \"def _format_default_functions(self):\\n self._out_formatter = count_out_formatter_general\\n self._core_characterizer = characterizer_1sh_counter\\n self._f_default_names = counter_featurenames\",\n \"def parser_formatter(format_class, **kwargs):\\n try:\\n return lambda prog: format_class(prog, **kwargs)\\n except TypeError:\\n return format_class\",\n \"def parser_formatter(format_class, **kwargs):\\n try:\\n return lambda prog: format_class(prog, **kwargs)\\n except TypeError:\\n return format_class\",\n \"def _format_default_functions(self):\\n self._out_formatter = null_out_formatter\\n self._f_default_names = lambda x: [0]\",\n \"def _translate_fmts(self):\\n fmt_info = []\\n fmt_append = fmt_info.append\\n \\n isvalid = self._is_valid_fmt\\n typlist = self._typlist\\n isstrvar = self._isstrvar\\n default_fmts = self._default_fmts\\n \\n for i, fmt in enumerate(self._fmtlist):\\n fmt = fmt.strip()\\n \\n iscalendar = (fmt[1] == 't' or fmt[1:3] == '-t')\\n \\n if iscalendar or not isvalid(fmt):\\n if isstrvar(i):\\n wid = min(typlist[i], 10)\\n fmt_append(('s', \\\"{{:>{}s}}\\\".format(wid), wid))\\n continue\\n else:\\n fmt = default_fmts[typlist[i]]\\n \\n last_char = fmt[-1]\\n if last_char == 's': # string\\n m = STR_FMT_RE.match(fmt)\\n align, _, wid = m.group(1), m.group(2), m.group(3)\\n new_align = (\\\"<\\\" if align == \\\"-\\\" \\n else \\\"^\\\" if align == \\\"~\\\" else \\\">\\\")\\n new = \\\"\\\".join((\\\"{:\\\", new_align, wid, \\\"s}\\\"))\\n fmt_append(('s', new, int(wid)))\\n elif last_char == 'H' or last_char == 'L': # binary\\n fmt_append((last_char, fmt, int(fmt[1:-1])))\\n elif last_char == 'x': # hexadecimal\\n fmt_append(('x', fmt, 21))\\n elif last_char in {'f', 'g', 'e', 'c'}: # numeric\\n m = NUM_FMT_RE.match(fmt)\\n align, _, wid, delim, prec, type, com = (m.group(1), m.group(2), \\n m.group(3), m.group(4),\\n m.group(5), m.group(6),\\n m.group(7))\\n aln = \\\"<\\\" if align == \\\"-\\\" else \\\">\\\"\\n sep = \\\",\\\" if com is not None else \\\"\\\"\\n if type == \\\"g\\\" and int(prec) == 0:\\n new = \\\"\\\".join((\\\"{:\\\", aln, wid, sep, type, \\\"}\\\"))\\n else:\\n new = \\\"\\\".join((\\\"{:\\\", aln, wid, sep, \\\".\\\", prec, type, \\\"}\\\"))\\n fmt_append((type, new, int(wid), delim, com))\\n \\n return fmt_info\",\n \"def path_formats():\\n return set(path_loaders.keys())\",\n \"def initFormat(self):\\n pass\",\n \"def asformat(self, format):\",\n \"def test_logging_formatter(self):\\n configure_logging()\\n\\n assert logging.Formatter.converter == time.gmtime\\n assert logging.Formatter.default_time_format == '%Y-%m-%dT%H:%M:%S'\\n assert logging.Formatter.default_msec_format == '%s.%03d'\",\n \"def _file_format_adapter(self):\\n raise NotImplementedError\",\n \"def get_format(self):\\n pass\",\n \"def display_strptime_formatters():\\n data = [\\n [\\\"%a\\\", \\\"Weekday as locale's abbreviated name.\\\", \\\"Mon\\\"],\\n [\\\"%A\\\", \\\"Weekday as locale's full name.\\\", \\\"Monday\\\"],\\n [\\\"%w\\\", \\\"Weekday as a decimal number, where 0 is Sunday and 6 is Saturday.\\\", \\\"1\\\"],\\n [\\\"%d\\\", \\\"Day of the month as a zero-padded decimal number.\\\", \\\"30\\\"],\\n [\\\"%-d\\\", \\\"Day of the month as a decimal number. (Platform specific)\\\", \\\"30\\\"],\\n [\\\"%b\\\", \\\"Month as locale's abbreviated name.\\\", \\\"Sep\\\"],\\n [\\\"%B\\\", \\\"Month as locale's full name.\\\", \\\"September\\\"],\\n [\\\"%m\\\", \\\"Month as a zero-padded decimal number.\\\", \\\"09\\\"],\\n [\\\"%-m\\\", \\\"Month as a decimal number. (Platform specific)\\\", \\\"9\\\"],\\n [\\\"%y\\\", \\\"Year without century as a zero-padded decimal number.\\\", \\\"13\\\"],\\n [\\\"%Y\\\", \\\"Year with century as a decimal number.\\\", \\\"2013\\\"],\\n [\\\"%H\\\", \\\"Hour (24-hour clock) as a zero-padded decimal number.\\\", \\\"07\\\"],\\n [\\\"%-H\\\", \\\"Hour (24-hour clock) as a decimal number. (Platform specific)\\\", \\\"7\\\"],\\n [\\\"%I\\\", \\\"Hour (12-hour clock) as a zero-padded decimal number.\\\", \\\"07\\\"],\\n [\\\"%-I\\\", \\\"Hour (12-hour clock) as a decimal number. (Platform specific)\\\", \\\"7\\\"],\\n [\\\"%p\\\", \\\"Locale's equivalent of either AM or PM.\\\", \\\"AM\\\"],\\n [\\\"%M\\\", \\\"Minute as a zero-padded decimal number.\\\", \\\"06\\\"],\\n [\\\"%-M\\\", \\\"Minute as a decimal number. (Platform specific)\\\", \\\"6\\\"],\\n [\\\"%S\\\", \\\"Second as a zero-padded decimal number.\\\", \\\"05\\\"],\\n [\\\"%-S\\\", \\\"Second as a decimal number. (Platform specific)\\\", \\\"5\\\"],\\n [\\\"%f\\\", \\\"Microsecond as a decimal number, zero-padded on the left.\\\", \\\"000000\\\"],\\n [\\\"%z\\\", \\\"UTC offset in the form +HHMM or -HHMM (empty string if the the object is naive).\\\", \\\"\\\"],\\n [\\\"%Z\\\", \\\"Time zone name (empty string if the object is naive).\\\", \\\"\\\"],\\n [\\\"%j\\\", \\\"Day of the year as a zero-padded decimal number.\\\", \\\"273\\\"],\\n [\\\"%-j\\\", \\\"Day of the year as a decimal number. (Platform specific)\\\", \\\"273\\\"],\\n [\\\"%U\\\", \\\"Week number of the year (Sunday as the first day of the week) as a zero padded decimal number. All days in a new year preceding the first Sunday are considered to be in week 0.\\\", \\\"39\\\"],\\n [\\\"%W\\\", \\\"Week number of the year (Monday as the first day of the week) as a decimal number. All days in a new year preceding the first Monday are considered to be in week 0.\\\", \\\"39\\\"],\\n [\\\"%c\\\", \\\"Locale's appropriate date and time representation.\\\", \\\"Mon Sep 30 07:06:05 2013\\\"],\\n [\\\"%x\\\", \\\"Locale's appropriate date representation.\\\", \\\"09/30/13\\\"],\\n [\\\"%X\\\", \\\"Locale's appropriate time representation.\\\", \\\"07:06:05\\\"],\\n [\\\"%%\\\", \\\"A literal '%' character.\\\", \\\"%\\\"]\\n ]\\n\\n display(HTML(\\n '<table><tr>{}</tr></table>'.format(\\n '</tr><tr>'.join(\\n '<td>{}</td>'.format('</td><td>'.join(str(_) for _ in row)) for row in data)\\n )\\n ))\",\n \"def register(file_format, extensions, reader, writer=None):\\n register_format(\\n fmt=file_format,\\n ext_to_fmt=_extension_to_filetype,\\n reader_map=_reader_map,\\n writer_map=_writer_map,\\n extensions=extensions,\\n reader=reader,\\n writer=writer,\\n )\",\n \"def register(file_format, extensions, reader, writer=None):\\n register_format(\\n fmt=file_format,\\n ext_to_fmt=_extension_to_filetype,\\n reader_map=_reader_map,\\n writer_map=_writer_map,\\n extensions=extensions,\\n reader=reader,\\n writer=writer,\\n )\",\n \"def available_formats() -> List[str]:\\n formats = [p.stem for p in Path(TEMPLATES_PATH).glob(f'*{TEMPLATE_SUFFIX}')]\\n return formats\",\n \"def initFormat(self):\\n self.formatList = []\",\n \"def test_available_output_formats():\\n assert set([\\\"GTiff\\\", \\\"PNG\\\", \\\"PNG_hillshade\\\", \\\"GeoJSON\\\"]).issubset(\\n set(available_output_formats())\\n )\",\n \"def reset_format(self):\\n ## Formatters\\n self._format_setters(*self.format_set_info)\\n self._format_getters(*self.format_get_info)\\n self._format_joining_functions()\",\n \"def available_output_formats() -> Dict:\\n output_formats = {}\\n for v in drivers:\\n driver_ = v.load()\\n if hasattr(driver_, \\\"METADATA\\\") and (driver_.METADATA[\\\"mode\\\"] in [\\\"w\\\", \\\"rw\\\"]):\\n output_formats[driver_.METADATA[\\\"driver_name\\\"]] = driver_.METADATA\\n return output_formats\",\n \"def getopt_format(self):\\n self._print_enum_opt(\\\"format\\\", FORMATTERS)\",\n \"def set_format_by_type(self, value, format):\\n self.set_render_func_by_type(value, format.format)\",\n \"def output_formats(self) -> List[DataFormat]:\\n return [DataFormat.NGEN_OUTPUT]\",\n \"def default_formatter(self, data):\\n return data\",\n \"def register_output_format(name):\\n\\n def check_decorator(fn):\\n _output_format_map[name] = fn\\n\\n def wrapper(*args, **kwargs):\\n return fn(*args, **kwargs)\\n\\n return wrapper\\n\\n return check_decorator\",\n \"def initFormat(self):\\n self.formatList = self.splitText(self.format)\",\n \"def formatter(question: dict):\\n fmt = question.get('possibilities', {}).get('format')\\n if fmt == 'date':\\n return pd.to_datetime\\n elif fmt == 'num':\\n return lambda x: x\\n else:\\n raise ValueError(f\\\"Question format {fmt} unknown\\\")\",\n \"def set_formatter(self, formatter):\\n self.format = formatter\",\n \"def source_formats(self):\\n formats = []\\n for source_path in self.source_paths:\\n formats.append('{}{}'.format(\\n source_path,\\n self.sub_base_pod_path))\\n return formats\",\n \"def Register(self, name, fn):\\n name = normalizeStr(name)\\n Logger.Debug(\\\"Registering Formatter:\\\", name)\\n self._formatters[name] = fn\",\n \"def _define_formats(self, workbook):\\n self.format_title = workbook.add_format({\\n 'bold': True,\\n 'align': 'center',\\n 'font_size': 12,\\n 'font': 'Arial',\\n 'border': False\\n })\\n self.format_header = workbook.add_format({\\n 'bold': True,\\n 'font_size': 10,\\n 'align': 'center',\\n 'font': 'Arial',\\n #'border': True\\n })\\n self.content_header = workbook.add_format({\\n 'bold': False,\\n 'font_size': 10,\\n 'align': 'center',\\n 'border': True,\\n 'font': 'Arial',\\n })\\n self.content_header_date = workbook.add_format({\\n 'bold': False,\\n 'font_size': 10,\\n 'border': True,\\n 'align': 'center',\\n 'font': 'Arial',\\n })\\n self.line_header = workbook.add_format({\\n 'bold': True,\\n 'font_size': 10,\\n 'align': 'center',\\n 'top': True,\\n 'bottom': True,\\n 'font': 'Arial',\\n })\\n self.line_header_light = workbook.add_format({\\n 'bold': False,\\n 'font_size': 10,\\n 'align': 'center',\\n 'text_wrap': True,\\n 'font': 'Arial',\\n 'valign': 'top'\\n })\\n self.line_header_light_date = workbook.add_format({\\n 'bold': False,\\n 'font_size': 10,\\n 'align': 'center',\\n 'font': 'Arial',\\n })\\n self.line_header_light_initial = workbook.add_format({\\n 'italic': True,\\n 'font_size': 10,\\n 'align': 'center',\\n 'bottom': True,\\n 'font': 'Arial',\\n 'valign': 'top'\\n })\\n self.line_header_light_ending = workbook.add_format({\\n 'italic': True,\\n 'font_size': 10,\\n 'align': 'center',\\n 'top': True,\\n 'font': 'Arial',\\n 'valign': 'top'\\n })\",\n \"def available_input_formats() -> Dict:\\n input_formats = {}\\n for v in drivers:\\n logger.debug(\\\"driver found: %s\\\", v)\\n driver_ = v.load()\\n if hasattr(driver_, \\\"METADATA\\\") and (driver_.METADATA[\\\"mode\\\"] in [\\\"r\\\", \\\"rw\\\"]):\\n input_formats[driver_.METADATA[\\\"driver_name\\\"]] = driver_.METADATA\\n return input_formats\",\n \"def format_(self):\\n return self.set_format or self.default_format or self.FALLBACK_FORMAT\",\n \"def format(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def available_input_formats():\\n input_formats = []\\n # Extensions.\\n for v in pkg_resources.iter_entry_points(_DRIVERS_ENTRY_POINT):\\n try:\\n input_formats.append(v.load().InputData.METADATA[\\\"driver_name\\\"])\\n except ImportError:\\n raise\\n except Exception:\\n pass\\n return input_formats\",\n \"def AddFormat(self, format):\\n self._legacy = False\\n if format:\\n self._format = format\",\n \"def define_log_pre_format_hooks(self):\\n return []\",\n \"def available_output_formats():\\n output_formats = []\\n for v in pkg_resources.iter_entry_points(_DRIVERS_ENTRY_POINT):\\n try:\\n output_formats.append(\\n v.load().OutputData.METADATA[\\\"driver_name\\\"])\\n except AttributeError:\\n pass\\n return output_formats\",\n \"def set_default_input_format(args):\\n if not args.inputFormat:\\n for pname, popt in parser_opts.items():\\n input_extension = os.path.splitext(args.input)[1]\\n if input_extension.lower() == popt.file_extension:\\n args.inputFormat = pname\\n log.info(\\\"You didn't set an input format. Assuming %s\\\", args.inputFormat)\\n break\\n else:\\n raise RuntimeError(\\\"Cannot determine input format. \\\"\\n \\\"Must be one of {}\\\".format(list(parser_opts.keys())))\",\n \"def _define_formats(self, workbook):\\n self.format_title_main_center = workbook.add_format({\\n 'bold': True,\\n 'align': 'left',\\n 'font_size': 14,\\n 'border': True,\\n 'font_name':'Arial',\\n 'align': 'Center',\\n 'bg_color': '#D8D7D7',\\n })\\n self.format_title = workbook.add_format({\\n 'align': 'left',\\n 'font_size': 12,\\n 'border': True,\\n 'font_name':'Arial',\\n 'text_wrap': True\\n })\\n self.format_title_noborder = workbook.add_format({\\n 'align': 'left',\\n 'font_size': 12,\\n 'border': False,\\n 'font_name':'Arial'\\n })\\n self.format_title_noborder_bold = workbook.add_format({\\n 'align': 'left',\\n 'font_size': 12,\\n 'bold': True,\\n 'border': False,\\n 'font_name':'Arial'\\n })\\n self.format_title_center = workbook.add_format({\\n 'align': 'left',\\n 'font_size': 12,\\n 'border': True,\\n 'align': 'Center',\\n 'font_name':'Arial'\\n })\\n self.format_title_bold = workbook.add_format({\\n 'align': 'left',\\n 'font_size': 12,\\n 'border': True,\\n 'font_name':'Arial',\\n 'bold': True,\\n })\\n self.format_title_center_bold = workbook.add_format({\\n 'align': 'left',\\n 'font_size': 12,\\n 'border': True,\\n 'font_name':'Arial',\\n 'align': 'Center',\\n 'bold': True,\\n })\\n self.format_title_number = workbook.add_format({\\n 'align': 'right',\\n 'font_size': 12,\\n 'border': True,\\n 'font_name':'Arial',\\n 'num_format': '#,##0.00',\\n })\\n self.format_title_number_bold = workbook.add_format({\\n 'align': 'right',\\n 'font_size': 12,\\n 'border': True,\\n 'font_name':'Arial',\\n 'num_format': '#,##0.00',\\n 'bold': True,\\n 'bg_color': '#D8D7D7',\\n })\\n \\n self.format_header = workbook.add_format({\\n 'bold': True,\\n 'border': True,\\n 'font_name':'Arial',\\n 'font_size': 12,\\n 'align': 'Center',\\n 'bg_color': '#D8D7D7', \\n })\\n\\n self.merge_format = workbook.add_format({\\n 'bold': 1,\\n 'border': 1,\\n 'align': 'center',\\n 'valign': 'vcenter',\\n })\",\n \"def format_to_extension(self, format):\",\n \"def determine_format(request, serializer, default_format='application/json'):\\n # First, check if they forced the format.\\n if request.GET.get('format'):\\n if request.GET['format'] in serializer.formats:\\n return serializer.get_mime_for_format(request.GET['format'])\\n \\n # If callback parameter is present, use JSONP.\\n if request.GET.has_key('callback'):\\n return serializer.get_mime_for_format('jsonp')\\n \\n # Try to fallback on the Accepts header.\\n if request.META.get('HTTP_ACCEPT', '*/*') != '*/*':\\n formats = list(serializer.supported_formats) or []\\n # Reverse the list, because mimeparse is weird like that. See also\\n # https://github.com/toastdriven/django-tastypie/issues#issue/12 for\\n # more information.\\n formats.reverse()\\n best_format = mimeparse.best_match(formats, request.META['HTTP_ACCEPT'])\\n \\n if best_format:\\n return best_format\\n \\n # No valid 'Accept' header/formats. Sane default.\\n return default_format\",\n \"def add_formatter(self, fmt):\\n if fmt and not isfunction(fmt):\\n raise TypeError(\\\"custom format function must be a type of function\\\")\\n\\n if fmt and fmt.__code__.co_argcount < 2:\\n raise TypeError(\\\"custom format function requires at least 2 arguments\\\")\\n\\n self.formatter = fmt\",\n \"def setInputFormats(self, value):\\n return self._set(inputFormats=value)\",\n \"def setDateOutputFormat(self,fmt):\\r\\n self.datefmt_out = fmt\",\n \"def load_print_formats(self, doclist):\\n\\t\\t# TODO: Process Print Formats for $import\\n\\t\\t# to deprecate code in print_format.py\\n\\t\\t# if this is implemented, clear CacheItem on saving print format\\n\\t\\tprint_formats = webnotes.conn.sql(\\\"\\\"\\\"\\\\\\n\\t\\t\\tSELECT * FROM `tabPrint Format`\\n\\t\\t\\tWHERE doc_type=%s AND docstatus<2\\\"\\\"\\\", doclist[0].fields.get('name'),\\n\\t\\t\\tas_dict=1)\\n\\t\\tfor pf in print_formats:\\n\\t\\t\\tif not pf: continue\\n\\t\\t\\tprint_format_doc = webnotes.model.doc.Document('Print Format', fielddata=pf)\\n\\t\\t\\tdoclist.append(print_format_doc)\",\n \"def get_format_tools(fmt: str, config: Config) -> FormatTools:\\n if fmt == \\\"rst\\\":\\n from . import ( # pylint: disable=cyclic-import,import-outside-toplevel\\n format_rst,\\n )\\n\\n return format_rst.RstTools(config)\\n else:\\n assert fmt == \\\"md\\\"\\n from . import ( # pylint: disable=cyclic-import,import-outside-toplevel\\n format_md,\\n )\\n\\n return format_md.MdTools(config)\",\n \"def get_formatters(self, method_string):\\n formatters = self.formatter_lookup_fn(method_string)\\n return formatters or get_default_formatters()\",\n \"def _load_serializers(self):\\n global _serializers\\n serializers = {}\\n for format in BUILTIN_SERIALIZERS:\\n self.register_serializer(format, BUILTIN_SERIALIZERS[format], serializers)\\n if hasattr(settings, \\\"SERIALIZATION_MODULES\\\"):\\n for format in settings.SERIALIZATION_MODULES:\\n self.register_serializer(format,\\n settings.SERIALIZATION_MODULES[format],\\n serializers)\\n _serializers = serializers\",\n \"def formatter(formatter_name):\\n\\n def _formatter_decorator(f):\\n def _formatter_wrapper(*wrapper_args, **wrapper_kwargs):\\n ctx = wrapper_args[1]\\n if not ctx.json and formatter_name in _formatter_functions:\\n ctx.format_function = _formatter_functions[formatter_name]\\n return f(*wrapper_args, **wrapper_kwargs)\\n\\n return _formatter_wrapper\\n\\n return _formatter_decorator\",\n \"def initFormat(self):\\n self.html = True\",\n \"def initFormat(self):\\n self.html = True\",\n \"def setup_fmt(self, ctx):\\n ctx.implicit_errors = False\",\n \"def determine_format(request, serializer, default_format='application/json'):\\r\\n # First, check if they forced the format.\\r\\n if request.GET.get('format'):\\r\\n if request.GET['format'] in serializer.formats:\\r\\n return serializer.get_mime_for_format(request.GET['format'])\\r\\n\\r\\n # Try to fallback on the Accepts header.\\r\\n if request.META.get('HTTP_ACCEPT', '*/*') != '*/*':\\r\\n formats = list(serializer.supported_formats) or []\\r\\n # Reverse the list, because mimeparse is weird like that. See also\\r\\n # https://github.com/toastdriven/django-tastypie/issues#issue/12 for\\r\\n # more information.\\r\\n formats.reverse()\\r\\n best_format = mimeparse.best_match(\\r\\n formats, request.META['HTTP_ACCEPT'])\\r\\n\\r\\n if best_format:\\r\\n return best_format\\r\\n\\r\\n # No valid 'Accept' header/formats. Sane default.\\r\\n return default_format\",\n \"def register_serializer(format, serializer_module, serializers=None):\\n module = importlib.import_module(serializer_module)\\n if serializers is None:\\n _test_serializers[format] = module\\n else:\\n serializers[format] = module\",\n \"def set_formatter(self, enable_time=False, enable_msg_count=True):\\n self.formatter = logging.Formatter(\\n '{}%(name)s - %(levelname)s - %(message)s'.format(\\n \\\"%(asctime)s - \\\" if enable_time else \\\"\\\",\\n ))\\n for handler in self.handlers:\\n handler.setFormatter(self.formatter)\\n return self.formatter\",\n \"def formats(self):\\n logger.debug(\\\"Get formats\\\")\\n return self._raw_api.formats.get()\",\n \"def __format__(self, *args, **kwargs): # real signature unknown\\r\\n pass\",\n \"def _set_real_format(self, fmt):\\n # try to use the _nomax variant if available\\n if not self._max and fmt + '_nomax' in self.formats:\\n self._format = self.formats[fmt + '_nomax']\\n elif fmt in self.formats:\\n self._format = self.formats[fmt]\\n else:\\n self._format = fmt\\n\\n self._format_line_count = self._format.count('\\\\n')\",\n \"def __init__(self, fmt, datefmt=None):\\n logging.Formatter.__init__(self, fmt, datefmt)\",\n \"def format(self, *args, **kwargs) -> String:\\n pass\",\n \"def __format__(self, format_specification=''):\\n return super().__format__(format_specification=format_specification)\",\n \"def formats():\\n if PIL_ENABLED:\\n return 'BMP', 'EPS', 'GIF', 'JPEG', 'MSP', 'PCX', 'PNG', 'SVG', 'TIFF', 'XBM'\\n else:\\n return 'EPS', 'SVG'\",\n \"def setFormat( self, fmt, style = '{' ):\\n formatter = logging.Formatter( fmt, style = style )\\n for handler in self.logger.handlers:\\n handler.setFormatter( formatter )\",\n \"def get_formats(self):\\n return tuple(self._names.keys())\",\n \"def GetCaptureFileFormats(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def addIfMissing(self, format):\\n self.setdefault(format.name, format)\",\n \"def handler_defaults(stdout_handler=stdout_handler, stderr_handler=stderr_handler):\\n\\n\\tfor handler in [stdout_handler, stderr_handler]:\\n\\t\\tif handler is not None:\\n\\t\\t\\thandler.setFormatter(default_formatter)\\n\\n\\tif stdout_handler is not None:\\n\\t\\tstdout_handler.setLevel(default_console_level)\\n\\t\\t# Ignore messages given to stderr.\\n\\t\\tstdout_handler.addFilter(stdout_filter)\\n\\n\\tif stderr_handler is not None:\\n\\t\\tstderr_handler.setLevel(max(default_console_level + 1, logging.WARNING))\",\n \"def get_import_formats(self):\\n return [f for f in self.formats if f().can_import()]\",\n \"def _determine_format(self, request):\\n return determine_format(request, self._meta.serializer, default_format=self._meta.default_format)\",\n \"def format(self):\\n ...\",\n \"def get_formatted_messages(formats, label, context):\\r\\n format_templates = {}\\r\\n for format in formats:\\r\\n # conditionally turn off autoescaping for .txt extensions in format\\r\\n if format.endswith(\\\".txt\\\"):\\r\\n context.autoescape = False\\r\\n format_templates[format] = render_to_string((\\r\\n 'notification/%s/%s' % (label, format),\\r\\n 'notification/%s' % format), context_instance=context)\\r\\n return format_templates\",\n \"def test_unsupported_format():\\n formatter = TabularOutputFormatter()\\n\\n with pytest.raises(ValueError):\\n formatter.format_name = \\\"foobar\\\"\\n\\n with pytest.raises(ValueError):\\n formatter.format_output((), (), format_name=\\\"foobar\\\")\",\n \"def setup(self, formats):\\n for f in formats:\\n try:\\n self.counters[f] += 1\\n except KeyError:\\n self.counters[f] = 1\\n self.vim.command(f\\\"set efm+={f}\\\")\",\n \"def sformatf(cls, msg, *args):\\n #formats = {\\\"%t\\\": \\\"%d\\\", \\\"%0t\\\": \\\"%0d\\\"}\\n #for s in formats:\\n # msg = msg.replace(s, formats[s])\\n #return sformatf(msg, *args)\\n # TODO substitute old types %s/%d etc with {}\\n #new_msg = cls.STR_RE.sub(r'{:\\\\1}', msg)\\n #print(\\\"new_msg is \\\" + new_msg)\\n for s in cls.formats:\\n if s == \\\"%h\\\" or s == \\\"%0h\\\":\\n msg = msg.replace(s, \\\"{:X}\\\")\\n else:\\n msg = msg.replace(s, \\\"{}\\\")\\n return msg.format(*args)\",\n \"def datetime_formats(self) -> localedata.LocaleDataDict:\\n return self._data['datetime_formats']\",\n \"def strfdate(self, fmt):\\n pattern = r'%({})'.format(reduce(lambda x, y: '{}|{}'.format(x, y), FORMAT_MAP.keys()))\\n for f in re.findall(pattern, fmt):\\n fmt = fmt.replace('%{}'.format(f), FORMAT_MAP[f](self))\\n return fmt\",\n \"def add_formatter(self, regexp, conv, userdata=None):\\n if isinstance(regexp, str):\\n regexp = re.compile(regexp)\\n self._formatters.append([regexp, conv, userdata])\",\n \"def date_formats(self) -> localedata.LocaleDataDict:\\n return self._data['date_formats']\",\n \"def interval_formats(self) -> localedata.LocaleDataDict:\\n return self._data['interval_formats']\",\n \"def register_converters(self, converter_list):\\n for converter in converter_list:\\n self.register_converter(converter)\",\n \"def after_init(self):\\n if self.options.format.appended:\\n self.error_format = self.options.format.appended[0]\",\n \"def basicConfig(**kwargs):\\n # Add thread safety in case someone mistakenly calls\\n # basicConfig() from multiple threads\\n logging._acquireLock()\\n try:\\n if len(logging.root.handlers) == 0:\\n handlers = kwargs.pop(\\\"handlers\\\", None)\\n if handlers is None:\\n if \\\"stream\\\" in kwargs and \\\"filename\\\" in kwargs:\\n raise ValueError(\\\"'stream' and 'filename' should not be \\\"\\n \\\"specified together\\\")\\n else:\\n if \\\"stream\\\" in kwargs or \\\"filename\\\" in kwargs:\\n raise ValueError(\\\"'stream' or 'filename' should not be \\\"\\n \\\"specified together with 'handlers'\\\")\\n if handlers is None:\\n filename = kwargs.pop(\\\"filename\\\", None)\\n mode = kwargs.pop(\\\"filemode\\\", 'a')\\n if filename:\\n h = logging.FileHandler(filename, mode)\\n else:\\n stream = kwargs.pop(\\\"stream\\\", None)\\n h = logging.StreamHandler(stream)\\n handlers = [h]\\n dfs = kwargs.pop(\\\"datefmt\\\", None)\\n style = kwargs.pop(\\\"style\\\", '%')\\n if style not in _STYLES:\\n raise ValueError('Style must be one of: %s' % ','.join(\\n _STYLES.keys()))\\n fs = kwargs.pop(\\\"format\\\", BASIC_FORMAT)\\n fmt = JsonFormatter(fs, dfs, style)\\n for h in handlers:\\n if h.formatter is None:\\n h.setFormatter(fmt)\\n logging.root.addHandler(h)\\n level = kwargs.pop(\\\"level\\\", None)\\n if level is not None:\\n logging.root.setLevel(level)\\n if kwargs:\\n keys = ', '.join(kwargs.keys())\\n raise ValueError('Unrecognised argument(s): %s' % keys)\\n finally:\\n logging._releaseLock()\",\n \"def get_renderers(self, request):\\n if self._format_override_parameter in request.REQUEST:\\n formats = request.REQUEST[self._format_override_parameter].split(',')\\n renderers, seen_formats = [], set()\\n for format in formats:\\n if format in self._renderers_by_format and format not in seen_formats:\\n renderers.extend(self._renderers_by_format[format])\\n elif request.META.get('HTTP_ACCEPT'):\\n accepts = self.parse_accept_header(request.META['HTTP_ACCEPT'])\\n renderers = MediaType.resolve(accepts, self._renderers)\\n elif self._default_format:\\n renderers = self._renderers_by_format[self._default_format]\\n else:\\n renderers = []\\n if self._force_fallback_format:\\n renderers.extend(self._renderers_by_format[self._force_fallback_format])\\n return renderers\",\n \"def test_available_input_formats():\\n assert set([\\\"Mapchete\\\", \\\"raster_file\\\", \\\"vector_file\\\"]).issubset(\\n set(available_input_formats())\\n )\",\n \"def assign_format(self):\\n if self.is_output or self.is_req_output:\\n if self.pname in self.tool_data[self.tool_name]['output_fmt']:\\n return self.tool_data[self.tool_name]['output_fmt'][self.pname]\\n elif self.pname in self.gen_out_fmt:\\n return self.gen_out_fmt[self.pname]\\n elif self.is_input:\\n if self.pname in self.tool_data[self.tool_name]['input_fmt']:\\n print(self.tool_data[self.tool_name])\\n return self.tool_data[self.tool_name]['input_fmt'][self.pname]\\n elif self.pname in self.gen_in_fmt:\\n return self.gen_in_fmt[self.pname]\\n else:\\n # Not sure yet what this will be used for, but I think we need it.\\n return ''\",\n \"def extension (formatStr):\\n assert False, \\\"TODO:\\\"\",\n \"def autodetect_format(file_data):\\n\\n # The first header line.\\n for line in file_data:\\n if line != []:\\n break\\n\\n # Sparky format.\\n if line[0] == 'Assignment':\\n return 'sparky'\\n\\n # NMRView format.\\n if line == ['label', 'dataset', 'sw', 'sf']:\\n return 'nmrview'\\n\\n # NMRPipe SeriesTab.\\n if line[0] == 'REMARK' and line[1] == 'SeriesTab':\\n return 'seriestab'\\n\\n # XEasy format.\\n if line == ['No.', 'Color', 'w1', 'w2', 'ass.', 'in', 'w1', 'ass.', 'in', 'w2', 'Volume', 'Vol.', 'Err.', 'Method', 'Comment']:\\n return 'xeasy'\\n\\n # Assume a generic format.\\n return 'generic'\",\n \"def update_placeholder_formats(self, format_string, placeholder_formats):\\n # Tokenize the format string and process them\\n output = []\\n for token in self.tokens(format_string):\\n if (\\n token.group(\\\"placeholder\\\")\\n and (not token.group(\\\"format\\\"))\\n and token.group(\\\"key\\\") in placeholder_formats\\n ):\\n output.append(f\\\"{{{token.group('key')}{placeholder_formats[token.group('key')]}}}\\\")\\n continue\\n value = token.group(0)\\n output.append(value)\\n return \\\"\\\".join(output)\",\n \"def initDefaultChoices(self):\\n return [text for text in self.formatList]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67433965","0.62260413","0.6008091","0.5960222","0.5885646","0.58462405","0.57293695","0.5707574","0.5638043","0.5609508","0.5559438","0.5524077","0.5505028","0.5505028","0.54933727","0.547053","0.54281515","0.53969175","0.53580284","0.5356706","0.53475726","0.53387696","0.53059214","0.5281043","0.5281043","0.52706","0.5270181","0.5226936","0.5218682","0.52131784","0.52028584","0.5199513","0.5191905","0.51844084","0.5182881","0.51708096","0.51654965","0.51597756","0.5154266","0.51517797","0.51251704","0.5123918","0.51210266","0.51088804","0.5096279","0.50961983","0.5091812","0.5062985","0.50500244","0.50431246","0.50288177","0.5027481","0.50265884","0.49947533","0.49846917","0.49813345","0.49785036","0.49765503","0.49645945","0.49552062","0.495294","0.495294","0.49435592","0.49295142","0.4914551","0.49045748","0.4904394","0.4902786","0.4893442","0.48902732","0.48766038","0.48760378","0.4865019","0.4844815","0.4841058","0.48340538","0.48290986","0.48231536","0.48172158","0.48026907","0.47949448","0.4775614","0.47721943","0.47719482","0.47597158","0.47528824","0.4748641","0.4747274","0.47369593","0.4732514","0.47209346","0.47069147","0.4706727","0.47038367","0.46971306","0.46891156","0.46875203","0.4686955","0.46821475","0.4676418"],"string":"[\n \"0.67433965\",\n \"0.62260413\",\n \"0.6008091\",\n \"0.5960222\",\n \"0.5885646\",\n \"0.58462405\",\n \"0.57293695\",\n \"0.5707574\",\n \"0.5638043\",\n \"0.5609508\",\n \"0.5559438\",\n \"0.5524077\",\n \"0.5505028\",\n \"0.5505028\",\n \"0.54933727\",\n \"0.547053\",\n \"0.54281515\",\n \"0.53969175\",\n \"0.53580284\",\n \"0.5356706\",\n \"0.53475726\",\n \"0.53387696\",\n \"0.53059214\",\n \"0.5281043\",\n \"0.5281043\",\n \"0.52706\",\n \"0.5270181\",\n \"0.5226936\",\n \"0.5218682\",\n \"0.52131784\",\n \"0.52028584\",\n \"0.5199513\",\n \"0.5191905\",\n \"0.51844084\",\n \"0.5182881\",\n \"0.51708096\",\n \"0.51654965\",\n \"0.51597756\",\n \"0.5154266\",\n \"0.51517797\",\n \"0.51251704\",\n \"0.5123918\",\n \"0.51210266\",\n \"0.51088804\",\n \"0.5096279\",\n \"0.50961983\",\n \"0.5091812\",\n \"0.5062985\",\n \"0.50500244\",\n \"0.50431246\",\n \"0.50288177\",\n \"0.5027481\",\n \"0.50265884\",\n \"0.49947533\",\n \"0.49846917\",\n \"0.49813345\",\n \"0.49785036\",\n \"0.49765503\",\n \"0.49645945\",\n \"0.49552062\",\n \"0.495294\",\n \"0.495294\",\n \"0.49435592\",\n \"0.49295142\",\n \"0.4914551\",\n \"0.49045748\",\n \"0.4904394\",\n \"0.4902786\",\n \"0.4893442\",\n \"0.48902732\",\n \"0.48766038\",\n \"0.48760378\",\n \"0.4865019\",\n \"0.4844815\",\n \"0.4841058\",\n \"0.48340538\",\n \"0.48290986\",\n \"0.48231536\",\n \"0.48172158\",\n \"0.48026907\",\n \"0.47949448\",\n \"0.4775614\",\n \"0.47721943\",\n \"0.47719482\",\n \"0.47597158\",\n \"0.47528824\",\n \"0.4748641\",\n \"0.4747274\",\n \"0.47369593\",\n \"0.4732514\",\n \"0.47209346\",\n \"0.47069147\",\n \"0.4706727\",\n \"0.47038367\",\n \"0.46971306\",\n \"0.46891156\",\n \"0.46875203\",\n \"0.4686955\",\n \"0.46821475\",\n \"0.4676418\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57387257"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":77683,"cells":{"query":{"kind":"string","value":"Verify if the generated headers are valid."},"document":{"kind":"string","value":"def is_valid_header(headers: Dict[str, Any]) -> bool:\n for name, value in headers.items():\n if not utils.is_latin_1_encodable(value):\n return False\n if utils.has_invalid_characters(name, value):\n return False\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_build_headers(self):\n\n headers = self_signed.build_headers()\n assert 'Content-Length' in headers\n assert 'X-Amz-Date' in headers\n assert 'Host' in headers\n assert 'X-Amz-Security-Token' in headers\n assert 'Content-Type' in headers\n assert 'Authorization' in headers","def test_headers(self):\n self.assert_expected_token_value()","def test_check_header(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = ['SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\r\n 'Description']\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix=0,\r\n desc_ix=3,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field=None)\r\n\r\n expected_errors = []\r\n expected_warnings = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)","def test_check_header_missing_fields(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = ['AAA', 'XXX', 'YYY',\r\n 'ZZZ']\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix=0,\r\n desc_ix=3,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field=None)\r\n\r\n expected_errors = [\r\n 'Found header field AAA, expected field SampleID\\t0,0',\r\n 'Found header field XXX, expected field BarcodeSequence\\t0,1',\r\n 'Found header field YYY, expected field LinkerPrimerSequence\\t0,2',\r\n 'Found header field ZZZ, last field should be Description\\t0,3']\r\n expected_warnings = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)","def validate_unique_header(self):\n valid = False\n unique_headers = set(self.headers)\n if len(unique_headers) == len(self.headers):\n valid = True\n else:\n seen_headers = set()\n duplicate_headers = set()\n for x in self.headers:\n if x in seen_headers or seen_headers.add(x):\n duplicate_headers.add(x)\n msg = f\"Duplicated header names are not allowed: {duplicate_headers}\"\n log_exception(Annotations.dev_logger, Annotations.user_logger, msg)\n self.store_validation_issue(\"error\", msg, \"format:cap:unique\")\n valid = False\n if any(\"Unnamed\" in s for s in list(unique_headers)):\n msg = \"Headers cannot contain empty values\"\n log_exception(Annotations.dev_logger, Annotations.user_logger, msg)\n self.store_validation_issue(\"error\", msg, \"format:cap:no-empty\")\n valid = False\n return valid","def verifyHeader(self, headers):\n for head in headers:\n if(hex(head[0]) == VID and hex(head[1]) == PID):\n return True\n return False","def validate_header(self, reply):\n # check message is from my agg to me\n check_equal(reply.header.sender, self.aggregator_uuid, self.logger)\n check_equal(reply.header.recipient, self.common_name, self.logger)\n\n # check that the federation id matches\n check_equal(reply.header.federation_id, self.federation_uuid, self.logger)\n\n # check that we agree on single_col_cert_common_name\n check_equal(reply.header.single_col_cert_common_name, self.single_col_cert_common_name, self.logger)","def test_check_header_required_fields(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\r\n 'Description']\r\n errors = []\r\n\r\n errors = check_header_required_fields(header,\r\n errors,\r\n sample_id_ix=0,\r\n desc_ix=4,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field='run_prefix')\r\n\r\n expected_errors = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n\r\n # Should find all as errors if not named correctly\r\n header = ['AAA', 'BBB', 'CCC', 'DDD',\r\n 'EEE']\r\n errors = []\r\n\r\n errors = check_header_required_fields(header,\r\n errors,\r\n sample_id_ix=0,\r\n desc_ix=4,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field='run_prefix')\r\n\r\n expected_errors = [\r\n 'Found header field AAA, expected field SampleID\\t0,0',\r\n 'Found header field BBB, expected field BarcodeSequence\\t0,1',\r\n 'Found header field CCC, expected field LinkerPrimerSequence\\t0,2',\r\n 'Found header field EEE, last field should be Description\\t0,4',\r\n 'Missing added demultiplex field run_prefix\\t-1,-1']\r\n\r\n self.assertEqual(errors, expected_errors)","def test_headers(self):\n msg = self.shortDescription()\n self.assertTrue(False, msg=msg)\n pass","def _validate_header(self):\n if 'X-Amz-Sns-Topic-Arn' in self._headers:\n if self._topic_arn != self._headers.get(\n 'X-Amz-Sns-Topic-Arn'):\n self.error = 'Invalid TopicArn.'\n raise ValueError('Invalid TopicArn')\n else:\n self.error = 'Invalid TopicArn'\n raise ValueError('Invalid TopicArn')\n\n return True","def validate_against_header_count(self):\n valid = False\n len_headers = len(\n [header for header in self.headers if \"Unnamed\" not in header]\n )\n len_annot_type = len(\n [\n annot_type\n for annot_type in self.annot_types\n if \"Unnamed\" not in annot_type\n ]\n )\n if not len_headers == len_annot_type:\n msg = (\n f\"Header mismatch: {len_annot_type} TYPE declarations \"\n f\"for {len_headers} column headers\"\n )\n self.store_validation_issue(\"error\", msg, \"format:cap:count\")\n else:\n valid = True\n return valid","def check_headers(self, headers):\n h = headers.values()[0]\n\n if 'DT' in PAR:\n if h.dt != PAR.DT:\n h.dt = PAR.DT\n\n if 'NT' in PAR:\n if h.nt != PAR.NT:\n print 'Warning: h.nt != PAR.NT'\n\n if 'NREC' in PAR:\n if h.nr != PAR.NREC:\n print 'Warning: h.nr != PAR.NREC'\n\n return h","def assert_header(self):\r\n\r\n if self.length > self.owner.settings[SETTINGS_MAX_FRAME_SIZE]:\r\n raise netius.ParserError(\r\n \"Headers are greater than SETTINGS_MAX_FRAME_SIZE\",\r\n stream = self.stream,\r\n error_code = FRAME_SIZE_ERROR\r\n )\r\n if self.last_type in (HEADERS, CONTINUATION) and not\\\r\n self.last_end_headers and not self.last_stream == self.stream:\r\n raise netius.ParserError(\r\n \"Cannot send frame from a different stream in middle of headers\",\r\n error_code = PROTOCOL_ERROR\r\n )","def _validate_header(self, cleartext_header, decrypted_header):\n import struct\n\n magic_number1 = struct.unpack(\"!I\", decrypted_header[:4])[0]\n # file_version = struct.unpack(\"!I\", decrypted_header[4:8])[0]\n # key_stretches = struct.unpack(\"!I\", decrypted_header[8:12])[0]\n magic_number2 = struct.unpack(\"!I\", decrypted_header[12:])[0]\n if (self.__magic_number != magic_number1 or\n self.__magic_number != magic_number2):\n raise DecryptionError()\n if cleartext_header != decrypted_header:\n raise FileCorruptionError()","def test_get_cleaned_headers(self):\r\n # Some duplicates.\r\n exp = ['foo', 'foo_2', 'foo_3', 'foo_4', 'fooo', 'foo_5', 'foo_6',\r\n 'foo_7', 'foo_8', 'foo_9', 'f2oo456', 'foo_10']\r\n obs = _get_cleaned_headers(\r\n ['foo', 'Foo', 'FOO', 'F_oO', 'F:Oo_o', '123foo', '#Foo',\r\n '123foo', ' 123Foo', 'f O\\tO#', ' f2\\too456', '456 foo'])\r\n self.assertEqual(obs, exp)\r\n\r\n # All unique.\r\n exp = ['foo', 'bar']\r\n obs = _get_cleaned_headers(['Fo#o', 'bar'])\r\n self.assertEqual(obs, exp)\r\n\r\n # Header consisting of only special characters and header that is\r\n # blank.\r\n self.assertRaises(GoogleSpreadsheetError, _get_cleaned_headers,\r\n ['Foo', '___', 'BAR'])\r\n self.assertRaises(GoogleSpreadsheetError, _get_cleaned_headers,\r\n ['Foo', '', 'BAR'])","def verify_checksum(self):\n return self.generate_header_checksum(omit_checksum=False) == 0","def check_headers():\n report = {}\n for header_name, msg in request.headers.items():\n if header_name.upper().startswith('SAND-'):\n checker = sand.header.header_name_to_checker.get(\n header_name.lower())\n if checker:\n checker.check_syntax(msg.strip())\n report[header_name] = checker.errors\n else:\n report[header_name] = [('Header name not supported by this ' +\n 'version of conformance server')]\n result = \"Report for SAND headers conformance:\\n\"\n if report:\n for name, errors in report.items():\n if errors:\n result += '%s: FAILED\\n' % name\n for msg in errors:\n result += ' %s\\n' % msg\n else:\n result += '%s: PASSED\\n' % name\n else:\n result += 'No SAND header found!\\n'\n return result, 200, {'Content-Type': 'text/plain'}","def check_header(self, name, value):\r\n if value in self.headers.get(name, ''):\r\n return True\r\n return False","def check_header(self, name, value):\r\n if value in self.headers.get(name, ''):\r\n return True\r\n return False","def check_header(self, entry):\n if entry not in self.metadata:\n raise SyntaxError(\"Header entry must be described in the metadata lines. Entry: %s is not in metadata.\" % entry)","def test_specific_headers_sent_with_request(self):\n req = self.httpbin.get_my_headers(dry_run=True)\n self.assertIn('All-Request-Headers', req.prepared_request.headers)\n request_data_headers = self.httpbin.client['get_my_headers']['headers']['All-Request-Headers']\n self.assertEqual(req.prepared_request.headers['All-Request-Headers'], request_data_headers)","def check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix,\r\n desc_ix,\r\n bc_ix,\r\n linker_primer_ix,\r\n added_demultiplex_field=None):\r\n\r\n # Check for duplicates, append to errors if found\r\n errors = check_header_dups(header, errors)\r\n\r\n # Check for valid characters\r\n warnings = check_header_chars(header, warnings)\r\n\r\n # Check for required header fields\r\n errors = check_header_required_fields(header, errors, sample_id_ix,\r\n desc_ix, bc_ix, linker_primer_ix, added_demultiplex_field)\r\n\r\n return errors, warnings","def _validate_header(self, header_row):\n\n self.logger.info(\"Validating header row.\")\n \n # assume value.\n is_valid = True\n\n # check if @header_row is perfect.\n required_keys = tuple(self.required_headers.keys())\n if sorted(header_row) == sorted(required_keys):\n self.logger.info(\"Header is valid.\")\n return is_valid\n else:\n self.logger.error(\"Header is invalid.\")\n is_valid = False\n\n # report on any missing header fields.\n missing_headers = [header for header in self.required_headers if header not in\n header_row]\n if len(missing_headers) != 0:\n self.logger.warning(\"Missing required fields: {}\".format(missing_headers))\n \n # report on any duplicate fields.\n duplicate_headers = [header for header in header_row if header_row.count(header) != 1]\n if len(duplicate_headers) != 0:\n self.logger.warning(\"Found duplicate fields: {}\".format(set(duplicate_headers)))\n\n # report on any extra fields.\n extra_headers = [header for header in header_row if header not in \n self.required_headers]\n if len(extra_headers) != 0:\n self.logger.warning(\"Found extra fields: {}\".format(extra_headers))\n \n return is_valid","def has_headers(self):\n for column in self.columns:\n if column.header:\n return True\n return False","def _validate_header(self, header: packets.PacketHeader):\n if header.set_id != self._set_id:\n raise ValueError(\"Packet set_id '{}', does not match RecoverySet id '{}'\"\n .format(header.set_id.hex(), self._set_id.hex()))","def test_check_header_bad_chars(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'AAA.^^2',\r\n 'Description']\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix=0,\r\n desc_ix=4,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field=None)\r\n\r\n expected_errors = []\r\n expected_warnings = [\r\n 'Found invalid character in AAA.^^2 header field.\\t0,3']\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)","def validate_header_keyword(self):\n\n valid = False\n if self.headers[0].upper() == \"NAME\":\n valid = True\n if self.headers[0] != \"NAME\":\n msg = f'File keyword \"NAME\" provided as {self.headers[0]}'\n self.store_validation_issue(\"warn\", msg, \"format:cap:name\")\n else:\n msg = \"Malformed file header row, missing NAME keyword. (Case Sensitive)\"\n self.store_validation_issue(\"error\", msg, \"format:cap:name\")\n return valid","def _ValidateCacheFileMetadataHeader(self, cache_file_metadata_header):\n return (cache_file_metadata_header.key_size > 0 and\n cache_file_metadata_header.key_size < self._MAXIMUM_URL_LENGTH and\n cache_file_metadata_header.format_version in (1, 2, 3) and\n cache_file_metadata_header.last_fetched_time > 0 and\n cache_file_metadata_header.fetch_count > 0)","def test_check_header_dups(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\r\n 'Description']\r\n errors = []\r\n\r\n errors = check_header_dups(header, errors)\r\n\r\n expected_errors = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n\r\n # Should give errors with dups\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix', 'run_prefix',\r\n 'Description']\r\n errors = []\r\n\r\n errors = check_header_dups(header, errors)\r\n\r\n expected_errors = [\r\n 'run_prefix found in header 2 times. Header fields must be unique.\\t0,3',\r\n 'run_prefix found in header 2 times. Header fields must be unique.\\t0,4']\r\n\r\n self.assertEqual(errors, expected_errors)","def validate_format(self):\n return all(\n [\n self.validate_header_keyword(),\n self.validate_type_keyword(),\n self.validate_type_annotations(),\n self.validate_unique_header(),\n self.validate_against_header_count(),\n ]\n )","def test_valid_header_no_message_added(self):\n\n node_mock = MagicMock()\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = self.EXPECTED_HEADER\n with self.assertNoMessages():\n self.checker.process_module(node_mock)","def assertTableHeaders(self, output_lines, field_names):\n table = self.parser.table(output_lines)\n headers = table['headers']\n for field in field_names:\n self.assertIn(field, headers)","def check_headerEntries(self, expected, found):\n\n # spreadsheets must have either a barcode field or a object ID field, but both are not required\n header1 = ('original master', 'object', 'barcode')\n header2 = ('original master', 'object',\n 'object identifier\\n(edit heading to specify type ' +\n '- e.g. barcode)')\n expected = self.remove_annoying(header1, header2, expected, found)\n\n bad_entries = []\n\n for header in expected:\n if header not in found:\n bad_entries.append(header)\n\n if bad_entries:\n self.raise_excelerror(\"Incorrect header entry for {0}.\"\n .format(bad_entries))\n return True","def assertHeaders(self, headers, json=False, binary=False):\n\n self.assertIsNotNone(headers['transaction-id'])\n self.assertIsNotNone(headers['content-length'])\n if json:\n self.assertEqual(headers['content-type'],\n 'application/json; charset=UTF-8')\n if binary:\n content_type = headers['content-type'].split(';')[0]\n self.assertEqual(content_type,\n 'application/octet-stream')","def validate_headers(self, headers):\n email = headers.get(\"email\")\n sessionID = headers.get(\"sessionID\")\n if email and sessionID:\n user = user_manager.create_user(email)\n if user is None:\n app.logger.debug(\"User with email {} not found\".format(email))\n return False\n return self.is_admin(user) and user.session_id == sessionID\n app.logger.debug(\"Missing headers email and/or sessionID\")\n return False","def check_header_required_fields(header,\r\n errors,\r\n sample_id_ix,\r\n desc_ix,\r\n bc_ix,\r\n linker_primer_ix,\r\n added_demultiplex_field=None):\r\n\r\n header_checks = {\r\n sample_id_ix: \"SampleID\",\r\n desc_ix: \"Description\",\r\n bc_ix: \"BarcodeSequence\",\r\n linker_primer_ix: \"LinkerPrimerSequence\"\r\n }\r\n\r\n for curr_check in header_checks:\r\n if (header[curr_check] != header_checks[curr_check] and\r\n header_checks[curr_check] == \"Description\"):\r\n errors.append('Found header field %s, last field should be %s' %\r\n (header[curr_check], header_checks[curr_check]) +\r\n '\\t%d,%d' % (0, curr_check))\r\n elif (header[curr_check] != header_checks[curr_check] and\r\n header_checks[curr_check] != \"Description\"):\r\n errors.append('Found header field %s, expected field %s' %\r\n (header[curr_check], header_checks[curr_check]) +\r\n '\\t%d,%d' % (0, curr_check))\r\n\r\n if added_demultiplex_field:\r\n if added_demultiplex_field not in header:\r\n errors.append('Missing added demultiplex field %s\\t%d,%d' %\r\n (added_demultiplex_field, -1, -1))\r\n\r\n return errors","def test_authorization_header_not_present(self, _get_key_secret):\n request = Request(self.environ)\n request.body = self.get_request_body()\n response = self.xmodule.grade_handler(request, '')\n real_response = self.get_response_values(response)\n expected_response = {\n 'action': None,\n 'code_major': 'failure',\n 'description': 'OAuth verification error: Malformed authorization header',\n 'messageIdentifier': self.defaults['messageIdentifier'],\n }\n\n assert response.status_code == 200\n self.assertDictEqual(expected_response, real_response)","def test_lti20_rest_good_headers(self):\r\n self.xmodule.verify_oauth_body_sign = Mock(return_value=True)\r\n\r\n request = Mock(headers={u'Content-Type': u'application/vnd.ims.lis.v2.result+json'})\r\n self.xmodule.verify_lti_2_0_result_rest_headers(request)\r\n # We just want the above call to complete without exceptions, and to have called verify_oauth_body_sign\r\n self.assertTrue(self.xmodule.verify_oauth_body_sign.called)","def test_headers(self):\r\n for path in self.get_files():\r\n po = polib.pofile(path)\r\n header = po.header\r\n self.assertEqual(\r\n header.find('edX translation file'),\r\n 0,\r\n msg='Missing header in %s:\\n\"%s\"' % (os.path.basename(path), header)\r\n )","def process_headers(fin, fout, fixed_headers):\n filtered_headers = set(item[0] for item in fixed_headers)\n filtered_headers.add(\"SAMPLE\")\n expected_values = {\n name: value for name, asserted, value in fixed_headers if asserted\n }\n errors = False\n for raw_line in fin:\n if raw_line.startswith('##'):\n # TODO: This will break if the metadata header is bad.\n name, value = raw_line[2:].rstrip().split('=', 1)\n if name in filtered_headers:\n if name in expected_values:\n if value != expected_values[name]:\n errors = True\n # TODO: propper logging\n sys.stderr.write(\n 'tcga-vcf-reheader: mismatch {}={}\\n'.format(\n name, value\n )\n )\n else: # Just some other header...\n fout.write(raw_line)\n else:\n break\n fout.write(raw_line) # raw_line should now be the data header line.\n return errors","def _validate_heading(self, heading_parts: List[str]):\n # Validate heading row.\n assert len(heading_parts) >= 4\n assert \"oxygen\" in heading_parts\n assert \"pulse\" in heading_parts\n assert \"blood_pressure_systolic\" in heading_parts\n assert \"blood_pressure_diastolic\" in heading_parts","def test_invalid_header_message_added(self):\n\n node_mock = MagicMock()\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = '# Invalid\\n# Header'\n with self.assertAddsMessages(pylint.testutils.Message(\n msg_id='invalid-file-header',\n line=1,\n args=self.EXPECTED_HEADER)):\n self.checker.process_module(node_mock)","def test_authorization_header_not_present(self, get_key_secret):\r\n request = Request(self.environ)\r\n request.body = self.get_request_body()\r\n response = self.xmodule.grade_handler(request, '')\r\n real_response = self.get_response_values(response)\r\n expected_response = {\r\n 'action': None,\r\n 'code_major': 'failure',\r\n 'description': 'OAuth verification error: Malformed authorization header',\r\n 'messageIdentifier': self.DEFAULTS['messageIdentifier'],\r\n }\r\n\r\n self.assertEqual(response.status_code, 200)\r\n self.assertDictEqual(expected_response, real_response)","def test_check_header_chars(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_p-%efix',\r\n 'Description']\r\n warnings = []\r\n\r\n warnings = check_header_chars(header, warnings)\r\n\r\n expected_warnings = [\r\n 'Found invalid character in run_p-%efix header field.\\t0,3']\r\n\r\n self.assertEqual(warnings, expected_warnings)","def _check_headers(cursor, headers):\n all_columns = set(chain.from_iterable(_columns(cursor, table) for table in DATA_TABLES))\n for header in headers:\n if header not in all_columns:\n raise ValueError('column {} not recognized'.format(header))","def check_no_header_response(response: HTTPResponse) -> bool:\n return response.status_code == 422","def check_header(filename: str, *, is_newly_created: bool = False) -> None:\n lines = get_header_lines(filename)\n check_header_present(filename, lines)\n is_py3_file = all(\"from __future__\" not in line for line in lines)\n if is_py3_file:\n lines = lines[:EXPECTED_NUM_PY3_LINES]\n copyright_line_index = 0\n expected_header = EXPECTED_HEADER_PY3\n else:\n copyright_line_index = 1\n expected_header = EXPECTED_HEADER_PY2\n check_copyright_year(\n filename, copyright_line=lines[copyright_line_index], is_newly_created=is_newly_created\n )\n check_matches_header(\n filename, lines, expected_header=expected_header, copyright_line_index=copyright_line_index\n )","def test_authorization_header_empty(self, _get_key_secret):\n request = Request(self.environ)\n request.authorization = \"bad authorization header\"\n request.body = self.get_request_body()\n response = self.xmodule.grade_handler(request, '')\n real_response = self.get_response_values(response)\n expected_response = {\n 'action': None,\n 'code_major': 'failure',\n 'description': 'OAuth verification error: Malformed authorization header',\n 'messageIdentifier': self.defaults['messageIdentifier'],\n }\n assert response.status_code == 200\n self.assertDictEqual(expected_response, real_response)","def test_h2_header_ok(self):\n self.set_frang_config(frang_config=\"http_strict_host_checking true;\")\n client = self.get_client(\"deproxy-1\")\n client.start()\n client.parsing = False\n\n first_headers = [(\":authority\", \"localhost\"), (\":path\", \"/\")]\n second_headers = [(\":path\", \"/\"), (\"host\", \"localhost\")]\n third_headers = [(\":authority\", \"localhost\"), (\":path\", \"/\"), (\"host\", \"localhost\")]\n fourth_headers = [\n (\":authority\", \"tempesta-tech.com\"),\n (\":path\", \"/\"),\n (\"forwarded\", \"host=tempesta-tech.com\"),\n (\"forwarded\", \"for=tempesta.com\"),\n ]\n\n header_list = [\n first_headers,\n first_headers, # as byte\n second_headers,\n second_headers, # as byte\n third_headers,\n third_headers, # as byte\n fourth_headers,\n fourth_headers, # as byte\n ]\n for header in header_list:\n head = [\n (\":scheme\", \"https\"),\n (\":method\", \"HEAD\"),\n ]\n head.extend(header)\n client.make_request(head)\n self.assertTrue(client.wait_for_response(1))\n\n self.check_response(client, status_code=\"200\", warning_msg=\"frang: \")","def check_valid_csv_header(self, row):\n obj = re.match(re.compile('^Year\\,Month\\,.'),\n ','.join(row))\n if not obj:\n raise Exception(\"Invalid Headers must be `Year` `Month` Check Sample file\")","def test_size_from_header(self):\n\n # pylint: disable=protected-access\n\n expected = False\n actual = self.file_instance.exists()\n\n self.assertEqual(expected, actual)\n\n expected = [element for _, element in self.to_print[\"basic\"].items()]\n\n actual = Prints(\n None, None, output_file=None, only_on_file=False\n )._size_from_header(self.to_print[\"basic\"])\n\n self.assertEqual(expected, actual)","def test_get_spreadsheet_headers(self):\r\n client = self.getClient()\r\n if client:\r\n exp = ['#SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\r\n 'Treatment', 'DOB', 'Description']\r\n obs = _get_spreadsheet_headers(client, self.spreadsheet_key,\r\n self.worksheet_id)\r\n self.assertEqual(obs, exp)\r\n else:\r\n raise GoogleSpreadsheetConnectionError(\"Cannot execute test \"\r\n \"without an active Internet connection.\")","def Headers_items0():\n assert_eq(\n sorted(k for k, v in Headers(API_KEY, API_SECRET).items()),\n ['x-dnsme-apiKey', 'x-dnsme-hmac', 'x-dnsme-requestDate'])","def validate_metadata(self):\n metadata = self.get_client_metadata()\n\n return True","def test_create_headers(headers, request_content_type_header, response_content_type_header, expected_headers):\n from HttpV2 import create_headers\n\n output = create_headers(headers, request_content_type_header, response_content_type_header)\n assert output == expected_headers","def test_authorization_header_empty(self, get_key_secret):\r\n request = Request(self.environ)\r\n request.authorization = \"bad authorization header\"\r\n request.body = self.get_request_body()\r\n response = self.xmodule.grade_handler(request, '')\r\n real_response = self.get_response_values(response)\r\n expected_response = {\r\n 'action': None,\r\n 'code_major': 'failure',\r\n 'description': 'OAuth verification error: Malformed authorization header',\r\n 'messageIdentifier': self.DEFAULTS['messageIdentifier'],\r\n }\r\n self.assertEqual(response.status_code, 200)\r\n self.assertDictEqual(expected_response, real_response)","def test_valid_header_not_at_top_message_added(self):\n\n node_mock = MagicMock()\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = 'print(\\'hello\\')\\n# Valid\\n# Header'\n with self.assertAddsMessages(pylint.testutils.Message(\n msg_id='invalid-file-header',\n line=1,\n args=self.EXPECTED_HEADER)):\n self.checker.process_module(node_mock)","def test_invalid_header_data(self):\n elect_data = {\n \"title\": \"Election A\",\n \"admin_id\": 1,\n \"default_election_type\": \"WinnerTakeAll\"\n }\n\n race_data = {\n \"title\": \"Race A\",\n \"elect_id\": 1\n }\n\n cand_data = {\n \"name\": \"Candidate A\",\n \"race_id\": 1\n }\n\n vote_data = {\n \"value\": \"1\",\n \"user_id\": 1,\n \"candidate_id\": 1\n }\n\n user_data = {\n \"name\": \"User A\",\n \"password\": \"whatever\",\n }\n\n datalist = [elect_data, race_data, cand_data, vote_data, user_data]\n endpoint_list = [\"elections\", \"races\", \"candidates\", \"votes\", \"users\"]\n endpoint_data_dict = dict(zip(endpoint_list, datalist))\n\n for endpoint, data in endpoint_data_dict.items():\n response = self.client.post(\"/api/{}\".format(endpoint),\n data=json.dumps(data),\n content_type=\"application/json\",\n headers=[(\"Accept\", \"application/json\")]\n )\n self.assertEqual(response.status_code, 422)\n self.assertEqual(response.mimetype, \"application/json\")","def has_bad_headers(self):\n\n headers = [self.sender, self.reply_to] + self.recipients\n for header in headers:\n if _has_newline(header):\n return True\n\n if self.subject:\n if _has_newline(self.subject):\n for linenum, line in enumerate(self.subject.split('\\r\\n')):\n if not line:\n return True\n if linenum > 0 and line[0] not in '\\t ':\n return True\n if _has_newline(line):\n return True\n if len(line.strip()) == 0:\n return True\n return False","def test_raw_empty(self):\n self.assertRaisesHeaderError([''])","def test_user_headers_sent_with_request(self):\n user_header = {'All-Request-Headers': 'Headers from user code'}\n req = self.httpbin.get_my_headers(headers=user_header, dry_run=True)\n self.assertIn('All-Request-Headers', req.prepared_request.headers)\n self.assertEqual(req.prepared_request.headers['All-Request-Headers'], user_header['All-Request-Headers'])","def test_content_length() -> None:\n assert \"CONTENT-LENGTH: 3\" in Fauxmo.add_http_headers(\"foo\")\n assert \"CONTENT-LENGTH: 4\" in Fauxmo.add_http_headers(\"föo\")","def test_header_parser_vanilla(self):\n lines = [\"Content-Type: application/json\", \"Accept: application/json\"]\n h = {\"Content-Type\": \"application/json\", \"Accept\": \"application/json\"}\n headers = parser._parse_headers(lines)\n self.assertEqual(h, headers)","def test_fasta_get_headers(self):\r\n\r\n header_records = mfau.get_record_headers(full_file_name)\r\n\r\n if debug:\r\n for header_record in header_records:\r\n print header_record.strip()\r\n\r\n self.assertGreaterEqual(len(header_records), 0)","def verify_header (filename, htypes=None):\n\n # dictionary\n dict_head = {\n # raw header\n # commenting out SIMPLE, BSCALE and BZERO - basic keywords\n # that will be present in images but not in binary fits tables\n #'SIMPLE': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_OK':True},\n #'BSCALE': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n #'BZERO': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BITPIX': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'NAXIS': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'NAXIS1': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'NAXIS2': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'BUNIT': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n #'CCD-AMP': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'SET-TEMP': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'CCD-TEMP': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'XBINNING': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'YBINNING': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n #'CCD-SET': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'ALTITUDE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'AZIMUTH': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'DOMEAZ': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'RADESYS': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'EPOCH': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'RA': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'RA-REF': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n #'RA-TEL': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'DEC': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'DEC-REF': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n #'DEC-TEL': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'HA': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'FLIPSTAT': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'EXPTIME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'ISTRACKI': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'ACQSTART': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'ACQEND': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GPSSTART': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GPSEND': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GPS-SHUT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'DATE-OBS': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'MJD-OBS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'LST': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'UTC': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'TIMESYS': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'ORIGIN': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'MPC-CODE': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'TELESCOP': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'CL-BASE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RH-MAST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RH-DOME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RH-AIRCO': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RH-PIER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PRESSURE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-PIER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-DOME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-ROOF': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-AIRCO': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-MAST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-STRUT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-CRING': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-SPIDER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-FWN': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-FWS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-M2HOLD': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-GUICAM': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-M1': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-CRYWIN': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-CRYGET': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-CRYCP': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PRES-CRY': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'WINDAVE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'WINDGUST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'WINDDIR': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'SITELAT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'SITELONG': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'ELEVATIO': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\n #'WEATIME': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'FILTER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n #'FILTERID': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'CCD-ID': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'CONTROLL': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'DETSPEED': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\n 'CCD-NW': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'CCD-NH': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'INSTRUME': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'FOCUSPOS': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\n 'IMAGETYP': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'OBJECT': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'AIRMASS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'ORIGFILE': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'OBSERVER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'ABOTVER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'PROGNAME': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'PROGID': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GUIDERST': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GUIDERFQ': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'TRAKTIME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'ADCX': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'ADCY': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n #\n # full header\n 'BB-V': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\n 'BB-START': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\n 'KW-V': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\n 'LOG': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'LOG-IMA': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'N-INFNAN': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'XTALK-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'XTALK-F': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'NONLIN-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'NONLIN-F': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'GAIN-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'GAIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'GAIN1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'GAIN16': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'OS-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'BIASMEAN': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'BIASM1': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'BIASM16': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RDNOISE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RDN1': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RDN16': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'BIAS1A0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BIAS1A1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'VFITOK1': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'BIAS16A0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BIAS16A1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'VFITOK16': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'MBIAS-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'MBIAS-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'MB-NDAYS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'SATURATE': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'NOBJ-SAT': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'MFLAT-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'MFLAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'MF-NDAYS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'MFRING-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'MFRING-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'FRRATIO': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'COSMIC-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'NCOSMICS': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'SAT-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'NSATS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'REDFILE': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'MASKFILE': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'S-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'S-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'S-NOBJ': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'S-FWHM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'S-FWSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'S-SEEING': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-SEESTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-ELONG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-ELOSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-BKG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-BKGSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-VIGNET': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'BKG-CORR': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'BKG-CHI2': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BKG-CF1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BKG-CF16': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BKG-FDEG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'BKG-FC0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'A-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'A-INDEX': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'A-PSCALE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-PSCALX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-PSCALY': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-ROT': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-ROTX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-ROTY': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-CAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'A-NAST': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'A-TNAST': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'A-NAMAX': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'A-DRA': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-DRASTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-DDEC': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-DDESTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PSF-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'PSF-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'PSF-RAD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-RADP': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-SIZE': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'PSF-FRAC': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-SAMP': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-CFGS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'PSF-NOBJ': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'PSF-FIX': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'PSF-PLDG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PSF-CHI2': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PSF-FWHM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-SEE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PSF-PMIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-PMAX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-PMED': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-PSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-BMIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-BMAX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-BMED': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-BSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMNM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMXM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMDM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-ESTM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMNM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMXM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMDM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FSTM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMNG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMXG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMDG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-ESTG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMNG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMXG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMDG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FSTG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PC-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'PC-CAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'PC-NCAL': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'PC-TNCAL': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-FNCAL': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-NCMAX': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-NCMIN': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-ZPFDG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-ZPF0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PC-TNSUB': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-NSUB': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-MZPD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PC-MZPS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PC-ZPDEF': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PC-ZP': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PC-ZPSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PC-EXTCO': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'AIRMASSC': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RA-CNTR': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'DEC-CNTR': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PC-AIRM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'NSIGMA': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'LIMEFLUX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'LIMMAG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'NOBJECTS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'RADECOFF': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'FORMAT-P': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'DUMCAT': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'QC-FLAG': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\n 'DATEFILE': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n #\n # transient header\n 'SWARP-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'SWARP-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'Z-REF': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'Z-DXYLOC': {'htype':'trans', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'Z-DX': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-DY': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-DXSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-DYSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-FNRLOC': {'htype':'trans', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'Z-FNR': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-FNRSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'Z-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'Z-SIZE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\n 'Z-BSIZE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\n 'Z-SCMED': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-SCSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-FPEMED': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\n 'Z-FPESTD': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\n 'T-NSIGMA': {'htype':'trans', 'dtype':int, 'DB':True, 'None_OK':True},\n 'T-LFLUX': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\n 'T-NTRANS': {'htype':'trans', 'dtype':int, 'DB':True, 'None_OK':True},\n 'T-FTRANS': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-LMAG': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-NFAKE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\n 'T-FAKESN': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\n 'MC-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'MC-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'MC-MODEL': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'TDUMCAT': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'TQC-FLAG': {'htype':'trans', 'dtype':str, 'DB':True, 'None_OK':False},\n }\n\n # read header of filename\n if isfile (filename):\n header = read_hdulist (filename, get_data=False, get_header=True)\n else:\n # return success=False if it does not exist\n log.warning ('file {} does not exist; not able to verify its header'\n .format(filename))\n return False\n\n\n # force [htypes] to be a list\n htypes_list = list(htypes)\n\n # loop keys in dict_head\n for key in dict_head.keys():\n\n # only check keywords with htype matching the input [htypes]\n if dict_head[key]['htype'] not in htypes_list:\n continue\n\n # check that key is present in header\n if key in header:\n\n # provide warning if dtype not as expected and header\n # keyword value is not 'None'\n if (dict_head[key]['dtype'] != type(header[key]) and\n header[key] != 'None'):\n log.warning ('dtype of keyword {}: {} does not match the '\n 'expected dtype: {} in header of {}'\n .format(key, type(header[key]),\n dict_head[key]['dtype'], filename))\n\n # if key goes to DataBase and value is 'None' or None\n # while 'None_OK' is False, raise an exception\n if (dict_head[key]['DB'] and not dict_head[key]['None_OK'] and\n (header[key] is None or header[key] == 'None')):\n msg = ('DataBase keyword {} not allowed to have \\'None\\' or '\n 'None value in header of {}'.format(key, filename))\n log.error (msg)\n raise ValueError (msg)\n\n\n else:\n msg = 'keyword {} not present in header of {}'.format(key, filename)\n # if keyword will be ingested into the database, raise an exception\n if dict_head[key]['DB']:\n log.error (msg)\n raise KeyError (msg)\n\n else:\n log.warning (msg)\n\n\n return","def check_csv_headers(csvfile, headers):\n\n with open(csvfile, 'rb') as f:\n csv_header = f.readline()\n\n # Check the lower ones\n if headers[1][0] not in csv_header.lower():\n return False\n\n return True","def check_headerRow(self, expected, found):\n\n # spreadsheets must have either a barcode field or a object ID field, but both are not required\n header1 = 'barcode'\n header2 = ('object identifier\\n(edit heading to specify type' +\n ' - e.g. barcode)')\n expected = self.remove_annoying(header1, header2, expected, found)\n\n missing = []\n\n for header in expected:\n if header not in found:\n missing.append(header)\n\n if missing:\n self.raise_excelerror(\"Missing required value- {0}.\"\n .format(missing))\n\n return True","def correct_header_fields():\n test_str = \"c0rrect_!!heAd3R fi3ld5__%%!! @\\n\"\n server = start_server()\n client = start_client()\n\n write_to(client, test_str)\n segments = read_segments_from(client)\n if not segments:\n return False\n teardown()\n\n # Start reference solution to get answers.\n ref_server = start_server(port=REF_PORT, reference=True)\n ref_client = start_client(server_port=REF_PORT, reference=True)\n\n # Get reference checksum.\n write_to(ref_client, test_str)\n ref_segment = read_segments_from(ref_client)[0]\n\n # Check the first sent segment. Should have all the same header fields as\n # the reference.\n segment = segments[0]\n\n # Check the flags first. Maybe decided to ACK all segments.\n if not segment.has_same_flags(ref_segment):\n if \"ACK\" in segment.flags:\n segment.flags.remove(\"ACK\")\n\n return (\n segment.seqno == ref_segment.seqno and\n (segment.ackno == 0 or segment.ackno == ref_segment.ackno) and\n segment.length == ref_segment.length and\n segment.has_same_flags(ref_segment) and\n segment.window == ref_segment.window and\n (segment.checksum == ref_segment.checksum or\n int(segment.checksum, 16) == segment.c_repr.cksum)\n )","def check_header_prerequisites(self, header):\n try: \n header_type = ContentType.objects.get_for_model(Header)\n header_prerequisites = Prerequisite.objects.filter(\n content_type__pk=header_type.id,\n object_id=header.id\n )\n return self.check_prerequisites(header_prerequisites)\n except Prerequisite.DoesNotExist:\n return True\n return True","def test_check_header_missing_added_demultiplex(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\r\n 'Description']\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix=0,\r\n desc_ix=4,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field='run_prefix')\r\n\r\n expected_errors = []\r\n expected_warnings = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = ['SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\r\n 'Description']\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix=0,\r\n desc_ix=3,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field='run_prefix')\r\n\r\n expected_errors = ['Missing added demultiplex field run_prefix\\t-1,-1']\r\n expected_warnings = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)","def test_is_fasta_header(self):\r\n\r\n is_fasta_header = False\r\n\r\n with open(full_file_name, \"r\") as in_file:\r\n for line in in_file:\r\n is_fasta_header = mfau.is_header_line(line)\r\n\r\n # only testing the first line\r\n break\r\n\r\n self.assertEqual(is_fasta_header, True)","def validate_date_header_given(request_headers: Dict[str, str]) -> None:\n if 'Date' in request_headers:\n return\n\n raise DateHeaderNotGiven","def can_add_licence_headers(self) -> bool:\n return False","def _validate(self):\n if not self._contents.has_key('type'):\n raise ValidationFailed(\"Metadata file %s contains no type field\" % (self._filename))\n \n if not self._contents.has_key('version'):\n raise ValidationFailed(\"Metadata file %s contains no version field\" %\n (self._filename))","def _generate_header_files(self):\n return True","def testCheckInternalHeaderWithBlinkMojo(self):\n\n mock_input_api = MockInputApi()\n potentially_bad_content = \"\"\"\n #include \"public/platform/modules/cache_storage.mojom-blink.h\"\n #include \"public/platform/modules/cache_storage.mojom-blink-forward.h\"\n #include \"public/platform/modules/cache_storage.mojom-blink-test-utils.h\"\n \"\"\"\n mock_input_api.files = [\n MockAffectedFile(\n mock_input_api.os_path.join('third_party', 'blink', 'renderer',\n 'core', 'a_header.h'),\n [potentially_bad_content], None)\n ]\n # Access to a protected member _CheckForWrongMojomIncludes\n # pylint: disable=W0212\n errors = PRESUBMIT._CheckForWrongMojomIncludes(mock_input_api,\n MockOutputApi())\n self.assertEqual([], errors)","def validate_auth_header(headers):\n if current_app.auth_db is None:\n raise NoAuthenticationDatabaseException\n\n if \"Authorization\" not in headers:\n raise NoAuthHeaderException\n\n auth_header = headers[\"Authorization\"].split(\" \")\n\n if len(auth_header) < 2 or auth_header[0] != \"Bearer\":\n raise InvalidAuthHeaderException\n\n token = auth_header[1]\n\n decoded = current_app.authenticator.decode_token(token)\n\n g.client_data = decoded\n\n if datetime.datetime.utcnow() > decoded.expiration:\n raise ExpiredTokenException\n\n database_token = current_app.auth_db.lookup_token(decoded.token_id)\n\n if database_token != decoded:\n raise InvalidTokenException\n\n return decoded","def test_header(self):\n\n self.assertIsInstance(self.image.header, Header)","def _check_duplicate_headers(self, docstring: PetscDocStringImpl) -> None:\n for heading, where in self.seen_headers.items():\n if len(where) <= 1:\n continue\n\n lasti = len(where) - 1\n src_list = []\n nbefore = 2\n nafter = 0\n prev_line_begin = 0\n for i, loc in enumerate(where):\n startline = loc.start.line\n if i:\n nbefore = startline - prev_line_begin - 1\n if i == lasti:\n nafter = 2\n src_list.append(loc.formatted(num_before_context=nbefore, num_after_context=nafter, trim=False))\n prev_line_begin = startline\n mess = \"Multiple '{}' subheadings. Much like Highlanders, there can only be one:\\n{}\".format(\n self.transform(self.name), '\\n'.join(src_list)\n )\n docstring.add_diagnostic(\n Diagnostic(Diagnostic.Kind.ERROR, self.diags.section_header_unique, mess, self.extent.start)\n )\n return","def _check_header_data(self, scan_data, min_rt=None, max_rt=None, ms_level=None, polarity=None):\n \n if min_rt is not None and scan_data['retention_time'] < min_rt:\n return False\n \n if max_rt is not None and scan_data['retention_time'] > max_rt:\n return False\n \n if ms_level is not None and scan_data['ms_level'] != ms_level:\n return False\n \n if polarity is not None and scan_data['polarity'] != polarity:\n return False\n \n return True","def verify(self):\n if len(self.headers) not in [1, 5]:\n raise IncorrectNumberOfExtensions(\"header\", \"5\", self)\n if len(self.pixeldata) not in [1, 2, 3]:\n raise IncorrectNumberOfExtensions(\"pixel\", \"1, 2, or 3\", self)\n if len(self.tabledata) not in [0,4]:\n raise IncorrectNumberOfExtensions(\"table\", \"4\", self)","def verify_raw_google_hash_header(google_hash: str) -> bool:\n\n return bool(re.match(r'(crc32c=[A-Za-z0-9+/=]+),(md5=[A-Za-z0-9+/=]+)', google_hash))","def has_supported_header_hormat(cls, csv_reader):\n return csv_reader.fieldnames == cls.INGFormatHeader","def is_valid(path):\n with open(path, 'rb') as handle:\n size = os.fstat(handle.fileno()).st_size\n try:\n mgz.header.parse_stream(handle)\n mgz.body.meta.parse_stream(handle)\n while handle.tell() < size:\n mgz.body.operation.parse_stream(handle)\n print('valid')\n return True\n except ConstructError:\n print('invalid')\n return False","def validate_column_names(self, cols):\n self.stdout.write('Verifying CSV header')\n csv_cols = set(cols)\n if self.required_csv_columns <= csv_cols:\n return True\n else:\n missing_cols = set(self.required_csv_columns).difference(csv_cols)\n raise ValidationError(\n \"These columns '{0}' are required, but missing in the CSV \"\n \"file.\".format(\n ', '.join(missing_cols)\n )\n )","def test_missing_header(barred_tac_list_importer, logger, db_conn):\n expect_failure(barred_tac_list_importer, exc_message='Metadata header, cannot find the column headers - tac, '\n '10000110')","def test_prepare_mac_header(self):\n self.assertEqual(prepare_mac_header(**self.mac_plain), self.auth_plain)\n self.assertEqual(prepare_mac_header(**self.mac_body), self.auth_body)\n self.assertEqual(prepare_mac_header(**self.mac_both), self.auth_both)","def test_headers(self):\n token = 'abc123'\n requests.get(self.url, auth=BearerAuth(token))\n self.assertEqual(httpretty.last_request().headers['Authorization'], 'Bearer {}'.format(token))","def check_header_dups(header,\r\n errors):\r\n\r\n for curr_elem in range(len(header)):\r\n if header.count(header[curr_elem]) != 1:\r\n errors.append('%s found in header %d times. ' %\r\n (header[curr_elem], header.count(header[curr_elem])) +\r\n 'Header fields must be unique.\\t%d,%d' % (0, curr_elem))\r\n\r\n return errors","def valid(self, nt_header):\n try:\n return (self.OriginalFirstThunk != 0 and\n self.OriginalFirstThunk < nt_header.OptionalHeader.SizeOfImage and\n self.FirstThunk != 0 and\n self.FirstThunk < nt_header.OptionalHeader.SizeOfImage and\n self.Name < nt_header.OptionalHeader.SizeOfImage)\n except obj.InvalidOffsetError:\n return False","def test_parse_header_complete(self):\n # try to process header with parameters etc in the XML\n data = parse_header(self.complete)\n self.assertEqual(data.get(\"database\"), \"Cats\")\n self.assertEqual(data.get(\"matrix\"), \"BLOSUM62\")","def generate_headers(self):\n raise NotImplementedError()","def _verify(self):\n pass","def test_invalid_header(self, tmpdir):\n path1 = tmpdir.join(\"invalid.csv\")\n path1.write(\"not,a,valid,header,row\")\n with pytest.raises(ValueError):\n parse_file(str(path1))\n\n path2 = tmpdir.join(\"valid.csv\")\n path2.write(\",\".join(HEADER_ROW))\n try:\n parse_file(str(path2))\n except ValueError:\n assert False, \"Unexpected ValueError\"","def _validate_signature(self):\n signing_string = '{}\\n{}\\n{}\\n{}\\n{}\\n{}\\n{}\\n{}\\n{}\\n{}\\n'.format(\n 'Message',\n self._message_encoded,\n 'MessageId',\n self._message_id,\n 'Timestamp',\n self._timestamp,\n 'TopicArn',\n self._topic_arn,\n 'Type',\n self._type)\n\n crt = crypto.load_certificate(crypto.FILETYPE_PEM, self._pem)\n signature = base64.b64decode(self._signature)\n\n try:\n crypto.verify(\n crt,\n signature,\n signing_string.encode('utf-8'),\n 'sha1')\n except:\n self.error = 'Invalid signature.'\n raise ValueError('Invalid signature.')\n\n return True","def validate(self, filepath):\n header_bytes = b''\n cypher_bytes = b''\n with open(filepath, 'rb') as f:\n header_bytes = f.read(16)\n cypher_bytes = f.read(16)\n data = self._decrypt(cypher_bytes, strip_padding=False)\n try:\n self._validate_header(header_bytes, data)\n except DecryptionError:\n return False\n return True","def testCheckPublicHeaderWithBlinkMojo(self):\n\n mock_input_api = MockInputApi()\n potentially_bad_content = \\\n '#include \"public/platform/modules/cache_storage.mojom-blink.h\"'\n mock_input_api.files = [\n MockAffectedFile(\n mock_input_api.os_path.join('third_party', 'blink', 'public',\n 'a_header.h'),\n [potentially_bad_content], None)\n ]\n # Access to a protected member _CheckForWrongMojomIncludes\n # pylint: disable=W0212\n errors = PRESUBMIT._CheckForWrongMojomIncludes(mock_input_api,\n MockOutputApi())\n self.assertEqual(\n 'Public blink headers using Blink variant mojoms found. ' +\n 'You must include .mojom-forward.h or .mojom-shared.h instead:',\n errors[0].message)","def handle_missing_duplicate_headers(self, expected_fields, bucket_name, error_filename):\n missing_headers = [cell for cell, count in expected_fields.items() if count == 0]\n duplicated_headers = [cell for cell, count in expected_fields.items() if count > 1]\n\n if missing_headers or duplicated_headers:\n self.write_missing_duplicated_headers(\n missing_headers, duplicated_headers, bucket_name,\n error_filename\n )\n raise_missing_duplicated_exception(missing_headers, duplicated_headers)","def valid(self, nt_header):\n try:\n return (self.AddressOfFunctions < nt_header.OptionalHeader.SizeOfImage and\n self.AddressOfNameOrdinals < nt_header.OptionalHeader.SizeOfImage and\n self.AddressOfNames < nt_header.OptionalHeader.SizeOfImage and\n self.NumberOfFunctions < 0x7FFF and\n self.NumberOfNames < 0x7FFF)\n except obj.InvalidOffsetError:\n return False","def verify_request_signature(req_info: StatusResponse) -> None:\n if not req_info.signature_check(req_info.xmlstr):\n raise ValueError(_(\"Message signature verification failure\"))"],"string":"[\n \"def test_build_headers(self):\\n\\n headers = self_signed.build_headers()\\n assert 'Content-Length' in headers\\n assert 'X-Amz-Date' in headers\\n assert 'Host' in headers\\n assert 'X-Amz-Security-Token' in headers\\n assert 'Content-Type' in headers\\n assert 'Authorization' in headers\",\n \"def test_headers(self):\\n self.assert_expected_token_value()\",\n \"def test_check_header(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = ['SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\\r\\n 'Description']\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix=0,\\r\\n desc_ix=3,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field=None)\\r\\n\\r\\n expected_errors = []\\r\\n expected_warnings = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def test_check_header_missing_fields(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = ['AAA', 'XXX', 'YYY',\\r\\n 'ZZZ']\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix=0,\\r\\n desc_ix=3,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field=None)\\r\\n\\r\\n expected_errors = [\\r\\n 'Found header field AAA, expected field SampleID\\\\t0,0',\\r\\n 'Found header field XXX, expected field BarcodeSequence\\\\t0,1',\\r\\n 'Found header field YYY, expected field LinkerPrimerSequence\\\\t0,2',\\r\\n 'Found header field ZZZ, last field should be Description\\\\t0,3']\\r\\n expected_warnings = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def validate_unique_header(self):\\n valid = False\\n unique_headers = set(self.headers)\\n if len(unique_headers) == len(self.headers):\\n valid = True\\n else:\\n seen_headers = set()\\n duplicate_headers = set()\\n for x in self.headers:\\n if x in seen_headers or seen_headers.add(x):\\n duplicate_headers.add(x)\\n msg = f\\\"Duplicated header names are not allowed: {duplicate_headers}\\\"\\n log_exception(Annotations.dev_logger, Annotations.user_logger, msg)\\n self.store_validation_issue(\\\"error\\\", msg, \\\"format:cap:unique\\\")\\n valid = False\\n if any(\\\"Unnamed\\\" in s for s in list(unique_headers)):\\n msg = \\\"Headers cannot contain empty values\\\"\\n log_exception(Annotations.dev_logger, Annotations.user_logger, msg)\\n self.store_validation_issue(\\\"error\\\", msg, \\\"format:cap:no-empty\\\")\\n valid = False\\n return valid\",\n \"def verifyHeader(self, headers):\\n for head in headers:\\n if(hex(head[0]) == VID and hex(head[1]) == PID):\\n return True\\n return False\",\n \"def validate_header(self, reply):\\n # check message is from my agg to me\\n check_equal(reply.header.sender, self.aggregator_uuid, self.logger)\\n check_equal(reply.header.recipient, self.common_name, self.logger)\\n\\n # check that the federation id matches\\n check_equal(reply.header.federation_id, self.federation_uuid, self.logger)\\n\\n # check that we agree on single_col_cert_common_name\\n check_equal(reply.header.single_col_cert_common_name, self.single_col_cert_common_name, self.logger)\",\n \"def test_check_header_required_fields(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\\r\\n 'Description']\\r\\n errors = []\\r\\n\\r\\n errors = check_header_required_fields(header,\\r\\n errors,\\r\\n sample_id_ix=0,\\r\\n desc_ix=4,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field='run_prefix')\\r\\n\\r\\n expected_errors = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n\\r\\n # Should find all as errors if not named correctly\\r\\n header = ['AAA', 'BBB', 'CCC', 'DDD',\\r\\n 'EEE']\\r\\n errors = []\\r\\n\\r\\n errors = check_header_required_fields(header,\\r\\n errors,\\r\\n sample_id_ix=0,\\r\\n desc_ix=4,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field='run_prefix')\\r\\n\\r\\n expected_errors = [\\r\\n 'Found header field AAA, expected field SampleID\\\\t0,0',\\r\\n 'Found header field BBB, expected field BarcodeSequence\\\\t0,1',\\r\\n 'Found header field CCC, expected field LinkerPrimerSequence\\\\t0,2',\\r\\n 'Found header field EEE, last field should be Description\\\\t0,4',\\r\\n 'Missing added demultiplex field run_prefix\\\\t-1,-1']\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\",\n \"def test_headers(self):\\n msg = self.shortDescription()\\n self.assertTrue(False, msg=msg)\\n pass\",\n \"def _validate_header(self):\\n if 'X-Amz-Sns-Topic-Arn' in self._headers:\\n if self._topic_arn != self._headers.get(\\n 'X-Amz-Sns-Topic-Arn'):\\n self.error = 'Invalid TopicArn.'\\n raise ValueError('Invalid TopicArn')\\n else:\\n self.error = 'Invalid TopicArn'\\n raise ValueError('Invalid TopicArn')\\n\\n return True\",\n \"def validate_against_header_count(self):\\n valid = False\\n len_headers = len(\\n [header for header in self.headers if \\\"Unnamed\\\" not in header]\\n )\\n len_annot_type = len(\\n [\\n annot_type\\n for annot_type in self.annot_types\\n if \\\"Unnamed\\\" not in annot_type\\n ]\\n )\\n if not len_headers == len_annot_type:\\n msg = (\\n f\\\"Header mismatch: {len_annot_type} TYPE declarations \\\"\\n f\\\"for {len_headers} column headers\\\"\\n )\\n self.store_validation_issue(\\\"error\\\", msg, \\\"format:cap:count\\\")\\n else:\\n valid = True\\n return valid\",\n \"def check_headers(self, headers):\\n h = headers.values()[0]\\n\\n if 'DT' in PAR:\\n if h.dt != PAR.DT:\\n h.dt = PAR.DT\\n\\n if 'NT' in PAR:\\n if h.nt != PAR.NT:\\n print 'Warning: h.nt != PAR.NT'\\n\\n if 'NREC' in PAR:\\n if h.nr != PAR.NREC:\\n print 'Warning: h.nr != PAR.NREC'\\n\\n return h\",\n \"def assert_header(self):\\r\\n\\r\\n if self.length > self.owner.settings[SETTINGS_MAX_FRAME_SIZE]:\\r\\n raise netius.ParserError(\\r\\n \\\"Headers are greater than SETTINGS_MAX_FRAME_SIZE\\\",\\r\\n stream = self.stream,\\r\\n error_code = FRAME_SIZE_ERROR\\r\\n )\\r\\n if self.last_type in (HEADERS, CONTINUATION) and not\\\\\\r\\n self.last_end_headers and not self.last_stream == self.stream:\\r\\n raise netius.ParserError(\\r\\n \\\"Cannot send frame from a different stream in middle of headers\\\",\\r\\n error_code = PROTOCOL_ERROR\\r\\n )\",\n \"def _validate_header(self, cleartext_header, decrypted_header):\\n import struct\\n\\n magic_number1 = struct.unpack(\\\"!I\\\", decrypted_header[:4])[0]\\n # file_version = struct.unpack(\\\"!I\\\", decrypted_header[4:8])[0]\\n # key_stretches = struct.unpack(\\\"!I\\\", decrypted_header[8:12])[0]\\n magic_number2 = struct.unpack(\\\"!I\\\", decrypted_header[12:])[0]\\n if (self.__magic_number != magic_number1 or\\n self.__magic_number != magic_number2):\\n raise DecryptionError()\\n if cleartext_header != decrypted_header:\\n raise FileCorruptionError()\",\n \"def test_get_cleaned_headers(self):\\r\\n # Some duplicates.\\r\\n exp = ['foo', 'foo_2', 'foo_3', 'foo_4', 'fooo', 'foo_5', 'foo_6',\\r\\n 'foo_7', 'foo_8', 'foo_9', 'f2oo456', 'foo_10']\\r\\n obs = _get_cleaned_headers(\\r\\n ['foo', 'Foo', 'FOO', 'F_oO', 'F:Oo_o', '123foo', '#Foo',\\r\\n '123foo', ' 123Foo', 'f O\\\\tO#', ' f2\\\\too456', '456 foo'])\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n # All unique.\\r\\n exp = ['foo', 'bar']\\r\\n obs = _get_cleaned_headers(['Fo#o', 'bar'])\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n # Header consisting of only special characters and header that is\\r\\n # blank.\\r\\n self.assertRaises(GoogleSpreadsheetError, _get_cleaned_headers,\\r\\n ['Foo', '___', 'BAR'])\\r\\n self.assertRaises(GoogleSpreadsheetError, _get_cleaned_headers,\\r\\n ['Foo', '', 'BAR'])\",\n \"def verify_checksum(self):\\n return self.generate_header_checksum(omit_checksum=False) == 0\",\n \"def check_headers():\\n report = {}\\n for header_name, msg in request.headers.items():\\n if header_name.upper().startswith('SAND-'):\\n checker = sand.header.header_name_to_checker.get(\\n header_name.lower())\\n if checker:\\n checker.check_syntax(msg.strip())\\n report[header_name] = checker.errors\\n else:\\n report[header_name] = [('Header name not supported by this ' +\\n 'version of conformance server')]\\n result = \\\"Report for SAND headers conformance:\\\\n\\\"\\n if report:\\n for name, errors in report.items():\\n if errors:\\n result += '%s: FAILED\\\\n' % name\\n for msg in errors:\\n result += ' %s\\\\n' % msg\\n else:\\n result += '%s: PASSED\\\\n' % name\\n else:\\n result += 'No SAND header found!\\\\n'\\n return result, 200, {'Content-Type': 'text/plain'}\",\n \"def check_header(self, name, value):\\r\\n if value in self.headers.get(name, ''):\\r\\n return True\\r\\n return False\",\n \"def check_header(self, name, value):\\r\\n if value in self.headers.get(name, ''):\\r\\n return True\\r\\n return False\",\n \"def check_header(self, entry):\\n if entry not in self.metadata:\\n raise SyntaxError(\\\"Header entry must be described in the metadata lines. Entry: %s is not in metadata.\\\" % entry)\",\n \"def test_specific_headers_sent_with_request(self):\\n req = self.httpbin.get_my_headers(dry_run=True)\\n self.assertIn('All-Request-Headers', req.prepared_request.headers)\\n request_data_headers = self.httpbin.client['get_my_headers']['headers']['All-Request-Headers']\\n self.assertEqual(req.prepared_request.headers['All-Request-Headers'], request_data_headers)\",\n \"def check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix,\\r\\n desc_ix,\\r\\n bc_ix,\\r\\n linker_primer_ix,\\r\\n added_demultiplex_field=None):\\r\\n\\r\\n # Check for duplicates, append to errors if found\\r\\n errors = check_header_dups(header, errors)\\r\\n\\r\\n # Check for valid characters\\r\\n warnings = check_header_chars(header, warnings)\\r\\n\\r\\n # Check for required header fields\\r\\n errors = check_header_required_fields(header, errors, sample_id_ix,\\r\\n desc_ix, bc_ix, linker_primer_ix, added_demultiplex_field)\\r\\n\\r\\n return errors, warnings\",\n \"def _validate_header(self, header_row):\\n\\n self.logger.info(\\\"Validating header row.\\\")\\n \\n # assume value.\\n is_valid = True\\n\\n # check if @header_row is perfect.\\n required_keys = tuple(self.required_headers.keys())\\n if sorted(header_row) == sorted(required_keys):\\n self.logger.info(\\\"Header is valid.\\\")\\n return is_valid\\n else:\\n self.logger.error(\\\"Header is invalid.\\\")\\n is_valid = False\\n\\n # report on any missing header fields.\\n missing_headers = [header for header in self.required_headers if header not in\\n header_row]\\n if len(missing_headers) != 0:\\n self.logger.warning(\\\"Missing required fields: {}\\\".format(missing_headers))\\n \\n # report on any duplicate fields.\\n duplicate_headers = [header for header in header_row if header_row.count(header) != 1]\\n if len(duplicate_headers) != 0:\\n self.logger.warning(\\\"Found duplicate fields: {}\\\".format(set(duplicate_headers)))\\n\\n # report on any extra fields.\\n extra_headers = [header for header in header_row if header not in \\n self.required_headers]\\n if len(extra_headers) != 0:\\n self.logger.warning(\\\"Found extra fields: {}\\\".format(extra_headers))\\n \\n return is_valid\",\n \"def has_headers(self):\\n for column in self.columns:\\n if column.header:\\n return True\\n return False\",\n \"def _validate_header(self, header: packets.PacketHeader):\\n if header.set_id != self._set_id:\\n raise ValueError(\\\"Packet set_id '{}', does not match RecoverySet id '{}'\\\"\\n .format(header.set_id.hex(), self._set_id.hex()))\",\n \"def test_check_header_bad_chars(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'AAA.^^2',\\r\\n 'Description']\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix=0,\\r\\n desc_ix=4,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field=None)\\r\\n\\r\\n expected_errors = []\\r\\n expected_warnings = [\\r\\n 'Found invalid character in AAA.^^2 header field.\\\\t0,3']\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def validate_header_keyword(self):\\n\\n valid = False\\n if self.headers[0].upper() == \\\"NAME\\\":\\n valid = True\\n if self.headers[0] != \\\"NAME\\\":\\n msg = f'File keyword \\\"NAME\\\" provided as {self.headers[0]}'\\n self.store_validation_issue(\\\"warn\\\", msg, \\\"format:cap:name\\\")\\n else:\\n msg = \\\"Malformed file header row, missing NAME keyword. (Case Sensitive)\\\"\\n self.store_validation_issue(\\\"error\\\", msg, \\\"format:cap:name\\\")\\n return valid\",\n \"def _ValidateCacheFileMetadataHeader(self, cache_file_metadata_header):\\n return (cache_file_metadata_header.key_size > 0 and\\n cache_file_metadata_header.key_size < self._MAXIMUM_URL_LENGTH and\\n cache_file_metadata_header.format_version in (1, 2, 3) and\\n cache_file_metadata_header.last_fetched_time > 0 and\\n cache_file_metadata_header.fetch_count > 0)\",\n \"def test_check_header_dups(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\\r\\n 'Description']\\r\\n errors = []\\r\\n\\r\\n errors = check_header_dups(header, errors)\\r\\n\\r\\n expected_errors = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n\\r\\n # Should give errors with dups\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix', 'run_prefix',\\r\\n 'Description']\\r\\n errors = []\\r\\n\\r\\n errors = check_header_dups(header, errors)\\r\\n\\r\\n expected_errors = [\\r\\n 'run_prefix found in header 2 times. Header fields must be unique.\\\\t0,3',\\r\\n 'run_prefix found in header 2 times. Header fields must be unique.\\\\t0,4']\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\",\n \"def validate_format(self):\\n return all(\\n [\\n self.validate_header_keyword(),\\n self.validate_type_keyword(),\\n self.validate_type_annotations(),\\n self.validate_unique_header(),\\n self.validate_against_header_count(),\\n ]\\n )\",\n \"def test_valid_header_no_message_added(self):\\n\\n node_mock = MagicMock()\\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = self.EXPECTED_HEADER\\n with self.assertNoMessages():\\n self.checker.process_module(node_mock)\",\n \"def assertTableHeaders(self, output_lines, field_names):\\n table = self.parser.table(output_lines)\\n headers = table['headers']\\n for field in field_names:\\n self.assertIn(field, headers)\",\n \"def check_headerEntries(self, expected, found):\\n\\n # spreadsheets must have either a barcode field or a object ID field, but both are not required\\n header1 = ('original master', 'object', 'barcode')\\n header2 = ('original master', 'object',\\n 'object identifier\\\\n(edit heading to specify type ' +\\n '- e.g. barcode)')\\n expected = self.remove_annoying(header1, header2, expected, found)\\n\\n bad_entries = []\\n\\n for header in expected:\\n if header not in found:\\n bad_entries.append(header)\\n\\n if bad_entries:\\n self.raise_excelerror(\\\"Incorrect header entry for {0}.\\\"\\n .format(bad_entries))\\n return True\",\n \"def assertHeaders(self, headers, json=False, binary=False):\\n\\n self.assertIsNotNone(headers['transaction-id'])\\n self.assertIsNotNone(headers['content-length'])\\n if json:\\n self.assertEqual(headers['content-type'],\\n 'application/json; charset=UTF-8')\\n if binary:\\n content_type = headers['content-type'].split(';')[0]\\n self.assertEqual(content_type,\\n 'application/octet-stream')\",\n \"def validate_headers(self, headers):\\n email = headers.get(\\\"email\\\")\\n sessionID = headers.get(\\\"sessionID\\\")\\n if email and sessionID:\\n user = user_manager.create_user(email)\\n if user is None:\\n app.logger.debug(\\\"User with email {} not found\\\".format(email))\\n return False\\n return self.is_admin(user) and user.session_id == sessionID\\n app.logger.debug(\\\"Missing headers email and/or sessionID\\\")\\n return False\",\n \"def check_header_required_fields(header,\\r\\n errors,\\r\\n sample_id_ix,\\r\\n desc_ix,\\r\\n bc_ix,\\r\\n linker_primer_ix,\\r\\n added_demultiplex_field=None):\\r\\n\\r\\n header_checks = {\\r\\n sample_id_ix: \\\"SampleID\\\",\\r\\n desc_ix: \\\"Description\\\",\\r\\n bc_ix: \\\"BarcodeSequence\\\",\\r\\n linker_primer_ix: \\\"LinkerPrimerSequence\\\"\\r\\n }\\r\\n\\r\\n for curr_check in header_checks:\\r\\n if (header[curr_check] != header_checks[curr_check] and\\r\\n header_checks[curr_check] == \\\"Description\\\"):\\r\\n errors.append('Found header field %s, last field should be %s' %\\r\\n (header[curr_check], header_checks[curr_check]) +\\r\\n '\\\\t%d,%d' % (0, curr_check))\\r\\n elif (header[curr_check] != header_checks[curr_check] and\\r\\n header_checks[curr_check] != \\\"Description\\\"):\\r\\n errors.append('Found header field %s, expected field %s' %\\r\\n (header[curr_check], header_checks[curr_check]) +\\r\\n '\\\\t%d,%d' % (0, curr_check))\\r\\n\\r\\n if added_demultiplex_field:\\r\\n if added_demultiplex_field not in header:\\r\\n errors.append('Missing added demultiplex field %s\\\\t%d,%d' %\\r\\n (added_demultiplex_field, -1, -1))\\r\\n\\r\\n return errors\",\n \"def test_authorization_header_not_present(self, _get_key_secret):\\n request = Request(self.environ)\\n request.body = self.get_request_body()\\n response = self.xmodule.grade_handler(request, '')\\n real_response = self.get_response_values(response)\\n expected_response = {\\n 'action': None,\\n 'code_major': 'failure',\\n 'description': 'OAuth verification error: Malformed authorization header',\\n 'messageIdentifier': self.defaults['messageIdentifier'],\\n }\\n\\n assert response.status_code == 200\\n self.assertDictEqual(expected_response, real_response)\",\n \"def test_lti20_rest_good_headers(self):\\r\\n self.xmodule.verify_oauth_body_sign = Mock(return_value=True)\\r\\n\\r\\n request = Mock(headers={u'Content-Type': u'application/vnd.ims.lis.v2.result+json'})\\r\\n self.xmodule.verify_lti_2_0_result_rest_headers(request)\\r\\n # We just want the above call to complete without exceptions, and to have called verify_oauth_body_sign\\r\\n self.assertTrue(self.xmodule.verify_oauth_body_sign.called)\",\n \"def test_headers(self):\\r\\n for path in self.get_files():\\r\\n po = polib.pofile(path)\\r\\n header = po.header\\r\\n self.assertEqual(\\r\\n header.find('edX translation file'),\\r\\n 0,\\r\\n msg='Missing header in %s:\\\\n\\\"%s\\\"' % (os.path.basename(path), header)\\r\\n )\",\n \"def process_headers(fin, fout, fixed_headers):\\n filtered_headers = set(item[0] for item in fixed_headers)\\n filtered_headers.add(\\\"SAMPLE\\\")\\n expected_values = {\\n name: value for name, asserted, value in fixed_headers if asserted\\n }\\n errors = False\\n for raw_line in fin:\\n if raw_line.startswith('##'):\\n # TODO: This will break if the metadata header is bad.\\n name, value = raw_line[2:].rstrip().split('=', 1)\\n if name in filtered_headers:\\n if name in expected_values:\\n if value != expected_values[name]:\\n errors = True\\n # TODO: propper logging\\n sys.stderr.write(\\n 'tcga-vcf-reheader: mismatch {}={}\\\\n'.format(\\n name, value\\n )\\n )\\n else: # Just some other header...\\n fout.write(raw_line)\\n else:\\n break\\n fout.write(raw_line) # raw_line should now be the data header line.\\n return errors\",\n \"def _validate_heading(self, heading_parts: List[str]):\\n # Validate heading row.\\n assert len(heading_parts) >= 4\\n assert \\\"oxygen\\\" in heading_parts\\n assert \\\"pulse\\\" in heading_parts\\n assert \\\"blood_pressure_systolic\\\" in heading_parts\\n assert \\\"blood_pressure_diastolic\\\" in heading_parts\",\n \"def test_invalid_header_message_added(self):\\n\\n node_mock = MagicMock()\\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = '# Invalid\\\\n# Header'\\n with self.assertAddsMessages(pylint.testutils.Message(\\n msg_id='invalid-file-header',\\n line=1,\\n args=self.EXPECTED_HEADER)):\\n self.checker.process_module(node_mock)\",\n \"def test_authorization_header_not_present(self, get_key_secret):\\r\\n request = Request(self.environ)\\r\\n request.body = self.get_request_body()\\r\\n response = self.xmodule.grade_handler(request, '')\\r\\n real_response = self.get_response_values(response)\\r\\n expected_response = {\\r\\n 'action': None,\\r\\n 'code_major': 'failure',\\r\\n 'description': 'OAuth verification error: Malformed authorization header',\\r\\n 'messageIdentifier': self.DEFAULTS['messageIdentifier'],\\r\\n }\\r\\n\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertDictEqual(expected_response, real_response)\",\n \"def test_check_header_chars(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_p-%efix',\\r\\n 'Description']\\r\\n warnings = []\\r\\n\\r\\n warnings = check_header_chars(header, warnings)\\r\\n\\r\\n expected_warnings = [\\r\\n 'Found invalid character in run_p-%efix header field.\\\\t0,3']\\r\\n\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def _check_headers(cursor, headers):\\n all_columns = set(chain.from_iterable(_columns(cursor, table) for table in DATA_TABLES))\\n for header in headers:\\n if header not in all_columns:\\n raise ValueError('column {} not recognized'.format(header))\",\n \"def check_no_header_response(response: HTTPResponse) -> bool:\\n return response.status_code == 422\",\n \"def check_header(filename: str, *, is_newly_created: bool = False) -> None:\\n lines = get_header_lines(filename)\\n check_header_present(filename, lines)\\n is_py3_file = all(\\\"from __future__\\\" not in line for line in lines)\\n if is_py3_file:\\n lines = lines[:EXPECTED_NUM_PY3_LINES]\\n copyright_line_index = 0\\n expected_header = EXPECTED_HEADER_PY3\\n else:\\n copyright_line_index = 1\\n expected_header = EXPECTED_HEADER_PY2\\n check_copyright_year(\\n filename, copyright_line=lines[copyright_line_index], is_newly_created=is_newly_created\\n )\\n check_matches_header(\\n filename, lines, expected_header=expected_header, copyright_line_index=copyright_line_index\\n )\",\n \"def test_authorization_header_empty(self, _get_key_secret):\\n request = Request(self.environ)\\n request.authorization = \\\"bad authorization header\\\"\\n request.body = self.get_request_body()\\n response = self.xmodule.grade_handler(request, '')\\n real_response = self.get_response_values(response)\\n expected_response = {\\n 'action': None,\\n 'code_major': 'failure',\\n 'description': 'OAuth verification error: Malformed authorization header',\\n 'messageIdentifier': self.defaults['messageIdentifier'],\\n }\\n assert response.status_code == 200\\n self.assertDictEqual(expected_response, real_response)\",\n \"def test_h2_header_ok(self):\\n self.set_frang_config(frang_config=\\\"http_strict_host_checking true;\\\")\\n client = self.get_client(\\\"deproxy-1\\\")\\n client.start()\\n client.parsing = False\\n\\n first_headers = [(\\\":authority\\\", \\\"localhost\\\"), (\\\":path\\\", \\\"/\\\")]\\n second_headers = [(\\\":path\\\", \\\"/\\\"), (\\\"host\\\", \\\"localhost\\\")]\\n third_headers = [(\\\":authority\\\", \\\"localhost\\\"), (\\\":path\\\", \\\"/\\\"), (\\\"host\\\", \\\"localhost\\\")]\\n fourth_headers = [\\n (\\\":authority\\\", \\\"tempesta-tech.com\\\"),\\n (\\\":path\\\", \\\"/\\\"),\\n (\\\"forwarded\\\", \\\"host=tempesta-tech.com\\\"),\\n (\\\"forwarded\\\", \\\"for=tempesta.com\\\"),\\n ]\\n\\n header_list = [\\n first_headers,\\n first_headers, # as byte\\n second_headers,\\n second_headers, # as byte\\n third_headers,\\n third_headers, # as byte\\n fourth_headers,\\n fourth_headers, # as byte\\n ]\\n for header in header_list:\\n head = [\\n (\\\":scheme\\\", \\\"https\\\"),\\n (\\\":method\\\", \\\"HEAD\\\"),\\n ]\\n head.extend(header)\\n client.make_request(head)\\n self.assertTrue(client.wait_for_response(1))\\n\\n self.check_response(client, status_code=\\\"200\\\", warning_msg=\\\"frang: \\\")\",\n \"def check_valid_csv_header(self, row):\\n obj = re.match(re.compile('^Year\\\\,Month\\\\,.'),\\n ','.join(row))\\n if not obj:\\n raise Exception(\\\"Invalid Headers must be `Year` `Month` Check Sample file\\\")\",\n \"def test_size_from_header(self):\\n\\n # pylint: disable=protected-access\\n\\n expected = False\\n actual = self.file_instance.exists()\\n\\n self.assertEqual(expected, actual)\\n\\n expected = [element for _, element in self.to_print[\\\"basic\\\"].items()]\\n\\n actual = Prints(\\n None, None, output_file=None, only_on_file=False\\n )._size_from_header(self.to_print[\\\"basic\\\"])\\n\\n self.assertEqual(expected, actual)\",\n \"def test_get_spreadsheet_headers(self):\\r\\n client = self.getClient()\\r\\n if client:\\r\\n exp = ['#SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\\r\\n 'Treatment', 'DOB', 'Description']\\r\\n obs = _get_spreadsheet_headers(client, self.spreadsheet_key,\\r\\n self.worksheet_id)\\r\\n self.assertEqual(obs, exp)\\r\\n else:\\r\\n raise GoogleSpreadsheetConnectionError(\\\"Cannot execute test \\\"\\r\\n \\\"without an active Internet connection.\\\")\",\n \"def Headers_items0():\\n assert_eq(\\n sorted(k for k, v in Headers(API_KEY, API_SECRET).items()),\\n ['x-dnsme-apiKey', 'x-dnsme-hmac', 'x-dnsme-requestDate'])\",\n \"def validate_metadata(self):\\n metadata = self.get_client_metadata()\\n\\n return True\",\n \"def test_create_headers(headers, request_content_type_header, response_content_type_header, expected_headers):\\n from HttpV2 import create_headers\\n\\n output = create_headers(headers, request_content_type_header, response_content_type_header)\\n assert output == expected_headers\",\n \"def test_authorization_header_empty(self, get_key_secret):\\r\\n request = Request(self.environ)\\r\\n request.authorization = \\\"bad authorization header\\\"\\r\\n request.body = self.get_request_body()\\r\\n response = self.xmodule.grade_handler(request, '')\\r\\n real_response = self.get_response_values(response)\\r\\n expected_response = {\\r\\n 'action': None,\\r\\n 'code_major': 'failure',\\r\\n 'description': 'OAuth verification error: Malformed authorization header',\\r\\n 'messageIdentifier': self.DEFAULTS['messageIdentifier'],\\r\\n }\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertDictEqual(expected_response, real_response)\",\n \"def test_valid_header_not_at_top_message_added(self):\\n\\n node_mock = MagicMock()\\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = 'print(\\\\'hello\\\\')\\\\n# Valid\\\\n# Header'\\n with self.assertAddsMessages(pylint.testutils.Message(\\n msg_id='invalid-file-header',\\n line=1,\\n args=self.EXPECTED_HEADER)):\\n self.checker.process_module(node_mock)\",\n \"def test_invalid_header_data(self):\\n elect_data = {\\n \\\"title\\\": \\\"Election A\\\",\\n \\\"admin_id\\\": 1,\\n \\\"default_election_type\\\": \\\"WinnerTakeAll\\\"\\n }\\n\\n race_data = {\\n \\\"title\\\": \\\"Race A\\\",\\n \\\"elect_id\\\": 1\\n }\\n\\n cand_data = {\\n \\\"name\\\": \\\"Candidate A\\\",\\n \\\"race_id\\\": 1\\n }\\n\\n vote_data = {\\n \\\"value\\\": \\\"1\\\",\\n \\\"user_id\\\": 1,\\n \\\"candidate_id\\\": 1\\n }\\n\\n user_data = {\\n \\\"name\\\": \\\"User A\\\",\\n \\\"password\\\": \\\"whatever\\\",\\n }\\n\\n datalist = [elect_data, race_data, cand_data, vote_data, user_data]\\n endpoint_list = [\\\"elections\\\", \\\"races\\\", \\\"candidates\\\", \\\"votes\\\", \\\"users\\\"]\\n endpoint_data_dict = dict(zip(endpoint_list, datalist))\\n\\n for endpoint, data in endpoint_data_dict.items():\\n response = self.client.post(\\\"/api/{}\\\".format(endpoint),\\n data=json.dumps(data),\\n content_type=\\\"application/json\\\",\\n headers=[(\\\"Accept\\\", \\\"application/json\\\")]\\n )\\n self.assertEqual(response.status_code, 422)\\n self.assertEqual(response.mimetype, \\\"application/json\\\")\",\n \"def has_bad_headers(self):\\n\\n headers = [self.sender, self.reply_to] + self.recipients\\n for header in headers:\\n if _has_newline(header):\\n return True\\n\\n if self.subject:\\n if _has_newline(self.subject):\\n for linenum, line in enumerate(self.subject.split('\\\\r\\\\n')):\\n if not line:\\n return True\\n if linenum > 0 and line[0] not in '\\\\t ':\\n return True\\n if _has_newline(line):\\n return True\\n if len(line.strip()) == 0:\\n return True\\n return False\",\n \"def test_raw_empty(self):\\n self.assertRaisesHeaderError([''])\",\n \"def test_user_headers_sent_with_request(self):\\n user_header = {'All-Request-Headers': 'Headers from user code'}\\n req = self.httpbin.get_my_headers(headers=user_header, dry_run=True)\\n self.assertIn('All-Request-Headers', req.prepared_request.headers)\\n self.assertEqual(req.prepared_request.headers['All-Request-Headers'], user_header['All-Request-Headers'])\",\n \"def test_content_length() -> None:\\n assert \\\"CONTENT-LENGTH: 3\\\" in Fauxmo.add_http_headers(\\\"foo\\\")\\n assert \\\"CONTENT-LENGTH: 4\\\" in Fauxmo.add_http_headers(\\\"föo\\\")\",\n \"def test_header_parser_vanilla(self):\\n lines = [\\\"Content-Type: application/json\\\", \\\"Accept: application/json\\\"]\\n h = {\\\"Content-Type\\\": \\\"application/json\\\", \\\"Accept\\\": \\\"application/json\\\"}\\n headers = parser._parse_headers(lines)\\n self.assertEqual(h, headers)\",\n \"def test_fasta_get_headers(self):\\r\\n\\r\\n header_records = mfau.get_record_headers(full_file_name)\\r\\n\\r\\n if debug:\\r\\n for header_record in header_records:\\r\\n print header_record.strip()\\r\\n\\r\\n self.assertGreaterEqual(len(header_records), 0)\",\n \"def verify_header (filename, htypes=None):\\n\\n # dictionary\\n dict_head = {\\n # raw header\\n # commenting out SIMPLE, BSCALE and BZERO - basic keywords\\n # that will be present in images but not in binary fits tables\\n #'SIMPLE': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_OK':True},\\n #'BSCALE': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n #'BZERO': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BITPIX': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'NAXIS': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'NAXIS1': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'NAXIS2': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'BUNIT': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n #'CCD-AMP': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'SET-TEMP': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'CCD-TEMP': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'XBINNING': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'YBINNING': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n #'CCD-SET': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'ALTITUDE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'AZIMUTH': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'DOMEAZ': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'RADESYS': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'EPOCH': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'RA': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'RA-REF': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n #'RA-TEL': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'DEC': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'DEC-REF': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n #'DEC-TEL': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'HA': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'FLIPSTAT': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'EXPTIME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'ISTRACKI': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'ACQSTART': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'ACQEND': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GPSSTART': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GPSEND': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GPS-SHUT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'DATE-OBS': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'MJD-OBS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'LST': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'UTC': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'TIMESYS': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'ORIGIN': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'MPC-CODE': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'TELESCOP': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'CL-BASE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RH-MAST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RH-DOME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RH-AIRCO': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RH-PIER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PRESSURE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-PIER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-DOME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-ROOF': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-AIRCO': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-MAST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-STRUT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-CRING': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-SPIDER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-FWN': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-FWS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-M2HOLD': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-GUICAM': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-M1': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-CRYWIN': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-CRYGET': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-CRYCP': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PRES-CRY': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'WINDAVE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'WINDGUST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'WINDDIR': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'SITELAT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'SITELONG': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'ELEVATIO': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\\n #'WEATIME': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'FILTER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n #'FILTERID': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'CCD-ID': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'CONTROLL': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'DETSPEED': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'CCD-NW': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'CCD-NH': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'INSTRUME': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'FOCUSPOS': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'IMAGETYP': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'OBJECT': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'AIRMASS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'ORIGFILE': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'OBSERVER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'ABOTVER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'PROGNAME': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'PROGID': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GUIDERST': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GUIDERFQ': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'TRAKTIME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'ADCX': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'ADCY': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n #\\n # full header\\n 'BB-V': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'BB-START': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'KW-V': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'LOG': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'LOG-IMA': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'N-INFNAN': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'XTALK-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'XTALK-F': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'NONLIN-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'NONLIN-F': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'GAIN-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'GAIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'GAIN1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'GAIN16': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'OS-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'BIASMEAN': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'BIASM1': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'BIASM16': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RDNOISE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RDN1': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RDN16': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'BIAS1A0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BIAS1A1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'VFITOK1': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'BIAS16A0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BIAS16A1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'VFITOK16': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'MBIAS-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'MBIAS-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'MB-NDAYS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'SATURATE': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'NOBJ-SAT': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'MFLAT-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'MFLAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'MF-NDAYS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'MFRING-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'MFRING-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'FRRATIO': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'COSMIC-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'NCOSMICS': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'SAT-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'NSATS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'REDFILE': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'MASKFILE': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'S-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'S-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'S-NOBJ': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'S-FWHM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'S-FWSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'S-SEEING': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-SEESTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-ELONG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-ELOSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-BKG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-BKGSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-VIGNET': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'BKG-CORR': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'BKG-CHI2': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BKG-CF1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BKG-CF16': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BKG-FDEG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'BKG-FC0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'A-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'A-INDEX': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'A-PSCALE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-PSCALX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-PSCALY': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-ROT': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-ROTX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-ROTY': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-CAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'A-NAST': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'A-TNAST': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'A-NAMAX': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'A-DRA': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-DRASTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-DDEC': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-DDESTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PSF-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'PSF-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'PSF-RAD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-RADP': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-SIZE': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'PSF-FRAC': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-SAMP': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-CFGS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'PSF-NOBJ': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'PSF-FIX': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'PSF-PLDG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PSF-CHI2': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PSF-FWHM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-SEE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PSF-PMIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-PMAX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-PMED': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-PSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-BMIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-BMAX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-BMED': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-BSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMNM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMXM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMDM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-ESTM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMNM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMXM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMDM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FSTM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMNG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMXG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMDG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-ESTG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMNG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMXG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMDG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FSTG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PC-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'PC-CAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'PC-NCAL': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'PC-TNCAL': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-FNCAL': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-NCMAX': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-NCMIN': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-ZPFDG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-ZPF0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PC-TNSUB': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-NSUB': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-MZPD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PC-MZPS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PC-ZPDEF': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PC-ZP': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PC-ZPSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PC-EXTCO': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'AIRMASSC': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RA-CNTR': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'DEC-CNTR': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PC-AIRM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'NSIGMA': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'LIMEFLUX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'LIMMAG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'NOBJECTS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'RADECOFF': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'FORMAT-P': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'DUMCAT': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'QC-FLAG': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'DATEFILE': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n #\\n # transient header\\n 'SWARP-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'SWARP-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'Z-REF': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'Z-DXYLOC': {'htype':'trans', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'Z-DX': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-DY': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-DXSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-DYSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-FNRLOC': {'htype':'trans', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'Z-FNR': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-FNRSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'Z-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'Z-SIZE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'Z-BSIZE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'Z-SCMED': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-SCSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-FPEMED': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'Z-FPESTD': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'T-NSIGMA': {'htype':'trans', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'T-LFLUX': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'T-NTRANS': {'htype':'trans', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'T-FTRANS': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-LMAG': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-NFAKE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'T-FAKESN': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'MC-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'MC-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'MC-MODEL': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'TDUMCAT': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'TQC-FLAG': {'htype':'trans', 'dtype':str, 'DB':True, 'None_OK':False},\\n }\\n\\n # read header of filename\\n if isfile (filename):\\n header = read_hdulist (filename, get_data=False, get_header=True)\\n else:\\n # return success=False if it does not exist\\n log.warning ('file {} does not exist; not able to verify its header'\\n .format(filename))\\n return False\\n\\n\\n # force [htypes] to be a list\\n htypes_list = list(htypes)\\n\\n # loop keys in dict_head\\n for key in dict_head.keys():\\n\\n # only check keywords with htype matching the input [htypes]\\n if dict_head[key]['htype'] not in htypes_list:\\n continue\\n\\n # check that key is present in header\\n if key in header:\\n\\n # provide warning if dtype not as expected and header\\n # keyword value is not 'None'\\n if (dict_head[key]['dtype'] != type(header[key]) and\\n header[key] != 'None'):\\n log.warning ('dtype of keyword {}: {} does not match the '\\n 'expected dtype: {} in header of {}'\\n .format(key, type(header[key]),\\n dict_head[key]['dtype'], filename))\\n\\n # if key goes to DataBase and value is 'None' or None\\n # while 'None_OK' is False, raise an exception\\n if (dict_head[key]['DB'] and not dict_head[key]['None_OK'] and\\n (header[key] is None or header[key] == 'None')):\\n msg = ('DataBase keyword {} not allowed to have \\\\'None\\\\' or '\\n 'None value in header of {}'.format(key, filename))\\n log.error (msg)\\n raise ValueError (msg)\\n\\n\\n else:\\n msg = 'keyword {} not present in header of {}'.format(key, filename)\\n # if keyword will be ingested into the database, raise an exception\\n if dict_head[key]['DB']:\\n log.error (msg)\\n raise KeyError (msg)\\n\\n else:\\n log.warning (msg)\\n\\n\\n return\",\n \"def check_csv_headers(csvfile, headers):\\n\\n with open(csvfile, 'rb') as f:\\n csv_header = f.readline()\\n\\n # Check the lower ones\\n if headers[1][0] not in csv_header.lower():\\n return False\\n\\n return True\",\n \"def check_headerRow(self, expected, found):\\n\\n # spreadsheets must have either a barcode field or a object ID field, but both are not required\\n header1 = 'barcode'\\n header2 = ('object identifier\\\\n(edit heading to specify type' +\\n ' - e.g. barcode)')\\n expected = self.remove_annoying(header1, header2, expected, found)\\n\\n missing = []\\n\\n for header in expected:\\n if header not in found:\\n missing.append(header)\\n\\n if missing:\\n self.raise_excelerror(\\\"Missing required value- {0}.\\\"\\n .format(missing))\\n\\n return True\",\n \"def correct_header_fields():\\n test_str = \\\"c0rrect_!!heAd3R fi3ld5__%%!! @\\\\n\\\"\\n server = start_server()\\n client = start_client()\\n\\n write_to(client, test_str)\\n segments = read_segments_from(client)\\n if not segments:\\n return False\\n teardown()\\n\\n # Start reference solution to get answers.\\n ref_server = start_server(port=REF_PORT, reference=True)\\n ref_client = start_client(server_port=REF_PORT, reference=True)\\n\\n # Get reference checksum.\\n write_to(ref_client, test_str)\\n ref_segment = read_segments_from(ref_client)[0]\\n\\n # Check the first sent segment. Should have all the same header fields as\\n # the reference.\\n segment = segments[0]\\n\\n # Check the flags first. Maybe decided to ACK all segments.\\n if not segment.has_same_flags(ref_segment):\\n if \\\"ACK\\\" in segment.flags:\\n segment.flags.remove(\\\"ACK\\\")\\n\\n return (\\n segment.seqno == ref_segment.seqno and\\n (segment.ackno == 0 or segment.ackno == ref_segment.ackno) and\\n segment.length == ref_segment.length and\\n segment.has_same_flags(ref_segment) and\\n segment.window == ref_segment.window and\\n (segment.checksum == ref_segment.checksum or\\n int(segment.checksum, 16) == segment.c_repr.cksum)\\n )\",\n \"def check_header_prerequisites(self, header):\\n try: \\n header_type = ContentType.objects.get_for_model(Header)\\n header_prerequisites = Prerequisite.objects.filter(\\n content_type__pk=header_type.id,\\n object_id=header.id\\n )\\n return self.check_prerequisites(header_prerequisites)\\n except Prerequisite.DoesNotExist:\\n return True\\n return True\",\n \"def test_check_header_missing_added_demultiplex(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\\r\\n 'Description']\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix=0,\\r\\n desc_ix=4,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field='run_prefix')\\r\\n\\r\\n expected_errors = []\\r\\n expected_warnings = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = ['SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\\r\\n 'Description']\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix=0,\\r\\n desc_ix=3,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field='run_prefix')\\r\\n\\r\\n expected_errors = ['Missing added demultiplex field run_prefix\\\\t-1,-1']\\r\\n expected_warnings = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def test_is_fasta_header(self):\\r\\n\\r\\n is_fasta_header = False\\r\\n\\r\\n with open(full_file_name, \\\"r\\\") as in_file:\\r\\n for line in in_file:\\r\\n is_fasta_header = mfau.is_header_line(line)\\r\\n\\r\\n # only testing the first line\\r\\n break\\r\\n\\r\\n self.assertEqual(is_fasta_header, True)\",\n \"def validate_date_header_given(request_headers: Dict[str, str]) -> None:\\n if 'Date' in request_headers:\\n return\\n\\n raise DateHeaderNotGiven\",\n \"def can_add_licence_headers(self) -> bool:\\n return False\",\n \"def _validate(self):\\n if not self._contents.has_key('type'):\\n raise ValidationFailed(\\\"Metadata file %s contains no type field\\\" % (self._filename))\\n \\n if not self._contents.has_key('version'):\\n raise ValidationFailed(\\\"Metadata file %s contains no version field\\\" %\\n (self._filename))\",\n \"def _generate_header_files(self):\\n return True\",\n \"def testCheckInternalHeaderWithBlinkMojo(self):\\n\\n mock_input_api = MockInputApi()\\n potentially_bad_content = \\\"\\\"\\\"\\n #include \\\"public/platform/modules/cache_storage.mojom-blink.h\\\"\\n #include \\\"public/platform/modules/cache_storage.mojom-blink-forward.h\\\"\\n #include \\\"public/platform/modules/cache_storage.mojom-blink-test-utils.h\\\"\\n \\\"\\\"\\\"\\n mock_input_api.files = [\\n MockAffectedFile(\\n mock_input_api.os_path.join('third_party', 'blink', 'renderer',\\n 'core', 'a_header.h'),\\n [potentially_bad_content], None)\\n ]\\n # Access to a protected member _CheckForWrongMojomIncludes\\n # pylint: disable=W0212\\n errors = PRESUBMIT._CheckForWrongMojomIncludes(mock_input_api,\\n MockOutputApi())\\n self.assertEqual([], errors)\",\n \"def validate_auth_header(headers):\\n if current_app.auth_db is None:\\n raise NoAuthenticationDatabaseException\\n\\n if \\\"Authorization\\\" not in headers:\\n raise NoAuthHeaderException\\n\\n auth_header = headers[\\\"Authorization\\\"].split(\\\" \\\")\\n\\n if len(auth_header) < 2 or auth_header[0] != \\\"Bearer\\\":\\n raise InvalidAuthHeaderException\\n\\n token = auth_header[1]\\n\\n decoded = current_app.authenticator.decode_token(token)\\n\\n g.client_data = decoded\\n\\n if datetime.datetime.utcnow() > decoded.expiration:\\n raise ExpiredTokenException\\n\\n database_token = current_app.auth_db.lookup_token(decoded.token_id)\\n\\n if database_token != decoded:\\n raise InvalidTokenException\\n\\n return decoded\",\n \"def test_header(self):\\n\\n self.assertIsInstance(self.image.header, Header)\",\n \"def _check_duplicate_headers(self, docstring: PetscDocStringImpl) -> None:\\n for heading, where in self.seen_headers.items():\\n if len(where) <= 1:\\n continue\\n\\n lasti = len(where) - 1\\n src_list = []\\n nbefore = 2\\n nafter = 0\\n prev_line_begin = 0\\n for i, loc in enumerate(where):\\n startline = loc.start.line\\n if i:\\n nbefore = startline - prev_line_begin - 1\\n if i == lasti:\\n nafter = 2\\n src_list.append(loc.formatted(num_before_context=nbefore, num_after_context=nafter, trim=False))\\n prev_line_begin = startline\\n mess = \\\"Multiple '{}' subheadings. Much like Highlanders, there can only be one:\\\\n{}\\\".format(\\n self.transform(self.name), '\\\\n'.join(src_list)\\n )\\n docstring.add_diagnostic(\\n Diagnostic(Diagnostic.Kind.ERROR, self.diags.section_header_unique, mess, self.extent.start)\\n )\\n return\",\n \"def _check_header_data(self, scan_data, min_rt=None, max_rt=None, ms_level=None, polarity=None):\\n \\n if min_rt is not None and scan_data['retention_time'] < min_rt:\\n return False\\n \\n if max_rt is not None and scan_data['retention_time'] > max_rt:\\n return False\\n \\n if ms_level is not None and scan_data['ms_level'] != ms_level:\\n return False\\n \\n if polarity is not None and scan_data['polarity'] != polarity:\\n return False\\n \\n return True\",\n \"def verify(self):\\n if len(self.headers) not in [1, 5]:\\n raise IncorrectNumberOfExtensions(\\\"header\\\", \\\"5\\\", self)\\n if len(self.pixeldata) not in [1, 2, 3]:\\n raise IncorrectNumberOfExtensions(\\\"pixel\\\", \\\"1, 2, or 3\\\", self)\\n if len(self.tabledata) not in [0,4]:\\n raise IncorrectNumberOfExtensions(\\\"table\\\", \\\"4\\\", self)\",\n \"def verify_raw_google_hash_header(google_hash: str) -> bool:\\n\\n return bool(re.match(r'(crc32c=[A-Za-z0-9+/=]+),(md5=[A-Za-z0-9+/=]+)', google_hash))\",\n \"def has_supported_header_hormat(cls, csv_reader):\\n return csv_reader.fieldnames == cls.INGFormatHeader\",\n \"def is_valid(path):\\n with open(path, 'rb') as handle:\\n size = os.fstat(handle.fileno()).st_size\\n try:\\n mgz.header.parse_stream(handle)\\n mgz.body.meta.parse_stream(handle)\\n while handle.tell() < size:\\n mgz.body.operation.parse_stream(handle)\\n print('valid')\\n return True\\n except ConstructError:\\n print('invalid')\\n return False\",\n \"def validate_column_names(self, cols):\\n self.stdout.write('Verifying CSV header')\\n csv_cols = set(cols)\\n if self.required_csv_columns <= csv_cols:\\n return True\\n else:\\n missing_cols = set(self.required_csv_columns).difference(csv_cols)\\n raise ValidationError(\\n \\\"These columns '{0}' are required, but missing in the CSV \\\"\\n \\\"file.\\\".format(\\n ', '.join(missing_cols)\\n )\\n )\",\n \"def test_missing_header(barred_tac_list_importer, logger, db_conn):\\n expect_failure(barred_tac_list_importer, exc_message='Metadata header, cannot find the column headers - tac, '\\n '10000110')\",\n \"def test_prepare_mac_header(self):\\n self.assertEqual(prepare_mac_header(**self.mac_plain), self.auth_plain)\\n self.assertEqual(prepare_mac_header(**self.mac_body), self.auth_body)\\n self.assertEqual(prepare_mac_header(**self.mac_both), self.auth_both)\",\n \"def test_headers(self):\\n token = 'abc123'\\n requests.get(self.url, auth=BearerAuth(token))\\n self.assertEqual(httpretty.last_request().headers['Authorization'], 'Bearer {}'.format(token))\",\n \"def check_header_dups(header,\\r\\n errors):\\r\\n\\r\\n for curr_elem in range(len(header)):\\r\\n if header.count(header[curr_elem]) != 1:\\r\\n errors.append('%s found in header %d times. ' %\\r\\n (header[curr_elem], header.count(header[curr_elem])) +\\r\\n 'Header fields must be unique.\\\\t%d,%d' % (0, curr_elem))\\r\\n\\r\\n return errors\",\n \"def valid(self, nt_header):\\n try:\\n return (self.OriginalFirstThunk != 0 and\\n self.OriginalFirstThunk < nt_header.OptionalHeader.SizeOfImage and\\n self.FirstThunk != 0 and\\n self.FirstThunk < nt_header.OptionalHeader.SizeOfImage and\\n self.Name < nt_header.OptionalHeader.SizeOfImage)\\n except obj.InvalidOffsetError:\\n return False\",\n \"def test_parse_header_complete(self):\\n # try to process header with parameters etc in the XML\\n data = parse_header(self.complete)\\n self.assertEqual(data.get(\\\"database\\\"), \\\"Cats\\\")\\n self.assertEqual(data.get(\\\"matrix\\\"), \\\"BLOSUM62\\\")\",\n \"def generate_headers(self):\\n raise NotImplementedError()\",\n \"def _verify(self):\\n pass\",\n \"def test_invalid_header(self, tmpdir):\\n path1 = tmpdir.join(\\\"invalid.csv\\\")\\n path1.write(\\\"not,a,valid,header,row\\\")\\n with pytest.raises(ValueError):\\n parse_file(str(path1))\\n\\n path2 = tmpdir.join(\\\"valid.csv\\\")\\n path2.write(\\\",\\\".join(HEADER_ROW))\\n try:\\n parse_file(str(path2))\\n except ValueError:\\n assert False, \\\"Unexpected ValueError\\\"\",\n \"def _validate_signature(self):\\n signing_string = '{}\\\\n{}\\\\n{}\\\\n{}\\\\n{}\\\\n{}\\\\n{}\\\\n{}\\\\n{}\\\\n{}\\\\n'.format(\\n 'Message',\\n self._message_encoded,\\n 'MessageId',\\n self._message_id,\\n 'Timestamp',\\n self._timestamp,\\n 'TopicArn',\\n self._topic_arn,\\n 'Type',\\n self._type)\\n\\n crt = crypto.load_certificate(crypto.FILETYPE_PEM, self._pem)\\n signature = base64.b64decode(self._signature)\\n\\n try:\\n crypto.verify(\\n crt,\\n signature,\\n signing_string.encode('utf-8'),\\n 'sha1')\\n except:\\n self.error = 'Invalid signature.'\\n raise ValueError('Invalid signature.')\\n\\n return True\",\n \"def validate(self, filepath):\\n header_bytes = b''\\n cypher_bytes = b''\\n with open(filepath, 'rb') as f:\\n header_bytes = f.read(16)\\n cypher_bytes = f.read(16)\\n data = self._decrypt(cypher_bytes, strip_padding=False)\\n try:\\n self._validate_header(header_bytes, data)\\n except DecryptionError:\\n return False\\n return True\",\n \"def testCheckPublicHeaderWithBlinkMojo(self):\\n\\n mock_input_api = MockInputApi()\\n potentially_bad_content = \\\\\\n '#include \\\"public/platform/modules/cache_storage.mojom-blink.h\\\"'\\n mock_input_api.files = [\\n MockAffectedFile(\\n mock_input_api.os_path.join('third_party', 'blink', 'public',\\n 'a_header.h'),\\n [potentially_bad_content], None)\\n ]\\n # Access to a protected member _CheckForWrongMojomIncludes\\n # pylint: disable=W0212\\n errors = PRESUBMIT._CheckForWrongMojomIncludes(mock_input_api,\\n MockOutputApi())\\n self.assertEqual(\\n 'Public blink headers using Blink variant mojoms found. ' +\\n 'You must include .mojom-forward.h or .mojom-shared.h instead:',\\n errors[0].message)\",\n \"def handle_missing_duplicate_headers(self, expected_fields, bucket_name, error_filename):\\n missing_headers = [cell for cell, count in expected_fields.items() if count == 0]\\n duplicated_headers = [cell for cell, count in expected_fields.items() if count > 1]\\n\\n if missing_headers or duplicated_headers:\\n self.write_missing_duplicated_headers(\\n missing_headers, duplicated_headers, bucket_name,\\n error_filename\\n )\\n raise_missing_duplicated_exception(missing_headers, duplicated_headers)\",\n \"def valid(self, nt_header):\\n try:\\n return (self.AddressOfFunctions < nt_header.OptionalHeader.SizeOfImage and\\n self.AddressOfNameOrdinals < nt_header.OptionalHeader.SizeOfImage and\\n self.AddressOfNames < nt_header.OptionalHeader.SizeOfImage and\\n self.NumberOfFunctions < 0x7FFF and\\n self.NumberOfNames < 0x7FFF)\\n except obj.InvalidOffsetError:\\n return False\",\n \"def verify_request_signature(req_info: StatusResponse) -> None:\\n if not req_info.signature_check(req_info.xmlstr):\\n raise ValueError(_(\\\"Message signature verification failure\\\"))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73248684","0.71754396","0.71661705","0.69765127","0.6962748","0.6939488","0.6889487","0.68174773","0.68034554","0.6791674","0.6682548","0.6604471","0.6590226","0.6554132","0.6513857","0.6459408","0.6422941","0.640519","0.640519","0.63898265","0.6378792","0.6358242","0.6349941","0.62824833","0.62776136","0.62756574","0.62706965","0.62475103","0.62471616","0.6239519","0.6210872","0.6210504","0.6198862","0.6193927","0.61793643","0.6178088","0.6135654","0.61356467","0.6135143","0.6124733","0.60791254","0.607806","0.60560876","0.6050779","0.60445756","0.6033167","0.6017505","0.6002537","0.5981468","0.59807426","0.59804255","0.5946994","0.5946645","0.5938103","0.5928016","0.5923215","0.59178734","0.59177357","0.591084","0.590623","0.5894743","0.5885459","0.58662367","0.58626884","0.5862373","0.5822433","0.5809445","0.5803707","0.58007914","0.5794821","0.5789562","0.57725984","0.57701117","0.5750246","0.5733347","0.57327217","0.57130206","0.5700009","0.5688913","0.56807363","0.56799585","0.5666621","0.5657102","0.5653942","0.5653126","0.56496876","0.5635497","0.5628357","0.562644","0.56180006","0.56176066","0.56173015","0.56148994","0.55989903","0.55959624","0.55943227","0.55906713","0.5583913","0.55821806","0.55763626"],"string":"[\n \"0.73248684\",\n \"0.71754396\",\n \"0.71661705\",\n \"0.69765127\",\n \"0.6962748\",\n \"0.6939488\",\n \"0.6889487\",\n \"0.68174773\",\n \"0.68034554\",\n \"0.6791674\",\n \"0.6682548\",\n \"0.6604471\",\n \"0.6590226\",\n \"0.6554132\",\n \"0.6513857\",\n \"0.6459408\",\n \"0.6422941\",\n \"0.640519\",\n \"0.640519\",\n \"0.63898265\",\n \"0.6378792\",\n \"0.6358242\",\n \"0.6349941\",\n \"0.62824833\",\n \"0.62776136\",\n \"0.62756574\",\n \"0.62706965\",\n \"0.62475103\",\n \"0.62471616\",\n \"0.6239519\",\n \"0.6210872\",\n \"0.6210504\",\n \"0.6198862\",\n \"0.6193927\",\n \"0.61793643\",\n \"0.6178088\",\n \"0.6135654\",\n \"0.61356467\",\n \"0.6135143\",\n \"0.6124733\",\n \"0.60791254\",\n \"0.607806\",\n \"0.60560876\",\n \"0.6050779\",\n \"0.60445756\",\n \"0.6033167\",\n \"0.6017505\",\n \"0.6002537\",\n \"0.5981468\",\n \"0.59807426\",\n \"0.59804255\",\n \"0.5946994\",\n \"0.5946645\",\n \"0.5938103\",\n \"0.5928016\",\n \"0.5923215\",\n \"0.59178734\",\n \"0.59177357\",\n \"0.591084\",\n \"0.590623\",\n \"0.5894743\",\n \"0.5885459\",\n \"0.58662367\",\n \"0.58626884\",\n \"0.5862373\",\n \"0.5822433\",\n \"0.5809445\",\n \"0.5803707\",\n \"0.58007914\",\n \"0.5794821\",\n \"0.5789562\",\n \"0.57725984\",\n \"0.57701117\",\n \"0.5750246\",\n \"0.5733347\",\n \"0.57327217\",\n \"0.57130206\",\n \"0.5700009\",\n \"0.5688913\",\n \"0.56807363\",\n \"0.56799585\",\n \"0.5666621\",\n \"0.5657102\",\n \"0.5653942\",\n \"0.5653126\",\n \"0.56496876\",\n \"0.5635497\",\n \"0.5628357\",\n \"0.562644\",\n \"0.56180006\",\n \"0.56176066\",\n \"0.56173015\",\n \"0.56148994\",\n \"0.55989903\",\n \"0.55959624\",\n \"0.55943227\",\n \"0.55906713\",\n \"0.5583913\",\n \"0.55821806\",\n \"0.55763626\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6863574"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":77684,"cells":{"query":{"kind":"string","value":"Surrogates are not allowed in a query string. `requests` and `werkzeug` will fail to send it to the application."},"document":{"kind":"string","value":"def is_valid_query(query: Dict[str, Any]) -> bool:\n for name, value in query.items():\n if is_illegal_surrogate(name) or is_illegal_surrogate(value):\n return False\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def query_params_sanitize(query_params):\n def allow_func(n, v):\n # This gets rid of any params beginning with \"oauth_\"\n if not n.startswith(\"oauth_\"):\n return True\n else:\n logging.warning(\"Protocol parameter ignored from URL query parameters: `%r`\", n)\n return False\n return query_filter(query_params, allow_func=allow_func)","def test_non_ascii_query_string_does_not_crash(self):\n request = self.rf.get(\"/slash\")\n request.META[\"QUERY_STRING\"] = \"drink=café\"\n r = CommonMiddleware(get_response_empty).process_request(request)\n self.assertIsNone(r)\n response = HttpResponseNotFound()\n r = CommonMiddleware(get_response_empty).process_response(request, response)\n self.assertEqual(r.status_code, 301)","def test_additional_query_args():\n assert (normalize_url(\"http://example.com?c=d\", [(\"a\", \"b\")]) ==\n \"http://example.com/?a=b&c=d\")\n assert (normalize_url(\"http://example.com\", [(\"a\", \"b\")]) ==\n \"http://example.com/?a=b\")\n assert (normalize_url(\"http://example.com\", [(\"résumé\", \"résumé\")]) ==\n \"http://example.com/?r%C3%A9sum%C3%A9=r%C3%A9sum%C3%A9\")","def test_dont_percent_encode_safe_chars_query():\n assert (normalize_url(\"http://example.com/a/?face=(-.-)\") ==\n \"http://example.com/a?face=(-.-)\")","def encoded_query_str(request):\n return updated_query_str(request)","def maybe_urlencoded(fixed_in: str) -> str:\n try:\n d = urllib.parse.parse_qs(fixed_in)\n # There may be additional known-good keys in the future.\n return d[\"fixed\"][0]\n except (ValueError, KeyError):\n return fixed_in","def create_query_sting(param_dict):\n params = \"&\".join([f\"{key}={value}\" for key, value in param_dict.items()])\n return params.replace(\"#\", \"%23\")","def updated_querystring(request, params):\n original_params = request.GET.copy()\n for key in params:\n if key in original_params:\n original_params.pop(key)\n original_params.update(params)\n return original_params.urlencode()","def updated_querystring(request, params):\n original_params = request.GET.copy()\n for key in params:\n if key in original_params:\n original_params.pop(key)\n original_params.update(params)\n return original_params.urlencode()","def get_query_string(self):\r\n pass","def test_percent_encode_querystring():\n assert (normalize_url(\"http://example.com/?a=hello{}\") ==\n \"http://example.com/?a=hello%7B%7D\")","def _get_query_part(params: dict) -> str:\n params_cleaned = {k: v for k, v in params.items() if v is not None}\n return ('?' + urlencode(params_cleaned, quote_via=quote, safe=\"/,\")) if params_cleaned else \"\"","def _prepare_params(self, params):\n if isinstance(params, six.string_types):\n return params\n return urllib.urlencode(params)","def url_replace(context, **kwargs):\n query = context['request'].GET.dict()\n query.update(kwargs)\n return urlencode(query)","def url_replace(context, **kwargs):\n query = context['request'].GET.dict()\n query.update(kwargs)\n return urlencode(query)","def request_protocol_params_sanitize(protocol_params):\n def allow_func(n, v):\n if n.startswith(\"oauth_\"):\n # This gets rid of \"realm\" or any non-OAuth param.\n if len(v) > 1:\n # Multiple values for a protocol parameter are not allowed.\n # We don't silently discard values because failing fast\n # is better than simply logging and waiting for the user\n # to figure it out all by herself.\n #\n # See Making Requests (http://tools.ietf.org/html/rfc5849#section-3.1)\n # Point 2. Each parameter MUST NOT appear more than once per\n # request, so we disallow multiple values for a protocol\n # parameter.\n raise InvalidOAuthParametersError(\"Multiple protocol parameter values found %r=%r\" % (n, v))\n elif n in (\"oauth_consumer_secret\", \"oauth_token_secret\", ):\n raise InsecureOAuthParametersError(\"[SECURITY-ISSUE] Client attempting to transmit confidential protocol parameter `%r`. Communication is insecure if this is in your server logs.\" % (n, ))\n else:\n return True\n else:\n logging.warning(\"Invalid protocol parameter ignored: `%r`\", n)\n return False\n return query_filter(protocol_params, allow_func=allow_func)","def test_unicode_query_string():\n assert (normalize_url(\"http://example.com/?file=résumé.pdf\") ==\n \"http://example.com/?file=r%C3%A9sum%C3%A9.pdf\")","def _clean_authorization_request_url(request_url):\n parsed_url = urlparse(request_url)\n query_params = dict(parse_qsl(parsed_url.query, keep_blank_values=True))\n for param in [\"code\", \"state\"]:\n if param in query_params:\n query_params[param] = \"redacted\"\n url_parts = list(parsed_url) # cast to list to override query params\n url_parts[4] = urlencode(query=query_params)\n request_url = urlunparse(url_parts)\n return request_url","def urlencode_s(query_params, allow_func=None):\n return \"&\".join([k + \"=\" + v for k, v in\n urlencode_sl(query_params, allow_func=allow_func)])","def query_string(self):\r\n return self._environ.get('QUERY_STRING', '')","def param_replace(context, **kwargs):\n d = context['request'].GET.copy()\n for k,v in kwargs.items():\n d[k] = v\n for k in [k for k,v in d.items() if not v]:\n del d[k]\n return d.urlencode()","def clean_params(self, url):\n if isinstance(url, unicode):\n url = url.encode(\"utf-8\")\n parts = list(urlparse.urlsplit(url))\n if not parts[3]:\n return url\n query = urlparse.parse_qsl(parts[3])\n query = [q for q in query if self._is_param_allowed(*q)]\n if query:\n parts[3] = urllib.urlencode(query)\n else:\n parts[3] = ''\n return urlparse.urlunsplit(parts).decode(\"utf-8\")","def query_string(self):\n return self._environ.get('QUERY_STRING', '')","def query_string(self):\n return self.environ.get('QUERY_STRING') or ''","def modify_query_params(context, **kwargs):\n request = context['request']\n params = request.GET.copy()\n for key, value in kwargs.items():\n if value == '':\n if key in params:\n del params[key]\n else:\n params[key] = value\n return ('?' + params.urlencode()) if params else ''","def add_query_param(request, key, val):\n iri = request.get_full_path()\n uri = iri_to_uri(iri)\n return escape(replace_query_param(uri, key, val))","def test_unicode():\n create_request(\"/\")\n unicodestring = (u'\\N{LATIN SMALL LETTER A WITH GRAVE}'\n u'\\N{LATIN SMALL LETTER E WITH GRAVE}'\n u'\\N{LATIN SMALL LETTER I WITH GRAVE}'\n u'\\N{LATIN SMALL LETTER O WITH GRAVE}'\n u'\\N{LATIN SMALL LETTER U WITH GRAVE}')\n print url(unicodestring)\n eq_(url('/', x=unicodestring),\n '/?x=%C3%A0%C3%A8%C3%AC%C3%B2%C3%B9'\n )","def _unicode_urlencode(params):\r\n if isinstance(params, dict):\r\n params = params.items()\r\n return urllib.parse.urlencode([(k, v.encode('utf-8') or v) for k, v in params])","def test_query_string():\n assert (normalize_url(\"http://example.com/?a=1\") ==\n \"http://example.com/?a=1\")\n assert (normalize_url(\"http://example.com?a=1\") ==\n \"http://example.com/?a=1\")\n assert (normalize_url(\"http://example.com/a?b=1\") ==\n \"http://example.com/a?b=1\")\n assert (normalize_url(\"http://example.com/a/?b=1\") ==\n \"http://example.com/a?b=1\")","def read_request(request):\n if request.args and 'q' in request.args:\n q = request.args.get('q')\n return urllib.parse.unquote(q)\n else:\n return None","def query_string(source=None, **kwargs):\n q = QueryDict('', True)\n if source:\n q.update(source)\n for k, v in kwargs.items():\n if v not in ['']:\n q.update({k: v})\n if q:\n return \"{}\".format('?' + q.urlencode())\n return q.urlencode()","def _sanitize_param(self, param):\n if param:\n # Can't send unicode.\n param = str(param)\n return param","def url_with_querystring(url, **kwargs):\n return url + '?' + urlencode(kwargs)","def fixup_parameters(url, backend):\n result = url\n if backend == \"django\":\n result = url.replace(\"{\", \"(?P<\").replace(\"}\", \">.+)\")\n\n return result","def test_url_params(self):\n params = ct.url_params(\"https://www.bad-actor.services/some/url-thats-long?debug=True&this=that\")\n assert isinstance(params, dict)\n assert len(params) == 2\n assert params[\"debug\"] == \"True\"\n assert params[\"this\"] == \"that\"","def smart_encode(**kwargs):\r\n args = dict(kwargs)\r\n for k, v in args.items():\r\n if v is None:\r\n del args[k]\r\n if not args:\r\n return ''\r\n return urlencode(args)","def test_list():\n create_request(\"/\")\n value = url('/', foo=['bar', u'\\N{LATIN SMALL LETTER A WITH GRAVE}']),\n assert '/?foo=bar&foo=%C3%A0' in value","def fix_slash(environ, wantslash):\n from colubrid.exceptions import HttpMoved\n #FIXME\n # argh. never did something that supid\n # find a better solution for that problem.\n url = quote(environ.get('SCRIPT_NAME', ''))\n url += quote(environ.get('PATH_INFO', ''))\n query = environ.get('QUERY_STRING', '')\n oldurl = query and ('%s?%s' % (url, query)) or url\n \n if oldurl and oldurl != '/':\n if url.endswith('/'):\n if not wantslash:\n url = url[:-1]\n else:\n if wantslash:\n url += '/'\n \n newurl = query and ('%s?%s' % (url, query)) or url\n if oldurl != newurl:\n raise HttpMoved(newurl)","def from_urlencode(self, data,options=None):\n qs = dict((k, v if len(v)>1 else v[0] )\n for k, v in urlparse.parse_qs(data).iteritems())\n return qs","def from_urlencode(self, data,options=None):\n qs = dict((k, v if len(v)>1 else v[0] )\n for k, v in urlparse.parse_qs(data).iteritems())\n return qs","def url_replace(request, field, value):\n _dict = request.GET.copy()\n _dict[field] = value\n return _dict.urlencode()","def queryparams(*args, **kwargs):\n args = dict(args)\n args.update(kwargs)\n return urllib.urlencode(args)","def urlencode(query):\n\n if hasattr(query, 'items'):\n # mapping objects\n query = query.items()\n l = []\n for k, v in query:\n k = quote_plus(k)\n if isinstance(v, basestring):\n v = quote_plus(v)\n l.append(k + '=' + v)\n else:\n v = quote_plus(unicode(v))\n l.append(k + '=' + v)\n return '&'.join(l)","def test_query_string_spaces():\n assert (normalize_url(\"http://example.com/search?q=a b&a=1\") ==\n \"http://example.com/search?a=1&q=a+b\")\n assert (normalize_url(\"http://example.com/search?q=a+b&a=1\") ==\n \"http://example.com/search?a=1&q=a+b\")\n assert (normalize_url(\"http://example.com/search?q=a%20b&a=1\") ==\n \"http://example.com/search?a=1&q=a+b\")","def test_normalize_percent_encoding_in_querystring():\n assert (normalize_url(\"http://example.com/?a=b%c2\") ==\n \"http://example.com/?a=b%C2\")","def do_urlencode(value):\n return urllib.quote(value.encode('utf8'))","def test_AlgorithmsHandler_GETMalformedQuery(self):\n response = self.testapp.get('/algorithms/?qqry=algorithm', expect_errors=True)\n self.assertEqual(400, response.status_int)\n self.assertIsNotNone(response.charset)\n self.assertIn('Malformed Data', response.normal_body.decode(encoding=response.charset))\n self.assertEqual('application/json', response.content_type)","def querystring(data, exclude=(), **kwargs):\n items = reduce(operator.add, (\n list((k, v) for v in values)\n for k, values in data.lists() if k not in exclude\n ), [])\n\n for key, value in kwargs.items():\n items.append((key, force_text(value)))\n\n return urlencode(sorted(items))","def query_string(context, add=None, remove=None):\n # Written as an inclusion tag to simplify getting the context.\n add = string_to_dict(add)\n remove = string_to_list(remove)\n params = dict(context['request'].GET.items())\n response = get_query_string(params, add, remove)\n return {'response': response}","def _generate_query_string(self):\n \n query_items = {}\n \n for key, val in self.__dict__.iteritems():\n if not key.startswith('_'):\n query_items[key] = val.encode('utf-8')\n \n return urllib.urlencode(query_items)","def url_escape(value, plus=True):\r\n quote = urllib_parse.quote_plus if plus else urllib_parse.quote\r\n return quote(utf8(value))","def urlparams(*_, **kwargs):\n non_empty = {k: v for k, v in kwargs.items() if v is not None}\n if non_empty:\n return '?{}'.format(urlencode(non_empty))\n return ''","def replace_query_params(cls, url: str, **params: Mapping[str, str]) -> str:\n url, _ = cls.separate_query_params(url, params.keys())\n return cls.add_query_params(url, **params)","def updated_query_str(request, *args):\n\n return urllib.urlencode(updated_query(request, *args))","def get_query_string(p, new_params=None, remove=None):\n if new_params is None:\n new_params = {}\n if remove is None:\n remove = []\n\n for r in remove:\n for k in p.keys():\n if k.startswith(r):\n del p[k]\n for k, v in new_params.items():\n if k in p and v is None:\n del p[k]\n elif v is not None:\n p[k] = v\n return mark_safe(\n '?' + '&'.join(\n [u'%s=%s' % (k, v) for k, v in p.items()]\n ).replace(' ', '%20')\n )","def is_uncased(request) -> bool:\n return request.param","def xml_safe(value):\n return CONTROL_CHARACTERS.sub('?', value)","def xml_safe(value):\n return CONTROL_CHARACTERS.sub('?', value)","def safe_urlencode(params, doseq=0):\n if IS_PY3:\n return urlencode(params, doseq)\n\n if hasattr(params, \"items\"):\n params = params.items()\n\n new_params = []\n\n for k, v in params:\n k = k.encode(\"utf-8\")\n\n if isinstance(v, (list, tuple)):\n new_params.append((k, [force_bytes(i) for i in v]))\n else:\n new_params.append((k, force_bytes(v)))\n\n return urlencode(new_params, doseq)","def url_with_query_str(url, *args, **kwargs):\n if len(args):\n d = args[0]\n elif len(kwargs):\n d = kwargs\n else:\n raise Exception('not found dict')\n if any(\"%\" in k for k in d.keys()):\n query = \"&\".join([\"{}={}\".format(k, v) for k, v in d.items()])\n else:\n query = urlencode(d)\n url = url.split('?')[0]\n return \"{}?{}\".format(url, query)","def parseQueryString():\n\tqs = cgi.FieldStorage()\n\treturn({'char': qs.getvalue('char'), 'zone': qs.getvalue('zone')})","def aws_urlquote(value):\n if isinstance(value, unicode):\n value = value.encode(\"utf-8\")\n return quote(value, \"/\")","def negotiate( request, variants ):","def _update_request_uri_query(self, request):\n if \"?\" in request.path:\n request.path, _, query_string = request.path.partition(\"?\")\n if query_string:\n query_params = query_string.split(\"&\")\n for query in query_params:\n if \"=\" in query:\n name, _, value = query.partition(\"=\")\n request.query.append((name, value))\n\n request.path = url_quote(request.path, \"/()$=',\")\n\n # add encoded queries to request.path.\n if request.query:\n request.path += \"?\"\n for name, value in request.query:\n if value is not None:\n request.path += \"{}={}{}\".format(name, url_quote(value, \"/()$=',\"), \"&\")\n request.path = request.path[:-1]\n\n return request.path, request.query","def _url_encode(self, text):\n try:\n return (urllib.quote(text.replace(u'and', u'&'), safe='')\n .replace(u'%20', u'+'))\n except:\n print('Using python3')\n return (urllib.parse.quote(text.replace(u'and', u'&'), safe='')\n .replace(u'%20', u'+'))","def valid_request(environ):\n if environ.get('REQUEST_METHOD') != 'GET':\n return False\n if environ.get('QUERY_STRING'):\n return False\n requested = environ.get('PATH_INFO', '/').lstrip('/')\n if not requested:\n return True\n if len(requested) > 40: # Larger than git SHA reference.\n return False\n if VALID_REQUEST.match(requested) is None:\n return False\n return True","def test_append_slash_redirect_querystring(self):\n request = self.rf.get(\"/slash?test=1\")\n resp = CommonMiddleware(get_response_404)(request)\n self.assertEqual(resp.url, \"/slash/?test=1\")","def test_unreserved_percentencoding():\n assert (normalize_url(\"http://www.example.com/%7Eusername/\") ==\n \"http://www.example.com/~username\")\n assert (normalize_url('http://example.com/foo%23bar') ==\n 'http://example.com/foo%23bar')\n assert (normalize_url('http://example.com/foo%2fbar') ==\n 'http://example.com/foo%2Fbar')\n assert (normalize_url('http://example.com/foo%3fbar') ==\n 'http://example.com/foo%3Fbar')","def unicode_urlencode(params):\n if isinstance(params, dict):\n params = params.items()\n return urlencode([(k, isinstance(v, unicode) and v.encode('utf-8') or v)\n for k, v in params])","def request(query):","def url_parse_query(query, encoding=None):\n if isinstance(query, unicode):\n if encoding is None:\n encoding = url_encoding\n query = query.encode(encoding, 'ignore')\n query = query.replace('?', '')\n\n l = set()\n for k, v, sep in parse_qsl(query, True):\n k = url_quote_part(k, '/-:,;')\n if not k:\n continue\n if v:\n v = url_quote_part(v, '/-:,;')\n l.add(\"%s=%s\" % (k, v))\n elif v is None:\n l.add(\"%s\" % k)\n else:\n # some sites do not work when the equal sign is missing\n l.add(\"%s=\" % k)\n query = '&'.join(sorted(l))\n return query","def add_querystring(context, **kwargs):\n\n updated = context['request'].GET.copy()\n\n # have to iterate over and not use .update as it's a QueryDict not a dict\n for k, v in kwargs.items():\n updated[k] = v\n\n return '?{}'.format(updated.urlencode()) if updated else ''","def ws_strip_txt(request) -> Dict[str, str]:\n return request.param","def signed_request(params):\n has_signature = False\n keys = params.keys()\n if \"signature\" in keys:\n has_signature = True\n keys.remove(\"signature\")\n keys.sort()\n if has_signature:\n keys.append(\"signature\")\n query_string = \"&\".join(quote(key, \"~\") + \"=\" + quote(params[key], \"~\") for key in keys)\n return query_string","def parse_query_string(s):\n res = {}\n pairs = s.split('&')\n for p in pairs:\n vals = [urldecode_plus(x) for x in p.split('=', 1)]\n if len(vals) == 1:\n res[vals[0]] = ''\n else:\n res[vals[0]] = vals[1]\n return res","def test_invalid_query_params(self):\n url = reverse(\"metrics\")\n client = APIClient()\n\n params = {\"limit\": \"foo\"}\n url = url + \"?\" + urlencode(params, quote_via=quote_plus)\n response = client.get(url, **self.headers)\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)","def test_unspecified_excluded(self):\n handler = self.create_handler(r'unspecified1=foo&unspecified2=5')\n self.assertEqual(handler.get_params(), {})","def test_percent_encode(self):\n self.gmail_case.set_query_arg('Ladies + Gentlemen')\n self.assertEqual(self.gmail_case.__repr__(), \n 'https://www.google.com/search?aqs=chrome..69i57j0l3.9438j0&sourceid=chrome&Ladies%20+%20Gentlemen&q=setter+python&ie=UTF-8&oq=setter+python')","def report_old():\n try:\n path = flask.request.args['q']\n except:\n app.logger.info('Unable to decode valid domains from q GET param')\n return flask.redirect('/error/1')\n\n return flask.redirect('/search/{}'.format(path))","def test_append_slash_quoted(self):\n request = self.rf.get(quote(\"/needsquoting#\"))\n r = CommonMiddleware(get_response_404)(request)\n self.assertEqual(r.status_code, 301)\n self.assertEqual(r.url, \"/needsquoting%23/\")","def append_query_param(url: str, key: str, value: str) -> str:\n template = '?' in url and '{}&{}={}' or '{}?{}={}'\n return template.format(url, key, value)","def test_query_sql_injection(self):\r\n\r\n q = '1%3D1;SELECT%20*%20FROM%20task%20WHERE%201=1'\r\n res = self.app.get('/api/task?' + q)\r\n error = json.loads(res.data)\r\n assert res.status_code == 415, error\r\n assert error['action'] == 'GET', error\r\n assert error['status'] == 'failed', error\r\n assert error['target'] == 'task', error\r\n\r\n q = 'app_id=1%3D1;SELECT%20*%20FROM%20task%20WHERE%201'\r\n res = self.app.get('/api/apappp?' + q)\r\n assert res.status_code == 404, res.data\r\n\r\n q = 'app_id=1%3D1;SELECT%20*%20FROM%20task%20WHERE%201'\r\n res = self.app.get('/api/' + q)\r\n assert res.status_code == 404, res.data\r\n\r\n q = 'app_id=1%3D1;SELECT%20*%20FROM%20task%20WHERE%201'\r\n res = self.app.get('/api' + q)\r\n assert res.status_code == 404, res.data","def urlQuote(string):\r\n return quote(string.encode(\"utf-8\"))","def sanitizeUrl(url):\n return url.split('?')[0]","def query_string_get(request, name, default_value=_NOT_SET, validator=None):\n return _XXX_get(request.rel_url.query, name, default_value, validator)","def _security_check_parameters(param_dict):\n for key, value in param_dict.iteritems():\n str_value = str(value) # Could easily be an int or a float\n for bad_str in [\";\", \"&&\", \">\", \"<\", \"|\"]:\n if bad_str in str_value:\n raise ValueError(\"Rejecting suspicious argument for %s\" % key)","def urlencode_sl(query_params, allow_func=None):\n query_params = query_params or {}\n encoded_pairs = []\n for k, v in query_params.items():\n # Keys are also percent-encoded according to OAuth spec.\n k = percent_encode(unicode_to_utf8(k))\n if allow_func and not allow_func(k, v):\n continue\n elif is_bytes_or_unicode(v):\n encoded_pairs.append((k, percent_encode(v),))\n else:\n if is_sequence(v):\n # Loop over the sequence.\n if len(v) > 0:\n for i in v:\n encoded_pairs.append((k, percent_encode(i), ))\n # ``urllib.urlencode()`` doesn't preserve blank lists.\n # Therefore, we're discarding them.\n #else:\n # # Preserve blank list values.\n # encoded_pairs.append((k, \"\", ))\n else:\n encoded_pairs.append((k, percent_encode(v),))\n # Sort after encoding according to the OAuth spec.\n return sorted(encoded_pairs)","def _unicode_urlencode(params):\n if isinstance(params, dict):\n params = list(params.items())\n for i, param in enumerate(params):\n if isinstance(param[1], list):\n params[i] = (param[0], json.dumps(param[1]),)\n\n result = urllib.parse.urlencode([(k, isinstance(v, str) and v.encode('utf-8') or v) for k, v in params])\n return result","def _create_query_str(data):\n params = []\n for name, value in data.items():\n params.append(name + '=' + str(value))\n\n return '?' + '&'.join(params)","def __init__(self, query_string: str) -> None:\n super().__init__(parse_qs(query_string))","def _quote(uri, options):\n suri = uri.strip()\n for c in _warnChars:\n if suri.find(c) != -1:\n if options != None:\n options.comment_graph.add_warning('Unusual character in uri:%s; possible error?' % suri)\n break\n return urllib.quote(suri, _unquotedChars)","def use_request_params(self, request):\r\n if request.params is None:\r\n return False\r\n\r\n if isinstance(request.params, (port.text_type, port.binary_type)):\r\n return False\r\n\r\n return True","def _escape_url(url, force_https=True):\n scheme, netloc, path, query, unused_fragment = urlparse.urlsplit(url)\n if force_https:\n scheme = 'https'\n path = urllib.quote(path)\n query = urllib.quote_plus(query, '=?&;')\n return urlparse.urlunsplit((scheme, netloc, path, query, unused_fragment))","def make_url_safe(self, url):\n return url.replace(' ', '%20')\\\n .replace('(', '%28')\\\n .replace(')', '%29')\\\n .replace('\"', '%22')","def urldecode(val):\n return urllib.unquote_plus(val)","def cleaned_string(val):\r\n return urllib.quote_plus(smart_str(val))","def normalize_params(url, params):\n # parse the url\n parse = urlparse(url)\n\n # Get the query list\n qs_list = parse_qsl(parse.query, keep_blank_values=True)\n must_encode = False if parse.query == urllib.parse.unquote(parse.query) else True\n if params is None:\n combined_list = qs_list\n else:\n # Needs to be encoded before sorting\n combined_list = [encode_pair(must_encode, key, value) for (key, value) in list(qs_list)]\n combined_list += params.items()\n\n encoded_list = [\"%s=%s\" % (key, value) for (key, value) in combined_list]\n sorted_list = sorted(encoded_list, key=lambda x: x)\n\n return \"&\".join(sorted_list)","def use_request_params(self, request):\r\n if request.params is None:\r\n return False\r\n\r\n # GET parameters get appended to the URL, so they're used\r\n if request.method.upper() in http.URLENCODE_METHODS:\r\n return True\r\n\r\n if request.method.upper() != 'POST':\r\n return False\r\n\r\n if isinstance(request.params, (port.text_type, port.binary_type)):\r\n return False\r\n\r\n return True","def test_clean_query_params(self):\n original_query_params = {\n \"name\": \"FAKE-NAME\",\n \"hostname\": \"FAKE-HOSTNAME\",\n \"version\": None,\n }\n\n cleaned_query_params = {\"name\": \"FAKE-NAME\", \"hostname\": \"FAKE-HOSTNAME\"}\n\n client = Client()\n original_query_params = client._clean_query_params(original_query_params)\n assert original_query_params == cleaned_query_params","def _sanitizeEnv(self, environ):\n reqUri = None\n if environ.has_key('REQUEST_URI'):\n reqUri = environ['REQUEST_URI'].split('?', 1)\n\n # Ensure QUERY_STRING exists\n if not environ.has_key('QUERY_STRING') or not environ['QUERY_STRING']:\n if reqUri is not None and len(reqUri) > 1:\n environ['QUERY_STRING'] = reqUri[1]\n else:\n environ['QUERY_STRING'] = ''\n\n # Check WSGI_SCRIPT_NAME\n scriptName = environ.get('WSGI_SCRIPT_NAME')\n if scriptName is None:\n scriptName = self.scriptName\n else:\n warnings.warn('WSGI_SCRIPT_NAME environment variable for scgi '\n 'servers is deprecated',\n DeprecationWarning)\n if scriptName.lower() == 'none':\n scriptName = None\n\n if scriptName is None:\n # Do nothing (most likely coming from cgi2scgi)\n return\n\n if scriptName is NoDefault:\n # Pull SCRIPT_NAME/PATH_INFO from environment, with empty defaults\n if not environ.has_key('SCRIPT_NAME'):\n environ['SCRIPT_INFO'] = ''\n if not environ.has_key('PATH_INFO') or not environ['PATH_INFO']:\n if reqUri is not None:\n environ['PATH_INFO'] = reqUri[0]\n else:\n environ['PATH_INFO'] = ''\n else:\n # Configured scriptName\n warnings.warn('Configured SCRIPT_NAME is deprecated\\n'\n 'Do not use WSGI_SCRIPT_NAME or the scriptName\\n'\n 'keyword parameter -- they will be going away',\n DeprecationWarning)\n\n value = environ['SCRIPT_NAME']\n value += environ.get('PATH_INFO', '')\n if not value.startswith(scriptName):\n self.logger.warning('scriptName does not match request URI')\n\n environ['PATH_INFO'] = value[len(scriptName):]\n environ['SCRIPT_NAME'] = scriptName","def urlencode(path):\n return urllib.quote_plus(path)"],"string":"[\n \"def query_params_sanitize(query_params):\\n def allow_func(n, v):\\n # This gets rid of any params beginning with \\\"oauth_\\\"\\n if not n.startswith(\\\"oauth_\\\"):\\n return True\\n else:\\n logging.warning(\\\"Protocol parameter ignored from URL query parameters: `%r`\\\", n)\\n return False\\n return query_filter(query_params, allow_func=allow_func)\",\n \"def test_non_ascii_query_string_does_not_crash(self):\\n request = self.rf.get(\\\"/slash\\\")\\n request.META[\\\"QUERY_STRING\\\"] = \\\"drink=café\\\"\\n r = CommonMiddleware(get_response_empty).process_request(request)\\n self.assertIsNone(r)\\n response = HttpResponseNotFound()\\n r = CommonMiddleware(get_response_empty).process_response(request, response)\\n self.assertEqual(r.status_code, 301)\",\n \"def test_additional_query_args():\\n assert (normalize_url(\\\"http://example.com?c=d\\\", [(\\\"a\\\", \\\"b\\\")]) ==\\n \\\"http://example.com/?a=b&c=d\\\")\\n assert (normalize_url(\\\"http://example.com\\\", [(\\\"a\\\", \\\"b\\\")]) ==\\n \\\"http://example.com/?a=b\\\")\\n assert (normalize_url(\\\"http://example.com\\\", [(\\\"résumé\\\", \\\"résumé\\\")]) ==\\n \\\"http://example.com/?r%C3%A9sum%C3%A9=r%C3%A9sum%C3%A9\\\")\",\n \"def test_dont_percent_encode_safe_chars_query():\\n assert (normalize_url(\\\"http://example.com/a/?face=(-.-)\\\") ==\\n \\\"http://example.com/a?face=(-.-)\\\")\",\n \"def encoded_query_str(request):\\n return updated_query_str(request)\",\n \"def maybe_urlencoded(fixed_in: str) -> str:\\n try:\\n d = urllib.parse.parse_qs(fixed_in)\\n # There may be additional known-good keys in the future.\\n return d[\\\"fixed\\\"][0]\\n except (ValueError, KeyError):\\n return fixed_in\",\n \"def create_query_sting(param_dict):\\n params = \\\"&\\\".join([f\\\"{key}={value}\\\" for key, value in param_dict.items()])\\n return params.replace(\\\"#\\\", \\\"%23\\\")\",\n \"def updated_querystring(request, params):\\n original_params = request.GET.copy()\\n for key in params:\\n if key in original_params:\\n original_params.pop(key)\\n original_params.update(params)\\n return original_params.urlencode()\",\n \"def updated_querystring(request, params):\\n original_params = request.GET.copy()\\n for key in params:\\n if key in original_params:\\n original_params.pop(key)\\n original_params.update(params)\\n return original_params.urlencode()\",\n \"def get_query_string(self):\\r\\n pass\",\n \"def test_percent_encode_querystring():\\n assert (normalize_url(\\\"http://example.com/?a=hello{}\\\") ==\\n \\\"http://example.com/?a=hello%7B%7D\\\")\",\n \"def _get_query_part(params: dict) -> str:\\n params_cleaned = {k: v for k, v in params.items() if v is not None}\\n return ('?' + urlencode(params_cleaned, quote_via=quote, safe=\\\"/,\\\")) if params_cleaned else \\\"\\\"\",\n \"def _prepare_params(self, params):\\n if isinstance(params, six.string_types):\\n return params\\n return urllib.urlencode(params)\",\n \"def url_replace(context, **kwargs):\\n query = context['request'].GET.dict()\\n query.update(kwargs)\\n return urlencode(query)\",\n \"def url_replace(context, **kwargs):\\n query = context['request'].GET.dict()\\n query.update(kwargs)\\n return urlencode(query)\",\n \"def request_protocol_params_sanitize(protocol_params):\\n def allow_func(n, v):\\n if n.startswith(\\\"oauth_\\\"):\\n # This gets rid of \\\"realm\\\" or any non-OAuth param.\\n if len(v) > 1:\\n # Multiple values for a protocol parameter are not allowed.\\n # We don't silently discard values because failing fast\\n # is better than simply logging and waiting for the user\\n # to figure it out all by herself.\\n #\\n # See Making Requests (http://tools.ietf.org/html/rfc5849#section-3.1)\\n # Point 2. Each parameter MUST NOT appear more than once per\\n # request, so we disallow multiple values for a protocol\\n # parameter.\\n raise InvalidOAuthParametersError(\\\"Multiple protocol parameter values found %r=%r\\\" % (n, v))\\n elif n in (\\\"oauth_consumer_secret\\\", \\\"oauth_token_secret\\\", ):\\n raise InsecureOAuthParametersError(\\\"[SECURITY-ISSUE] Client attempting to transmit confidential protocol parameter `%r`. Communication is insecure if this is in your server logs.\\\" % (n, ))\\n else:\\n return True\\n else:\\n logging.warning(\\\"Invalid protocol parameter ignored: `%r`\\\", n)\\n return False\\n return query_filter(protocol_params, allow_func=allow_func)\",\n \"def test_unicode_query_string():\\n assert (normalize_url(\\\"http://example.com/?file=résumé.pdf\\\") ==\\n \\\"http://example.com/?file=r%C3%A9sum%C3%A9.pdf\\\")\",\n \"def _clean_authorization_request_url(request_url):\\n parsed_url = urlparse(request_url)\\n query_params = dict(parse_qsl(parsed_url.query, keep_blank_values=True))\\n for param in [\\\"code\\\", \\\"state\\\"]:\\n if param in query_params:\\n query_params[param] = \\\"redacted\\\"\\n url_parts = list(parsed_url) # cast to list to override query params\\n url_parts[4] = urlencode(query=query_params)\\n request_url = urlunparse(url_parts)\\n return request_url\",\n \"def urlencode_s(query_params, allow_func=None):\\n return \\\"&\\\".join([k + \\\"=\\\" + v for k, v in\\n urlencode_sl(query_params, allow_func=allow_func)])\",\n \"def query_string(self):\\r\\n return self._environ.get('QUERY_STRING', '')\",\n \"def param_replace(context, **kwargs):\\n d = context['request'].GET.copy()\\n for k,v in kwargs.items():\\n d[k] = v\\n for k in [k for k,v in d.items() if not v]:\\n del d[k]\\n return d.urlencode()\",\n \"def clean_params(self, url):\\n if isinstance(url, unicode):\\n url = url.encode(\\\"utf-8\\\")\\n parts = list(urlparse.urlsplit(url))\\n if not parts[3]:\\n return url\\n query = urlparse.parse_qsl(parts[3])\\n query = [q for q in query if self._is_param_allowed(*q)]\\n if query:\\n parts[3] = urllib.urlencode(query)\\n else:\\n parts[3] = ''\\n return urlparse.urlunsplit(parts).decode(\\\"utf-8\\\")\",\n \"def query_string(self):\\n return self._environ.get('QUERY_STRING', '')\",\n \"def query_string(self):\\n return self.environ.get('QUERY_STRING') or ''\",\n \"def modify_query_params(context, **kwargs):\\n request = context['request']\\n params = request.GET.copy()\\n for key, value in kwargs.items():\\n if value == '':\\n if key in params:\\n del params[key]\\n else:\\n params[key] = value\\n return ('?' + params.urlencode()) if params else ''\",\n \"def add_query_param(request, key, val):\\n iri = request.get_full_path()\\n uri = iri_to_uri(iri)\\n return escape(replace_query_param(uri, key, val))\",\n \"def test_unicode():\\n create_request(\\\"/\\\")\\n unicodestring = (u'\\\\N{LATIN SMALL LETTER A WITH GRAVE}'\\n u'\\\\N{LATIN SMALL LETTER E WITH GRAVE}'\\n u'\\\\N{LATIN SMALL LETTER I WITH GRAVE}'\\n u'\\\\N{LATIN SMALL LETTER O WITH GRAVE}'\\n u'\\\\N{LATIN SMALL LETTER U WITH GRAVE}')\\n print url(unicodestring)\\n eq_(url('/', x=unicodestring),\\n '/?x=%C3%A0%C3%A8%C3%AC%C3%B2%C3%B9'\\n )\",\n \"def _unicode_urlencode(params):\\r\\n if isinstance(params, dict):\\r\\n params = params.items()\\r\\n return urllib.parse.urlencode([(k, v.encode('utf-8') or v) for k, v in params])\",\n \"def test_query_string():\\n assert (normalize_url(\\\"http://example.com/?a=1\\\") ==\\n \\\"http://example.com/?a=1\\\")\\n assert (normalize_url(\\\"http://example.com?a=1\\\") ==\\n \\\"http://example.com/?a=1\\\")\\n assert (normalize_url(\\\"http://example.com/a?b=1\\\") ==\\n \\\"http://example.com/a?b=1\\\")\\n assert (normalize_url(\\\"http://example.com/a/?b=1\\\") ==\\n \\\"http://example.com/a?b=1\\\")\",\n \"def read_request(request):\\n if request.args and 'q' in request.args:\\n q = request.args.get('q')\\n return urllib.parse.unquote(q)\\n else:\\n return None\",\n \"def query_string(source=None, **kwargs):\\n q = QueryDict('', True)\\n if source:\\n q.update(source)\\n for k, v in kwargs.items():\\n if v not in ['']:\\n q.update({k: v})\\n if q:\\n return \\\"{}\\\".format('?' + q.urlencode())\\n return q.urlencode()\",\n \"def _sanitize_param(self, param):\\n if param:\\n # Can't send unicode.\\n param = str(param)\\n return param\",\n \"def url_with_querystring(url, **kwargs):\\n return url + '?' + urlencode(kwargs)\",\n \"def fixup_parameters(url, backend):\\n result = url\\n if backend == \\\"django\\\":\\n result = url.replace(\\\"{\\\", \\\"(?P<\\\").replace(\\\"}\\\", \\\">.+)\\\")\\n\\n return result\",\n \"def test_url_params(self):\\n params = ct.url_params(\\\"https://www.bad-actor.services/some/url-thats-long?debug=True&this=that\\\")\\n assert isinstance(params, dict)\\n assert len(params) == 2\\n assert params[\\\"debug\\\"] == \\\"True\\\"\\n assert params[\\\"this\\\"] == \\\"that\\\"\",\n \"def smart_encode(**kwargs):\\r\\n args = dict(kwargs)\\r\\n for k, v in args.items():\\r\\n if v is None:\\r\\n del args[k]\\r\\n if not args:\\r\\n return ''\\r\\n return urlencode(args)\",\n \"def test_list():\\n create_request(\\\"/\\\")\\n value = url('/', foo=['bar', u'\\\\N{LATIN SMALL LETTER A WITH GRAVE}']),\\n assert '/?foo=bar&foo=%C3%A0' in value\",\n \"def fix_slash(environ, wantslash):\\n from colubrid.exceptions import HttpMoved\\n #FIXME\\n # argh. never did something that supid\\n # find a better solution for that problem.\\n url = quote(environ.get('SCRIPT_NAME', ''))\\n url += quote(environ.get('PATH_INFO', ''))\\n query = environ.get('QUERY_STRING', '')\\n oldurl = query and ('%s?%s' % (url, query)) or url\\n \\n if oldurl and oldurl != '/':\\n if url.endswith('/'):\\n if not wantslash:\\n url = url[:-1]\\n else:\\n if wantslash:\\n url += '/'\\n \\n newurl = query and ('%s?%s' % (url, query)) or url\\n if oldurl != newurl:\\n raise HttpMoved(newurl)\",\n \"def from_urlencode(self, data,options=None):\\n qs = dict((k, v if len(v)>1 else v[0] )\\n for k, v in urlparse.parse_qs(data).iteritems())\\n return qs\",\n \"def from_urlencode(self, data,options=None):\\n qs = dict((k, v if len(v)>1 else v[0] )\\n for k, v in urlparse.parse_qs(data).iteritems())\\n return qs\",\n \"def url_replace(request, field, value):\\n _dict = request.GET.copy()\\n _dict[field] = value\\n return _dict.urlencode()\",\n \"def queryparams(*args, **kwargs):\\n args = dict(args)\\n args.update(kwargs)\\n return urllib.urlencode(args)\",\n \"def urlencode(query):\\n\\n if hasattr(query, 'items'):\\n # mapping objects\\n query = query.items()\\n l = []\\n for k, v in query:\\n k = quote_plus(k)\\n if isinstance(v, basestring):\\n v = quote_plus(v)\\n l.append(k + '=' + v)\\n else:\\n v = quote_plus(unicode(v))\\n l.append(k + '=' + v)\\n return '&'.join(l)\",\n \"def test_query_string_spaces():\\n assert (normalize_url(\\\"http://example.com/search?q=a b&a=1\\\") ==\\n \\\"http://example.com/search?a=1&q=a+b\\\")\\n assert (normalize_url(\\\"http://example.com/search?q=a+b&a=1\\\") ==\\n \\\"http://example.com/search?a=1&q=a+b\\\")\\n assert (normalize_url(\\\"http://example.com/search?q=a%20b&a=1\\\") ==\\n \\\"http://example.com/search?a=1&q=a+b\\\")\",\n \"def test_normalize_percent_encoding_in_querystring():\\n assert (normalize_url(\\\"http://example.com/?a=b%c2\\\") ==\\n \\\"http://example.com/?a=b%C2\\\")\",\n \"def do_urlencode(value):\\n return urllib.quote(value.encode('utf8'))\",\n \"def test_AlgorithmsHandler_GETMalformedQuery(self):\\n response = self.testapp.get('/algorithms/?qqry=algorithm', expect_errors=True)\\n self.assertEqual(400, response.status_int)\\n self.assertIsNotNone(response.charset)\\n self.assertIn('Malformed Data', response.normal_body.decode(encoding=response.charset))\\n self.assertEqual('application/json', response.content_type)\",\n \"def querystring(data, exclude=(), **kwargs):\\n items = reduce(operator.add, (\\n list((k, v) for v in values)\\n for k, values in data.lists() if k not in exclude\\n ), [])\\n\\n for key, value in kwargs.items():\\n items.append((key, force_text(value)))\\n\\n return urlencode(sorted(items))\",\n \"def query_string(context, add=None, remove=None):\\n # Written as an inclusion tag to simplify getting the context.\\n add = string_to_dict(add)\\n remove = string_to_list(remove)\\n params = dict(context['request'].GET.items())\\n response = get_query_string(params, add, remove)\\n return {'response': response}\",\n \"def _generate_query_string(self):\\n \\n query_items = {}\\n \\n for key, val in self.__dict__.iteritems():\\n if not key.startswith('_'):\\n query_items[key] = val.encode('utf-8')\\n \\n return urllib.urlencode(query_items)\",\n \"def url_escape(value, plus=True):\\r\\n quote = urllib_parse.quote_plus if plus else urllib_parse.quote\\r\\n return quote(utf8(value))\",\n \"def urlparams(*_, **kwargs):\\n non_empty = {k: v for k, v in kwargs.items() if v is not None}\\n if non_empty:\\n return '?{}'.format(urlencode(non_empty))\\n return ''\",\n \"def replace_query_params(cls, url: str, **params: Mapping[str, str]) -> str:\\n url, _ = cls.separate_query_params(url, params.keys())\\n return cls.add_query_params(url, **params)\",\n \"def updated_query_str(request, *args):\\n\\n return urllib.urlencode(updated_query(request, *args))\",\n \"def get_query_string(p, new_params=None, remove=None):\\n if new_params is None:\\n new_params = {}\\n if remove is None:\\n remove = []\\n\\n for r in remove:\\n for k in p.keys():\\n if k.startswith(r):\\n del p[k]\\n for k, v in new_params.items():\\n if k in p and v is None:\\n del p[k]\\n elif v is not None:\\n p[k] = v\\n return mark_safe(\\n '?' + '&'.join(\\n [u'%s=%s' % (k, v) for k, v in p.items()]\\n ).replace(' ', '%20')\\n )\",\n \"def is_uncased(request) -> bool:\\n return request.param\",\n \"def xml_safe(value):\\n return CONTROL_CHARACTERS.sub('?', value)\",\n \"def xml_safe(value):\\n return CONTROL_CHARACTERS.sub('?', value)\",\n \"def safe_urlencode(params, doseq=0):\\n if IS_PY3:\\n return urlencode(params, doseq)\\n\\n if hasattr(params, \\\"items\\\"):\\n params = params.items()\\n\\n new_params = []\\n\\n for k, v in params:\\n k = k.encode(\\\"utf-8\\\")\\n\\n if isinstance(v, (list, tuple)):\\n new_params.append((k, [force_bytes(i) for i in v]))\\n else:\\n new_params.append((k, force_bytes(v)))\\n\\n return urlencode(new_params, doseq)\",\n \"def url_with_query_str(url, *args, **kwargs):\\n if len(args):\\n d = args[0]\\n elif len(kwargs):\\n d = kwargs\\n else:\\n raise Exception('not found dict')\\n if any(\\\"%\\\" in k for k in d.keys()):\\n query = \\\"&\\\".join([\\\"{}={}\\\".format(k, v) for k, v in d.items()])\\n else:\\n query = urlencode(d)\\n url = url.split('?')[0]\\n return \\\"{}?{}\\\".format(url, query)\",\n \"def parseQueryString():\\n\\tqs = cgi.FieldStorage()\\n\\treturn({'char': qs.getvalue('char'), 'zone': qs.getvalue('zone')})\",\n \"def aws_urlquote(value):\\n if isinstance(value, unicode):\\n value = value.encode(\\\"utf-8\\\")\\n return quote(value, \\\"/\\\")\",\n \"def negotiate( request, variants ):\",\n \"def _update_request_uri_query(self, request):\\n if \\\"?\\\" in request.path:\\n request.path, _, query_string = request.path.partition(\\\"?\\\")\\n if query_string:\\n query_params = query_string.split(\\\"&\\\")\\n for query in query_params:\\n if \\\"=\\\" in query:\\n name, _, value = query.partition(\\\"=\\\")\\n request.query.append((name, value))\\n\\n request.path = url_quote(request.path, \\\"/()$=',\\\")\\n\\n # add encoded queries to request.path.\\n if request.query:\\n request.path += \\\"?\\\"\\n for name, value in request.query:\\n if value is not None:\\n request.path += \\\"{}={}{}\\\".format(name, url_quote(value, \\\"/()$=',\\\"), \\\"&\\\")\\n request.path = request.path[:-1]\\n\\n return request.path, request.query\",\n \"def _url_encode(self, text):\\n try:\\n return (urllib.quote(text.replace(u'and', u'&'), safe='')\\n .replace(u'%20', u'+'))\\n except:\\n print('Using python3')\\n return (urllib.parse.quote(text.replace(u'and', u'&'), safe='')\\n .replace(u'%20', u'+'))\",\n \"def valid_request(environ):\\n if environ.get('REQUEST_METHOD') != 'GET':\\n return False\\n if environ.get('QUERY_STRING'):\\n return False\\n requested = environ.get('PATH_INFO', '/').lstrip('/')\\n if not requested:\\n return True\\n if len(requested) > 40: # Larger than git SHA reference.\\n return False\\n if VALID_REQUEST.match(requested) is None:\\n return False\\n return True\",\n \"def test_append_slash_redirect_querystring(self):\\n request = self.rf.get(\\\"/slash?test=1\\\")\\n resp = CommonMiddleware(get_response_404)(request)\\n self.assertEqual(resp.url, \\\"/slash/?test=1\\\")\",\n \"def test_unreserved_percentencoding():\\n assert (normalize_url(\\\"http://www.example.com/%7Eusername/\\\") ==\\n \\\"http://www.example.com/~username\\\")\\n assert (normalize_url('http://example.com/foo%23bar') ==\\n 'http://example.com/foo%23bar')\\n assert (normalize_url('http://example.com/foo%2fbar') ==\\n 'http://example.com/foo%2Fbar')\\n assert (normalize_url('http://example.com/foo%3fbar') ==\\n 'http://example.com/foo%3Fbar')\",\n \"def unicode_urlencode(params):\\n if isinstance(params, dict):\\n params = params.items()\\n return urlencode([(k, isinstance(v, unicode) and v.encode('utf-8') or v)\\n for k, v in params])\",\n \"def request(query):\",\n \"def url_parse_query(query, encoding=None):\\n if isinstance(query, unicode):\\n if encoding is None:\\n encoding = url_encoding\\n query = query.encode(encoding, 'ignore')\\n query = query.replace('?', '')\\n\\n l = set()\\n for k, v, sep in parse_qsl(query, True):\\n k = url_quote_part(k, '/-:,;')\\n if not k:\\n continue\\n if v:\\n v = url_quote_part(v, '/-:,;')\\n l.add(\\\"%s=%s\\\" % (k, v))\\n elif v is None:\\n l.add(\\\"%s\\\" % k)\\n else:\\n # some sites do not work when the equal sign is missing\\n l.add(\\\"%s=\\\" % k)\\n query = '&'.join(sorted(l))\\n return query\",\n \"def add_querystring(context, **kwargs):\\n\\n updated = context['request'].GET.copy()\\n\\n # have to iterate over and not use .update as it's a QueryDict not a dict\\n for k, v in kwargs.items():\\n updated[k] = v\\n\\n return '?{}'.format(updated.urlencode()) if updated else ''\",\n \"def ws_strip_txt(request) -> Dict[str, str]:\\n return request.param\",\n \"def signed_request(params):\\n has_signature = False\\n keys = params.keys()\\n if \\\"signature\\\" in keys:\\n has_signature = True\\n keys.remove(\\\"signature\\\")\\n keys.sort()\\n if has_signature:\\n keys.append(\\\"signature\\\")\\n query_string = \\\"&\\\".join(quote(key, \\\"~\\\") + \\\"=\\\" + quote(params[key], \\\"~\\\") for key in keys)\\n return query_string\",\n \"def parse_query_string(s):\\n res = {}\\n pairs = s.split('&')\\n for p in pairs:\\n vals = [urldecode_plus(x) for x in p.split('=', 1)]\\n if len(vals) == 1:\\n res[vals[0]] = ''\\n else:\\n res[vals[0]] = vals[1]\\n return res\",\n \"def test_invalid_query_params(self):\\n url = reverse(\\\"metrics\\\")\\n client = APIClient()\\n\\n params = {\\\"limit\\\": \\\"foo\\\"}\\n url = url + \\\"?\\\" + urlencode(params, quote_via=quote_plus)\\n response = client.get(url, **self.headers)\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_unspecified_excluded(self):\\n handler = self.create_handler(r'unspecified1=foo&unspecified2=5')\\n self.assertEqual(handler.get_params(), {})\",\n \"def test_percent_encode(self):\\n self.gmail_case.set_query_arg('Ladies + Gentlemen')\\n self.assertEqual(self.gmail_case.__repr__(), \\n 'https://www.google.com/search?aqs=chrome..69i57j0l3.9438j0&sourceid=chrome&Ladies%20+%20Gentlemen&q=setter+python&ie=UTF-8&oq=setter+python')\",\n \"def report_old():\\n try:\\n path = flask.request.args['q']\\n except:\\n app.logger.info('Unable to decode valid domains from q GET param')\\n return flask.redirect('/error/1')\\n\\n return flask.redirect('/search/{}'.format(path))\",\n \"def test_append_slash_quoted(self):\\n request = self.rf.get(quote(\\\"/needsquoting#\\\"))\\n r = CommonMiddleware(get_response_404)(request)\\n self.assertEqual(r.status_code, 301)\\n self.assertEqual(r.url, \\\"/needsquoting%23/\\\")\",\n \"def append_query_param(url: str, key: str, value: str) -> str:\\n template = '?' in url and '{}&{}={}' or '{}?{}={}'\\n return template.format(url, key, value)\",\n \"def test_query_sql_injection(self):\\r\\n\\r\\n q = '1%3D1;SELECT%20*%20FROM%20task%20WHERE%201=1'\\r\\n res = self.app.get('/api/task?' + q)\\r\\n error = json.loads(res.data)\\r\\n assert res.status_code == 415, error\\r\\n assert error['action'] == 'GET', error\\r\\n assert error['status'] == 'failed', error\\r\\n assert error['target'] == 'task', error\\r\\n\\r\\n q = 'app_id=1%3D1;SELECT%20*%20FROM%20task%20WHERE%201'\\r\\n res = self.app.get('/api/apappp?' + q)\\r\\n assert res.status_code == 404, res.data\\r\\n\\r\\n q = 'app_id=1%3D1;SELECT%20*%20FROM%20task%20WHERE%201'\\r\\n res = self.app.get('/api/' + q)\\r\\n assert res.status_code == 404, res.data\\r\\n\\r\\n q = 'app_id=1%3D1;SELECT%20*%20FROM%20task%20WHERE%201'\\r\\n res = self.app.get('/api' + q)\\r\\n assert res.status_code == 404, res.data\",\n \"def urlQuote(string):\\r\\n return quote(string.encode(\\\"utf-8\\\"))\",\n \"def sanitizeUrl(url):\\n return url.split('?')[0]\",\n \"def query_string_get(request, name, default_value=_NOT_SET, validator=None):\\n return _XXX_get(request.rel_url.query, name, default_value, validator)\",\n \"def _security_check_parameters(param_dict):\\n for key, value in param_dict.iteritems():\\n str_value = str(value) # Could easily be an int or a float\\n for bad_str in [\\\";\\\", \\\"&&\\\", \\\">\\\", \\\"<\\\", \\\"|\\\"]:\\n if bad_str in str_value:\\n raise ValueError(\\\"Rejecting suspicious argument for %s\\\" % key)\",\n \"def urlencode_sl(query_params, allow_func=None):\\n query_params = query_params or {}\\n encoded_pairs = []\\n for k, v in query_params.items():\\n # Keys are also percent-encoded according to OAuth spec.\\n k = percent_encode(unicode_to_utf8(k))\\n if allow_func and not allow_func(k, v):\\n continue\\n elif is_bytes_or_unicode(v):\\n encoded_pairs.append((k, percent_encode(v),))\\n else:\\n if is_sequence(v):\\n # Loop over the sequence.\\n if len(v) > 0:\\n for i in v:\\n encoded_pairs.append((k, percent_encode(i), ))\\n # ``urllib.urlencode()`` doesn't preserve blank lists.\\n # Therefore, we're discarding them.\\n #else:\\n # # Preserve blank list values.\\n # encoded_pairs.append((k, \\\"\\\", ))\\n else:\\n encoded_pairs.append((k, percent_encode(v),))\\n # Sort after encoding according to the OAuth spec.\\n return sorted(encoded_pairs)\",\n \"def _unicode_urlencode(params):\\n if isinstance(params, dict):\\n params = list(params.items())\\n for i, param in enumerate(params):\\n if isinstance(param[1], list):\\n params[i] = (param[0], json.dumps(param[1]),)\\n\\n result = urllib.parse.urlencode([(k, isinstance(v, str) and v.encode('utf-8') or v) for k, v in params])\\n return result\",\n \"def _create_query_str(data):\\n params = []\\n for name, value in data.items():\\n params.append(name + '=' + str(value))\\n\\n return '?' + '&'.join(params)\",\n \"def __init__(self, query_string: str) -> None:\\n super().__init__(parse_qs(query_string))\",\n \"def _quote(uri, options):\\n suri = uri.strip()\\n for c in _warnChars:\\n if suri.find(c) != -1:\\n if options != None:\\n options.comment_graph.add_warning('Unusual character in uri:%s; possible error?' % suri)\\n break\\n return urllib.quote(suri, _unquotedChars)\",\n \"def use_request_params(self, request):\\r\\n if request.params is None:\\r\\n return False\\r\\n\\r\\n if isinstance(request.params, (port.text_type, port.binary_type)):\\r\\n return False\\r\\n\\r\\n return True\",\n \"def _escape_url(url, force_https=True):\\n scheme, netloc, path, query, unused_fragment = urlparse.urlsplit(url)\\n if force_https:\\n scheme = 'https'\\n path = urllib.quote(path)\\n query = urllib.quote_plus(query, '=?&;')\\n return urlparse.urlunsplit((scheme, netloc, path, query, unused_fragment))\",\n \"def make_url_safe(self, url):\\n return url.replace(' ', '%20')\\\\\\n .replace('(', '%28')\\\\\\n .replace(')', '%29')\\\\\\n .replace('\\\"', '%22')\",\n \"def urldecode(val):\\n return urllib.unquote_plus(val)\",\n \"def cleaned_string(val):\\r\\n return urllib.quote_plus(smart_str(val))\",\n \"def normalize_params(url, params):\\n # parse the url\\n parse = urlparse(url)\\n\\n # Get the query list\\n qs_list = parse_qsl(parse.query, keep_blank_values=True)\\n must_encode = False if parse.query == urllib.parse.unquote(parse.query) else True\\n if params is None:\\n combined_list = qs_list\\n else:\\n # Needs to be encoded before sorting\\n combined_list = [encode_pair(must_encode, key, value) for (key, value) in list(qs_list)]\\n combined_list += params.items()\\n\\n encoded_list = [\\\"%s=%s\\\" % (key, value) for (key, value) in combined_list]\\n sorted_list = sorted(encoded_list, key=lambda x: x)\\n\\n return \\\"&\\\".join(sorted_list)\",\n \"def use_request_params(self, request):\\r\\n if request.params is None:\\r\\n return False\\r\\n\\r\\n # GET parameters get appended to the URL, so they're used\\r\\n if request.method.upper() in http.URLENCODE_METHODS:\\r\\n return True\\r\\n\\r\\n if request.method.upper() != 'POST':\\r\\n return False\\r\\n\\r\\n if isinstance(request.params, (port.text_type, port.binary_type)):\\r\\n return False\\r\\n\\r\\n return True\",\n \"def test_clean_query_params(self):\\n original_query_params = {\\n \\\"name\\\": \\\"FAKE-NAME\\\",\\n \\\"hostname\\\": \\\"FAKE-HOSTNAME\\\",\\n \\\"version\\\": None,\\n }\\n\\n cleaned_query_params = {\\\"name\\\": \\\"FAKE-NAME\\\", \\\"hostname\\\": \\\"FAKE-HOSTNAME\\\"}\\n\\n client = Client()\\n original_query_params = client._clean_query_params(original_query_params)\\n assert original_query_params == cleaned_query_params\",\n \"def _sanitizeEnv(self, environ):\\n reqUri = None\\n if environ.has_key('REQUEST_URI'):\\n reqUri = environ['REQUEST_URI'].split('?', 1)\\n\\n # Ensure QUERY_STRING exists\\n if not environ.has_key('QUERY_STRING') or not environ['QUERY_STRING']:\\n if reqUri is not None and len(reqUri) > 1:\\n environ['QUERY_STRING'] = reqUri[1]\\n else:\\n environ['QUERY_STRING'] = ''\\n\\n # Check WSGI_SCRIPT_NAME\\n scriptName = environ.get('WSGI_SCRIPT_NAME')\\n if scriptName is None:\\n scriptName = self.scriptName\\n else:\\n warnings.warn('WSGI_SCRIPT_NAME environment variable for scgi '\\n 'servers is deprecated',\\n DeprecationWarning)\\n if scriptName.lower() == 'none':\\n scriptName = None\\n\\n if scriptName is None:\\n # Do nothing (most likely coming from cgi2scgi)\\n return\\n\\n if scriptName is NoDefault:\\n # Pull SCRIPT_NAME/PATH_INFO from environment, with empty defaults\\n if not environ.has_key('SCRIPT_NAME'):\\n environ['SCRIPT_INFO'] = ''\\n if not environ.has_key('PATH_INFO') or not environ['PATH_INFO']:\\n if reqUri is not None:\\n environ['PATH_INFO'] = reqUri[0]\\n else:\\n environ['PATH_INFO'] = ''\\n else:\\n # Configured scriptName\\n warnings.warn('Configured SCRIPT_NAME is deprecated\\\\n'\\n 'Do not use WSGI_SCRIPT_NAME or the scriptName\\\\n'\\n 'keyword parameter -- they will be going away',\\n DeprecationWarning)\\n\\n value = environ['SCRIPT_NAME']\\n value += environ.get('PATH_INFO', '')\\n if not value.startswith(scriptName):\\n self.logger.warning('scriptName does not match request URI')\\n\\n environ['PATH_INFO'] = value[len(scriptName):]\\n environ['SCRIPT_NAME'] = scriptName\",\n \"def urlencode(path):\\n return urllib.quote_plus(path)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65669465","0.65147066","0.6183156","0.6004749","0.5999434","0.5922218","0.59101033","0.5864199","0.5864199","0.57987845","0.57948476","0.5750507","0.57338244","0.5732014","0.5732014","0.57237566","0.5696393","0.5689057","0.56888187","0.5682486","0.56790143","0.56397206","0.5602477","0.56007594","0.5575577","0.55524135","0.55426294","0.5541775","0.5521118","0.5500689","0.54859823","0.5482594","0.54785377","0.54785305","0.5474609","0.54578805","0.54408354","0.5427969","0.5417609","0.5417609","0.5415125","0.5407694","0.5406467","0.5405769","0.5403444","0.5379285","0.53626364","0.5359116","0.5340919","0.5338104","0.5315874","0.5284611","0.52832323","0.5257469","0.5253044","0.525008","0.5243808","0.5243808","0.52375615","0.52313614","0.52242035","0.52047855","0.5193759","0.5152035","0.5142769","0.51405865","0.5137453","0.50907505","0.5089009","0.5079872","0.50773996","0.5077359","0.50749576","0.50717854","0.5059754","0.505878","0.5056406","0.50525254","0.5050179","0.5047445","0.50461286","0.504265","0.50399196","0.5017479","0.5016801","0.50145555","0.5013981","0.4999343","0.49667865","0.49651396","0.49630457","0.4958982","0.4958007","0.4955613","0.49516502","0.4949368","0.4936993","0.49186963","0.49161184","0.49095622","0.4908745"],"string":"[\n \"0.65669465\",\n \"0.65147066\",\n \"0.6183156\",\n \"0.6004749\",\n \"0.5999434\",\n \"0.5922218\",\n \"0.59101033\",\n \"0.5864199\",\n \"0.5864199\",\n \"0.57987845\",\n \"0.57948476\",\n \"0.5750507\",\n \"0.57338244\",\n \"0.5732014\",\n \"0.5732014\",\n \"0.57237566\",\n \"0.5696393\",\n \"0.5689057\",\n \"0.56888187\",\n \"0.5682486\",\n \"0.56790143\",\n \"0.56397206\",\n \"0.5602477\",\n \"0.56007594\",\n \"0.5575577\",\n \"0.55524135\",\n \"0.55426294\",\n \"0.5541775\",\n \"0.5521118\",\n \"0.5500689\",\n \"0.54859823\",\n \"0.5482594\",\n \"0.54785377\",\n \"0.54785305\",\n \"0.5474609\",\n \"0.54578805\",\n \"0.54408354\",\n \"0.5427969\",\n \"0.5417609\",\n \"0.5417609\",\n \"0.5415125\",\n \"0.5407694\",\n \"0.5406467\",\n \"0.5405769\",\n \"0.5403444\",\n \"0.5379285\",\n \"0.53626364\",\n \"0.5359116\",\n \"0.5340919\",\n \"0.5338104\",\n \"0.5315874\",\n \"0.5284611\",\n \"0.52832323\",\n \"0.5257469\",\n \"0.5253044\",\n \"0.525008\",\n \"0.5243808\",\n \"0.5243808\",\n \"0.52375615\",\n \"0.52313614\",\n \"0.52242035\",\n \"0.52047855\",\n \"0.5193759\",\n \"0.5152035\",\n \"0.5142769\",\n \"0.51405865\",\n \"0.5137453\",\n \"0.50907505\",\n \"0.5089009\",\n \"0.5079872\",\n \"0.50773996\",\n \"0.5077359\",\n \"0.50749576\",\n \"0.50717854\",\n \"0.5059754\",\n \"0.505878\",\n \"0.5056406\",\n \"0.50525254\",\n \"0.5050179\",\n \"0.5047445\",\n \"0.50461286\",\n \"0.504265\",\n \"0.50399196\",\n \"0.5017479\",\n \"0.5016801\",\n \"0.50145555\",\n \"0.5013981\",\n \"0.4999343\",\n \"0.49667865\",\n \"0.49651396\",\n \"0.49630457\",\n \"0.4958982\",\n \"0.4958007\",\n \"0.4955613\",\n \"0.49516502\",\n \"0.4949368\",\n \"0.4936993\",\n \"0.49186963\",\n \"0.49161184\",\n \"0.49095622\",\n \"0.4908745\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":77685,"cells":{"query":{"kind":"string","value":"A strategy that creates `Case` instances. Explicit `path_parameters`, `headers`, `cookies`, `query`, `body` arguments will be used in the resulting `Case` object."},"document":{"kind":"string","value":"def get_case_strategy( # pylint: disable=too-many-locals\n draw: Callable,\n endpoint: Endpoint,\n hooks: Optional[HookDispatcher] = None,\n feedback: Optional[Feedback] = None,\n data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),\n path_parameters: Any = NOT_SET,\n headers: Any = NOT_SET,\n cookies: Any = NOT_SET,\n query: Any = NOT_SET,\n body: Any = NOT_SET,\n) -> Any:\n to_strategy = {DataGenerationMethod.positive: make_positive_strategy}[data_generation_method]\n\n context = HookContext(endpoint)\n\n if path_parameters is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"path\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"path\")\n path_parameters = draw(strategy)\n if headers is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"header\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"header\")\n headers = draw(strategy)\n if cookies is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"cookie\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"cookie\")\n cookies = draw(strategy)\n if query is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"query\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"query\")\n query = draw(strategy)\n\n media_type = None\n if body is NOT_SET:\n if endpoint.body:\n parameter = draw(st.sampled_from(endpoint.body.items))\n strategy = _get_body_strategy(parameter, to_strategy)\n media_type = parameter.media_type\n body = draw(strategy)\n else:\n media_types = endpoint.get_request_payload_content_types() or [\"application/json\"]\n # Take the first available media type.\n # POSSIBLE IMPROVEMENT:\n # - Test examples for each available media type on Open API 2.0;\n # - On Open API 3.0, media types are explicit, and each example has it. We can pass `OpenAPIBody.media_type`\n # here from the examples handling code.\n media_type = media_types[0]\n if endpoint.schema.validate_schema and endpoint.method.upper() == \"GET\" and endpoint.body:\n raise InvalidSchema(\"Body parameters are defined for GET request.\")\n return Case(\n endpoint=endpoint,\n feedback=feedback,\n media_type=media_type,\n path_parameters=path_parameters,\n headers=headers,\n cookies=cookies,\n query=query,\n body=body,\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def request_case(self, casenum, case):\n # Anonymous or authenticated session?\n is_mod_request = case['method'].upper() in self.modification_methods\n needs_user = case.get('user', is_mod_request)\n if needs_user:\n session = self.user_session\n else:\n session = requests\n\n # Setup request\n requester = getattr(session, case['method'].lower())\n full_uri = self.uri(case['endpoint'])\n kwargs = {'allow_redirects': False}\n\n # Setup headers\n headers = {}\n accept = case.get('accept', 'application/vnd.api+json')\n if accept:\n headers['accept'] = accept\n if is_mod_request and self.csrftoken:\n headers['X-CSRFToken'] = self.csrftoken\n if headers:\n kwargs['headers'] = headers\n\n # Add POST data\n if case.get('data'):\n content_type = case.get(\n 'content_type', 'application/vnd.api+json')\n if content_type == 'application/x-www-form-urlencoded':\n kwargs['data'] = case['data']\n else:\n headers['Content-Type'] = content_type\n kwargs['data'] = json.dumps(\n case['data'], indent=4, separators=(',', ': '))\n\n # Make request\n response = requester(full_uri, **kwargs)\n return response","def create_case(\n case_attrs: schemas.CaseBase = Body(...),\n data_file: UploadFile | None = None,\n db: Session = Depends(get_db),\n) -> Any:\n case = crud.case.create(db, obj_in=case_attrs, data_file=data_file)\n case_with_site = crud.case.get_case_with_site(db, id=case.id)\n if not case_with_site:\n # This should never happen.\n raise HTTPException(status_code=400, detail=\"Case not found\")\n (case, site) = case_with_site\n return schemas.CaseWithTaskInfo.get_case_with_task_info(case, site)","def rules_with_cases(cls, search_pattern: str, CaseEnum: Type[TCaseEnum], detect_case: Callable[[Match], TCaseEnum], rules: Callable[[TCaseEnum], List[Dict[str, str]]]) -> PhonTransform:\n cases: List[TCaseEnum] = list(CaseEnum)\n rule_dict = {case: {k: v for rule in rules(case) for k, v in rule.items()} for case in cases}\n sub_func = lambda match: rule_dict[detect_case(match)][match['key']]\n return cls(search_pattern, sub_func)","def create(self, data):\n\t\tassert isinstance(data, dict), 'The data type must be a dictionary'\n\t\tassert data, 'Case data must not be an empty dictionary'\n\n\t\turl = f'{self.root.url}/api/v1.2/cases'\n\t\tdata = json.dumps(data)\n\t\treturn self.root.r('POST', url, data, headers=None, verify=self.root.verify)","def parse(self, case: Case, response: GenericResponse) -> ParsedData:\n context = expressions.ExpressionContext(case=case, response=response)\n parameters = {\n parameter: expressions.evaluate(expression, context) for parameter, expression in self.parameters.items()\n }\n return ParsedData(\n parameters=parameters,\n # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#link-object\n # > A literal value or {expression} to use as a request body when calling the target operation.\n # In this case all literals will be passed as is, and expressions will be evaluated\n body=expressions.evaluate(self.request_body, context),\n )","def __init__(self, case, timezone=pytz.UTC, override_user_id=None):\n self.case = case\n self.timezone = timezone\n self.override_user_id = override_user_id","def __init__(self, case, timezone=pytz.UTC, override_user_id=None):\n self.case = case\n self.timezone = timezone\n self.override_user_id = override_user_id","def __init__(self, case, subject, negated = False):\n self.case = case\n self.results = case.results\n self.subject = subject\n self.negated = negated\n self.meaning = \"should not\" if negated else \"should\"\n\n # set by corresponding assertion methods\n self.verb = None\n self.object = None # the right-hand sided second argument\n self.done = False\n self.success = True # no meaning while done = False, just optimism","def case(self, case_id, is_external=False):\r\n return cases.Case(self, case_id, is_external)","def setCaseStrategy(self, strategy):\n return self._set(caseStrategy=strategy)","def setCaseStrategy(self, strategy):\n return self._set(caseStrategy=strategy)","def from_args(self, headers=None, url=None, filename=None, body=None):\n cls = Response\n if headers is not None:\n cls = self.from_headers(headers)\n if cls is Response and url is not None:\n cls = self.from_filename(url)\n if cls is Response and filename is not None:\n cls = self.from_filename(filename)\n if cls is Response and body is not None:\n cls = self.from_body(body)\n return cls","def from_case(case, outputContents):\n return KnownCase(case.caseType, case.problemNumber, case.caseNumber,\n case.inputContents, outputContents)","def make(self, **kwargs):\n raise NotImplementedError","def __init__(self, response_data: Any, **kwargs) -> None:\r\n self.case_check = case_check(settings.CASE)\r\n self.ignored_keys = set_ignored_keys(**kwargs)\r\n if isinstance(response_data, dict):\r\n self.test_dict(response_data)\r\n elif isinstance(response_data, list):\r\n self.test_list(response_data)\r\n else:\r\n logger.debug('Skipping case check')","def __init__(self, case, **kwargs):\n SystemTestsCommon.__init__(self, case, **kwargs)","def build_case(case_data, adapter):\n LOG.info(\"build case with id: {0}\".format(case_data[\"case_id\"]))\n case_obj = {\n \"_id\": case_data[\"case_id\"],\n \"display_name\": case_data.get(\"display_name\", case_data[\"case_id\"]),\n }\n\n # Check if institute exists in database\n try:\n institute_id = case_data[\"owner\"]\n except KeyError as err:\n raise ConfigError(\"Case has to have a institute\")\n institute_obj = adapter.institute(institute_id)\n if not institute_obj:\n raise IntegrityError(\"Institute %s not found in database\" % institute_id)\n case_obj[\"owner\"] = case_data[\"owner\"]\n\n # Owner allways has to be part of collaborators\n collaborators = set(case_data.get(\"collaborators\", []))\n collaborators.add(case_data[\"owner\"])\n case_obj[\"collaborators\"] = list(collaborators)\n\n if case_data.get(\"assignee\"):\n case_obj[\"assignees\"] = [case_data[\"assignee\"]]\n\n case_obj[\"smn_tsv\"] = case_data.get(\"smn_tsv\")\n\n # Individuals\n ind_objs = []\n try:\n for individual in case_data.get(\"individuals\", []):\n ind_objs.append(build_individual(individual))\n except Exception as error:\n raise error\n # sort the samples to put the affected individual first\n sorted_inds = sorted(ind_objs, key=lambda ind: -ind[\"phenotype\"])\n case_obj[\"individuals\"] = sorted_inds\n\n now = datetime.now()\n case_obj[\"created_at\"] = now\n case_obj[\"updated_at\"] = now\n\n if case_data.get(\"suspects\"):\n case_obj[\"suspects\"] = case_data[\"suspects\"]\n if case_data.get(\"causatives\"):\n case_obj[\"causatives\"] = case_data[\"causatives\"]\n\n case_obj[\"synopsis\"] = case_data.get(\"synopsis\", \"\")\n\n case_obj[\"status\"] = \"inactive\"\n case_obj[\"is_research\"] = False\n case_obj[\"research_requested\"] = False\n case_obj[\"rerun_requested\"] = False\n\n case_obj[\"lims_id\"] = case_data.get(\"lims_id\", \"\")\n\n analysis_date = case_data.get(\"analysis_date\")\n if analysis_date:\n case_obj[\"analysis_date\"] = analysis_date\n\n # We store some metadata and references about gene panels in 'panels'\n case_panels = case_data.get(\"gene_panels\", [])\n default_panels = case_data.get(\"default_panels\", [])\n panels = []\n\n for panel_name in case_panels:\n panel_obj = adapter.gene_panel(panel_name)\n if not panel_obj:\n LOG.warning(\n \"Panel %s does not exist in database and will not be saved in case document.\"\n % panel_name\n )\n continue\n panel = {\n \"panel_id\": panel_obj[\"_id\"],\n \"panel_name\": panel_obj[\"panel_name\"],\n \"display_name\": panel_obj[\"display_name\"],\n \"version\": panel_obj[\"version\"],\n \"updated_at\": panel_obj[\"date\"],\n \"nr_genes\": len(panel_obj[\"genes\"]),\n }\n if panel_name in default_panels:\n panel[\"is_default\"] = True\n else:\n panel[\"is_default\"] = False\n panels.append(panel)\n\n case_obj[\"panels\"] = panels\n\n case_obj[\"dynamic_gene_list\"] = []\n\n # Meta data\n genome_build = case_data.get(\"genome_build\", \"37\")\n if not genome_build in [\"37\", \"38\"]:\n pass\n\n case_obj[\"genome_build\"] = genome_build\n\n if case_data.get(\"rank_model_version\"):\n case_obj[\"rank_model_version\"] = str(case_data[\"rank_model_version\"])\n\n if case_data.get(\"sv_rank_model_version\"):\n case_obj[\"sv_rank_model_version\"] = str(case_data[\"sv_rank_model_version\"])\n\n if case_data.get(\"rank_score_threshold\"):\n case_obj[\"rank_score_threshold\"] = float(case_data[\"rank_score_threshold\"])\n\n # Cohort information\n if case_data.get(\"cohorts\"):\n case_obj[\"cohorts\"] = case_data[\"cohorts\"]\n # Check if all case cohorts are registered under the institute\n institute_cohorts = set(institute_obj.get(\"cohorts\", []))\n all_cohorts = institute_cohorts.union(set(case_obj[\"cohorts\"]))\n if len(all_cohorts) > len(institute_cohorts):\n # if not, update institute with new cohorts\n LOG.warning(\"Updating institute object with new cohort terms\")\n adapter.institute_collection.find_one_and_update(\n {\"_id\": institute_obj[\"_id\"]}, {\"$set\": {\"cohorts\": list(all_cohorts)}}\n )\n\n # phenotype information\n\n if case_data.get(\"phenotype_terms\"):\n phenotypes = []\n for phenotype in case_data[\"phenotype_terms\"]:\n phenotype_obj = adapter.hpo_term(phenotype)\n if phenotype_obj is None:\n LOG.warning(\n f\"Could not find term with ID '{phenotype}' in HPO collection, skipping phenotype term.\"\n )\n continue\n\n phenotypes.append(\n {\"phenotype_id\": phenotype, \"feature\": phenotype_obj.get(\"description\")}\n )\n if phenotypes:\n case_obj[\"phenotype_terms\"] = phenotypes\n\n # phenotype groups\n if case_data.get(\"phenotype_groups\"):\n phenotype_groups = []\n for phenotype in case_data[\"phenotype_groups\"]:\n phenotype_obj = build_phenotype(phenotype, adapter)\n if phenotype_obj:\n phenotype_groups.append(phenotype_obj)\n if phenotype_groups:\n case_obj[\"phenotype_groups\"] = phenotype_groups\n\n # Files\n case_obj[\"madeline_info\"] = case_data.get(\"madeline_info\")\n\n case_obj[\"custom_images\"] = case_data.get(\"custom_images\")\n\n for report_key in [report.get(\"key_name\") for report in CUSTOM_CASE_REPORTS.values()]:\n if report_key in case_data:\n case_obj[report_key] = case_data.get(report_key)\n\n case_obj[\"vcf_files\"] = case_data.get(\"vcf_files\", {})\n case_obj[\"delivery_report\"] = case_data.get(\"delivery_report\")\n\n _populate_pipeline_info(case_obj, case_data)\n\n case_obj[\"has_svvariants\"] = bool(\n case_obj[\"vcf_files\"].get(\"vcf_sv\") or case_obj[\"vcf_files\"].get(\"vcf_sv_research\")\n )\n\n case_obj[\"has_strvariants\"] = bool(case_obj[\"vcf_files\"].get(\"vcf_str\"))\n\n case_obj[\"has_meivariants\"] = bool(case_obj[\"vcf_files\"].get(\"vcf_mei\"))\n\n case_obj[\"is_migrated\"] = False\n\n # What experiment is used, alternatives are rare (rare disease) or cancer\n case_obj[\"track\"] = case_data.get(\"track\", \"rare\")\n\n case_obj[\"group\"] = case_data.get(\"group\", [])\n\n return case_obj","def _get_case_data(arg=None,\n project_name=None, fields=None, size=get_setting_value('DEFAULT_SIZE'), page=1,\n data_category=None, query_args={}, verify=False, **kwargs):\n return get_data(endpoint='cases', arg=arg, project_name=project_name, fields=fields, size=size,\n page=page, data_category=data_category, query_args=query_args,\n verify=verify, **kwargs)","def setUp(self):\n # Scheme, host, path\n self.ftp_case = uri.URI.parse_uri('ftp://ftp.is.co.za/rfc/rfc1808.txt')\n # Scheme, ipv6, path, query\n self.ldap_case = uri.URI.parse_uri(\n 'ldap://[2001:db8::7]/c=GB?objectClass?one')\n # Path, nothing else\n self.news_case = uri.URI.parse_uri(\n \"news:comp.infosystems.www.servers.unix\")\n # Path with scheme\n self.urn_case = uri.URI.parse_uri(\n \"urn:oasis:names:specification:docbook:dtd:xml:4.1.2\")\n # Path with scheme and port\n self.telnet_case = uri.URI.parse_uri(\"telnet://192.0.2.16:80/\")\n # Scheme, authority, path, query, fragment\n self.foo_case = uri.URI.parse_uri(\n \"foo://herp@example.com:8042/over/there?name=ferret#nose\") \n self.sld_case = uri.URI.parse_uri(\n \"http://www.amazon.co.uk/search/product_page?id=52342\")\n # Scheme, host, path, query, fragment\n self.gmail_case = uri.URI.parse_uri(\n 'https://www.google.com/search?q=setter+python&oq=setter+python&aqs=chrome..69i57j0l3.9438j0&sourceid=chrome&ie=UTF-8')\n # Same as the above, but from direct initialization\n self.gmail_case_from_init = uri.URI(\n path='/search', scheme='https', authority='www.google.com', \n query='q=setter+python&oq=setter+python&aqs=chrome..69i57j0l3.9438j0&sourceid=chrome&ie=UTF-8')\n # Pure path with dot segments\n self.dot_case = uri.URI(path='/a/b/c/./../../g')\n # Another pure path with dot segments\n self.dot_case2 = uri.URI(path='mid/content=5/../6')\n # A more complete IPV6 sample, with a port\n self.sample_ipv6_case = uri.URI.parse_uri(\n 'http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html')\n # An example with a percent-encoded authority\n self.percent_host = uri.URI(authority='herp%2fballoon', scheme='ftP')","def __init__(self, parms, body, env):\n self.parms = parms\n self.body = body\n self.env = env","def __init__(self, name, method, url, headers={}, auth=None, body=None, expected_status=None, expected_body=None):\n \n self.name = name\n self.method = method\n self.url = url\n self.headers = headers\n self.auth = auth\n self.body = body\n self.expected_status = expected_status\n self.expected_body = expected_body","def __init__(\n self,\n store: Store,\n hk_api: HousekeeperAPI,\n case_tags: List[Set[str]],\n sample_tags: List[Set[str]],\n project_base_path: Path,\n delivery_type: str,\n force_all: bool = False,\n ignore_missing_bundles: bool = False,\n ):\n self.store = store\n self.hk_api = hk_api\n self.project_base_path: Path = project_base_path\n self.case_tags: List[Set[str]] = case_tags\n self.all_case_tags: Set[str] = {tag for tags in case_tags for tag in tags}\n self.sample_tags: List[Set[str]] = sample_tags\n self.customer_id: str = \"\"\n self.ticket: str = \"\"\n self.dry_run = False\n self.delivery_type: str = delivery_type\n self.skip_missing_bundle: bool = (\n self.delivery_type in constants.SKIP_MISSING or ignore_missing_bundles\n )\n self.deliver_failed_samples = force_all","def set_data(self, case: Case, **kwargs: Any) -> None:\n context = kwargs[\"context\"]\n self.set_parameters(case, context)\n self.set_body(case, context)\n case.set_source(context.response, context.case)","def gen_case(self, stmt: statements.Case) -> None:\n block = self.builder.new_block()\n assert self.switch_options is not None\n value = self.context.eval_expr(stmt.value)\n if value in self.switch_options:\n self.error(\"Case defined multiple times\", stmt.location)\n self.switch_options[value] = block\n self.builder.emit_jump(block) # fall through\n self.builder.set_block(block)\n self.gen_stmt(stmt.statement)","def prepare_case(infos: CaseInfos):\n case = GraphVisualizerCase()\n\n case.connected = infos.connected\n\n case.set_central_text(infos.centered_text)\n\n case.set_bottom_left_text(infos.bot_left_text)\n case.set_bottom_rigth_text(infos.bot_right_text)\n case.set_top_left_text(infos.top_left_text)\n case.set_top_right_text(infos.top_right_text)\n if infos.border_width != 0:\n case.set_central_border(infos.border_width)\n\n return case","def create_test_instance(cls, **kwargs):\n # create a instance with random parameters\n obj = super(LibraryBinaryNumeric, cls).create_test_instance(**kwargs)\n # choose an optimal interaction matrix\n obj.choose_sensitivity_matrix('auto')\n return obj","def when(self, case_expr, result_expr) -> Self:\n cases = self.cases + (case_expr,)\n results = self.results + (result_expr,)\n return self.copy(cases=cases, results=results)","def __init__(self, schema: dict, **kwargs) -> None:\r\n self.case_check = case_check(settings.CASE)\r\n self.ignored_keys = set_ignored_keys(**kwargs)\r\n if read_type(schema) == 'object':\r\n logger.debug('root -> dict')\r\n self.test_dict(schema)\r\n elif read_type(schema) == 'array':\r\n logger.debug('root -> list')\r\n self.test_list(schema)\r\n else:\r\n logger.debug('Skipping case check')","def create(\n self, name, subject=None, assignee=None, description=None, findings=None\n ):\n return self._cases_service.create(\n name,\n subject=subject,\n assignee=assignee,\n description=description,\n findings=findings,\n )","def __createCovidModelInstance(self, *args, **kwargs):\n try:\n if 'MODEL_TYPE' in kwargs:\n if kwargs['MODEL_TYPE'] == CovidModel.AGGREGATE_CASES_DECEASED:\n covidModel = CovidAggregateTotals() \n self.CovidData = covidModel.getData(*args,**kwargs)\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\n return \n \n if kwargs['MODEL_TYPE'] == CovidModel.MONTHLY_CASES_DECEASED:\n covidModel = CovidMonthlyTotals() \n self.CovidData = covidModel.getData(*args,**kwargs)\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\n return \n\n if kwargs['MODEL_TYPE'] == CovidModel.PAST_30_DAYS:\n covidModel = CovidDailyTotals() \n self.CovidData = covidModel.getData(*args,**kwargs)\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\n return \n\n if kwargs['MODEL_TYPE'] == CovidModel.MESSAGES:\n covidModel = CovidMessages() \n self.CovidData = covidModel.getData(*args,**kwargs)\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\n return\n\n if kwargs['MODEL_TYPE'] == CovidModel.LOCATIONS:\n covidModel = CovidLocationInfo() \n self.CovidData = covidModel.getData(*args,**kwargs)\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\n return\n\n print (\"CovidMessages.__createCovidModelInstance() - did not receive a recognizable model type - no model object instantiated. Args received = \",kwargs)\n return None\n except:\n print (\"CovidMessages.__createCovidModelInstance() - unexpected error: \",sys.exc_info()[0])\n return None","def __init__(self, headers=None, body=None, status=None,\n request_headers={}):\n self.headers = headers\n self.body = body\n self.status_code = status\n self.request = mock.Mock()\n self.request.headers = request_headers","def create(self, *args, **kwargs):\n factory = self.factory\n\n kwargs = coalesce_options(dict(kwargs),\n self.option_types)\n\n return factory(*args, **kwargs)","def get_or_create_test_case(\n self,\n test_case_fqn: str,\n entity_link: Optional[str] = None,\n test_suite_fqn: Optional[str] = None,\n test_definition_fqn: Optional[str] = None,\n test_case_parameter_values: Optional[str] = None,\n ):\n test_case = self.get_by_name(entity=TestCase, fqn=test_case_fqn, fields=[\"*\"])\n\n if test_case:\n return test_case\n\n logger.info(\n f\"TestCase {test_case_fqn} not found. Creating TestCase {test_case_fqn}\"\n )\n\n test_case = self.create_or_update(\n CreateTestCaseRequest(\n name=test_case_fqn.split(\".\")[-1],\n entityLink=entity_link,\n testSuite=self.get_entity_reference(\n entity=TestSuite,\n fqn=test_suite_fqn,\n ),\n testDefinition=self.get_entity_reference(\n entity=TestDefinition,\n fqn=test_definition_fqn,\n ),\n parameterValues=test_case_parameter_values,\n )\n )\n return test_case","def _instantiate(cls, **kwargs):\n return cls(**kwargs)","def make_object(obj, kwargs):\n return obj(**kwargs)","def splits(cls, **kwargs):\n kwargs_copy = {x: y for x, y in kwargs.items()}\n if 'mode' not in kwargs:\n kwargs_copy['mode'] = 'answer'\n train = cls(split='train', **kwargs_copy)\n val = cls(split='val', **kwargs_copy)\n # test = cls(split='test', **kwargs_copy)\n return train, val","def factory_method(self):\n pass","def factory_method(self):\n pass","def __init__(self, case_file_path, session_file_path):\n try:\n self.df_cases = pd.read_csv(case_file_path)\n except FileNotFoundError:\n print(\"Case data not found.\")\n\n try:\n self.df_sessions = pd.read_csv(session_file_path)\n except FileNotFoundError:\n print(\"Session data not found\")\n\n self.model = self.create_model()","def create_from_request(cls, request: HttpRequest) -> BaseContext:\n\n return cast(\n BaseContext,\n cls.objects.create(\n performed_by_id=getattr(request.user, \"id\", None),\n context_type=\"http-request\",\n context={\n \"method\": request.method,\n \"path\": request.path,\n \"query_params\": {\n key: request.GET.getlist(key) for key in request.GET\n },\n },\n ),\n )","def create_request(params={}, path='/', method='POST'):\n request = DummyRequest(path)\n request.method = method\n request.args = params\n return request","def __init__(self, traffic_obj):\n self.request, self.response = traffic_obj[0], traffic_obj[1]\n self.param_dict = {}\n self.reflect = []","def __new__(cls, *, required = ..., step_type = ..., title = ..., values= ...):\n # required\n if required is ...:\n required = False\n else:\n required = validate_required(required)\n \n # title\n if title is ...:\n title = ''\n else:\n title = validate_title(title)\n \n # step_type\n if step_type is ...:\n step_type = VerificationScreenStepType.rules\n else:\n step_type = validate_type(step_type)\n \n # values\n if values is ...:\n values = None\n else:\n values = validate_values(values)\n \n # Construct\n self = object.__new__(cls)\n self.required = required\n self.title = title\n self.type = step_type\n self.values = values\n return self","def __init__(self, segments, lemma = None, case = None):\n self.segments = segments\n if isinstance(self.segments, str):\n self.segments = [Segment.new_segment(s) for s in self.segments]\n self.lemma = lemma\n self.case = case","def requests_request_factory(method, endpoint, urlargs, data, is_json, headers,\n files, verify_ssl):\n client_func = getattr(requests, method.lower())\n\n if headers is None:\n headers = [('Content-Type', 'application/json')] if is_json else []\n\n if data is not None:\n request_args = dict(\n data=json.dumps(data) if is_json else data,\n headers=dict(headers),\n )\n else:\n request_args = {}\n\n if files is not None:\n request_args['files'] = files\n\n return client_func(\n url_for(\n endpoint,\n _external=True,\n _scheme='https',\n **urlargs\n ),\n verify=verify_ssl,\n **request_args\n )","def cases(\n case_id,\n institute,\n reruns,\n finished,\n causatives,\n research_requested,\n rerun_monitor,\n is_research,\n status,\n within_days,\n json,\n):\n adapter = store\n\n models = []\n if case_id:\n case_obj = adapter.case(case_id=case_id)\n if case_obj:\n models.append(case_obj)\n else:\n LOG.info(\"No case with id {}\".format(case_id))\n\n else:\n models = adapter.cases(\n collaborator=institute,\n reruns=reruns,\n rerun_monitor=rerun_monitor,\n finished=finished,\n has_causatives=causatives,\n research_requested=research_requested,\n is_research=is_research,\n status=status,\n within_days=within_days,\n )\n models = [case_obj for case_obj in models]\n if len(models) == 0:\n LOG.info(\"No cases could be found\")\n\n if json:\n click.echo(json_lib.dumps(models, default=jsonconverter))\n return\n\n for model in models:\n pp(model)","def __init__(self, allow_none=False, excludes=None, request_types=None):\n self.funcs = {}\n self.instance = None\n self.allow_none = allow_none\n if excludes is None:\n self.excludes = []\n else:\n self.excludes = excludes\n if request_types is None:\n self.request_types = ['all']\n else:\n self.request_types = request_types","def test_flow(client, unrestricted_case, elasticsearch):\n # start with case\n response = client.get(api_reverse(\"cases-detail\", args=[unrestricted_case.id]))\n check_response(response)\n content = response.json()\n # onwards to court\n court_url = content.get(\"court\")[\"url\"]\n assert court_url\n response = client.get(court_url)\n check_response(response)\n # onwards to jurisdiction\n jurisdiction_url = content.get(\"jurisdiction\")[\"url\"]\n assert jurisdiction_url\n response = client.get(jurisdiction_url)\n check_response(response)\n content = response.json()\n assert content.get(\"name\") == unrestricted_case.jurisdiction.name","def request_factory() -> RequestFactory:\n\n return RequestFactory()","def __init__(self, *, condition: typing.Optional[\"RoutingRuleCondition\"]=None, host_name: typing.Optional[str]=None, http_redirect_code: typing.Optional[str]=None, protocol: typing.Optional[\"RedirectProtocol\"]=None, replace_key: typing.Optional[\"ReplaceKey\"]=None):\n self._values = {\n }\n if condition is not None: self._values[\"condition\"] = condition\n if host_name is not None: self._values[\"host_name\"] = host_name\n if http_redirect_code is not None: self._values[\"http_redirect_code\"] = http_redirect_code\n if protocol is not None: self._values[\"protocol\"] = protocol\n if replace_key is not None: self._values[\"replace_key\"] = replace_key","def genCase(self, CID, client, rat):\n ret = {\n CID: {\n 'client': client,\n 'rat': rat,\n }\n }\n return (ret)","def create_mock_request_matcher(self, method, path, body_type='JSON', body=None, exact=True):\n req = {}\n req['method'] = method\n req['path'] = path\n\n if body_type == 'JSON' and body:\n match_type = 'STRICT' if exact else 'ONLY_MATCHING_FIELDS'\n req['body'] = {'type': body_type, 'json': json.dumps(body), 'matchType': match_type}\n\n if body_type == 'JSON_SCHEMA' and body:\n if isinstance(body, str):\n json_string = body\n else:\n json_string = json.dumps(body)\n req['body'] = {'type': body_type, 'jsonSchema': json_string}\n\n return req","def make_request(self, environ, **kwargs):\n factory = self.get(abcs.ARequest)\n request = factory(environ, self, **kwargs)\n self._set_request_attributes(request)\n return request","def build(cls, **kwargs):\n return cls(kwargs) #pylint: disable=no-value-for-parameter","def test_get_case_by_id(self):\n pass","def _test_factory(case, dec):\n a, b, q, r, e, s, knownfailure = case\n if knownfailure:\n pytest.xfail(reason=knownfailure)\n\n x = solve_discrete_are(a, b, q, r, e, s)\n if e is None:\n e = np.eye(a.shape[0])\n if s is None:\n s = np.zeros_like(b)\n res = a.conj().T.dot(x.dot(a)) - e.conj().T.dot(x.dot(e)) + q\n res -= (a.conj().T.dot(x.dot(b)) + s).dot(\n solve(r+b.conj().T.dot(x.dot(b)),\n (b.conj().T.dot(x.dot(a)) + s.conj().T)\n )\n )\n assert_array_almost_equal(res, np.zeros_like(res), decimal=dec)","def make(cls, **kwargs):\r\n return cls().fill(**kwargs)","def create_factory(cls, *args):\n raise NotImplementedError","def create(cls, request):\n if isinstance(request, Request):\n request = request.prepare()\n\n # Method\n method = request.method.lower()\n\n # Cookies\n cookie = {}\n if request._cookies is not None:\n # cookies are stored in a cookiejar object\n cookie = request._cookies.get_dict()\n\n # Preparing a request formats the URL with params, strip them out again\n o = urlparse(request.url)\n params = parse_qs(o.query)\n # extract the URL without query parameters\n url = o._replace(query=None).geturl()\n\n # Order matters because all python requests issued from a session\n # include Accept */* which does not necessarily match the content type\n mimetype = request.headers.get(\"Content-Type\") or request.headers.get(\n \"Accept\"\n )\n\n # Headers - request.headers is not an instance of Headers\n # which is expected\n header = Headers(dict(request.headers))\n\n # Body\n # TODO: figure out if request._body_position is relevant\n body = request.body\n\n # Path gets deduced by path finder against spec\n parameters = RequestParameters(\n query=ImmutableMultiDict(params),\n header=header,\n cookie=cookie,\n )\n return OpenAPIRequest(\n full_url_pattern=url,\n method=method,\n parameters=parameters,\n body=body,\n mimetype=mimetype,\n )","def factory(cls, request_type: str, **data: str) -> 'SecretRequest':\n for klass in cls.__subclasses__():\n if klass.slug == request_type:\n return klass(**data)\n raise ValueError('No such request type')","def create(self, obj):\r\n request = http.Request('POST', self.get_url(), self.wrap_object(obj))\r\n\r\n return request, parsers.parse_json","def create_and_exercise(\n self,\n __template_id,\n __payload,\n __choice_name,\n __argument=None,\n *,\n workflow_id=None,\n command_id=None,\n read_as=None,\n act_as=None,\n ):\n raise NotImplementedError","def __init__(\n self,\n settings=None,\n scenario=None,\n living_expenses_strategy=None,\n saving_strategy=None,\n withdrawal_strategy=None,\n tax_treatment=None\n ):\n # Set up instance:\n super().__init__()\n self.default_values = copy(DEFAULTVALUES)\n self.default_types = copy(DEFAULTTYPES)\n self.default_builders = copy(DEFAULTBUILDERS)\n # Store args as attributes:\n # For `settings` specifically, use the default values provided\n # by the class if none are provided explicitly.\n if settings is None:\n self.settings = Settings()\n else:\n self.settings = settings\n # For the rest, None is allowed:\n self.scenario = scenario\n self.living_expenses_strategy = living_expenses_strategy\n self.saving_strategy = saving_strategy\n self.withdrawal_strategy = withdrawal_strategy\n self.tax_treatment = tax_treatment\n # Some params aren't used to build Forecast and so are not\n # received as input to __init__. Create attrs for them here:\n self.allocation_strategy = None","def __init__(self, verbose=False, case_sensitive=False):\n self._verbose = verbose\n self._case_sensitive = case_sensitive","def instantiate_subject(cls, *args, **kwargs) -> Any:\n return cls.subject_type()(*args, **kwargs)","def case(mapper, sources, default_source=None) -> ObservableBase:\n from ..operators.observable.case import case\n return case(mapper, sources, default_source)","def create(cls, **dictionary):\n if cls.__name__ == 'Square':\n object = cls(1)\n object.update(**dictionary)\n return object\n\n if cls.__name__ == 'Rectangle':\n object = cls(1, 2)\n object.update(**dictionary)\n return object","def test_reader_instantiates(self):\n cr = CaseReader(self.filename)\n self.assertTrue(isinstance(cr, HDF5CaseReader), msg='CaseReader not'\n ' returning the correct subclass.')","def _test_factory(case, dec):\n a, b, q, r, knownfailure = case\n if knownfailure:\n pytest.xfail(reason=knownfailure)\n\n x = solve_discrete_are(a, b, q, r)\n res = a.conj().T.dot(x.dot(a)) - x + q\n res -= a.conj().T.dot(x.dot(b)).dot(\n solve(r+b.conj().T.dot(x.dot(b)), b.conj().T).dot(x.dot(a))\n )\n assert_array_almost_equal(res, np.zeros_like(res), decimal=dec)","def make_case_el(case, header_els, opinions):\n case_el = renderer.make_case_el(case)\n case_el.text = \"\\n\"\n\n # head matter\n head_el = renderer.make_opinion_el({'type': 'head'})\n if header_els:\n head_el.text = \"\\n\"\n head_el.extend(header_els)\n case_el.append(head_el)\n # opinions\n for opinion_els in opinions:\n\n # add body to case\n if opinion_els:\n opinion_type = opinion_els[0].attrib.pop('opinion-type', 'majority')\n else:\n opinion_type = 'majority'\n body_el = renderer.make_opinion_el({'type': opinion_type})\n if opinion_els:\n body_el.text = \"\\n\"\n body_el.extend(opinion_els)\n case_el.append(body_el)\n return case_el","def __init__(__self__, *,\n creation_time: Optional[pulumi.Input['TimestampArgs']] = None,\n output: Optional[pulumi.Input['FileReferenceArgs']] = None,\n test_case: Optional[pulumi.Input['TestCaseReferenceArgs']] = None):\n if creation_time is not None:\n pulumi.set(__self__, \"creation_time\", creation_time)\n if output is not None:\n pulumi.set(__self__, \"output\", output)\n if test_case is not None:\n pulumi.set(__self__, \"test_case\", test_case)","def _test_factory(case, dec):\n a, b, q, r, e, s, knownfailure = case\n if knownfailure:\n pytest.xfail(reason=knownfailure)\n\n x = solve_continuous_are(a, b, q, r, e, s)\n res = a.conj().T.dot(x.dot(e)) + e.conj().T.dot(x.dot(a)) + q\n out_fact = e.conj().T.dot(x).dot(b) + s\n res -= out_fact.dot(solve(np.atleast_2d(r), out_fact.conj().T))\n assert_array_almost_equal(res, np.zeros_like(res), decimal=dec)","def test_params(self):\n cr = CaseReader(self.filename)\n last_case = cr.get_case(-1)\n self.assertIsNone(last_case.parameters,\n \"Case erroneously contains parameters.\")","def _test_factory(case, dec):\n a, b, q, r, knownfailure = case\n if knownfailure:\n pytest.xfail(reason=knownfailure)\n\n x = solve_continuous_are(a, b, q, r)\n res = x.dot(a) + a.conj().T.dot(x) + q\n out_fact = x.dot(b)\n res -= out_fact.dot(solve(np.atleast_2d(r), out_fact.conj().T))\n assert_array_almost_equal(res, np.zeros_like(res), decimal=dec)","def create(self, **kwargs):\n url_str = self.base_url\n newheaders = self.get_headers()\n payload = kwargs['definition']\n resp, body = self.client.json_request('POST', url_str,\n data=payload,\n headers=newheaders)\n return resp","def cases(cases_):\n\n def wrapper(func):\n def inner(*args):\n for case in cases_:\n new_args = args + (case if (isinstance(case, tuple)) else (case,))\n func(*new_args)\n\n return inner\n\n return wrapper","def create(cls, **kwargs):\n return cls().requests.post('plan', data=kwargs)","def sow_cases(\n self,\n fn_args,\n cases,\n combos=None,\n constants=None,\n verbosity=1,\n batchsize=None,\n num_batches=None,\n ):\n if batchsize is not None:\n self.batchsize = batchsize\n if num_batches is not None:\n self.num_batches = num_batches\n\n fn_args = parse_fn_args(self._fn, fn_args)\n cases = parse_cases(cases, fn_args)\n constants = self.parse_constants(constants)\n\n self.choose_batch_settings(combos=combos, cases=cases)\n self.prepare(fn_args=fn_args, combos=combos, cases=cases)\n\n with Sower(self) as sow_fn:\n case_runner(\n fn=sow_fn,\n fn_args=fn_args,\n cases=cases,\n combos=combos,\n constants=constants,\n verbosity=verbosity,\n parse=False,\n )","def __call__(self):\n return self.cls(**self.kwargs)","def setParameters(self, case_name, email, password, results, message):\n self.case_name = str(case_name)\n self.email = str(email)\n self.password = str(password)\n self.results = str(results)\n self.message = str(message)","def __init__(self, case, image_id, image, json=False, config_file=None):\n super().__init__()\n self.case = case\n self.config = dfdewey_config.load_config(config_file)\n self.opensearch = None\n self.image = image\n self.image_id = image_id\n self.images = {}\n self.json = json\n self.postgresql = None\n self.scanner = None\n\n if self.config:\n self.postgresql = PostgresqlDataStore(\n host=self.config.PG_HOST, port=self.config.PG_PORT,\n db_name=self.config.PG_DB_NAME)\n self.opensearch = OpenSearchDataStore(\n host=self.config.OS_HOST, port=self.config.OS_PORT,\n url=self.config.OS_URL)\n else:\n self.postgresql = PostgresqlDataStore()\n self.opensearch = OpenSearchDataStore()\n\n if image != 'all':\n self.image = os.path.abspath(self.image)\n image_hash = self.postgresql.get_image_hash(self.image_id)\n if image_hash:\n self.images[image_hash] = self.image\n else:\n self.images = self.postgresql.get_case_images(self.case)","def __init__(self, method, protocol, host, port, path, auth_path,\r\n params, headers, body):\r\n self.method = method\r\n self.protocol = protocol\r\n self.host = host\r\n self.port = port\r\n self.path = path\r\n if auth_path is None:\r\n auth_path = path\r\n self.auth_path = auth_path\r\n self.params = params\r\n # chunked Transfer-Encoding should act only on PUT request.\r\n if headers and 'Transfer-Encoding' in headers and \\\r\n headers['Transfer-Encoding'] == 'chunked' and \\\r\n self.method != 'PUT':\r\n self.headers = headers.copy()\r\n del self.headers['Transfer-Encoding']\r\n else:\r\n self.headers = headers\r\n self.body = body","def _make_request(self, payload, headers=None):\n pathparts = REQ_PATH.split(b\"/\")\n if pathparts[0] == b\"\":\n pathparts = pathparts[1:]\n dreq = DummyRequest(pathparts)\n dreq.requestHeaders = Headers(headers or {})\n dreq.responseCode = 200 # default to 200\n\n if isinstance(payload, dict):\n payload = json.dumps(payload)\n\n dreq.content = BytesIO(payload.encode())\n dreq.method = \"POST\"\n\n return dreq","def __new__(cls,name,description,args_in,required=True,data_type=None,schema=None):\n mydict={\n \"name\":name,\n \"description\":description,\n \"in\":args_in,\n \"required\":required,\n \"schema\":schema,\n \"type\":data_type,\n }\n if args_in!=\"body\":\n mydict[\"type\"]=data_type\n return mydict","def createRequest(self, **kwargs):\n for k,v in kwargs.items():\n self.request[\"content\"][k] = v\n \n return self.request","def makeTraffic(key, *opts):\n cls = TRAFFIC_CTORS.get(key, None)\n if cls is None:\n raise KeyError('unknown traffic key')\n\n try:\n return cls(*opts)\n except TypeError:\n raise IndexError('traffic ' + key + ' expects arguments: ' + cls.ARGUMENTS_DESCRIPTION)","def make_context(self, args, **kwargs):\n #The following headers will be available from Auth filter:\n #'X-Tenant-Id', 'X-Tenant-Name', 'X-User-Id',\n #'X-User-Name', 'X-Roles'\n context_params = {'auth_tok' : args.headers['X-Auth-Token'],\n 'user' : args.headers['X-User-Id'],\n 'tenant' : args.headers['X-Tenant-Id'] }\n\n LOG.debug(\"Building context with params: %s\" % context_params)\n \n return ReddwarfContext(**context_params)","def _create_request_context(self, *args, **kwargs) -> Context:\n return Context()","def new(cls, **kwargs):\n return cls(**kwargs)","def build_context_behavior(forensics_data: dict) -> dict:\n return assign_params(\n Path=forensics_data.get('path'),\n URL=forensics_data.get('url'),\n )","def test_constructor_is_nt_so_all_args_work(self):\n u1 = url.URL(\n \"somedriver\",\n \"user\",\n \"secret\",\n \"10.20.30.40\",\n 1234,\n \"DB\",\n {\"key\": \"value\"},\n )\n eq_(\n u1,\n url.make_url(\n \"somedriver://user:secret@10.20.30.40:1234/DB?key=value\"\n ),\n )","def create(cls, fn: Callable[[DurableEntityContext], None]) -> Callable[[Any], str]:\n def handle(context) -> str:\n # It is not clear when the context JSON would be found\n # inside a \"body\"-key, but this pattern matches the\n # orchestrator implementation, so we keep it for safety.\n context_body = getattr(context, \"body\", None)\n if context_body is None:\n context_body = context\n ctx, batch = DurableEntityContext.from_json(context_body)\n return Entity(fn).handle(ctx, batch)\n return handle","def default_factory(*args, **kwargs):\n obj = RandomGameEntity()\n obj.build(*args, **kwargs)\n return obj","def __init__(self, path = None, method = None, host = None):\n self.path = path\n self.method = method\n self.host = host\n self.headers = []\n self._body = None","def api_request_factory() -> APIRequestFactory:\n\n return APIRequestFactory()","def _make_context():\n return {'User': User, 'CreditCard': CreditCard, 'Transaction': Transaction, 'db': db, 'jsonify':jsonify}","def make_case_dir(self):\n\n mkdir(directory=self.dir)\n mkdir(directory=self.sub_dir)","def __init__(self, **kwargs):\n self.club_id = kwargs[\"club_id\"]\n self.club_name = kwargs[\"club_name\"]\n\n self.contact_name = kwargs[\"contact_name\"]\n self.address_1 = kwargs[\"address_1\"]\n self.address_2 = kwargs[\"address_2\"]\n self.city = kwargs[\"city\"]\n self.state = kwargs[\"state\"]\n self.zipcode = kwargs[\"zipcode\"]\n self.phone_number = kwargs[\"phone_number\"]\n\n self.division = kwargs[\"division\"]\n self.ncca_conf = kwargs[\"ncca_conf\"]","def __init__(self, **kwargs):\n self.postKey = kwargs.get(\"postKey\")\n self.location = kwargs.get(\"location\")\n self.category = kwargs.get(\"category\")\n self.source = kwargs.get(\"source\")\n self.heading = kwargs.get(\"heading\")\n self.body = kwargs.get(\"body\")\n self.latitude = kwargs.get(\"latitude\")\n self.longitude = kwargs.get(\"longitude\")\n self.language = kwargs.get(\"language\")\n self.price = kwargs.get(\"price\")\n self.currency = kwargs.get(\"currency\")\n self.images = kwargs.get(\"images\", [])\n self.externalID = kwargs.get(\"externalID\")\n self.externalURL = kwargs.get(\"externalURL\")\n self.accountName = kwargs.get(\"accountName\")\n self.accountID = kwargs.get(\"accountID\")\n self.timestamp = kwargs.get(\"timestamp\")\n self.expiration = kwargs.get(\"expiration\")\n self.annotations = kwargs.get(\"annotations\", {})\n self.trustedAnnotations = kwargs.get(\"trustedAnnotations\", {})\n self.clickCount = kwargs.get(\"clickCount\")","def __init__(__self__, *,\n creation_time: 'outputs.TimestampResponse',\n output: 'outputs.FileReferenceResponse',\n test_case: 'outputs.TestCaseReferenceResponse'):\n pulumi.set(__self__, \"creation_time\", creation_time)\n pulumi.set(__self__, \"output\", output)\n pulumi.set(__self__, \"test_case\", test_case)"],"string":"[\n \"def request_case(self, casenum, case):\\n # Anonymous or authenticated session?\\n is_mod_request = case['method'].upper() in self.modification_methods\\n needs_user = case.get('user', is_mod_request)\\n if needs_user:\\n session = self.user_session\\n else:\\n session = requests\\n\\n # Setup request\\n requester = getattr(session, case['method'].lower())\\n full_uri = self.uri(case['endpoint'])\\n kwargs = {'allow_redirects': False}\\n\\n # Setup headers\\n headers = {}\\n accept = case.get('accept', 'application/vnd.api+json')\\n if accept:\\n headers['accept'] = accept\\n if is_mod_request and self.csrftoken:\\n headers['X-CSRFToken'] = self.csrftoken\\n if headers:\\n kwargs['headers'] = headers\\n\\n # Add POST data\\n if case.get('data'):\\n content_type = case.get(\\n 'content_type', 'application/vnd.api+json')\\n if content_type == 'application/x-www-form-urlencoded':\\n kwargs['data'] = case['data']\\n else:\\n headers['Content-Type'] = content_type\\n kwargs['data'] = json.dumps(\\n case['data'], indent=4, separators=(',', ': '))\\n\\n # Make request\\n response = requester(full_uri, **kwargs)\\n return response\",\n \"def create_case(\\n case_attrs: schemas.CaseBase = Body(...),\\n data_file: UploadFile | None = None,\\n db: Session = Depends(get_db),\\n) -> Any:\\n case = crud.case.create(db, obj_in=case_attrs, data_file=data_file)\\n case_with_site = crud.case.get_case_with_site(db, id=case.id)\\n if not case_with_site:\\n # This should never happen.\\n raise HTTPException(status_code=400, detail=\\\"Case not found\\\")\\n (case, site) = case_with_site\\n return schemas.CaseWithTaskInfo.get_case_with_task_info(case, site)\",\n \"def rules_with_cases(cls, search_pattern: str, CaseEnum: Type[TCaseEnum], detect_case: Callable[[Match], TCaseEnum], rules: Callable[[TCaseEnum], List[Dict[str, str]]]) -> PhonTransform:\\n cases: List[TCaseEnum] = list(CaseEnum)\\n rule_dict = {case: {k: v for rule in rules(case) for k, v in rule.items()} for case in cases}\\n sub_func = lambda match: rule_dict[detect_case(match)][match['key']]\\n return cls(search_pattern, sub_func)\",\n \"def create(self, data):\\n\\t\\tassert isinstance(data, dict), 'The data type must be a dictionary'\\n\\t\\tassert data, 'Case data must not be an empty dictionary'\\n\\n\\t\\turl = f'{self.root.url}/api/v1.2/cases'\\n\\t\\tdata = json.dumps(data)\\n\\t\\treturn self.root.r('POST', url, data, headers=None, verify=self.root.verify)\",\n \"def parse(self, case: Case, response: GenericResponse) -> ParsedData:\\n context = expressions.ExpressionContext(case=case, response=response)\\n parameters = {\\n parameter: expressions.evaluate(expression, context) for parameter, expression in self.parameters.items()\\n }\\n return ParsedData(\\n parameters=parameters,\\n # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#link-object\\n # > A literal value or {expression} to use as a request body when calling the target operation.\\n # In this case all literals will be passed as is, and expressions will be evaluated\\n body=expressions.evaluate(self.request_body, context),\\n )\",\n \"def __init__(self, case, timezone=pytz.UTC, override_user_id=None):\\n self.case = case\\n self.timezone = timezone\\n self.override_user_id = override_user_id\",\n \"def __init__(self, case, timezone=pytz.UTC, override_user_id=None):\\n self.case = case\\n self.timezone = timezone\\n self.override_user_id = override_user_id\",\n \"def __init__(self, case, subject, negated = False):\\n self.case = case\\n self.results = case.results\\n self.subject = subject\\n self.negated = negated\\n self.meaning = \\\"should not\\\" if negated else \\\"should\\\"\\n\\n # set by corresponding assertion methods\\n self.verb = None\\n self.object = None # the right-hand sided second argument\\n self.done = False\\n self.success = True # no meaning while done = False, just optimism\",\n \"def case(self, case_id, is_external=False):\\r\\n return cases.Case(self, case_id, is_external)\",\n \"def setCaseStrategy(self, strategy):\\n return self._set(caseStrategy=strategy)\",\n \"def setCaseStrategy(self, strategy):\\n return self._set(caseStrategy=strategy)\",\n \"def from_args(self, headers=None, url=None, filename=None, body=None):\\n cls = Response\\n if headers is not None:\\n cls = self.from_headers(headers)\\n if cls is Response and url is not None:\\n cls = self.from_filename(url)\\n if cls is Response and filename is not None:\\n cls = self.from_filename(filename)\\n if cls is Response and body is not None:\\n cls = self.from_body(body)\\n return cls\",\n \"def from_case(case, outputContents):\\n return KnownCase(case.caseType, case.problemNumber, case.caseNumber,\\n case.inputContents, outputContents)\",\n \"def make(self, **kwargs):\\n raise NotImplementedError\",\n \"def __init__(self, response_data: Any, **kwargs) -> None:\\r\\n self.case_check = case_check(settings.CASE)\\r\\n self.ignored_keys = set_ignored_keys(**kwargs)\\r\\n if isinstance(response_data, dict):\\r\\n self.test_dict(response_data)\\r\\n elif isinstance(response_data, list):\\r\\n self.test_list(response_data)\\r\\n else:\\r\\n logger.debug('Skipping case check')\",\n \"def __init__(self, case, **kwargs):\\n SystemTestsCommon.__init__(self, case, **kwargs)\",\n \"def build_case(case_data, adapter):\\n LOG.info(\\\"build case with id: {0}\\\".format(case_data[\\\"case_id\\\"]))\\n case_obj = {\\n \\\"_id\\\": case_data[\\\"case_id\\\"],\\n \\\"display_name\\\": case_data.get(\\\"display_name\\\", case_data[\\\"case_id\\\"]),\\n }\\n\\n # Check if institute exists in database\\n try:\\n institute_id = case_data[\\\"owner\\\"]\\n except KeyError as err:\\n raise ConfigError(\\\"Case has to have a institute\\\")\\n institute_obj = adapter.institute(institute_id)\\n if not institute_obj:\\n raise IntegrityError(\\\"Institute %s not found in database\\\" % institute_id)\\n case_obj[\\\"owner\\\"] = case_data[\\\"owner\\\"]\\n\\n # Owner allways has to be part of collaborators\\n collaborators = set(case_data.get(\\\"collaborators\\\", []))\\n collaborators.add(case_data[\\\"owner\\\"])\\n case_obj[\\\"collaborators\\\"] = list(collaborators)\\n\\n if case_data.get(\\\"assignee\\\"):\\n case_obj[\\\"assignees\\\"] = [case_data[\\\"assignee\\\"]]\\n\\n case_obj[\\\"smn_tsv\\\"] = case_data.get(\\\"smn_tsv\\\")\\n\\n # Individuals\\n ind_objs = []\\n try:\\n for individual in case_data.get(\\\"individuals\\\", []):\\n ind_objs.append(build_individual(individual))\\n except Exception as error:\\n raise error\\n # sort the samples to put the affected individual first\\n sorted_inds = sorted(ind_objs, key=lambda ind: -ind[\\\"phenotype\\\"])\\n case_obj[\\\"individuals\\\"] = sorted_inds\\n\\n now = datetime.now()\\n case_obj[\\\"created_at\\\"] = now\\n case_obj[\\\"updated_at\\\"] = now\\n\\n if case_data.get(\\\"suspects\\\"):\\n case_obj[\\\"suspects\\\"] = case_data[\\\"suspects\\\"]\\n if case_data.get(\\\"causatives\\\"):\\n case_obj[\\\"causatives\\\"] = case_data[\\\"causatives\\\"]\\n\\n case_obj[\\\"synopsis\\\"] = case_data.get(\\\"synopsis\\\", \\\"\\\")\\n\\n case_obj[\\\"status\\\"] = \\\"inactive\\\"\\n case_obj[\\\"is_research\\\"] = False\\n case_obj[\\\"research_requested\\\"] = False\\n case_obj[\\\"rerun_requested\\\"] = False\\n\\n case_obj[\\\"lims_id\\\"] = case_data.get(\\\"lims_id\\\", \\\"\\\")\\n\\n analysis_date = case_data.get(\\\"analysis_date\\\")\\n if analysis_date:\\n case_obj[\\\"analysis_date\\\"] = analysis_date\\n\\n # We store some metadata and references about gene panels in 'panels'\\n case_panels = case_data.get(\\\"gene_panels\\\", [])\\n default_panels = case_data.get(\\\"default_panels\\\", [])\\n panels = []\\n\\n for panel_name in case_panels:\\n panel_obj = adapter.gene_panel(panel_name)\\n if not panel_obj:\\n LOG.warning(\\n \\\"Panel %s does not exist in database and will not be saved in case document.\\\"\\n % panel_name\\n )\\n continue\\n panel = {\\n \\\"panel_id\\\": panel_obj[\\\"_id\\\"],\\n \\\"panel_name\\\": panel_obj[\\\"panel_name\\\"],\\n \\\"display_name\\\": panel_obj[\\\"display_name\\\"],\\n \\\"version\\\": panel_obj[\\\"version\\\"],\\n \\\"updated_at\\\": panel_obj[\\\"date\\\"],\\n \\\"nr_genes\\\": len(panel_obj[\\\"genes\\\"]),\\n }\\n if panel_name in default_panels:\\n panel[\\\"is_default\\\"] = True\\n else:\\n panel[\\\"is_default\\\"] = False\\n panels.append(panel)\\n\\n case_obj[\\\"panels\\\"] = panels\\n\\n case_obj[\\\"dynamic_gene_list\\\"] = []\\n\\n # Meta data\\n genome_build = case_data.get(\\\"genome_build\\\", \\\"37\\\")\\n if not genome_build in [\\\"37\\\", \\\"38\\\"]:\\n pass\\n\\n case_obj[\\\"genome_build\\\"] = genome_build\\n\\n if case_data.get(\\\"rank_model_version\\\"):\\n case_obj[\\\"rank_model_version\\\"] = str(case_data[\\\"rank_model_version\\\"])\\n\\n if case_data.get(\\\"sv_rank_model_version\\\"):\\n case_obj[\\\"sv_rank_model_version\\\"] = str(case_data[\\\"sv_rank_model_version\\\"])\\n\\n if case_data.get(\\\"rank_score_threshold\\\"):\\n case_obj[\\\"rank_score_threshold\\\"] = float(case_data[\\\"rank_score_threshold\\\"])\\n\\n # Cohort information\\n if case_data.get(\\\"cohorts\\\"):\\n case_obj[\\\"cohorts\\\"] = case_data[\\\"cohorts\\\"]\\n # Check if all case cohorts are registered under the institute\\n institute_cohorts = set(institute_obj.get(\\\"cohorts\\\", []))\\n all_cohorts = institute_cohorts.union(set(case_obj[\\\"cohorts\\\"]))\\n if len(all_cohorts) > len(institute_cohorts):\\n # if not, update institute with new cohorts\\n LOG.warning(\\\"Updating institute object with new cohort terms\\\")\\n adapter.institute_collection.find_one_and_update(\\n {\\\"_id\\\": institute_obj[\\\"_id\\\"]}, {\\\"$set\\\": {\\\"cohorts\\\": list(all_cohorts)}}\\n )\\n\\n # phenotype information\\n\\n if case_data.get(\\\"phenotype_terms\\\"):\\n phenotypes = []\\n for phenotype in case_data[\\\"phenotype_terms\\\"]:\\n phenotype_obj = adapter.hpo_term(phenotype)\\n if phenotype_obj is None:\\n LOG.warning(\\n f\\\"Could not find term with ID '{phenotype}' in HPO collection, skipping phenotype term.\\\"\\n )\\n continue\\n\\n phenotypes.append(\\n {\\\"phenotype_id\\\": phenotype, \\\"feature\\\": phenotype_obj.get(\\\"description\\\")}\\n )\\n if phenotypes:\\n case_obj[\\\"phenotype_terms\\\"] = phenotypes\\n\\n # phenotype groups\\n if case_data.get(\\\"phenotype_groups\\\"):\\n phenotype_groups = []\\n for phenotype in case_data[\\\"phenotype_groups\\\"]:\\n phenotype_obj = build_phenotype(phenotype, adapter)\\n if phenotype_obj:\\n phenotype_groups.append(phenotype_obj)\\n if phenotype_groups:\\n case_obj[\\\"phenotype_groups\\\"] = phenotype_groups\\n\\n # Files\\n case_obj[\\\"madeline_info\\\"] = case_data.get(\\\"madeline_info\\\")\\n\\n case_obj[\\\"custom_images\\\"] = case_data.get(\\\"custom_images\\\")\\n\\n for report_key in [report.get(\\\"key_name\\\") for report in CUSTOM_CASE_REPORTS.values()]:\\n if report_key in case_data:\\n case_obj[report_key] = case_data.get(report_key)\\n\\n case_obj[\\\"vcf_files\\\"] = case_data.get(\\\"vcf_files\\\", {})\\n case_obj[\\\"delivery_report\\\"] = case_data.get(\\\"delivery_report\\\")\\n\\n _populate_pipeline_info(case_obj, case_data)\\n\\n case_obj[\\\"has_svvariants\\\"] = bool(\\n case_obj[\\\"vcf_files\\\"].get(\\\"vcf_sv\\\") or case_obj[\\\"vcf_files\\\"].get(\\\"vcf_sv_research\\\")\\n )\\n\\n case_obj[\\\"has_strvariants\\\"] = bool(case_obj[\\\"vcf_files\\\"].get(\\\"vcf_str\\\"))\\n\\n case_obj[\\\"has_meivariants\\\"] = bool(case_obj[\\\"vcf_files\\\"].get(\\\"vcf_mei\\\"))\\n\\n case_obj[\\\"is_migrated\\\"] = False\\n\\n # What experiment is used, alternatives are rare (rare disease) or cancer\\n case_obj[\\\"track\\\"] = case_data.get(\\\"track\\\", \\\"rare\\\")\\n\\n case_obj[\\\"group\\\"] = case_data.get(\\\"group\\\", [])\\n\\n return case_obj\",\n \"def _get_case_data(arg=None,\\n project_name=None, fields=None, size=get_setting_value('DEFAULT_SIZE'), page=1,\\n data_category=None, query_args={}, verify=False, **kwargs):\\n return get_data(endpoint='cases', arg=arg, project_name=project_name, fields=fields, size=size,\\n page=page, data_category=data_category, query_args=query_args,\\n verify=verify, **kwargs)\",\n \"def setUp(self):\\n # Scheme, host, path\\n self.ftp_case = uri.URI.parse_uri('ftp://ftp.is.co.za/rfc/rfc1808.txt')\\n # Scheme, ipv6, path, query\\n self.ldap_case = uri.URI.parse_uri(\\n 'ldap://[2001:db8::7]/c=GB?objectClass?one')\\n # Path, nothing else\\n self.news_case = uri.URI.parse_uri(\\n \\\"news:comp.infosystems.www.servers.unix\\\")\\n # Path with scheme\\n self.urn_case = uri.URI.parse_uri(\\n \\\"urn:oasis:names:specification:docbook:dtd:xml:4.1.2\\\")\\n # Path with scheme and port\\n self.telnet_case = uri.URI.parse_uri(\\\"telnet://192.0.2.16:80/\\\")\\n # Scheme, authority, path, query, fragment\\n self.foo_case = uri.URI.parse_uri(\\n \\\"foo://herp@example.com:8042/over/there?name=ferret#nose\\\") \\n self.sld_case = uri.URI.parse_uri(\\n \\\"http://www.amazon.co.uk/search/product_page?id=52342\\\")\\n # Scheme, host, path, query, fragment\\n self.gmail_case = uri.URI.parse_uri(\\n 'https://www.google.com/search?q=setter+python&oq=setter+python&aqs=chrome..69i57j0l3.9438j0&sourceid=chrome&ie=UTF-8')\\n # Same as the above, but from direct initialization\\n self.gmail_case_from_init = uri.URI(\\n path='/search', scheme='https', authority='www.google.com', \\n query='q=setter+python&oq=setter+python&aqs=chrome..69i57j0l3.9438j0&sourceid=chrome&ie=UTF-8')\\n # Pure path with dot segments\\n self.dot_case = uri.URI(path='/a/b/c/./../../g')\\n # Another pure path with dot segments\\n self.dot_case2 = uri.URI(path='mid/content=5/../6')\\n # A more complete IPV6 sample, with a port\\n self.sample_ipv6_case = uri.URI.parse_uri(\\n 'http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html')\\n # An example with a percent-encoded authority\\n self.percent_host = uri.URI(authority='herp%2fballoon', scheme='ftP')\",\n \"def __init__(self, parms, body, env):\\n self.parms = parms\\n self.body = body\\n self.env = env\",\n \"def __init__(self, name, method, url, headers={}, auth=None, body=None, expected_status=None, expected_body=None):\\n \\n self.name = name\\n self.method = method\\n self.url = url\\n self.headers = headers\\n self.auth = auth\\n self.body = body\\n self.expected_status = expected_status\\n self.expected_body = expected_body\",\n \"def __init__(\\n self,\\n store: Store,\\n hk_api: HousekeeperAPI,\\n case_tags: List[Set[str]],\\n sample_tags: List[Set[str]],\\n project_base_path: Path,\\n delivery_type: str,\\n force_all: bool = False,\\n ignore_missing_bundles: bool = False,\\n ):\\n self.store = store\\n self.hk_api = hk_api\\n self.project_base_path: Path = project_base_path\\n self.case_tags: List[Set[str]] = case_tags\\n self.all_case_tags: Set[str] = {tag for tags in case_tags for tag in tags}\\n self.sample_tags: List[Set[str]] = sample_tags\\n self.customer_id: str = \\\"\\\"\\n self.ticket: str = \\\"\\\"\\n self.dry_run = False\\n self.delivery_type: str = delivery_type\\n self.skip_missing_bundle: bool = (\\n self.delivery_type in constants.SKIP_MISSING or ignore_missing_bundles\\n )\\n self.deliver_failed_samples = force_all\",\n \"def set_data(self, case: Case, **kwargs: Any) -> None:\\n context = kwargs[\\\"context\\\"]\\n self.set_parameters(case, context)\\n self.set_body(case, context)\\n case.set_source(context.response, context.case)\",\n \"def gen_case(self, stmt: statements.Case) -> None:\\n block = self.builder.new_block()\\n assert self.switch_options is not None\\n value = self.context.eval_expr(stmt.value)\\n if value in self.switch_options:\\n self.error(\\\"Case defined multiple times\\\", stmt.location)\\n self.switch_options[value] = block\\n self.builder.emit_jump(block) # fall through\\n self.builder.set_block(block)\\n self.gen_stmt(stmt.statement)\",\n \"def prepare_case(infos: CaseInfos):\\n case = GraphVisualizerCase()\\n\\n case.connected = infos.connected\\n\\n case.set_central_text(infos.centered_text)\\n\\n case.set_bottom_left_text(infos.bot_left_text)\\n case.set_bottom_rigth_text(infos.bot_right_text)\\n case.set_top_left_text(infos.top_left_text)\\n case.set_top_right_text(infos.top_right_text)\\n if infos.border_width != 0:\\n case.set_central_border(infos.border_width)\\n\\n return case\",\n \"def create_test_instance(cls, **kwargs):\\n # create a instance with random parameters\\n obj = super(LibraryBinaryNumeric, cls).create_test_instance(**kwargs)\\n # choose an optimal interaction matrix\\n obj.choose_sensitivity_matrix('auto')\\n return obj\",\n \"def when(self, case_expr, result_expr) -> Self:\\n cases = self.cases + (case_expr,)\\n results = self.results + (result_expr,)\\n return self.copy(cases=cases, results=results)\",\n \"def __init__(self, schema: dict, **kwargs) -> None:\\r\\n self.case_check = case_check(settings.CASE)\\r\\n self.ignored_keys = set_ignored_keys(**kwargs)\\r\\n if read_type(schema) == 'object':\\r\\n logger.debug('root -> dict')\\r\\n self.test_dict(schema)\\r\\n elif read_type(schema) == 'array':\\r\\n logger.debug('root -> list')\\r\\n self.test_list(schema)\\r\\n else:\\r\\n logger.debug('Skipping case check')\",\n \"def create(\\n self, name, subject=None, assignee=None, description=None, findings=None\\n ):\\n return self._cases_service.create(\\n name,\\n subject=subject,\\n assignee=assignee,\\n description=description,\\n findings=findings,\\n )\",\n \"def __createCovidModelInstance(self, *args, **kwargs):\\n try:\\n if 'MODEL_TYPE' in kwargs:\\n if kwargs['MODEL_TYPE'] == CovidModel.AGGREGATE_CASES_DECEASED:\\n covidModel = CovidAggregateTotals() \\n self.CovidData = covidModel.getData(*args,**kwargs)\\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\\n return \\n \\n if kwargs['MODEL_TYPE'] == CovidModel.MONTHLY_CASES_DECEASED:\\n covidModel = CovidMonthlyTotals() \\n self.CovidData = covidModel.getData(*args,**kwargs)\\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\\n return \\n\\n if kwargs['MODEL_TYPE'] == CovidModel.PAST_30_DAYS:\\n covidModel = CovidDailyTotals() \\n self.CovidData = covidModel.getData(*args,**kwargs)\\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\\n return \\n\\n if kwargs['MODEL_TYPE'] == CovidModel.MESSAGES:\\n covidModel = CovidMessages() \\n self.CovidData = covidModel.getData(*args,**kwargs)\\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\\n return\\n\\n if kwargs['MODEL_TYPE'] == CovidModel.LOCATIONS:\\n covidModel = CovidLocationInfo() \\n self.CovidData = covidModel.getData(*args,**kwargs)\\n self.DataAvailable=self.__isDataAvailable(self.CovidData)\\n return\\n\\n print (\\\"CovidMessages.__createCovidModelInstance() - did not receive a recognizable model type - no model object instantiated. Args received = \\\",kwargs)\\n return None\\n except:\\n print (\\\"CovidMessages.__createCovidModelInstance() - unexpected error: \\\",sys.exc_info()[0])\\n return None\",\n \"def __init__(self, headers=None, body=None, status=None,\\n request_headers={}):\\n self.headers = headers\\n self.body = body\\n self.status_code = status\\n self.request = mock.Mock()\\n self.request.headers = request_headers\",\n \"def create(self, *args, **kwargs):\\n factory = self.factory\\n\\n kwargs = coalesce_options(dict(kwargs),\\n self.option_types)\\n\\n return factory(*args, **kwargs)\",\n \"def get_or_create_test_case(\\n self,\\n test_case_fqn: str,\\n entity_link: Optional[str] = None,\\n test_suite_fqn: Optional[str] = None,\\n test_definition_fqn: Optional[str] = None,\\n test_case_parameter_values: Optional[str] = None,\\n ):\\n test_case = self.get_by_name(entity=TestCase, fqn=test_case_fqn, fields=[\\\"*\\\"])\\n\\n if test_case:\\n return test_case\\n\\n logger.info(\\n f\\\"TestCase {test_case_fqn} not found. Creating TestCase {test_case_fqn}\\\"\\n )\\n\\n test_case = self.create_or_update(\\n CreateTestCaseRequest(\\n name=test_case_fqn.split(\\\".\\\")[-1],\\n entityLink=entity_link,\\n testSuite=self.get_entity_reference(\\n entity=TestSuite,\\n fqn=test_suite_fqn,\\n ),\\n testDefinition=self.get_entity_reference(\\n entity=TestDefinition,\\n fqn=test_definition_fqn,\\n ),\\n parameterValues=test_case_parameter_values,\\n )\\n )\\n return test_case\",\n \"def _instantiate(cls, **kwargs):\\n return cls(**kwargs)\",\n \"def make_object(obj, kwargs):\\n return obj(**kwargs)\",\n \"def splits(cls, **kwargs):\\n kwargs_copy = {x: y for x, y in kwargs.items()}\\n if 'mode' not in kwargs:\\n kwargs_copy['mode'] = 'answer'\\n train = cls(split='train', **kwargs_copy)\\n val = cls(split='val', **kwargs_copy)\\n # test = cls(split='test', **kwargs_copy)\\n return train, val\",\n \"def factory_method(self):\\n pass\",\n \"def factory_method(self):\\n pass\",\n \"def __init__(self, case_file_path, session_file_path):\\n try:\\n self.df_cases = pd.read_csv(case_file_path)\\n except FileNotFoundError:\\n print(\\\"Case data not found.\\\")\\n\\n try:\\n self.df_sessions = pd.read_csv(session_file_path)\\n except FileNotFoundError:\\n print(\\\"Session data not found\\\")\\n\\n self.model = self.create_model()\",\n \"def create_from_request(cls, request: HttpRequest) -> BaseContext:\\n\\n return cast(\\n BaseContext,\\n cls.objects.create(\\n performed_by_id=getattr(request.user, \\\"id\\\", None),\\n context_type=\\\"http-request\\\",\\n context={\\n \\\"method\\\": request.method,\\n \\\"path\\\": request.path,\\n \\\"query_params\\\": {\\n key: request.GET.getlist(key) for key in request.GET\\n },\\n },\\n ),\\n )\",\n \"def create_request(params={}, path='/', method='POST'):\\n request = DummyRequest(path)\\n request.method = method\\n request.args = params\\n return request\",\n \"def __init__(self, traffic_obj):\\n self.request, self.response = traffic_obj[0], traffic_obj[1]\\n self.param_dict = {}\\n self.reflect = []\",\n \"def __new__(cls, *, required = ..., step_type = ..., title = ..., values= ...):\\n # required\\n if required is ...:\\n required = False\\n else:\\n required = validate_required(required)\\n \\n # title\\n if title is ...:\\n title = ''\\n else:\\n title = validate_title(title)\\n \\n # step_type\\n if step_type is ...:\\n step_type = VerificationScreenStepType.rules\\n else:\\n step_type = validate_type(step_type)\\n \\n # values\\n if values is ...:\\n values = None\\n else:\\n values = validate_values(values)\\n \\n # Construct\\n self = object.__new__(cls)\\n self.required = required\\n self.title = title\\n self.type = step_type\\n self.values = values\\n return self\",\n \"def __init__(self, segments, lemma = None, case = None):\\n self.segments = segments\\n if isinstance(self.segments, str):\\n self.segments = [Segment.new_segment(s) for s in self.segments]\\n self.lemma = lemma\\n self.case = case\",\n \"def requests_request_factory(method, endpoint, urlargs, data, is_json, headers,\\n files, verify_ssl):\\n client_func = getattr(requests, method.lower())\\n\\n if headers is None:\\n headers = [('Content-Type', 'application/json')] if is_json else []\\n\\n if data is not None:\\n request_args = dict(\\n data=json.dumps(data) if is_json else data,\\n headers=dict(headers),\\n )\\n else:\\n request_args = {}\\n\\n if files is not None:\\n request_args['files'] = files\\n\\n return client_func(\\n url_for(\\n endpoint,\\n _external=True,\\n _scheme='https',\\n **urlargs\\n ),\\n verify=verify_ssl,\\n **request_args\\n )\",\n \"def cases(\\n case_id,\\n institute,\\n reruns,\\n finished,\\n causatives,\\n research_requested,\\n rerun_monitor,\\n is_research,\\n status,\\n within_days,\\n json,\\n):\\n adapter = store\\n\\n models = []\\n if case_id:\\n case_obj = adapter.case(case_id=case_id)\\n if case_obj:\\n models.append(case_obj)\\n else:\\n LOG.info(\\\"No case with id {}\\\".format(case_id))\\n\\n else:\\n models = adapter.cases(\\n collaborator=institute,\\n reruns=reruns,\\n rerun_monitor=rerun_monitor,\\n finished=finished,\\n has_causatives=causatives,\\n research_requested=research_requested,\\n is_research=is_research,\\n status=status,\\n within_days=within_days,\\n )\\n models = [case_obj for case_obj in models]\\n if len(models) == 0:\\n LOG.info(\\\"No cases could be found\\\")\\n\\n if json:\\n click.echo(json_lib.dumps(models, default=jsonconverter))\\n return\\n\\n for model in models:\\n pp(model)\",\n \"def __init__(self, allow_none=False, excludes=None, request_types=None):\\n self.funcs = {}\\n self.instance = None\\n self.allow_none = allow_none\\n if excludes is None:\\n self.excludes = []\\n else:\\n self.excludes = excludes\\n if request_types is None:\\n self.request_types = ['all']\\n else:\\n self.request_types = request_types\",\n \"def test_flow(client, unrestricted_case, elasticsearch):\\n # start with case\\n response = client.get(api_reverse(\\\"cases-detail\\\", args=[unrestricted_case.id]))\\n check_response(response)\\n content = response.json()\\n # onwards to court\\n court_url = content.get(\\\"court\\\")[\\\"url\\\"]\\n assert court_url\\n response = client.get(court_url)\\n check_response(response)\\n # onwards to jurisdiction\\n jurisdiction_url = content.get(\\\"jurisdiction\\\")[\\\"url\\\"]\\n assert jurisdiction_url\\n response = client.get(jurisdiction_url)\\n check_response(response)\\n content = response.json()\\n assert content.get(\\\"name\\\") == unrestricted_case.jurisdiction.name\",\n \"def request_factory() -> RequestFactory:\\n\\n return RequestFactory()\",\n \"def __init__(self, *, condition: typing.Optional[\\\"RoutingRuleCondition\\\"]=None, host_name: typing.Optional[str]=None, http_redirect_code: typing.Optional[str]=None, protocol: typing.Optional[\\\"RedirectProtocol\\\"]=None, replace_key: typing.Optional[\\\"ReplaceKey\\\"]=None):\\n self._values = {\\n }\\n if condition is not None: self._values[\\\"condition\\\"] = condition\\n if host_name is not None: self._values[\\\"host_name\\\"] = host_name\\n if http_redirect_code is not None: self._values[\\\"http_redirect_code\\\"] = http_redirect_code\\n if protocol is not None: self._values[\\\"protocol\\\"] = protocol\\n if replace_key is not None: self._values[\\\"replace_key\\\"] = replace_key\",\n \"def genCase(self, CID, client, rat):\\n ret = {\\n CID: {\\n 'client': client,\\n 'rat': rat,\\n }\\n }\\n return (ret)\",\n \"def create_mock_request_matcher(self, method, path, body_type='JSON', body=None, exact=True):\\n req = {}\\n req['method'] = method\\n req['path'] = path\\n\\n if body_type == 'JSON' and body:\\n match_type = 'STRICT' if exact else 'ONLY_MATCHING_FIELDS'\\n req['body'] = {'type': body_type, 'json': json.dumps(body), 'matchType': match_type}\\n\\n if body_type == 'JSON_SCHEMA' and body:\\n if isinstance(body, str):\\n json_string = body\\n else:\\n json_string = json.dumps(body)\\n req['body'] = {'type': body_type, 'jsonSchema': json_string}\\n\\n return req\",\n \"def make_request(self, environ, **kwargs):\\n factory = self.get(abcs.ARequest)\\n request = factory(environ, self, **kwargs)\\n self._set_request_attributes(request)\\n return request\",\n \"def build(cls, **kwargs):\\n return cls(kwargs) #pylint: disable=no-value-for-parameter\",\n \"def test_get_case_by_id(self):\\n pass\",\n \"def _test_factory(case, dec):\\n a, b, q, r, e, s, knownfailure = case\\n if knownfailure:\\n pytest.xfail(reason=knownfailure)\\n\\n x = solve_discrete_are(a, b, q, r, e, s)\\n if e is None:\\n e = np.eye(a.shape[0])\\n if s is None:\\n s = np.zeros_like(b)\\n res = a.conj().T.dot(x.dot(a)) - e.conj().T.dot(x.dot(e)) + q\\n res -= (a.conj().T.dot(x.dot(b)) + s).dot(\\n solve(r+b.conj().T.dot(x.dot(b)),\\n (b.conj().T.dot(x.dot(a)) + s.conj().T)\\n )\\n )\\n assert_array_almost_equal(res, np.zeros_like(res), decimal=dec)\",\n \"def make(cls, **kwargs):\\r\\n return cls().fill(**kwargs)\",\n \"def create_factory(cls, *args):\\n raise NotImplementedError\",\n \"def create(cls, request):\\n if isinstance(request, Request):\\n request = request.prepare()\\n\\n # Method\\n method = request.method.lower()\\n\\n # Cookies\\n cookie = {}\\n if request._cookies is not None:\\n # cookies are stored in a cookiejar object\\n cookie = request._cookies.get_dict()\\n\\n # Preparing a request formats the URL with params, strip them out again\\n o = urlparse(request.url)\\n params = parse_qs(o.query)\\n # extract the URL without query parameters\\n url = o._replace(query=None).geturl()\\n\\n # Order matters because all python requests issued from a session\\n # include Accept */* which does not necessarily match the content type\\n mimetype = request.headers.get(\\\"Content-Type\\\") or request.headers.get(\\n \\\"Accept\\\"\\n )\\n\\n # Headers - request.headers is not an instance of Headers\\n # which is expected\\n header = Headers(dict(request.headers))\\n\\n # Body\\n # TODO: figure out if request._body_position is relevant\\n body = request.body\\n\\n # Path gets deduced by path finder against spec\\n parameters = RequestParameters(\\n query=ImmutableMultiDict(params),\\n header=header,\\n cookie=cookie,\\n )\\n return OpenAPIRequest(\\n full_url_pattern=url,\\n method=method,\\n parameters=parameters,\\n body=body,\\n mimetype=mimetype,\\n )\",\n \"def factory(cls, request_type: str, **data: str) -> 'SecretRequest':\\n for klass in cls.__subclasses__():\\n if klass.slug == request_type:\\n return klass(**data)\\n raise ValueError('No such request type')\",\n \"def create(self, obj):\\r\\n request = http.Request('POST', self.get_url(), self.wrap_object(obj))\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def create_and_exercise(\\n self,\\n __template_id,\\n __payload,\\n __choice_name,\\n __argument=None,\\n *,\\n workflow_id=None,\\n command_id=None,\\n read_as=None,\\n act_as=None,\\n ):\\n raise NotImplementedError\",\n \"def __init__(\\n self,\\n settings=None,\\n scenario=None,\\n living_expenses_strategy=None,\\n saving_strategy=None,\\n withdrawal_strategy=None,\\n tax_treatment=None\\n ):\\n # Set up instance:\\n super().__init__()\\n self.default_values = copy(DEFAULTVALUES)\\n self.default_types = copy(DEFAULTTYPES)\\n self.default_builders = copy(DEFAULTBUILDERS)\\n # Store args as attributes:\\n # For `settings` specifically, use the default values provided\\n # by the class if none are provided explicitly.\\n if settings is None:\\n self.settings = Settings()\\n else:\\n self.settings = settings\\n # For the rest, None is allowed:\\n self.scenario = scenario\\n self.living_expenses_strategy = living_expenses_strategy\\n self.saving_strategy = saving_strategy\\n self.withdrawal_strategy = withdrawal_strategy\\n self.tax_treatment = tax_treatment\\n # Some params aren't used to build Forecast and so are not\\n # received as input to __init__. Create attrs for them here:\\n self.allocation_strategy = None\",\n \"def __init__(self, verbose=False, case_sensitive=False):\\n self._verbose = verbose\\n self._case_sensitive = case_sensitive\",\n \"def instantiate_subject(cls, *args, **kwargs) -> Any:\\n return cls.subject_type()(*args, **kwargs)\",\n \"def case(mapper, sources, default_source=None) -> ObservableBase:\\n from ..operators.observable.case import case\\n return case(mapper, sources, default_source)\",\n \"def create(cls, **dictionary):\\n if cls.__name__ == 'Square':\\n object = cls(1)\\n object.update(**dictionary)\\n return object\\n\\n if cls.__name__ == 'Rectangle':\\n object = cls(1, 2)\\n object.update(**dictionary)\\n return object\",\n \"def test_reader_instantiates(self):\\n cr = CaseReader(self.filename)\\n self.assertTrue(isinstance(cr, HDF5CaseReader), msg='CaseReader not'\\n ' returning the correct subclass.')\",\n \"def _test_factory(case, dec):\\n a, b, q, r, knownfailure = case\\n if knownfailure:\\n pytest.xfail(reason=knownfailure)\\n\\n x = solve_discrete_are(a, b, q, r)\\n res = a.conj().T.dot(x.dot(a)) - x + q\\n res -= a.conj().T.dot(x.dot(b)).dot(\\n solve(r+b.conj().T.dot(x.dot(b)), b.conj().T).dot(x.dot(a))\\n )\\n assert_array_almost_equal(res, np.zeros_like(res), decimal=dec)\",\n \"def make_case_el(case, header_els, opinions):\\n case_el = renderer.make_case_el(case)\\n case_el.text = \\\"\\\\n\\\"\\n\\n # head matter\\n head_el = renderer.make_opinion_el({'type': 'head'})\\n if header_els:\\n head_el.text = \\\"\\\\n\\\"\\n head_el.extend(header_els)\\n case_el.append(head_el)\\n # opinions\\n for opinion_els in opinions:\\n\\n # add body to case\\n if opinion_els:\\n opinion_type = opinion_els[0].attrib.pop('opinion-type', 'majority')\\n else:\\n opinion_type = 'majority'\\n body_el = renderer.make_opinion_el({'type': opinion_type})\\n if opinion_els:\\n body_el.text = \\\"\\\\n\\\"\\n body_el.extend(opinion_els)\\n case_el.append(body_el)\\n return case_el\",\n \"def __init__(__self__, *,\\n creation_time: Optional[pulumi.Input['TimestampArgs']] = None,\\n output: Optional[pulumi.Input['FileReferenceArgs']] = None,\\n test_case: Optional[pulumi.Input['TestCaseReferenceArgs']] = None):\\n if creation_time is not None:\\n pulumi.set(__self__, \\\"creation_time\\\", creation_time)\\n if output is not None:\\n pulumi.set(__self__, \\\"output\\\", output)\\n if test_case is not None:\\n pulumi.set(__self__, \\\"test_case\\\", test_case)\",\n \"def _test_factory(case, dec):\\n a, b, q, r, e, s, knownfailure = case\\n if knownfailure:\\n pytest.xfail(reason=knownfailure)\\n\\n x = solve_continuous_are(a, b, q, r, e, s)\\n res = a.conj().T.dot(x.dot(e)) + e.conj().T.dot(x.dot(a)) + q\\n out_fact = e.conj().T.dot(x).dot(b) + s\\n res -= out_fact.dot(solve(np.atleast_2d(r), out_fact.conj().T))\\n assert_array_almost_equal(res, np.zeros_like(res), decimal=dec)\",\n \"def test_params(self):\\n cr = CaseReader(self.filename)\\n last_case = cr.get_case(-1)\\n self.assertIsNone(last_case.parameters,\\n \\\"Case erroneously contains parameters.\\\")\",\n \"def _test_factory(case, dec):\\n a, b, q, r, knownfailure = case\\n if knownfailure:\\n pytest.xfail(reason=knownfailure)\\n\\n x = solve_continuous_are(a, b, q, r)\\n res = x.dot(a) + a.conj().T.dot(x) + q\\n out_fact = x.dot(b)\\n res -= out_fact.dot(solve(np.atleast_2d(r), out_fact.conj().T))\\n assert_array_almost_equal(res, np.zeros_like(res), decimal=dec)\",\n \"def create(self, **kwargs):\\n url_str = self.base_url\\n newheaders = self.get_headers()\\n payload = kwargs['definition']\\n resp, body = self.client.json_request('POST', url_str,\\n data=payload,\\n headers=newheaders)\\n return resp\",\n \"def cases(cases_):\\n\\n def wrapper(func):\\n def inner(*args):\\n for case in cases_:\\n new_args = args + (case if (isinstance(case, tuple)) else (case,))\\n func(*new_args)\\n\\n return inner\\n\\n return wrapper\",\n \"def create(cls, **kwargs):\\n return cls().requests.post('plan', data=kwargs)\",\n \"def sow_cases(\\n self,\\n fn_args,\\n cases,\\n combos=None,\\n constants=None,\\n verbosity=1,\\n batchsize=None,\\n num_batches=None,\\n ):\\n if batchsize is not None:\\n self.batchsize = batchsize\\n if num_batches is not None:\\n self.num_batches = num_batches\\n\\n fn_args = parse_fn_args(self._fn, fn_args)\\n cases = parse_cases(cases, fn_args)\\n constants = self.parse_constants(constants)\\n\\n self.choose_batch_settings(combos=combos, cases=cases)\\n self.prepare(fn_args=fn_args, combos=combos, cases=cases)\\n\\n with Sower(self) as sow_fn:\\n case_runner(\\n fn=sow_fn,\\n fn_args=fn_args,\\n cases=cases,\\n combos=combos,\\n constants=constants,\\n verbosity=verbosity,\\n parse=False,\\n )\",\n \"def __call__(self):\\n return self.cls(**self.kwargs)\",\n \"def setParameters(self, case_name, email, password, results, message):\\n self.case_name = str(case_name)\\n self.email = str(email)\\n self.password = str(password)\\n self.results = str(results)\\n self.message = str(message)\",\n \"def __init__(self, case, image_id, image, json=False, config_file=None):\\n super().__init__()\\n self.case = case\\n self.config = dfdewey_config.load_config(config_file)\\n self.opensearch = None\\n self.image = image\\n self.image_id = image_id\\n self.images = {}\\n self.json = json\\n self.postgresql = None\\n self.scanner = None\\n\\n if self.config:\\n self.postgresql = PostgresqlDataStore(\\n host=self.config.PG_HOST, port=self.config.PG_PORT,\\n db_name=self.config.PG_DB_NAME)\\n self.opensearch = OpenSearchDataStore(\\n host=self.config.OS_HOST, port=self.config.OS_PORT,\\n url=self.config.OS_URL)\\n else:\\n self.postgresql = PostgresqlDataStore()\\n self.opensearch = OpenSearchDataStore()\\n\\n if image != 'all':\\n self.image = os.path.abspath(self.image)\\n image_hash = self.postgresql.get_image_hash(self.image_id)\\n if image_hash:\\n self.images[image_hash] = self.image\\n else:\\n self.images = self.postgresql.get_case_images(self.case)\",\n \"def __init__(self, method, protocol, host, port, path, auth_path,\\r\\n params, headers, body):\\r\\n self.method = method\\r\\n self.protocol = protocol\\r\\n self.host = host\\r\\n self.port = port\\r\\n self.path = path\\r\\n if auth_path is None:\\r\\n auth_path = path\\r\\n self.auth_path = auth_path\\r\\n self.params = params\\r\\n # chunked Transfer-Encoding should act only on PUT request.\\r\\n if headers and 'Transfer-Encoding' in headers and \\\\\\r\\n headers['Transfer-Encoding'] == 'chunked' and \\\\\\r\\n self.method != 'PUT':\\r\\n self.headers = headers.copy()\\r\\n del self.headers['Transfer-Encoding']\\r\\n else:\\r\\n self.headers = headers\\r\\n self.body = body\",\n \"def _make_request(self, payload, headers=None):\\n pathparts = REQ_PATH.split(b\\\"/\\\")\\n if pathparts[0] == b\\\"\\\":\\n pathparts = pathparts[1:]\\n dreq = DummyRequest(pathparts)\\n dreq.requestHeaders = Headers(headers or {})\\n dreq.responseCode = 200 # default to 200\\n\\n if isinstance(payload, dict):\\n payload = json.dumps(payload)\\n\\n dreq.content = BytesIO(payload.encode())\\n dreq.method = \\\"POST\\\"\\n\\n return dreq\",\n \"def __new__(cls,name,description,args_in,required=True,data_type=None,schema=None):\\n mydict={\\n \\\"name\\\":name,\\n \\\"description\\\":description,\\n \\\"in\\\":args_in,\\n \\\"required\\\":required,\\n \\\"schema\\\":schema,\\n \\\"type\\\":data_type,\\n }\\n if args_in!=\\\"body\\\":\\n mydict[\\\"type\\\"]=data_type\\n return mydict\",\n \"def createRequest(self, **kwargs):\\n for k,v in kwargs.items():\\n self.request[\\\"content\\\"][k] = v\\n \\n return self.request\",\n \"def makeTraffic(key, *opts):\\n cls = TRAFFIC_CTORS.get(key, None)\\n if cls is None:\\n raise KeyError('unknown traffic key')\\n\\n try:\\n return cls(*opts)\\n except TypeError:\\n raise IndexError('traffic ' + key + ' expects arguments: ' + cls.ARGUMENTS_DESCRIPTION)\",\n \"def make_context(self, args, **kwargs):\\n #The following headers will be available from Auth filter:\\n #'X-Tenant-Id', 'X-Tenant-Name', 'X-User-Id',\\n #'X-User-Name', 'X-Roles'\\n context_params = {'auth_tok' : args.headers['X-Auth-Token'],\\n 'user' : args.headers['X-User-Id'],\\n 'tenant' : args.headers['X-Tenant-Id'] }\\n\\n LOG.debug(\\\"Building context with params: %s\\\" % context_params)\\n \\n return ReddwarfContext(**context_params)\",\n \"def _create_request_context(self, *args, **kwargs) -> Context:\\n return Context()\",\n \"def new(cls, **kwargs):\\n return cls(**kwargs)\",\n \"def build_context_behavior(forensics_data: dict) -> dict:\\n return assign_params(\\n Path=forensics_data.get('path'),\\n URL=forensics_data.get('url'),\\n )\",\n \"def test_constructor_is_nt_so_all_args_work(self):\\n u1 = url.URL(\\n \\\"somedriver\\\",\\n \\\"user\\\",\\n \\\"secret\\\",\\n \\\"10.20.30.40\\\",\\n 1234,\\n \\\"DB\\\",\\n {\\\"key\\\": \\\"value\\\"},\\n )\\n eq_(\\n u1,\\n url.make_url(\\n \\\"somedriver://user:secret@10.20.30.40:1234/DB?key=value\\\"\\n ),\\n )\",\n \"def create(cls, fn: Callable[[DurableEntityContext], None]) -> Callable[[Any], str]:\\n def handle(context) -> str:\\n # It is not clear when the context JSON would be found\\n # inside a \\\"body\\\"-key, but this pattern matches the\\n # orchestrator implementation, so we keep it for safety.\\n context_body = getattr(context, \\\"body\\\", None)\\n if context_body is None:\\n context_body = context\\n ctx, batch = DurableEntityContext.from_json(context_body)\\n return Entity(fn).handle(ctx, batch)\\n return handle\",\n \"def default_factory(*args, **kwargs):\\n obj = RandomGameEntity()\\n obj.build(*args, **kwargs)\\n return obj\",\n \"def __init__(self, path = None, method = None, host = None):\\n self.path = path\\n self.method = method\\n self.host = host\\n self.headers = []\\n self._body = None\",\n \"def api_request_factory() -> APIRequestFactory:\\n\\n return APIRequestFactory()\",\n \"def _make_context():\\n return {'User': User, 'CreditCard': CreditCard, 'Transaction': Transaction, 'db': db, 'jsonify':jsonify}\",\n \"def make_case_dir(self):\\n\\n mkdir(directory=self.dir)\\n mkdir(directory=self.sub_dir)\",\n \"def __init__(self, **kwargs):\\n self.club_id = kwargs[\\\"club_id\\\"]\\n self.club_name = kwargs[\\\"club_name\\\"]\\n\\n self.contact_name = kwargs[\\\"contact_name\\\"]\\n self.address_1 = kwargs[\\\"address_1\\\"]\\n self.address_2 = kwargs[\\\"address_2\\\"]\\n self.city = kwargs[\\\"city\\\"]\\n self.state = kwargs[\\\"state\\\"]\\n self.zipcode = kwargs[\\\"zipcode\\\"]\\n self.phone_number = kwargs[\\\"phone_number\\\"]\\n\\n self.division = kwargs[\\\"division\\\"]\\n self.ncca_conf = kwargs[\\\"ncca_conf\\\"]\",\n \"def __init__(self, **kwargs):\\n self.postKey = kwargs.get(\\\"postKey\\\")\\n self.location = kwargs.get(\\\"location\\\")\\n self.category = kwargs.get(\\\"category\\\")\\n self.source = kwargs.get(\\\"source\\\")\\n self.heading = kwargs.get(\\\"heading\\\")\\n self.body = kwargs.get(\\\"body\\\")\\n self.latitude = kwargs.get(\\\"latitude\\\")\\n self.longitude = kwargs.get(\\\"longitude\\\")\\n self.language = kwargs.get(\\\"language\\\")\\n self.price = kwargs.get(\\\"price\\\")\\n self.currency = kwargs.get(\\\"currency\\\")\\n self.images = kwargs.get(\\\"images\\\", [])\\n self.externalID = kwargs.get(\\\"externalID\\\")\\n self.externalURL = kwargs.get(\\\"externalURL\\\")\\n self.accountName = kwargs.get(\\\"accountName\\\")\\n self.accountID = kwargs.get(\\\"accountID\\\")\\n self.timestamp = kwargs.get(\\\"timestamp\\\")\\n self.expiration = kwargs.get(\\\"expiration\\\")\\n self.annotations = kwargs.get(\\\"annotations\\\", {})\\n self.trustedAnnotations = kwargs.get(\\\"trustedAnnotations\\\", {})\\n self.clickCount = kwargs.get(\\\"clickCount\\\")\",\n \"def __init__(__self__, *,\\n creation_time: 'outputs.TimestampResponse',\\n output: 'outputs.FileReferenceResponse',\\n test_case: 'outputs.TestCaseReferenceResponse'):\\n pulumi.set(__self__, \\\"creation_time\\\", creation_time)\\n pulumi.set(__self__, \\\"output\\\", output)\\n pulumi.set(__self__, \\\"test_case\\\", test_case)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.575196","0.57027084","0.5673386","0.5494484","0.54804766","0.5334432","0.5334432","0.52071553","0.51731235","0.51614434","0.51614434","0.50898486","0.50793946","0.5054101","0.5024315","0.5018465","0.50131065","0.50022775","0.49648806","0.49112797","0.48994878","0.48863682","0.48832184","0.48266777","0.48030114","0.47810453","0.4755938","0.4733669","0.4727804","0.47272673","0.46996617","0.46612167","0.46436998","0.46405238","0.46016005","0.45925862","0.45749873","0.45749873","0.45654783","0.4556966","0.45509472","0.45454136","0.4538791","0.4517916","0.45178333","0.45121408","0.45095024","0.44923037","0.44921407","0.44918048","0.4491154","0.44789374","0.4472208","0.44593865","0.44522628","0.44521448","0.44499516","0.4447385","0.44455105","0.44267988","0.44088885","0.44081062","0.44053963","0.43934274","0.43931493","0.4383458","0.43800944","0.4379942","0.43753105","0.4374658","0.43695995","0.43680847","0.4364473","0.43571457","0.4344645","0.43379846","0.4337542","0.4335544","0.43320358","0.43307275","0.4329181","0.4328112","0.43264693","0.43048772","0.43046948","0.42890662","0.42890012","0.42889637","0.42868724","0.42861187","0.42836732","0.42772472","0.42771024","0.4266005","0.4260172","0.42594516","0.42530835","0.42530686","0.4250442","0.42501593"],"string":"[\n \"0.575196\",\n \"0.57027084\",\n \"0.5673386\",\n \"0.5494484\",\n \"0.54804766\",\n \"0.5334432\",\n \"0.5334432\",\n \"0.52071553\",\n \"0.51731235\",\n \"0.51614434\",\n \"0.51614434\",\n \"0.50898486\",\n \"0.50793946\",\n \"0.5054101\",\n \"0.5024315\",\n \"0.5018465\",\n \"0.50131065\",\n \"0.50022775\",\n \"0.49648806\",\n \"0.49112797\",\n \"0.48994878\",\n \"0.48863682\",\n \"0.48832184\",\n \"0.48266777\",\n \"0.48030114\",\n \"0.47810453\",\n \"0.4755938\",\n \"0.4733669\",\n \"0.4727804\",\n \"0.47272673\",\n \"0.46996617\",\n \"0.46612167\",\n \"0.46436998\",\n \"0.46405238\",\n \"0.46016005\",\n \"0.45925862\",\n \"0.45749873\",\n \"0.45749873\",\n \"0.45654783\",\n \"0.4556966\",\n \"0.45509472\",\n \"0.45454136\",\n \"0.4538791\",\n \"0.4517916\",\n \"0.45178333\",\n \"0.45121408\",\n \"0.45095024\",\n \"0.44923037\",\n \"0.44921407\",\n \"0.44918048\",\n \"0.4491154\",\n \"0.44789374\",\n \"0.4472208\",\n \"0.44593865\",\n \"0.44522628\",\n \"0.44521448\",\n \"0.44499516\",\n \"0.4447385\",\n \"0.44455105\",\n \"0.44267988\",\n \"0.44088885\",\n \"0.44081062\",\n \"0.44053963\",\n \"0.43934274\",\n \"0.43931493\",\n \"0.4383458\",\n \"0.43800944\",\n \"0.4379942\",\n \"0.43753105\",\n \"0.4374658\",\n \"0.43695995\",\n \"0.43680847\",\n \"0.4364473\",\n \"0.43571457\",\n \"0.4344645\",\n \"0.43379846\",\n \"0.4337542\",\n \"0.4335544\",\n \"0.43320358\",\n \"0.43307275\",\n \"0.4329181\",\n \"0.4328112\",\n \"0.43264693\",\n \"0.43048772\",\n \"0.43046948\",\n \"0.42890662\",\n \"0.42890012\",\n \"0.42889637\",\n \"0.42868724\",\n \"0.42861187\",\n \"0.42836732\",\n \"0.42772472\",\n \"0.42771024\",\n \"0.4266005\",\n \"0.4260172\",\n \"0.42594516\",\n \"0.42530835\",\n \"0.42530686\",\n \"0.4250442\",\n \"0.42501593\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5888172"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":77686,"cells":{"query":{"kind":"string","value":"Create a new strategy for the case's component from the endpoint parameters."},"document":{"kind":"string","value":"def get_parameters_strategy(\n endpoint: Endpoint, to_strategy: Callable[[Dict[str, Any]], st.SearchStrategy], location: str\n) -> st.SearchStrategy:\n parameters = getattr(endpoint, LOCATION_TO_CONTAINER[location])\n if parameters:\n schema = parameters_to_json_schema(parameters)\n strategy = to_strategy(schema)\n serialize = endpoint.get_parameter_serializer(location)\n if serialize is not None:\n strategy = strategy.map(serialize)\n filter_func = {\n \"path\": is_valid_path,\n \"header\": is_valid_header,\n \"cookie\": is_valid_header,\n \"query\": is_valid_query,\n }[location]\n strategy = strategy.filter(filter_func)\n map_func = {\"path\": quote_all}.get(location)\n if map_func:\n strategy = strategy.map(map_func)\n return strategy\n # No parameters defined for this location\n return st.none()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_case_strategy( # pylint: disable=too-many-locals\n draw: Callable,\n endpoint: Endpoint,\n hooks: Optional[HookDispatcher] = None,\n feedback: Optional[Feedback] = None,\n data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),\n path_parameters: Any = NOT_SET,\n headers: Any = NOT_SET,\n cookies: Any = NOT_SET,\n query: Any = NOT_SET,\n body: Any = NOT_SET,\n) -> Any:\n to_strategy = {DataGenerationMethod.positive: make_positive_strategy}[data_generation_method]\n\n context = HookContext(endpoint)\n\n if path_parameters is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"path\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"path\")\n path_parameters = draw(strategy)\n if headers is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"header\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"header\")\n headers = draw(strategy)\n if cookies is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"cookie\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"cookie\")\n cookies = draw(strategy)\n if query is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"query\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"query\")\n query = draw(strategy)\n\n media_type = None\n if body is NOT_SET:\n if endpoint.body:\n parameter = draw(st.sampled_from(endpoint.body.items))\n strategy = _get_body_strategy(parameter, to_strategy)\n media_type = parameter.media_type\n body = draw(strategy)\n else:\n media_types = endpoint.get_request_payload_content_types() or [\"application/json\"]\n # Take the first available media type.\n # POSSIBLE IMPROVEMENT:\n # - Test examples for each available media type on Open API 2.0;\n # - On Open API 3.0, media types are explicit, and each example has it. We can pass `OpenAPIBody.media_type`\n # here from the examples handling code.\n media_type = media_types[0]\n if endpoint.schema.validate_schema and endpoint.method.upper() == \"GET\" and endpoint.body:\n raise InvalidSchema(\"Body parameters are defined for GET request.\")\n return Case(\n endpoint=endpoint,\n feedback=feedback,\n media_type=media_type,\n path_parameters=path_parameters,\n headers=headers,\n cookies=cookies,\n query=query,\n body=body,\n )","def create_test_strategy(context, **kw):\n strategy = get_test_strategy(context, **kw)\n strategy.create()\n return strategy","def make_endpoint(self, collected: List[ParsedData]) -> Endpoint:\n # We split the gathered data among all locations & store the original parameter\n containers = {\n location: {\n parameter.name: {\"options\": [], \"parameter\": parameter}\n for parameter in getattr(self.endpoint, container_name)\n }\n for location, container_name in LOCATION_TO_CONTAINER.items()\n }\n # There might be duplicates in the data\n for item in set(collected):\n for name, value in item.parameters.items():\n container = self._get_container_by_parameter_name(name, containers)\n container.append(value)\n # These are the final `path_parameters`, `query`, and other endpoint components\n components: Dict[str, ParameterSet] = {\n container_name: getattr(self.endpoint, container_name).__class__()\n for location, container_name in LOCATION_TO_CONTAINER.items()\n }\n # Here are all components that are filled with parameters\n for location, parameters in containers.items():\n for name, parameter_data in parameters.items():\n if parameter_data[\"options\"]:\n definition = deepcopy(parameter_data[\"parameter\"].definition)\n if \"schema\" in definition:\n # The actual schema doesn't matter since we have a list of allowed values\n definition[\"schema\"] = {\"enum\": parameter_data[\"options\"]}\n else:\n # Other schema-related keywords will be ignored later, during the canonicalisation step\n # inside `hypothesis-jsonschema`\n definition[\"enum\"] = parameter_data[\"options\"]\n components[LOCATION_TO_CONTAINER[location]].add(parameter_data[\"parameter\"].__class__(definition))\n else:\n # No options were gathered for this parameter - use the original one\n components[LOCATION_TO_CONTAINER[location]].add(parameter_data[\"parameter\"])\n return self.endpoint.clone(**components)","def __init__(self):\n self.strategy = Strategy(self)","def create_strategy(config):\n build_strategy = paddle.static.BuildStrategy()\n exec_strategy = paddle.static.ExecutionStrategy()\n\n exec_strategy.num_threads = 1\n exec_strategy.num_iteration_per_drop_scope = (\n 10000\n if 'AMP' in config and config.AMP.get(\"use_pure_fp16\", False) else 10)\n\n fuse_op = True if 'AMP' in config else False\n\n fuse_bn_act_ops = config.get('fuse_bn_act_ops', fuse_op)\n fuse_elewise_add_act_ops = config.get('fuse_elewise_add_act_ops', fuse_op)\n fuse_bn_add_act_ops = config.get('fuse_bn_add_act_ops', fuse_op)\n enable_addto = config.get('enable_addto', fuse_op)\n\n build_strategy.fuse_bn_act_ops = fuse_bn_act_ops\n build_strategy.fuse_elewise_add_act_ops = fuse_elewise_add_act_ops\n build_strategy.fuse_bn_add_act_ops = fuse_bn_add_act_ops\n build_strategy.enable_addto = enable_addto\n\n return build_strategy, exec_strategy","def build_allocation_strategy(self, *args, **kwargs):\n return self.build_param(\n Parameter.ALLOCATION_STRATEGY, AllocationStrategy, *args,\n _special_builder=False, **kwargs)","def strategy(func):\n strategies.append(func)\n return func","def strategy(strategy_name: str):\r\n def wrapper(finder_class):\r\n global strategies\r\n strategies[strategy_name] = finder_class\r\n return finder_class\r\n return wrapper","def get_strategy(self): \n if self._strategy is ServerSide:\n self.arguments = [ask_for_port()]\n\n elif self._strategy is ClientSide:\n self.arguments = [ask_for_recipient(), \n ask_for_listening_port(),\n self._get_header(),\n ask_for_test()]\n return self._strategy(*self.arguments)","def InitStrategy(self, sname, strategy):\n\n self._string = sname\n\n self.strategy = strategy\n self.postracker = position.PositionTracker(self.strategy)","def build_endpoint(self, **kwargs):\n\n raise NotImplementedError()","def __init__(__self__, *,\n accelerator_id: Optional[pulumi.Input[str]] = None,\n address: Optional[pulumi.Input[str]] = None,\n custom_routing_endpoint_traffic_policy_id: Optional[pulumi.Input[str]] = None,\n endpoint_group_id: Optional[pulumi.Input[str]] = None,\n endpoint_id: Optional[pulumi.Input[str]] = None,\n listener_id: Optional[pulumi.Input[str]] = None,\n port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['CustomRoutingEndpointTrafficPolicyPortRangeArgs']]]] = None,\n status: Optional[pulumi.Input[str]] = None):\n if accelerator_id is not None:\n pulumi.set(__self__, \"accelerator_id\", accelerator_id)\n if address is not None:\n pulumi.set(__self__, \"address\", address)\n if custom_routing_endpoint_traffic_policy_id is not None:\n pulumi.set(__self__, \"custom_routing_endpoint_traffic_policy_id\", custom_routing_endpoint_traffic_policy_id)\n if endpoint_group_id is not None:\n pulumi.set(__self__, \"endpoint_group_id\", endpoint_group_id)\n if endpoint_id is not None:\n pulumi.set(__self__, \"endpoint_id\", endpoint_id)\n if listener_id is not None:\n pulumi.set(__self__, \"listener_id\", listener_id)\n if port_ranges is not None:\n pulumi.set(__self__, \"port_ranges\", port_ranges)\n if status is not None:\n pulumi.set(__self__, \"status\", status)","def protocol_factory_method(self):\n pass","def make(cls, cluster_name: str, backend: 'backends.Backend',\n task: 'task_lib.Task', retry_until_up: bool) -> 'StrategyExecutor':\n task_resources = task.resources\n assert len(task_resources) == 1, 'Only one resource is supported.'\n resources: 'sky.Resources' = list(task_resources)[0]\n\n spot_recovery = resources.spot_recovery\n assert spot_recovery is not None, (\n 'spot_recovery is required to use spot strategy.')\n # Remove the spot_recovery field from the resources, as the strategy\n # will be handled by the strategy class.\n task.set_resources({resources.copy(spot_recovery=None)})\n return SPOT_STRATEGIES[spot_recovery](cluster_name, backend, task,\n retry_until_up)","def create(\n self,\n config: dict,\n mode: str,\n light_model: Optional[LightModel],\n entity_domain: str,\n ) -> PowerCalculationStrategyInterface:\n if mode == MODE_LINEAR:\n return self._create_linear(config, light_model, entity_domain)\n\n if mode == MODE_FIXED:\n return self._create_fixed(config, light_model)\n\n if mode == MODE_LUT:\n return self._create_lut(light_model)\n\n raise UnsupportedMode(\"Invalid calculation mode\", mode)","def strategy(self) -> AwesomeVersionStrategy:\n return version_strategy(self.string)","def create_behavior(self, name, parameters):\n return self._behaviors[name](parameters)","def __init__(self, strategy=None):\n self.strategy = strategy if strategy is not None else GenericStrategyComponent()\n self.is_game_over = False\n self.is_kicked = False\n self.is_winner = False","def __init__(self, endpoint_a, endpoint_b):\n self.endpoint_a = endpoint_a\n self.endpoint_b = endpoint_b","def _create_algorithm(algo_name, algo_options, origin):\n if origin == \"nlopt\":\n algo = pg.algorithm(pg.nlopt(solver=algo_name))\n for option, val in algo_options.items():\n setattr(algo.extract(pg.nlopt), option, val)\n elif origin == \"pygmo\":\n pygmo_uda = getattr(pg, algo_name)\n algo_options = algo_options.copy()\n if \"popsize\" in algo_options:\n del algo_options[\"popsize\"]\n algo = pg.algorithm(pygmo_uda(**algo_options))\n\n return algo","def __init__(self, id: int=None, strategy_id: int=None, operator: str=None, comment: str=None, price: float=None, quantity: int=None, target_prices: List[float]=None, stop_loss_prices: List[float]=None): # noqa: E501\n self.swagger_types = {\n 'id': int,\n 'strategy_id': int,\n 'operator': str,\n 'comment': str,\n 'price': float,\n 'quantity': int,\n 'target_prices': List[float],\n 'stop_loss_prices': List[float]\n }\n\n self.attribute_map = {\n 'id': 'id',\n 'strategy_id': 'strategy_id',\n 'operator': 'operator',\n 'comment': 'comment',\n 'price': 'price',\n 'quantity': 'quantity',\n 'target_prices': 'target_prices',\n 'stop_loss_prices': 'stop_loss_prices'\n }\n self._id = id\n self._strategy_id = strategy_id\n self._operator = operator\n self._comment = comment\n self._price = price\n self._quantity = quantity\n self._target_prices = target_prices\n self._stop_loss_prices = stop_loss_prices","def create_servicech(self, conf, params):\n\t\tpass","def __new__(cls, component, *args, **kwargs):\n if cls.dependencies:\n for dependency in cls.dependencies:\n component.load_feature(dependency, *args, **kwargs)\n return super(Feature, cls).__new__(cls)","def setStrategy(self, value):\n return self._set(strategy=value)","def setCaseStrategy(self, strategy):\n return self._set(caseStrategy=strategy)","def setCaseStrategy(self, strategy):\n return self._set(caseStrategy=strategy)","def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None,\n address: Optional[pulumi.Input[str]] = None,\n endpoint_id: Optional[pulumi.Input[str]] = None,\n port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CustomRoutingEndpointTrafficPolicyPortRangeArgs']]]]] = None,\n __props__=None):\n ...","def __init__(\n self,\n config: Optional[AlgorithmConfig] = None,\n env=None, # deprecated arg\n logger_creator: Optional[Callable[[], Logger]] = None,\n **kwargs,\n ):\n config = config or self.get_default_config()\n\n # Translate possible dict into an AlgorithmConfig object, as well as,\n # resolving generic config objects into specific ones (e.g. passing\n # an `AlgorithmConfig` super-class instance into a PPO constructor,\n # which normally would expect a PPOConfig object).\n if isinstance(config, dict):\n default_config = self.get_default_config()\n # `self.get_default_config()` also returned a dict ->\n # Last resort: Create core AlgorithmConfig from merged dicts.\n if isinstance(default_config, dict):\n config = AlgorithmConfig.from_dict(\n config_dict=self.merge_algorithm_configs(\n default_config, config, True\n )\n )\n # Default config is an AlgorithmConfig -> update its properties\n # from the given config dict.\n else:\n config = default_config.update_from_dict(config)\n else:\n default_config = self.get_default_config()\n # Given AlgorithmConfig is not of the same type as the default config:\n # This could be the case e.g. if the user is building an algo from a\n # generic AlgorithmConfig() object.\n if not isinstance(config, type(default_config)):\n config = default_config.update_from_dict(config.to_dict())\n\n # In case this algo is using a generic config (with no algo_class set), set it\n # here.\n if config.algo_class is None:\n config.algo_class = type(self)\n\n if env is not None:\n deprecation_warning(\n old=f\"algo = Algorithm(env='{env}', ...)\",\n new=f\"algo = AlgorithmConfig().environment('{env}').build()\",\n error=False,\n )\n config.environment(env)\n\n # Validate and freeze our AlgorithmConfig object (no more changes possible).\n config.validate()\n config.freeze()\n\n # Convert `env` provided in config into a concrete env creator callable, which\n # takes an EnvContext (config dict) as arg and returning an RLlib supported Env\n # type (e.g. a gym.Env).\n self._env_id, self.env_creator = self._get_env_id_and_creator(\n config.env, config\n )\n env_descr = (\n self._env_id.__name__ if isinstance(self._env_id, type) else self._env_id\n )\n\n # Placeholder for a local replay buffer instance.\n self.local_replay_buffer = None\n\n # Create a default logger creator if no logger_creator is specified\n if logger_creator is None:\n # Default logdir prefix containing the agent's name and the\n # env id.\n timestr = datetime.today().strftime(\"%Y-%m-%d_%H-%M-%S\")\n env_descr_for_dir = re.sub(\"[/\\\\\\\\]\", \"-\", str(env_descr))\n logdir_prefix = f\"{str(self)}_{env_descr_for_dir}_{timestr}\"\n if not os.path.exists(DEFAULT_RESULTS_DIR):\n # Possible race condition if dir is created several times on\n # rollout workers\n os.makedirs(DEFAULT_RESULTS_DIR, exist_ok=True)\n logdir = tempfile.mkdtemp(prefix=logdir_prefix, dir=DEFAULT_RESULTS_DIR)\n\n # Allow users to more precisely configure the created logger\n # via \"logger_config.type\".\n if config.logger_config and \"type\" in config.logger_config:\n\n def default_logger_creator(config):\n \"\"\"Creates a custom logger with the default prefix.\"\"\"\n cfg = config[\"logger_config\"].copy()\n cls = cfg.pop(\"type\")\n # Provide default for logdir, in case the user does\n # not specify this in the \"logger_config\" dict.\n logdir_ = cfg.pop(\"logdir\", logdir)\n return from_config(cls=cls, _args=[cfg], logdir=logdir_)\n\n # If no `type` given, use tune's UnifiedLogger as last resort.\n else:\n\n def default_logger_creator(config):\n \"\"\"Creates a Unified logger with the default prefix.\"\"\"\n return UnifiedLogger(config, logdir, loggers=None)\n\n logger_creator = default_logger_creator\n\n # Metrics-related properties.\n self._timers = defaultdict(_Timer)\n self._counters = defaultdict(int)\n self._episode_history = []\n self._episodes_to_be_collected = []\n\n # The fully qualified AlgorithmConfig used for evaluation\n # (or None if evaluation not setup).\n self.evaluation_config: Optional[AlgorithmConfig] = None\n # Evaluation WorkerSet and metrics last returned by `self.evaluate()`.\n self.evaluation_workers: Optional[WorkerSet] = None\n # Initialize common evaluation_metrics to nan, before they become\n # available. We want to make sure the metrics are always present\n # (although their values may be nan), so that Tune does not complain\n # when we use these as stopping criteria.\n self.evaluation_metrics = {\n # TODO: Don't dump sampler results into top-level.\n \"evaluation\": {\n \"episode_reward_max\": np.nan,\n \"episode_reward_min\": np.nan,\n \"episode_reward_mean\": np.nan,\n \"sampler_results\": {\n \"episode_reward_max\": np.nan,\n \"episode_reward_min\": np.nan,\n \"episode_reward_mean\": np.nan,\n },\n },\n }\n\n super().__init__(\n config=config,\n logger_creator=logger_creator,\n **kwargs,\n )\n\n # Check, whether `training_iteration` is still a tune.Trainable property\n # and has not been overridden by the user in the attempt to implement the\n # algos logic (this should be done now inside `training_step`).\n try:\n assert isinstance(self.training_iteration, int)\n except AssertionError:\n raise AssertionError(\n \"Your Algorithm's `training_iteration` seems to be overridden by your \"\n \"custom training logic! To solve this problem, simply rename your \"\n \"`self.training_iteration()` method into `self.training_step`.\"\n )","def _CreateSolutionStrategy(self):\n raise Exception(\"Mesh motion solving strategy must be created by the derived class.\")","def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None,\n accelerator_id: Optional[pulumi.Input[str]] = None,\n basic_endpoint_group_name: Optional[pulumi.Input[str]] = None,\n description: Optional[pulumi.Input[str]] = None,\n endpoint_address: Optional[pulumi.Input[str]] = None,\n endpoint_group_region: Optional[pulumi.Input[str]] = None,\n endpoint_sub_address: Optional[pulumi.Input[str]] = None,\n endpoint_type: Optional[pulumi.Input[str]] = None,\n __props__=None):\n ...","def create(cls, **props: Any) -> 'ResolverOp':\n real_instance = super().__call__()\n cls._check_kwargs(props)\n for name, value in props.items():\n setattr(real_instance, name, value)\n return real_instance","def create(cls, **props: Any) -> 'ResolverOp':\n real_instance = super().__call__()\n cls._check_kwargs(props)\n for name, value in props.items():\n setattr(real_instance, name, value)\n return real_instance","def create_endpoint(EndpointName=None, EndpointConfigName=None, Tags=None):\n pass","def _using(*args, validator: \"DictValidator\") -> \"DictValidator\":\n\n def setup_strategy(validator, strategy) -> \"DictValidator\":\n if isinstance(strategy, SortingStrategy):\n validator.sorting = strategy\n elif isinstance(strategy, FilteringStrategy):\n validator.filtering = strategy\n elif isinstance(strategy, PrintingStrategy):\n validator.printing = strategy\n else:\n raise CertumException(\"The strategy provided for the validator is unknown.\")\n return validator\n\n for arg in args:\n if isinstance(arg, list):\n for strategy in arg:\n validator = setup_strategy(validator, strategy)\n elif isinstance(arg, Strategy):\n validator = setup_strategy(validator, arg)\n else:\n raise CertumException(\"The strategy provided for the validator is unknown.\")\n\n return validator","def generate_object(self, **kwargs):\n from ranger_performance_tool import perf_globals\n service_type_mapping = perf_globals.CONFIG_READER.get_config_value(\"secondary\", \"service_type_mapping\")\n if \"id\" not in kwargs:\n kwargs[\"id\"] = self.random_generator.generate_int()\n if \"name\" not in kwargs:\n kwargs[\"name\"] = self.random_generator.generate_string()\n if \"service\" not in kwargs:\n enabled_service = random.choice(perf_globals.CONFIG_READER.get_config_value(\"secondary\", \"enabled_services\"))\n service_type = service_type_mapping[enabled_service]\n kwargs[\"service\"] = enabled_service\n kwargs[\"serviceType\"] = service_type\n policy_object = RangerPolicy()\n for key, value in kwargs.items():\n if key not in dir(policy_object):\n raise Exception(\"Invalid key: \" + key)\n policy_object[key] = value\n service_type = policy_object.serviceType\n service_store = perf_globals.OBJECT_STORE.service_store[service_type]\n policy_object.resources = service_store.generate_resources()\n return policy_object","def get_factory():","def __init__(self, designation):\n try:\n self._designation = designation.lower()\n parts = self._designation.split(\"/\")\n self.mutate: mutation.MutationStrategy = mutation.__strategies__[parts[0]](int(parts[1]))\n self.crossover: crossover.CrossoverStrategy = crossover.__strategies__[parts[2]]()\n if len(parts) >= 4:\n self.repair: repair.RepairStrategy = repair.__strategies__[parts[3]]()\n else:\n self.repair: repair.RepairStrategy = repair.clip()\n self._designation += \"/clip\"\n except AttributeError or KeyError or IndexError or ValueError:\n raise ValueError(f\"Invalid evolution strategy '{designation}'\")","def strategy(self, opponent):\n raise NotImplementedError()","def __init__(self, startTime, strategy, buyOrSell, underlying, orderQuantity, daysBeforeClose, expCycle=None,\n optimalDTE=None, minimumDTE=None, roc=None, minDaysToEarnings=None, minCredit=None,\n profitTargetPercent=None, customManagement=None, maxBidAsk=None, maxMidDev=None,\n minDaysSinceEarnings=None, minIVR=None, minBuyingPower=None):\n\n if self.__class__ == Strategy:\n raise NotImplementedError, \"Cannot create object of class Strategy; must use derived classes such \" \\\n \"as StrangleStrat.\"\n\n self.__startTime = startTime\n self.__strategy = strategy\n self.__buyOrSell = buyOrSell\n self.__underlying = underlying\n self.__orderQuantity = orderQuantity\n self.__daysBeforeClose = daysBeforeClose\n self.__expCycle = expCycle\n self.__optimalDTE = optimalDTE\n self.__minimumDTE = minimumDTE\n self.__roc = roc\n self.__minDaysToEarnings = minDaysToEarnings\n self.__minCredit = minCredit\n self.__profitTargetPercent = profitTargetPercent\n self.__customManagement = customManagement\n self.__maxBidAsk = maxBidAsk\n self.__maxMidDev = maxMidDev\n self.__minDaysSinceEarnings = minDaysSinceEarnings\n self.__minIVR = minIVR\n self.__minBuyingPower = minBuyingPower","def create_endpoint(self, endpoint_id, endpoint_ref):\n raise exception.NotImplemented() # pragma: no cover","def create(\n config_path,\n destination_database,\n destination_environment,\n algorithm_instance,\n ext_params_str=None\n ):\n\n # Create config service to get acon file path.\n config_service = ConfigService(config_path)\n acon_path = config_service.get_acon_path(\n destination_database,\n destination_environment,\n algorithm_instance\n )\n acon_dict = Util.load_dict(acon_path)\n\n if ext_params_str:\n ext_params_dict = json.loads(ext_params_str)\n acon_dict = Util.merge_nested_dicts(acon_dict, ext_params_dict)\n\n return AlgorithmConfigurationHadoop(algorithm_instance, acon_dict)","def __selectStrategy( self ):\n chosenStrategy = self.activeStrategies[self.chosenStrategy]\n self.__incrementChosenStrategy()\n return chosenStrategy","def get_test_strategy(context, **kw):\n obj_cls = objects.Strategy\n db_data = db_utils.get_test_strategy(**kw)\n obj_data = _load_related_objects(context, obj_cls, db_data)\n\n return _load_test_obj(context, obj_cls, obj_data, **kw)","def load_strategy_class(self):\n path2 = Path(__file__).parent.parent.joinpath(\"strategies\")\n self.load_strategy_class_from_folder(path2, \"vnpy.app.cta_strategy.strategies\")","def port_factory_method(self):\n pass","def __init__(self, runner, params, **kwargs):\n storage = InMemoryFeatureStorage(self, parent_cache=None)\n super(LiveTradingOrders, self).__init__(runner, params, storage)\n\n self.strategy_name = params['strategy_name']\n self.strategy_desc = params['strategy_desc']\n self.trading_user_id = params['trading_user_id']\n\n # Field of the order to use for alignment (i.e. placed_time or settled_time)\n shared_objects = self._runner.shared_objects()\n self.sync_field = params['sync_field']\n self._helper = MongoStrategyHelper(fixture_cache=shared_objects['fixture_cache'])\n self._fixture_cache = shared_objects['fixture_cache']","def to_component_func(entity: ComponentEntity, component_creation_func) -> Callable[..., Command]:\n func_name = \"[component] {}\".format(entity.display_name)\n\n func_docstring_lines = []\n if entity.description is not None:\n func_docstring_lines.append(entity.description.strip())\n\n if isinstance(entity, DataTransferImportComponent):\n all_params = get_dynamic_source_parameter(entity.source)\n else:\n all_params = get_dynamic_input_parameter(entity.inputs)\n\n flattened_group_keys = []\n # Flatten all group parameters, for function parameter validation.\n from azure.ai.ml.entities._inputs_outputs import GroupInput\n\n for name, item in entity.inputs.items():\n if isinstance(item, GroupInput):\n flattened_group_keys.extend(list(item.flatten(group_parameter_name=name).keys()))\n\n doc_string = entity.description\n # Try add yaml to doc string\n try:\n yaml_str = entity._yaml_str if entity._yaml_str else entity._to_yaml()\n doc_string = \"{0}\\n\\nComponent yaml:\\n```yaml\\n{1}\\n```\".format(doc_string, yaml_str)\n except Exception: # pylint: disable=broad-except\n pass\n\n params_assignment_str = \", \".join([f\"{param.name}=xxx\" for param in all_params])\n example = f\"component_func({params_assignment_str})\"\n\n dynamic_func = create_kw_function_from_parameters(\n component_creation_func,\n documentation=doc_string,\n parameters=all_params,\n func_name=func_name,\n flattened_group_keys=flattened_group_keys,\n )\n\n dynamic_func._func_calling_example = example\n dynamic_func._has_parameters = bool(all_params)\n return dynamic_func","def buildProtocol(self, addr):\n p = self.protocol()\n p.factory = self\n\n return p","def __init__(self, runner, params, **kwargs):\n storage = InMemoryFeatureStorage(self, parent_cache=None)\n super(BacktestOrders, self).__init__(runner, params, storage)\n\n self.strategy_name = params['strategy_name']\n self.strategy_desc = params['strategy_desc']\n self.strategy_code = params['strategy_code']\n self.trading_user_id = params['trading_user_id']\n self.backtest_kwargs = params['backtest_kwargs']\n\n # Field of the order to use for alignment (i.e. placed_time or settled_time)\n shared_objects = self._runner.shared_objects()\n self.sync_field = params['sync_field']\n if 'helper' in kwargs:\n self._helper = kwargs['helper']\n else:\n self._helper = MongoStrategyHelper(fixture_cache=shared_objects['fixture_cache'])\n self._fixture_cache = shared_objects['fixture_cache']","def __init__(self, name,\n # expected_arg = default_val # expected arguments\n mechanisms={}, # custom mechanisms\n config_file=None, parameters={}, # parameter configuration\n # additional_arg = default_val # component-specific args\n **keywords # parameter keywords\n ):\n # Call the class constructor to get default argument processing\n # Component.__init__(self, name, config_file, mechanisms)\n \n # Set up the default mechanisms for this class\n #\n # Mechanisms that are specific to this component can be\n # contained in the file defining the mechanism. More generic\n # mechanisms that may be used by multiople component types\n # should be placed in the mechanisms/ diretory and imported\n # before use.\n #\n self.default_mechanisms = {\n # 'mechanism' : MechanismConstructor()\n }\n\n # Add (or overwrite) any mechanisms passed as arguments\n self.custom_mechanisms = mechanisms\n\n # Create the config_file name (optional)\n if config_file == None:\n config_file = self.name.tolower() + \".csv\"\n self.config_file = config_file\n \n # Set the component parameter values\n self.default_parameters = {\n # 'parameter' : value\n }\n self.parameters = get_parameters(\n config_file, parameters, self.default_parameters, **keywords)\n\n # Fill in any missing values for default parameters\n # Alternative setup for setting parameter values\n #","def post(self):\n\n self.set_header('content-type', 'application/json')\n body = self.request.body\n try:\n # root用户组不可以创建策略\n # manager用户组、普通用户组可以创建策略\n if self.group.is_root():\n return self.process_error(-1, 'root用户组没有权限创建策略')\n\n strategies = []\n for _ in json.loads(body):\n _[\"group_id\"] = self.group.id\n strategies.append(Strategy.from_dict(_))\n except Exception as err:\n return self.process_error(400, \"invalid request body: {}\".format(err.message))\n\n for _ in strategies:\n # add current time as version, for backwards compatability\n _.version = millis_now()\n\n try:\n for s in strategies:\n gen_variables_from_strategy(s, effective_check=False)\n\n for s in strategies:\n s.version = millis_now()\n\n dao = StrategyCustDao()\n for s in strategies:\n dao.add_strategy(s)\n self.finish(json_dumps({\"status\": 200, \"msg\": \"ok\", \"values\": []}))\n except Exception as err:\n traceback.print_exc()\n return self.process_error(500, err.message)","def get_address(supvisors, strategy, addresses, expected_loading):\n if strategy == StartingStrategies.CONFIG:\n instance = ConfigStrategy(supvisors)\n if strategy == StartingStrategies.LESS_LOADED:\n instance = LessLoadedStrategy(supvisors)\n if strategy == StartingStrategies.MOST_LOADED:\n instance = MostLoadedStrategy(supvisors)\n # apply strategy result\n return instance.get_address(addresses, expected_loading)","def _gen_partial_strategy(mesh: DeviceMesh) -> PlacementStrategy:\n # NOTE: we use AVG by default, avg reduction is needed depending on\n # the loss function, for most loss function it should do\n # gradient averaging. There might be certain cases it should\n # not do gradient averaging (i.e. sum) but it's pretty rare.\n # TODO: Only NCCL supports AVG so using backend like Gloo would\n # crash, we should figure out a way to support avg reduction\n # for non-NCCL backend\n reduce_op = c10d.ReduceOp.AVG # type: ignore[attr-defined]\n return PlacementStrategy(\n output_spec=DTensorSpec(mesh=mesh, placements=[_Partial(reduce_op)]),\n )","def _create_linear(\n self, config: dict, light_model: LightModel, entity_domain: str\n ) -> LinearStrategy:\n linear_config = config.get(CONF_LINEAR)\n\n if linear_config is None:\n # Below is for BC compatibility\n if config.get(CONF_MIN_WATT) is not None:\n _LOGGER.warning(\n \"min_watt is deprecated and will be removed in version 0.3, use linear->min_power\"\n )\n linear_config = {\n CONF_MIN_POWER: config.get(CONF_MIN_WATT),\n CONF_MAX_POWER: config.get(CONF_MAX_WATT),\n }\n\n elif light_model is not None:\n linear_config = light_model.linear_mode_config\n\n return LinearStrategy(linear_config, entity_domain)","def create_candidate(ctx, pipeline):\n\n return Candidate(\n pipeline=pipeline,\n formulas=ctx.matrix.formulas,\n train=_evaluate_predictions(ctx, pipeline, *ctx.training_data()),\n test=_evaluate_predictions(ctx, pipeline, *ctx.testing_data()),\n )","def get_request_and_strategy(self, auth_entry=None, redirect_uri=None):\r\n request = self.request_factory.get(\r\n pipeline.get_complete_url(self.backend_name) +\r\n '?redirect_state=redirect_state_value&code=code_value&state=state_value')\r\n request.user = auth_models.AnonymousUser()\r\n request.session = cache.SessionStore()\r\n request.session[self.backend_name + '_state'] = 'state_value'\r\n\r\n if auth_entry:\r\n request.session[pipeline.AUTH_ENTRY_KEY] = auth_entry\r\n\r\n strategy = social_utils.load_strategy(backend=self.backend_name, redirect_uri=redirect_uri, request=request)\r\n request.social_strategy = strategy\r\n\r\n return request, strategy","def _generate_trading_instances(self, strategy_params_dict):\n print(\"Creating DataHandler, Strategy, Portfolio, and ExecutionHandler for\")\n print(\"strategy parameter list: %s...\" % strategy_params_dict)\n\n # Set internal data members equal to the classes we passed in earlier, along with necessary parameters.\n # https://softwareengineering.stackexchange.com/questions/131403/what-is-the-name-of-in-python/131415\n self.data_handler = self.data_handler_class(self.events, self.csv_dir, self.symbol_list)\n self.strategy = self.strategy_class(self.data_handler, self.events, **strategy_params_dict)\n self.portfolio = self.portfolio_class(self.data_handler, self.events, self.start_date, self.initial_capital)\n self.execution_handler = self.execution_handler_class(self.events) # The Event Queue sent to ExecutionHandler","def get_estimator_fn(num_gpus,\n variable_strategy,\n run_config,\n hparams):\n estimator = tf.estimator.Estimator(\n model_fn=get_model_fn(num_gpus, variable_strategy,\n run_config.num_worker_replicas or 1),\n config=run_config,\n params=hparams)\n\n return estimator","def from_state(state: Dict) -> \"Algorithm\":\n algorithm_class: Type[Algorithm] = state.get(\"algorithm_class\")\n if algorithm_class is None:\n raise ValueError(\n \"No `algorithm_class` key was found in given `state`! \"\n \"Cannot create new Algorithm.\"\n )\n # algo_class = get_trainable_cls(algo_class_name)\n # Create the new algo.\n config = state.get(\"config\")\n if not config:\n raise ValueError(\"No `config` found in given Algorithm state!\")\n new_algo = algorithm_class(config=config)\n # Set the new algo's state.\n new_algo.__setstate__(state)\n # Return the new algo.\n return new_algo","def __init__(__self__, *,\n accelerator_id: pulumi.Input[str],\n endpoint_group_region: pulumi.Input[str],\n basic_endpoint_group_name: Optional[pulumi.Input[str]] = None,\n description: Optional[pulumi.Input[str]] = None,\n endpoint_address: Optional[pulumi.Input[str]] = None,\n endpoint_sub_address: Optional[pulumi.Input[str]] = None,\n endpoint_type: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"accelerator_id\", accelerator_id)\n pulumi.set(__self__, \"endpoint_group_region\", endpoint_group_region)\n if basic_endpoint_group_name is not None:\n pulumi.set(__self__, \"basic_endpoint_group_name\", basic_endpoint_group_name)\n if description is not None:\n pulumi.set(__self__, \"description\", description)\n if endpoint_address is not None:\n pulumi.set(__self__, \"endpoint_address\", endpoint_address)\n if endpoint_sub_address is not None:\n pulumi.set(__self__, \"endpoint_sub_address\", endpoint_sub_address)\n if endpoint_type is not None:\n pulumi.set(__self__, \"endpoint_type\", endpoint_type)","def initialize_implementation(self):\n # call overridable methods to get number of inputs/outputs\n n_inputs = self.get_number_of_input_connections()\n n_outputs = self.get_number_of_output_ports()\n\n # call overrides to get implementation for teca execution\n # phase implementations\n import teca_py\n self.impl = teca_py.teca_programmable_algorithm.New()\n self.impl.set_number_of_input_connections(n_inputs)\n self.impl.set_number_of_output_ports(n_outputs)\n self.impl.set_name(self.__class__.__name__)\n self.impl.set_report_callback(self.get_report_callback())\n self.impl.set_request_callback(self.get_request_callback())\n self.impl.set_execute_callback(self.get_execute_callback())","def __init__(__self__, *,\n address: pulumi.Input[str],\n endpoint_id: pulumi.Input[str],\n port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['CustomRoutingEndpointTrafficPolicyPortRangeArgs']]]] = None):\n pulumi.set(__self__, \"address\", address)\n pulumi.set(__self__, \"endpoint_id\", endpoint_id)\n if port_ranges is not None:\n pulumi.set(__self__, \"port_ranges\", port_ranges)","def get_estimator(arguments):\n \n numerical_indices = [1, 2, 4, 5,6,7,8,9,10,11,12,13,14]\n categorical_indices = [0]\n original_indices = list(set(range(59))-set(numerical_indices)-set(categorical_indices))\n \n p1 = make_pipeline(my_module.PositionalSelector(categorical_indices),OneHotEncoder())\n p2 = make_pipeline(my_module.PositionalSelector(numerical_indices),StandardScaler())\n p3 = make_pipeline(my_module.PositionalSelector(original_indices))\n \n feats = FeatureUnion([('categoricals', p1),\n ('numericals', p2),\n ('originals', p3),])\n \n # tolerance and C are expected to be passed as\n # command line argument to task.py\n pipeline = Pipeline([('pre', feats),\n ('estimator', linear_model.LogisticRegression(penalty=\"l2\",\n tol=arguments.tol,\n C = arguments.C,\n solver='lbfgs',\n max_iter=10000))])\n \n # tolerance and C are expected to be passed as\n # command line argument to task.py\n #classifier = linear_model.LogisticRegression(\n # penalty=\"l2\",\n # tol=arguments.tol,\n # C = arguments.C,\n # solver='lbfgs',\n # max_iter=1000\n #)\n \n return pipeline","def get_factory():\n # Get config from Django settings\n sdk_config = settings.SPLITIO\n api_key = settings.SPLITIO.get('apiKey', '')\n\n return get_splitio_factory(\n api_key,\n config=sdk_config,\n **{k: sdk_config[k] for k in ('sdk_api_base_url', 'events_api_base_url', 'auth_api_base_url', 'streaming_api_base_url') if k in sdk_config}\n )","def from_params(self, params):\n raise NotImplementedError()","def generate():\n strategies = []\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy4))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeStrategy))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\n\n # Add HPS Dojo strategies\n strategies.extend(\n generate_meta_strategy_pair(HPSDojoStrategy))\n\n # Add testing please ignore strategies\n strategies.extend(\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\n\n # Add testimono strategy\n strategies.extend(\n generate_meta_strategy_pair(TestimonoStrategy))\n\n # Add RPS Geometry\n strategies.extend(\n generate_meta_strategy_pair(GeometryV4Strategy))\n\n # Add Iocaine Powder strategy\n strategies.extend(\n generate_meta_strategy_pair(IocanePowderStrategy))\n\n # Add are you a lucker strategies\n strategies.extend(\n generate_meta_strategy_pair(AreYouALuckerStrategy))\n\n # By default, rotate everything\n do_rotations = [True for _ in strategies]\n\n # Anti Trivial\n strategies.extend(\n generate_meta_strategy_pair(\n AntiTrivialStrategy, mirroring=False))\n do_rotations.extend([False])\n\n return strategies, do_rotations","def __init__(\n self,\n name: str,\n createStepName: str,\n surface: Region,\n interactionProperty: str,\n enforcement: SymbolicConstant = SURFACE_TO_SURFACE,\n thickness: Boolean = ON,\n smooth: float = 0,\n contactControls: str = \"\",\n ):\n super().__init__()\n pass","def generate():\n strategies = []\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy4))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeStrategy))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\n\n # Add HPS Dojo strategies\n strategies.extend(\n generate_meta_strategy_pair(HPSDojoStrategy))\n\n # Add testing please ignore strategies\n strategies.extend(\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\n\n # Add testimono strategy\n strategies.extend(\n generate_meta_strategy_pair(TestimonoStrategy))\n\n # Add RPS Geometry\n strategies.extend(\n generate_meta_strategy_pair(GeometryV4Strategy))\n\n # Add Iocaine Powder strategy\n strategies.extend(\n generate_meta_strategy_pair(IocanePowderStrategy))\n\n # Add are you a lucker strategies\n strategies.extend(\n generate_meta_strategy_pair(AreYouALuckerStrategy))\n\n # Add Greenberg strategies\n strategies.extend(\n generate_meta_strategy_pair(GreenbergStrategy))\n\n # Add RPS Meta Fix strategies\n strategies.extend(\n generate_meta_strategy_pair(RPSMetaFixStrategy))\n\n # By default, rotate everything\n do_rotations = [True for _ in strategies]\n\n # Anti Trivial\n strategies.extend(\n generate_meta_strategy_pair(\n AntiTrivialStrategy, mirroring=False))\n do_rotations.extend([False])\n\n return strategies, do_rotations","def generate():\n strategies = []\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy4))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeStrategy))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\n\n # Add HPS Dojo strategies\n strategies.extend(\n generate_meta_strategy_pair(HPSDojoStrategy))\n\n # Add testing please ignore strategies\n strategies.extend(\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\n\n # Add testimono strategy\n strategies.extend(\n generate_meta_strategy_pair(TestimonoStrategy))\n\n # Add RPS Geometry\n strategies.extend(\n generate_meta_strategy_pair(GeometryV4Strategy))\n\n # Add Iocaine Powder strategy\n strategies.extend(\n generate_meta_strategy_pair(IocanePowderStrategy))\n\n # By default, rotate everything\n do_rotations = [True for _ in strategies]\n\n # Anti Trivial\n strategies.extend(\n generate_meta_strategy_pair(\n AntiTrivialStrategy, mirroring=False))\n do_rotations.extend([False])\n\n return strategies, do_rotations","def create_factory(cls, *args):\n raise NotImplementedError","def generate():\n strategies = []\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy4))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeStrategy))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\n\n # Add HPS Dojo strategies\n strategies.extend(\n generate_meta_strategy_pair(HPSDojoStrategy))\n\n # Add testing please ignore strategies\n strategies.extend(\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\n\n # Add testimono strategy\n strategies.extend(\n generate_meta_strategy_pair(TestimonoStrategy))\n\n # Add RPS Geometry\n strategies.extend(\n generate_meta_strategy_pair(GeometryV4Strategy))\n\n # Add Iocaine Powder strategy\n strategies.extend(\n generate_meta_strategy_pair(IocanePowderStrategy))\n\n # Add are you a lucker strategies\n strategies.extend(\n generate_meta_strategy_pair(AreYouALuckerStrategy))\n\n # Add RPS Meta Fix strategies\n strategies.extend(\n generate_meta_strategy_pair(RPSMetaFixStrategy))\n\n # By default, rotate everything\n do_rotations = [True for _ in strategies]\n\n # Anti Trivial\n strategies.extend(\n generate_meta_strategy_pair(\n AntiTrivialStrategy, mirroring=False))\n do_rotations.extend([False])\n\n return strategies, do_rotations","def __init__(__self__, *,\n accelerator_id: Optional[pulumi.Input[str]] = None,\n basic_endpoint_group_name: Optional[pulumi.Input[str]] = None,\n description: Optional[pulumi.Input[str]] = None,\n endpoint_address: Optional[pulumi.Input[str]] = None,\n endpoint_group_region: Optional[pulumi.Input[str]] = None,\n endpoint_sub_address: Optional[pulumi.Input[str]] = None,\n endpoint_type: Optional[pulumi.Input[str]] = None,\n status: Optional[pulumi.Input[str]] = None):\n if accelerator_id is not None:\n pulumi.set(__self__, \"accelerator_id\", accelerator_id)\n if basic_endpoint_group_name is not None:\n pulumi.set(__self__, \"basic_endpoint_group_name\", basic_endpoint_group_name)\n if description is not None:\n pulumi.set(__self__, \"description\", description)\n if endpoint_address is not None:\n pulumi.set(__self__, \"endpoint_address\", endpoint_address)\n if endpoint_group_region is not None:\n pulumi.set(__self__, \"endpoint_group_region\", endpoint_group_region)\n if endpoint_sub_address is not None:\n pulumi.set(__self__, \"endpoint_sub_address\", endpoint_sub_address)\n if endpoint_type is not None:\n pulumi.set(__self__, \"endpoint_type\", endpoint_type)\n if status is not None:\n pulumi.set(__self__, \"status\", status)","def create_endpoint(*args):\n endpoint = ''\n for arg in args:\n endpoint = endpoint + str(arg) + \"/\"\n endpoint = endpoint[:-1]\n endpoint = endpoint + \".json\"\n return endpoint","def apply_hooks(\n endpoint: Endpoint,\n context: HookContext,\n hooks: Optional[HookDispatcher],\n strategy: st.SearchStrategy[Case],\n location: str,\n) -> st.SearchStrategy[Case]:\n strategy = _apply_hooks(context, GLOBAL_HOOK_DISPATCHER, strategy, location)\n strategy = _apply_hooks(context, endpoint.schema.hooks, strategy, location)\n if hooks is not None:\n strategy = _apply_hooks(context, hooks, strategy, location)\n return strategy","def buildProtocol(self,addr):\r\n p = self.protocol(self.server)\r\n p.factory = self\r\n return p","def get_by_name(cls, context, name, eager=False):\n\n db_strategy = cls.dbapi.get_strategy_by_name(\n context, name, eager=eager)\n strategy = cls._from_db_object(cls(context), db_strategy, eager=eager)\n return strategy","def create_payment_strategy(platform=None, payer_id=None):\n patron = create_patron(email=payer_id)\n platform = PaymentStrategy.TRANSFER if platform is None else platform\n payer_id = \"\" if payer_id is None else payer_id\n return PaymentStrategy.objects.create(\n platform=platform, id_in_platform=payer_id, patron=patron)","def get_strategy(task_type: TaskType, **kwargs: Any) -> 'RepoBuildStrategy':\n\n build_strategies = {\n TaskType.IFW_TASK_TYPE: IFWRepoBuildStrategy,\n TaskType.QBSP_TASK_TYPE: QBSPRepoBuildStrategy,\n }\n return build_strategies[task_type](**kwargs)","def factory(self):\n raise NotImplementedError()","def create(\n cls: type[T],\n parameter_handler: TP,\n topology: \"Topology\",\n ) -> T:\n if type(parameter_handler) not in cls.allowed_parameter_handlers():\n raise InvalidParameterHandlerError(type(parameter_handler))\n\n handler = cls()\n if hasattr(handler, \"fractional_bondorder_method\"):\n if getattr(parameter_handler, \"fractional_bondorder_method\", None):\n handler.fractional_bond_order_method = ( # type: ignore[attr-defined]\n parameter_handler.fractional_bondorder_method\n )\n handler.fractional_bond_order_interpolation = ( # type: ignore[attr-defined]\n parameter_handler.fractional_bondorder_interpolation\n )\n handler.store_matches(parameter_handler=parameter_handler, topology=topology)\n handler.store_potentials(parameter_handler=parameter_handler)\n\n return handler","def create(cls, original_args, process_args, base_url, host_url, services):\n return cls(original_args, process_args, base_url, host_url, services)","def _create_impl(self):","def _create_fixed(self, config: dict, light_model: LightModel) -> FixedStrategy:\n fixed_config = config.get(CONF_FIXED)\n if fixed_config is None and light_model is not None:\n fixed_config = light_model.fixed_mode_config\n\n # BC compat\n if fixed_config is None:\n _LOGGER.warning(\n \"watt is deprecated and will be removed in version 0.3, use fixed->power\"\n )\n fixed_config = {CONF_POWER: config.get(CONF_WATT)}\n\n return FixedStrategy(\n fixed_config.get(CONF_POWER), fixed_config.get(CONF_STATES_POWER)\n )","def from_pipeline_spec_dict(cls, pipeline_spec_dict: Dict[str, Any],\n component_name: str) -> 'Implementation':\n executor_key = utils.sanitize_executor_label(component_name)\n executor = pipeline_spec_dict['deploymentSpec']['executors'].get(\n executor_key)\n if executor is not None:\n container_spec = ContainerSpecImplementation.from_container_dict(\n executor['container']) if executor else None\n return Implementation(container=container_spec)\n else:\n pipeline_spec = json_format.ParseDict(\n pipeline_spec_dict, pipeline_spec_pb2.PipelineSpec())\n return Implementation(graph=pipeline_spec)","def generate():\n strategies = []\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeStrategy))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\n\n # Add HPS Dojo strategies\n strategies.extend(\n generate_meta_strategy_pair(HPSDojoStrategy))\n\n # Add testing please ignore strategies\n strategies.extend(\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\n\n # Add testimono strategy\n strategies.extend(\n generate_meta_strategy_pair(TestimonoStrategy))\n\n # Add RPS Geometry\n strategies.extend(\n generate_meta_strategy_pair(GeometryV4Strategy))\n\n # Add Iocaine Powder strategy\n strategies.extend(\n generate_meta_strategy_pair(IocanePowderStrategy))\n\n # By default, rotate everything\n do_rotations = [True for _ in strategies]\n\n # Anti Trivial\n strategies.extend(\n generate_meta_strategy_pair(\n AntiTrivialStrategy, mirroring=False))\n do_rotations.extend([False])\n\n return strategies, do_rotations","async def connection_factory(*args, **kwargs):\n if args[1] == \"5L\":\n protocol.telegram = {\n LUXEMBOURG_EQUIPMENT_IDENTIFIER: CosemObject(\n [{\"value\": \"12345678\", \"unit\": \"\"}]\n ),\n EQUIPMENT_IDENTIFIER_GAS: CosemObject(\n [{\"value\": \"123456789\", \"unit\": \"\"}]\n ),\n }\n if args[1] == \"5S\":\n protocol.telegram = {\n P1_MESSAGE_TIMESTAMP: CosemObject([{\"value\": \"12345678\", \"unit\": \"\"}]),\n }\n if args[1] == \"Q3D\":\n protocol.telegram = {\n Q3D_EQUIPMENT_IDENTIFIER: CosemObject(\n [{\"value\": \"12345678\", \"unit\": \"\"}]\n ),\n }\n\n return (transport, protocol)","def get_by_id(cls, context, strategy_id, eager=False):\n db_strategy = cls.dbapi.get_strategy_by_id(\n context, strategy_id, eager=eager)\n strategy = cls._from_db_object(cls(context), db_strategy, eager=eager)\n return strategy","def generate():\n strategies = []\n\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\n strategies.extend(\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeStrategy))\n\n # Add decision tree strategies\n strategies.extend(\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\n\n # Add HPS Dojo strategies\n strategies.extend(\n generate_meta_strategy_pair(HPSDojoStrategy))\n\n # Add testing please ignore strategies\n strategies.extend(\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\n\n # Add testimono strategy\n strategies.extend(\n generate_meta_strategy_pair(TestimonoStrategy))\n\n # Add RPS Geometry\n strategies.extend(\n generate_meta_strategy_pair(GeometryV4Strategy))\n\n # By default, rotate everything\n do_rotations = [True for _ in strategies]\n\n # Anti Trivial\n strategies.extend(\n generate_meta_strategy_pair(\n AntiTrivialStrategy, mirroring=False))\n do_rotations.extend([False])\n\n return strategies, do_rotations","def port_factory_method(self):\n if self.is_secure:\n return HTTPSSecurePort()\n return HTTPPort()","def factory_method(self):\n pass","def factory_method(self):\n pass","def endpoint_create(self, endpoint_name=None, config=None):\n if config is None:\n raise Exception(\"Config required!\")\n if endpoint_name is None:\n self.request('/v1.1/endpoint', 'PUT', body=config)\n else:\n self.request('/v1.1/endpoints/%s' % endpoint_name, 'PUT', body=config)","def buildProtocol(self, addr):\n protocol = PortalBot()\n protocol.factory = self\n protocol.nickname = self.nickname\n protocol.channel = self.channel\n protocol.network = self.network\n protocol.port = self.port\n protocol.ssl = self.ssl\n protocol.nicklist = []\n return protocol","def register_factory(self, factory, from_protocol, to_protocol):\n\n from traits.adaptation.adaptation_offer import AdaptationOffer\n\n self.register_offer(\n AdaptationOffer(\n factory=factory,\n from_protocol=from_protocol,\n to_protocol=to_protocol,\n )\n )\n\n return","def __init__(self, params):\n\n # set up logger\n self.logger = logging.getLogger('sweeper')\n\n essential_keys = ['num_nodes']\n for key in essential_keys:\n if key not in params:\n msg = 'need %s to instantiate step, only got %s' % (key, str(params.keys()))\n self.logger.error(msg)\n raise ParameterError(msg)\n\n if 'collocation_class' not in params:\n params['collocation_class'] = CollBase\n\n # prepare random generator for initial guess\n if params.get('initial_guess', 'spread') == 'random':\n params['random_seed'] = params.get('random_seed', 1984)\n self.rng = np.random.RandomState(params['random_seed'])\n\n self.params = _Pars(params)\n\n self.coll = params['collocation_class'](**params)\n\n if not self.coll.right_is_node and not self.params.do_coll_update:\n self.logger.warning(\n 'we need to do a collocation update here, since the right end point is not a node. Changing this!'\n )\n self.params.do_coll_update = True\n\n # This will be set as soon as the sweeper is instantiated at the level\n self.__level = None\n\n self.parallelizable = False","def __call__(self):\n \n p = self.protocol()\n p.factory = self\n return p","def __init__(__self__, *,\n endpoint_type: pulumi.Input[str],\n resource_id: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"endpoint_type\", 'HybridConnection')\n if resource_id is not None:\n pulumi.set(__self__, \"resource_id\", resource_id)","def factory(container, name, factory):","def create_model_endpoint(\n cls,\n db_session: sqlalchemy.orm.Session,\n model_endpoint: mlrun.common.schemas.ModelEndpoint,\n ) -> mlrun.common.schemas.ModelEndpoint:\n\n if model_endpoint.spec.model_uri or model_endpoint.status.feature_stats:\n logger.info(\n \"Getting feature metadata\",\n project=model_endpoint.metadata.project,\n model=model_endpoint.spec.model,\n function=model_endpoint.spec.function_uri,\n model_uri=model_endpoint.spec.model_uri,\n )\n\n # If model artifact was supplied, grab model metadata from artifact\n if model_endpoint.spec.model_uri:\n logger.info(\n \"Getting model object, inferring column names and collecting feature stats\"\n )\n run_db = mlrun.api.api.utils.get_run_db_instance(db_session)\n model_obj: mlrun.artifacts.ModelArtifact = (\n mlrun.datastore.store_resources.get_store_resource(\n model_endpoint.spec.model_uri, db=run_db\n )\n )\n\n # Get stats from model object if not found in model endpoint object\n if not model_endpoint.status.feature_stats and hasattr(\n model_obj, \"feature_stats\"\n ):\n if model_obj.spec.feature_stats:\n mlrun.common.model_monitoring.helpers.pad_features_hist(\n mlrun.common.model_monitoring.helpers.FeatureStats(\n model_obj.spec.feature_stats\n )\n )\n model_endpoint.status.feature_stats = model_obj.spec.feature_stats\n # Get labels from model object if not found in model endpoint object\n if not model_endpoint.spec.label_names and model_obj.spec.outputs:\n model_label_names = [\n mlrun.api.crud.model_monitoring.helpers.clean_feature_name(f.name)\n for f in model_obj.spec.outputs\n ]\n model_endpoint.spec.label_names = model_label_names\n\n # Get algorithm from model object if not found in model endpoint object\n if not model_endpoint.spec.algorithm and model_obj.spec.algorithm:\n model_endpoint.spec.algorithm = model_obj.spec.algorithm\n\n # Create monitoring feature set if monitoring found in model endpoint object\n if (\n model_endpoint.spec.monitoring_mode\n == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled.value\n ):\n monitoring_feature_set = cls.create_monitoring_feature_set(\n model_endpoint, model_obj, db_session, run_db\n )\n # Link model endpoint object to feature set URI\n model_endpoint.status.monitoring_feature_set_uri = (\n monitoring_feature_set.uri\n )\n\n # If feature_stats was either populated by model_uri or by manual input, make sure to keep the names\n # of the features. If feature_names was supplied, replace the names set in feature_stats, otherwise - make\n # sure to keep a clean version of the names\n if model_endpoint.status.feature_stats:\n logger.info(\"Feature stats found, cleaning feature names\")\n if model_endpoint.spec.feature_names:\n # Validate that the length of feature_stats is equal to the length of feature_names and label_names\n cls._validate_length_features_and_labels(model_endpoint=model_endpoint)\n\n # Clean feature names in both feature_stats and feature_names\n (\n model_endpoint.status.feature_stats,\n model_endpoint.spec.feature_names,\n ) = cls._adjust_feature_names_and_stats(model_endpoint=model_endpoint)\n\n logger.info(\n \"Done preparing feature names and stats\",\n feature_names=model_endpoint.spec.feature_names,\n )\n\n # If none of the above was supplied, feature names will be assigned on first contact with the model monitoring\n # system\n logger.info(\"Creating model endpoint\", endpoint_id=model_endpoint.metadata.uid)\n\n # Write the new model endpoint\n model_endpoint_store = get_model_endpoint_store(\n project=model_endpoint.metadata.project,\n secret_provider=mlrun.api.crud.secrets.get_project_secret_provider(\n project=model_endpoint.metadata.project\n ),\n )\n model_endpoint_store.write_model_endpoint(endpoint=model_endpoint.flat_dict())\n\n logger.info(\"Model endpoint created\", endpoint_id=model_endpoint.metadata.uid)\n\n return model_endpoint","def create_algorithm(AlgorithmName=None, AlgorithmDescription=None, TrainingSpecification=None, InferenceSpecification=None, ValidationSpecification=None, CertifyForMarketplace=None):\n pass"],"string":"[\n \"def get_case_strategy( # pylint: disable=too-many-locals\\n draw: Callable,\\n endpoint: Endpoint,\\n hooks: Optional[HookDispatcher] = None,\\n feedback: Optional[Feedback] = None,\\n data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),\\n path_parameters: Any = NOT_SET,\\n headers: Any = NOT_SET,\\n cookies: Any = NOT_SET,\\n query: Any = NOT_SET,\\n body: Any = NOT_SET,\\n) -> Any:\\n to_strategy = {DataGenerationMethod.positive: make_positive_strategy}[data_generation_method]\\n\\n context = HookContext(endpoint)\\n\\n if path_parameters is NOT_SET:\\n strategy = get_parameters_strategy(endpoint, to_strategy, \\\"path\\\")\\n strategy = apply_hooks(endpoint, context, hooks, strategy, \\\"path\\\")\\n path_parameters = draw(strategy)\\n if headers is NOT_SET:\\n strategy = get_parameters_strategy(endpoint, to_strategy, \\\"header\\\")\\n strategy = apply_hooks(endpoint, context, hooks, strategy, \\\"header\\\")\\n headers = draw(strategy)\\n if cookies is NOT_SET:\\n strategy = get_parameters_strategy(endpoint, to_strategy, \\\"cookie\\\")\\n strategy = apply_hooks(endpoint, context, hooks, strategy, \\\"cookie\\\")\\n cookies = draw(strategy)\\n if query is NOT_SET:\\n strategy = get_parameters_strategy(endpoint, to_strategy, \\\"query\\\")\\n strategy = apply_hooks(endpoint, context, hooks, strategy, \\\"query\\\")\\n query = draw(strategy)\\n\\n media_type = None\\n if body is NOT_SET:\\n if endpoint.body:\\n parameter = draw(st.sampled_from(endpoint.body.items))\\n strategy = _get_body_strategy(parameter, to_strategy)\\n media_type = parameter.media_type\\n body = draw(strategy)\\n else:\\n media_types = endpoint.get_request_payload_content_types() or [\\\"application/json\\\"]\\n # Take the first available media type.\\n # POSSIBLE IMPROVEMENT:\\n # - Test examples for each available media type on Open API 2.0;\\n # - On Open API 3.0, media types are explicit, and each example has it. We can pass `OpenAPIBody.media_type`\\n # here from the examples handling code.\\n media_type = media_types[0]\\n if endpoint.schema.validate_schema and endpoint.method.upper() == \\\"GET\\\" and endpoint.body:\\n raise InvalidSchema(\\\"Body parameters are defined for GET request.\\\")\\n return Case(\\n endpoint=endpoint,\\n feedback=feedback,\\n media_type=media_type,\\n path_parameters=path_parameters,\\n headers=headers,\\n cookies=cookies,\\n query=query,\\n body=body,\\n )\",\n \"def create_test_strategy(context, **kw):\\n strategy = get_test_strategy(context, **kw)\\n strategy.create()\\n return strategy\",\n \"def make_endpoint(self, collected: List[ParsedData]) -> Endpoint:\\n # We split the gathered data among all locations & store the original parameter\\n containers = {\\n location: {\\n parameter.name: {\\\"options\\\": [], \\\"parameter\\\": parameter}\\n for parameter in getattr(self.endpoint, container_name)\\n }\\n for location, container_name in LOCATION_TO_CONTAINER.items()\\n }\\n # There might be duplicates in the data\\n for item in set(collected):\\n for name, value in item.parameters.items():\\n container = self._get_container_by_parameter_name(name, containers)\\n container.append(value)\\n # These are the final `path_parameters`, `query`, and other endpoint components\\n components: Dict[str, ParameterSet] = {\\n container_name: getattr(self.endpoint, container_name).__class__()\\n for location, container_name in LOCATION_TO_CONTAINER.items()\\n }\\n # Here are all components that are filled with parameters\\n for location, parameters in containers.items():\\n for name, parameter_data in parameters.items():\\n if parameter_data[\\\"options\\\"]:\\n definition = deepcopy(parameter_data[\\\"parameter\\\"].definition)\\n if \\\"schema\\\" in definition:\\n # The actual schema doesn't matter since we have a list of allowed values\\n definition[\\\"schema\\\"] = {\\\"enum\\\": parameter_data[\\\"options\\\"]}\\n else:\\n # Other schema-related keywords will be ignored later, during the canonicalisation step\\n # inside `hypothesis-jsonschema`\\n definition[\\\"enum\\\"] = parameter_data[\\\"options\\\"]\\n components[LOCATION_TO_CONTAINER[location]].add(parameter_data[\\\"parameter\\\"].__class__(definition))\\n else:\\n # No options were gathered for this parameter - use the original one\\n components[LOCATION_TO_CONTAINER[location]].add(parameter_data[\\\"parameter\\\"])\\n return self.endpoint.clone(**components)\",\n \"def __init__(self):\\n self.strategy = Strategy(self)\",\n \"def create_strategy(config):\\n build_strategy = paddle.static.BuildStrategy()\\n exec_strategy = paddle.static.ExecutionStrategy()\\n\\n exec_strategy.num_threads = 1\\n exec_strategy.num_iteration_per_drop_scope = (\\n 10000\\n if 'AMP' in config and config.AMP.get(\\\"use_pure_fp16\\\", False) else 10)\\n\\n fuse_op = True if 'AMP' in config else False\\n\\n fuse_bn_act_ops = config.get('fuse_bn_act_ops', fuse_op)\\n fuse_elewise_add_act_ops = config.get('fuse_elewise_add_act_ops', fuse_op)\\n fuse_bn_add_act_ops = config.get('fuse_bn_add_act_ops', fuse_op)\\n enable_addto = config.get('enable_addto', fuse_op)\\n\\n build_strategy.fuse_bn_act_ops = fuse_bn_act_ops\\n build_strategy.fuse_elewise_add_act_ops = fuse_elewise_add_act_ops\\n build_strategy.fuse_bn_add_act_ops = fuse_bn_add_act_ops\\n build_strategy.enable_addto = enable_addto\\n\\n return build_strategy, exec_strategy\",\n \"def build_allocation_strategy(self, *args, **kwargs):\\n return self.build_param(\\n Parameter.ALLOCATION_STRATEGY, AllocationStrategy, *args,\\n _special_builder=False, **kwargs)\",\n \"def strategy(func):\\n strategies.append(func)\\n return func\",\n \"def strategy(strategy_name: str):\\r\\n def wrapper(finder_class):\\r\\n global strategies\\r\\n strategies[strategy_name] = finder_class\\r\\n return finder_class\\r\\n return wrapper\",\n \"def get_strategy(self): \\n if self._strategy is ServerSide:\\n self.arguments = [ask_for_port()]\\n\\n elif self._strategy is ClientSide:\\n self.arguments = [ask_for_recipient(), \\n ask_for_listening_port(),\\n self._get_header(),\\n ask_for_test()]\\n return self._strategy(*self.arguments)\",\n \"def InitStrategy(self, sname, strategy):\\n\\n self._string = sname\\n\\n self.strategy = strategy\\n self.postracker = position.PositionTracker(self.strategy)\",\n \"def build_endpoint(self, **kwargs):\\n\\n raise NotImplementedError()\",\n \"def __init__(__self__, *,\\n accelerator_id: Optional[pulumi.Input[str]] = None,\\n address: Optional[pulumi.Input[str]] = None,\\n custom_routing_endpoint_traffic_policy_id: Optional[pulumi.Input[str]] = None,\\n endpoint_group_id: Optional[pulumi.Input[str]] = None,\\n endpoint_id: Optional[pulumi.Input[str]] = None,\\n listener_id: Optional[pulumi.Input[str]] = None,\\n port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['CustomRoutingEndpointTrafficPolicyPortRangeArgs']]]] = None,\\n status: Optional[pulumi.Input[str]] = None):\\n if accelerator_id is not None:\\n pulumi.set(__self__, \\\"accelerator_id\\\", accelerator_id)\\n if address is not None:\\n pulumi.set(__self__, \\\"address\\\", address)\\n if custom_routing_endpoint_traffic_policy_id is not None:\\n pulumi.set(__self__, \\\"custom_routing_endpoint_traffic_policy_id\\\", custom_routing_endpoint_traffic_policy_id)\\n if endpoint_group_id is not None:\\n pulumi.set(__self__, \\\"endpoint_group_id\\\", endpoint_group_id)\\n if endpoint_id is not None:\\n pulumi.set(__self__, \\\"endpoint_id\\\", endpoint_id)\\n if listener_id is not None:\\n pulumi.set(__self__, \\\"listener_id\\\", listener_id)\\n if port_ranges is not None:\\n pulumi.set(__self__, \\\"port_ranges\\\", port_ranges)\\n if status is not None:\\n pulumi.set(__self__, \\\"status\\\", status)\",\n \"def protocol_factory_method(self):\\n pass\",\n \"def make(cls, cluster_name: str, backend: 'backends.Backend',\\n task: 'task_lib.Task', retry_until_up: bool) -> 'StrategyExecutor':\\n task_resources = task.resources\\n assert len(task_resources) == 1, 'Only one resource is supported.'\\n resources: 'sky.Resources' = list(task_resources)[0]\\n\\n spot_recovery = resources.spot_recovery\\n assert spot_recovery is not None, (\\n 'spot_recovery is required to use spot strategy.')\\n # Remove the spot_recovery field from the resources, as the strategy\\n # will be handled by the strategy class.\\n task.set_resources({resources.copy(spot_recovery=None)})\\n return SPOT_STRATEGIES[spot_recovery](cluster_name, backend, task,\\n retry_until_up)\",\n \"def create(\\n self,\\n config: dict,\\n mode: str,\\n light_model: Optional[LightModel],\\n entity_domain: str,\\n ) -> PowerCalculationStrategyInterface:\\n if mode == MODE_LINEAR:\\n return self._create_linear(config, light_model, entity_domain)\\n\\n if mode == MODE_FIXED:\\n return self._create_fixed(config, light_model)\\n\\n if mode == MODE_LUT:\\n return self._create_lut(light_model)\\n\\n raise UnsupportedMode(\\\"Invalid calculation mode\\\", mode)\",\n \"def strategy(self) -> AwesomeVersionStrategy:\\n return version_strategy(self.string)\",\n \"def create_behavior(self, name, parameters):\\n return self._behaviors[name](parameters)\",\n \"def __init__(self, strategy=None):\\n self.strategy = strategy if strategy is not None else GenericStrategyComponent()\\n self.is_game_over = False\\n self.is_kicked = False\\n self.is_winner = False\",\n \"def __init__(self, endpoint_a, endpoint_b):\\n self.endpoint_a = endpoint_a\\n self.endpoint_b = endpoint_b\",\n \"def _create_algorithm(algo_name, algo_options, origin):\\n if origin == \\\"nlopt\\\":\\n algo = pg.algorithm(pg.nlopt(solver=algo_name))\\n for option, val in algo_options.items():\\n setattr(algo.extract(pg.nlopt), option, val)\\n elif origin == \\\"pygmo\\\":\\n pygmo_uda = getattr(pg, algo_name)\\n algo_options = algo_options.copy()\\n if \\\"popsize\\\" in algo_options:\\n del algo_options[\\\"popsize\\\"]\\n algo = pg.algorithm(pygmo_uda(**algo_options))\\n\\n return algo\",\n \"def __init__(self, id: int=None, strategy_id: int=None, operator: str=None, comment: str=None, price: float=None, quantity: int=None, target_prices: List[float]=None, stop_loss_prices: List[float]=None): # noqa: E501\\n self.swagger_types = {\\n 'id': int,\\n 'strategy_id': int,\\n 'operator': str,\\n 'comment': str,\\n 'price': float,\\n 'quantity': int,\\n 'target_prices': List[float],\\n 'stop_loss_prices': List[float]\\n }\\n\\n self.attribute_map = {\\n 'id': 'id',\\n 'strategy_id': 'strategy_id',\\n 'operator': 'operator',\\n 'comment': 'comment',\\n 'price': 'price',\\n 'quantity': 'quantity',\\n 'target_prices': 'target_prices',\\n 'stop_loss_prices': 'stop_loss_prices'\\n }\\n self._id = id\\n self._strategy_id = strategy_id\\n self._operator = operator\\n self._comment = comment\\n self._price = price\\n self._quantity = quantity\\n self._target_prices = target_prices\\n self._stop_loss_prices = stop_loss_prices\",\n \"def create_servicech(self, conf, params):\\n\\t\\tpass\",\n \"def __new__(cls, component, *args, **kwargs):\\n if cls.dependencies:\\n for dependency in cls.dependencies:\\n component.load_feature(dependency, *args, **kwargs)\\n return super(Feature, cls).__new__(cls)\",\n \"def setStrategy(self, value):\\n return self._set(strategy=value)\",\n \"def setCaseStrategy(self, strategy):\\n return self._set(caseStrategy=strategy)\",\n \"def setCaseStrategy(self, strategy):\\n return self._set(caseStrategy=strategy)\",\n \"def __init__(__self__,\\n resource_name: str,\\n opts: Optional[pulumi.ResourceOptions] = None,\\n address: Optional[pulumi.Input[str]] = None,\\n endpoint_id: Optional[pulumi.Input[str]] = None,\\n port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CustomRoutingEndpointTrafficPolicyPortRangeArgs']]]]] = None,\\n __props__=None):\\n ...\",\n \"def __init__(\\n self,\\n config: Optional[AlgorithmConfig] = None,\\n env=None, # deprecated arg\\n logger_creator: Optional[Callable[[], Logger]] = None,\\n **kwargs,\\n ):\\n config = config or self.get_default_config()\\n\\n # Translate possible dict into an AlgorithmConfig object, as well as,\\n # resolving generic config objects into specific ones (e.g. passing\\n # an `AlgorithmConfig` super-class instance into a PPO constructor,\\n # which normally would expect a PPOConfig object).\\n if isinstance(config, dict):\\n default_config = self.get_default_config()\\n # `self.get_default_config()` also returned a dict ->\\n # Last resort: Create core AlgorithmConfig from merged dicts.\\n if isinstance(default_config, dict):\\n config = AlgorithmConfig.from_dict(\\n config_dict=self.merge_algorithm_configs(\\n default_config, config, True\\n )\\n )\\n # Default config is an AlgorithmConfig -> update its properties\\n # from the given config dict.\\n else:\\n config = default_config.update_from_dict(config)\\n else:\\n default_config = self.get_default_config()\\n # Given AlgorithmConfig is not of the same type as the default config:\\n # This could be the case e.g. if the user is building an algo from a\\n # generic AlgorithmConfig() object.\\n if not isinstance(config, type(default_config)):\\n config = default_config.update_from_dict(config.to_dict())\\n\\n # In case this algo is using a generic config (with no algo_class set), set it\\n # here.\\n if config.algo_class is None:\\n config.algo_class = type(self)\\n\\n if env is not None:\\n deprecation_warning(\\n old=f\\\"algo = Algorithm(env='{env}', ...)\\\",\\n new=f\\\"algo = AlgorithmConfig().environment('{env}').build()\\\",\\n error=False,\\n )\\n config.environment(env)\\n\\n # Validate and freeze our AlgorithmConfig object (no more changes possible).\\n config.validate()\\n config.freeze()\\n\\n # Convert `env` provided in config into a concrete env creator callable, which\\n # takes an EnvContext (config dict) as arg and returning an RLlib supported Env\\n # type (e.g. a gym.Env).\\n self._env_id, self.env_creator = self._get_env_id_and_creator(\\n config.env, config\\n )\\n env_descr = (\\n self._env_id.__name__ if isinstance(self._env_id, type) else self._env_id\\n )\\n\\n # Placeholder for a local replay buffer instance.\\n self.local_replay_buffer = None\\n\\n # Create a default logger creator if no logger_creator is specified\\n if logger_creator is None:\\n # Default logdir prefix containing the agent's name and the\\n # env id.\\n timestr = datetime.today().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\\n env_descr_for_dir = re.sub(\\\"[/\\\\\\\\\\\\\\\\]\\\", \\\"-\\\", str(env_descr))\\n logdir_prefix = f\\\"{str(self)}_{env_descr_for_dir}_{timestr}\\\"\\n if not os.path.exists(DEFAULT_RESULTS_DIR):\\n # Possible race condition if dir is created several times on\\n # rollout workers\\n os.makedirs(DEFAULT_RESULTS_DIR, exist_ok=True)\\n logdir = tempfile.mkdtemp(prefix=logdir_prefix, dir=DEFAULT_RESULTS_DIR)\\n\\n # Allow users to more precisely configure the created logger\\n # via \\\"logger_config.type\\\".\\n if config.logger_config and \\\"type\\\" in config.logger_config:\\n\\n def default_logger_creator(config):\\n \\\"\\\"\\\"Creates a custom logger with the default prefix.\\\"\\\"\\\"\\n cfg = config[\\\"logger_config\\\"].copy()\\n cls = cfg.pop(\\\"type\\\")\\n # Provide default for logdir, in case the user does\\n # not specify this in the \\\"logger_config\\\" dict.\\n logdir_ = cfg.pop(\\\"logdir\\\", logdir)\\n return from_config(cls=cls, _args=[cfg], logdir=logdir_)\\n\\n # If no `type` given, use tune's UnifiedLogger as last resort.\\n else:\\n\\n def default_logger_creator(config):\\n \\\"\\\"\\\"Creates a Unified logger with the default prefix.\\\"\\\"\\\"\\n return UnifiedLogger(config, logdir, loggers=None)\\n\\n logger_creator = default_logger_creator\\n\\n # Metrics-related properties.\\n self._timers = defaultdict(_Timer)\\n self._counters = defaultdict(int)\\n self._episode_history = []\\n self._episodes_to_be_collected = []\\n\\n # The fully qualified AlgorithmConfig used for evaluation\\n # (or None if evaluation not setup).\\n self.evaluation_config: Optional[AlgorithmConfig] = None\\n # Evaluation WorkerSet and metrics last returned by `self.evaluate()`.\\n self.evaluation_workers: Optional[WorkerSet] = None\\n # Initialize common evaluation_metrics to nan, before they become\\n # available. We want to make sure the metrics are always present\\n # (although their values may be nan), so that Tune does not complain\\n # when we use these as stopping criteria.\\n self.evaluation_metrics = {\\n # TODO: Don't dump sampler results into top-level.\\n \\\"evaluation\\\": {\\n \\\"episode_reward_max\\\": np.nan,\\n \\\"episode_reward_min\\\": np.nan,\\n \\\"episode_reward_mean\\\": np.nan,\\n \\\"sampler_results\\\": {\\n \\\"episode_reward_max\\\": np.nan,\\n \\\"episode_reward_min\\\": np.nan,\\n \\\"episode_reward_mean\\\": np.nan,\\n },\\n },\\n }\\n\\n super().__init__(\\n config=config,\\n logger_creator=logger_creator,\\n **kwargs,\\n )\\n\\n # Check, whether `training_iteration` is still a tune.Trainable property\\n # and has not been overridden by the user in the attempt to implement the\\n # algos logic (this should be done now inside `training_step`).\\n try:\\n assert isinstance(self.training_iteration, int)\\n except AssertionError:\\n raise AssertionError(\\n \\\"Your Algorithm's `training_iteration` seems to be overridden by your \\\"\\n \\\"custom training logic! To solve this problem, simply rename your \\\"\\n \\\"`self.training_iteration()` method into `self.training_step`.\\\"\\n )\",\n \"def _CreateSolutionStrategy(self):\\n raise Exception(\\\"Mesh motion solving strategy must be created by the derived class.\\\")\",\n \"def __init__(__self__,\\n resource_name: str,\\n opts: Optional[pulumi.ResourceOptions] = None,\\n accelerator_id: Optional[pulumi.Input[str]] = None,\\n basic_endpoint_group_name: Optional[pulumi.Input[str]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n endpoint_address: Optional[pulumi.Input[str]] = None,\\n endpoint_group_region: Optional[pulumi.Input[str]] = None,\\n endpoint_sub_address: Optional[pulumi.Input[str]] = None,\\n endpoint_type: Optional[pulumi.Input[str]] = None,\\n __props__=None):\\n ...\",\n \"def create(cls, **props: Any) -> 'ResolverOp':\\n real_instance = super().__call__()\\n cls._check_kwargs(props)\\n for name, value in props.items():\\n setattr(real_instance, name, value)\\n return real_instance\",\n \"def create(cls, **props: Any) -> 'ResolverOp':\\n real_instance = super().__call__()\\n cls._check_kwargs(props)\\n for name, value in props.items():\\n setattr(real_instance, name, value)\\n return real_instance\",\n \"def create_endpoint(EndpointName=None, EndpointConfigName=None, Tags=None):\\n pass\",\n \"def _using(*args, validator: \\\"DictValidator\\\") -> \\\"DictValidator\\\":\\n\\n def setup_strategy(validator, strategy) -> \\\"DictValidator\\\":\\n if isinstance(strategy, SortingStrategy):\\n validator.sorting = strategy\\n elif isinstance(strategy, FilteringStrategy):\\n validator.filtering = strategy\\n elif isinstance(strategy, PrintingStrategy):\\n validator.printing = strategy\\n else:\\n raise CertumException(\\\"The strategy provided for the validator is unknown.\\\")\\n return validator\\n\\n for arg in args:\\n if isinstance(arg, list):\\n for strategy in arg:\\n validator = setup_strategy(validator, strategy)\\n elif isinstance(arg, Strategy):\\n validator = setup_strategy(validator, arg)\\n else:\\n raise CertumException(\\\"The strategy provided for the validator is unknown.\\\")\\n\\n return validator\",\n \"def generate_object(self, **kwargs):\\n from ranger_performance_tool import perf_globals\\n service_type_mapping = perf_globals.CONFIG_READER.get_config_value(\\\"secondary\\\", \\\"service_type_mapping\\\")\\n if \\\"id\\\" not in kwargs:\\n kwargs[\\\"id\\\"] = self.random_generator.generate_int()\\n if \\\"name\\\" not in kwargs:\\n kwargs[\\\"name\\\"] = self.random_generator.generate_string()\\n if \\\"service\\\" not in kwargs:\\n enabled_service = random.choice(perf_globals.CONFIG_READER.get_config_value(\\\"secondary\\\", \\\"enabled_services\\\"))\\n service_type = service_type_mapping[enabled_service]\\n kwargs[\\\"service\\\"] = enabled_service\\n kwargs[\\\"serviceType\\\"] = service_type\\n policy_object = RangerPolicy()\\n for key, value in kwargs.items():\\n if key not in dir(policy_object):\\n raise Exception(\\\"Invalid key: \\\" + key)\\n policy_object[key] = value\\n service_type = policy_object.serviceType\\n service_store = perf_globals.OBJECT_STORE.service_store[service_type]\\n policy_object.resources = service_store.generate_resources()\\n return policy_object\",\n \"def get_factory():\",\n \"def __init__(self, designation):\\n try:\\n self._designation = designation.lower()\\n parts = self._designation.split(\\\"/\\\")\\n self.mutate: mutation.MutationStrategy = mutation.__strategies__[parts[0]](int(parts[1]))\\n self.crossover: crossover.CrossoverStrategy = crossover.__strategies__[parts[2]]()\\n if len(parts) >= 4:\\n self.repair: repair.RepairStrategy = repair.__strategies__[parts[3]]()\\n else:\\n self.repair: repair.RepairStrategy = repair.clip()\\n self._designation += \\\"/clip\\\"\\n except AttributeError or KeyError or IndexError or ValueError:\\n raise ValueError(f\\\"Invalid evolution strategy '{designation}'\\\")\",\n \"def strategy(self, opponent):\\n raise NotImplementedError()\",\n \"def __init__(self, startTime, strategy, buyOrSell, underlying, orderQuantity, daysBeforeClose, expCycle=None,\\n optimalDTE=None, minimumDTE=None, roc=None, minDaysToEarnings=None, minCredit=None,\\n profitTargetPercent=None, customManagement=None, maxBidAsk=None, maxMidDev=None,\\n minDaysSinceEarnings=None, minIVR=None, minBuyingPower=None):\\n\\n if self.__class__ == Strategy:\\n raise NotImplementedError, \\\"Cannot create object of class Strategy; must use derived classes such \\\" \\\\\\n \\\"as StrangleStrat.\\\"\\n\\n self.__startTime = startTime\\n self.__strategy = strategy\\n self.__buyOrSell = buyOrSell\\n self.__underlying = underlying\\n self.__orderQuantity = orderQuantity\\n self.__daysBeforeClose = daysBeforeClose\\n self.__expCycle = expCycle\\n self.__optimalDTE = optimalDTE\\n self.__minimumDTE = minimumDTE\\n self.__roc = roc\\n self.__minDaysToEarnings = minDaysToEarnings\\n self.__minCredit = minCredit\\n self.__profitTargetPercent = profitTargetPercent\\n self.__customManagement = customManagement\\n self.__maxBidAsk = maxBidAsk\\n self.__maxMidDev = maxMidDev\\n self.__minDaysSinceEarnings = minDaysSinceEarnings\\n self.__minIVR = minIVR\\n self.__minBuyingPower = minBuyingPower\",\n \"def create_endpoint(self, endpoint_id, endpoint_ref):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def create(\\n config_path,\\n destination_database,\\n destination_environment,\\n algorithm_instance,\\n ext_params_str=None\\n ):\\n\\n # Create config service to get acon file path.\\n config_service = ConfigService(config_path)\\n acon_path = config_service.get_acon_path(\\n destination_database,\\n destination_environment,\\n algorithm_instance\\n )\\n acon_dict = Util.load_dict(acon_path)\\n\\n if ext_params_str:\\n ext_params_dict = json.loads(ext_params_str)\\n acon_dict = Util.merge_nested_dicts(acon_dict, ext_params_dict)\\n\\n return AlgorithmConfigurationHadoop(algorithm_instance, acon_dict)\",\n \"def __selectStrategy( self ):\\n chosenStrategy = self.activeStrategies[self.chosenStrategy]\\n self.__incrementChosenStrategy()\\n return chosenStrategy\",\n \"def get_test_strategy(context, **kw):\\n obj_cls = objects.Strategy\\n db_data = db_utils.get_test_strategy(**kw)\\n obj_data = _load_related_objects(context, obj_cls, db_data)\\n\\n return _load_test_obj(context, obj_cls, obj_data, **kw)\",\n \"def load_strategy_class(self):\\n path2 = Path(__file__).parent.parent.joinpath(\\\"strategies\\\")\\n self.load_strategy_class_from_folder(path2, \\\"vnpy.app.cta_strategy.strategies\\\")\",\n \"def port_factory_method(self):\\n pass\",\n \"def __init__(self, runner, params, **kwargs):\\n storage = InMemoryFeatureStorage(self, parent_cache=None)\\n super(LiveTradingOrders, self).__init__(runner, params, storage)\\n\\n self.strategy_name = params['strategy_name']\\n self.strategy_desc = params['strategy_desc']\\n self.trading_user_id = params['trading_user_id']\\n\\n # Field of the order to use for alignment (i.e. placed_time or settled_time)\\n shared_objects = self._runner.shared_objects()\\n self.sync_field = params['sync_field']\\n self._helper = MongoStrategyHelper(fixture_cache=shared_objects['fixture_cache'])\\n self._fixture_cache = shared_objects['fixture_cache']\",\n \"def to_component_func(entity: ComponentEntity, component_creation_func) -> Callable[..., Command]:\\n func_name = \\\"[component] {}\\\".format(entity.display_name)\\n\\n func_docstring_lines = []\\n if entity.description is not None:\\n func_docstring_lines.append(entity.description.strip())\\n\\n if isinstance(entity, DataTransferImportComponent):\\n all_params = get_dynamic_source_parameter(entity.source)\\n else:\\n all_params = get_dynamic_input_parameter(entity.inputs)\\n\\n flattened_group_keys = []\\n # Flatten all group parameters, for function parameter validation.\\n from azure.ai.ml.entities._inputs_outputs import GroupInput\\n\\n for name, item in entity.inputs.items():\\n if isinstance(item, GroupInput):\\n flattened_group_keys.extend(list(item.flatten(group_parameter_name=name).keys()))\\n\\n doc_string = entity.description\\n # Try add yaml to doc string\\n try:\\n yaml_str = entity._yaml_str if entity._yaml_str else entity._to_yaml()\\n doc_string = \\\"{0}\\\\n\\\\nComponent yaml:\\\\n```yaml\\\\n{1}\\\\n```\\\".format(doc_string, yaml_str)\\n except Exception: # pylint: disable=broad-except\\n pass\\n\\n params_assignment_str = \\\", \\\".join([f\\\"{param.name}=xxx\\\" for param in all_params])\\n example = f\\\"component_func({params_assignment_str})\\\"\\n\\n dynamic_func = create_kw_function_from_parameters(\\n component_creation_func,\\n documentation=doc_string,\\n parameters=all_params,\\n func_name=func_name,\\n flattened_group_keys=flattened_group_keys,\\n )\\n\\n dynamic_func._func_calling_example = example\\n dynamic_func._has_parameters = bool(all_params)\\n return dynamic_func\",\n \"def buildProtocol(self, addr):\\n p = self.protocol()\\n p.factory = self\\n\\n return p\",\n \"def __init__(self, runner, params, **kwargs):\\n storage = InMemoryFeatureStorage(self, parent_cache=None)\\n super(BacktestOrders, self).__init__(runner, params, storage)\\n\\n self.strategy_name = params['strategy_name']\\n self.strategy_desc = params['strategy_desc']\\n self.strategy_code = params['strategy_code']\\n self.trading_user_id = params['trading_user_id']\\n self.backtest_kwargs = params['backtest_kwargs']\\n\\n # Field of the order to use for alignment (i.e. placed_time or settled_time)\\n shared_objects = self._runner.shared_objects()\\n self.sync_field = params['sync_field']\\n if 'helper' in kwargs:\\n self._helper = kwargs['helper']\\n else:\\n self._helper = MongoStrategyHelper(fixture_cache=shared_objects['fixture_cache'])\\n self._fixture_cache = shared_objects['fixture_cache']\",\n \"def __init__(self, name,\\n # expected_arg = default_val # expected arguments\\n mechanisms={}, # custom mechanisms\\n config_file=None, parameters={}, # parameter configuration\\n # additional_arg = default_val # component-specific args\\n **keywords # parameter keywords\\n ):\\n # Call the class constructor to get default argument processing\\n # Component.__init__(self, name, config_file, mechanisms)\\n \\n # Set up the default mechanisms for this class\\n #\\n # Mechanisms that are specific to this component can be\\n # contained in the file defining the mechanism. More generic\\n # mechanisms that may be used by multiople component types\\n # should be placed in the mechanisms/ diretory and imported\\n # before use.\\n #\\n self.default_mechanisms = {\\n # 'mechanism' : MechanismConstructor()\\n }\\n\\n # Add (or overwrite) any mechanisms passed as arguments\\n self.custom_mechanisms = mechanisms\\n\\n # Create the config_file name (optional)\\n if config_file == None:\\n config_file = self.name.tolower() + \\\".csv\\\"\\n self.config_file = config_file\\n \\n # Set the component parameter values\\n self.default_parameters = {\\n # 'parameter' : value\\n }\\n self.parameters = get_parameters(\\n config_file, parameters, self.default_parameters, **keywords)\\n\\n # Fill in any missing values for default parameters\\n # Alternative setup for setting parameter values\\n #\",\n \"def post(self):\\n\\n self.set_header('content-type', 'application/json')\\n body = self.request.body\\n try:\\n # root用户组不可以创建策略\\n # manager用户组、普通用户组可以创建策略\\n if self.group.is_root():\\n return self.process_error(-1, 'root用户组没有权限创建策略')\\n\\n strategies = []\\n for _ in json.loads(body):\\n _[\\\"group_id\\\"] = self.group.id\\n strategies.append(Strategy.from_dict(_))\\n except Exception as err:\\n return self.process_error(400, \\\"invalid request body: {}\\\".format(err.message))\\n\\n for _ in strategies:\\n # add current time as version, for backwards compatability\\n _.version = millis_now()\\n\\n try:\\n for s in strategies:\\n gen_variables_from_strategy(s, effective_check=False)\\n\\n for s in strategies:\\n s.version = millis_now()\\n\\n dao = StrategyCustDao()\\n for s in strategies:\\n dao.add_strategy(s)\\n self.finish(json_dumps({\\\"status\\\": 200, \\\"msg\\\": \\\"ok\\\", \\\"values\\\": []}))\\n except Exception as err:\\n traceback.print_exc()\\n return self.process_error(500, err.message)\",\n \"def get_address(supvisors, strategy, addresses, expected_loading):\\n if strategy == StartingStrategies.CONFIG:\\n instance = ConfigStrategy(supvisors)\\n if strategy == StartingStrategies.LESS_LOADED:\\n instance = LessLoadedStrategy(supvisors)\\n if strategy == StartingStrategies.MOST_LOADED:\\n instance = MostLoadedStrategy(supvisors)\\n # apply strategy result\\n return instance.get_address(addresses, expected_loading)\",\n \"def _gen_partial_strategy(mesh: DeviceMesh) -> PlacementStrategy:\\n # NOTE: we use AVG by default, avg reduction is needed depending on\\n # the loss function, for most loss function it should do\\n # gradient averaging. There might be certain cases it should\\n # not do gradient averaging (i.e. sum) but it's pretty rare.\\n # TODO: Only NCCL supports AVG so using backend like Gloo would\\n # crash, we should figure out a way to support avg reduction\\n # for non-NCCL backend\\n reduce_op = c10d.ReduceOp.AVG # type: ignore[attr-defined]\\n return PlacementStrategy(\\n output_spec=DTensorSpec(mesh=mesh, placements=[_Partial(reduce_op)]),\\n )\",\n \"def _create_linear(\\n self, config: dict, light_model: LightModel, entity_domain: str\\n ) -> LinearStrategy:\\n linear_config = config.get(CONF_LINEAR)\\n\\n if linear_config is None:\\n # Below is for BC compatibility\\n if config.get(CONF_MIN_WATT) is not None:\\n _LOGGER.warning(\\n \\\"min_watt is deprecated and will be removed in version 0.3, use linear->min_power\\\"\\n )\\n linear_config = {\\n CONF_MIN_POWER: config.get(CONF_MIN_WATT),\\n CONF_MAX_POWER: config.get(CONF_MAX_WATT),\\n }\\n\\n elif light_model is not None:\\n linear_config = light_model.linear_mode_config\\n\\n return LinearStrategy(linear_config, entity_domain)\",\n \"def create_candidate(ctx, pipeline):\\n\\n return Candidate(\\n pipeline=pipeline,\\n formulas=ctx.matrix.formulas,\\n train=_evaluate_predictions(ctx, pipeline, *ctx.training_data()),\\n test=_evaluate_predictions(ctx, pipeline, *ctx.testing_data()),\\n )\",\n \"def get_request_and_strategy(self, auth_entry=None, redirect_uri=None):\\r\\n request = self.request_factory.get(\\r\\n pipeline.get_complete_url(self.backend_name) +\\r\\n '?redirect_state=redirect_state_value&code=code_value&state=state_value')\\r\\n request.user = auth_models.AnonymousUser()\\r\\n request.session = cache.SessionStore()\\r\\n request.session[self.backend_name + '_state'] = 'state_value'\\r\\n\\r\\n if auth_entry:\\r\\n request.session[pipeline.AUTH_ENTRY_KEY] = auth_entry\\r\\n\\r\\n strategy = social_utils.load_strategy(backend=self.backend_name, redirect_uri=redirect_uri, request=request)\\r\\n request.social_strategy = strategy\\r\\n\\r\\n return request, strategy\",\n \"def _generate_trading_instances(self, strategy_params_dict):\\n print(\\\"Creating DataHandler, Strategy, Portfolio, and ExecutionHandler for\\\")\\n print(\\\"strategy parameter list: %s...\\\" % strategy_params_dict)\\n\\n # Set internal data members equal to the classes we passed in earlier, along with necessary parameters.\\n # https://softwareengineering.stackexchange.com/questions/131403/what-is-the-name-of-in-python/131415\\n self.data_handler = self.data_handler_class(self.events, self.csv_dir, self.symbol_list)\\n self.strategy = self.strategy_class(self.data_handler, self.events, **strategy_params_dict)\\n self.portfolio = self.portfolio_class(self.data_handler, self.events, self.start_date, self.initial_capital)\\n self.execution_handler = self.execution_handler_class(self.events) # The Event Queue sent to ExecutionHandler\",\n \"def get_estimator_fn(num_gpus,\\n variable_strategy,\\n run_config,\\n hparams):\\n estimator = tf.estimator.Estimator(\\n model_fn=get_model_fn(num_gpus, variable_strategy,\\n run_config.num_worker_replicas or 1),\\n config=run_config,\\n params=hparams)\\n\\n return estimator\",\n \"def from_state(state: Dict) -> \\\"Algorithm\\\":\\n algorithm_class: Type[Algorithm] = state.get(\\\"algorithm_class\\\")\\n if algorithm_class is None:\\n raise ValueError(\\n \\\"No `algorithm_class` key was found in given `state`! \\\"\\n \\\"Cannot create new Algorithm.\\\"\\n )\\n # algo_class = get_trainable_cls(algo_class_name)\\n # Create the new algo.\\n config = state.get(\\\"config\\\")\\n if not config:\\n raise ValueError(\\\"No `config` found in given Algorithm state!\\\")\\n new_algo = algorithm_class(config=config)\\n # Set the new algo's state.\\n new_algo.__setstate__(state)\\n # Return the new algo.\\n return new_algo\",\n \"def __init__(__self__, *,\\n accelerator_id: pulumi.Input[str],\\n endpoint_group_region: pulumi.Input[str],\\n basic_endpoint_group_name: Optional[pulumi.Input[str]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n endpoint_address: Optional[pulumi.Input[str]] = None,\\n endpoint_sub_address: Optional[pulumi.Input[str]] = None,\\n endpoint_type: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"accelerator_id\\\", accelerator_id)\\n pulumi.set(__self__, \\\"endpoint_group_region\\\", endpoint_group_region)\\n if basic_endpoint_group_name is not None:\\n pulumi.set(__self__, \\\"basic_endpoint_group_name\\\", basic_endpoint_group_name)\\n if description is not None:\\n pulumi.set(__self__, \\\"description\\\", description)\\n if endpoint_address is not None:\\n pulumi.set(__self__, \\\"endpoint_address\\\", endpoint_address)\\n if endpoint_sub_address is not None:\\n pulumi.set(__self__, \\\"endpoint_sub_address\\\", endpoint_sub_address)\\n if endpoint_type is not None:\\n pulumi.set(__self__, \\\"endpoint_type\\\", endpoint_type)\",\n \"def initialize_implementation(self):\\n # call overridable methods to get number of inputs/outputs\\n n_inputs = self.get_number_of_input_connections()\\n n_outputs = self.get_number_of_output_ports()\\n\\n # call overrides to get implementation for teca execution\\n # phase implementations\\n import teca_py\\n self.impl = teca_py.teca_programmable_algorithm.New()\\n self.impl.set_number_of_input_connections(n_inputs)\\n self.impl.set_number_of_output_ports(n_outputs)\\n self.impl.set_name(self.__class__.__name__)\\n self.impl.set_report_callback(self.get_report_callback())\\n self.impl.set_request_callback(self.get_request_callback())\\n self.impl.set_execute_callback(self.get_execute_callback())\",\n \"def __init__(__self__, *,\\n address: pulumi.Input[str],\\n endpoint_id: pulumi.Input[str],\\n port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['CustomRoutingEndpointTrafficPolicyPortRangeArgs']]]] = None):\\n pulumi.set(__self__, \\\"address\\\", address)\\n pulumi.set(__self__, \\\"endpoint_id\\\", endpoint_id)\\n if port_ranges is not None:\\n pulumi.set(__self__, \\\"port_ranges\\\", port_ranges)\",\n \"def get_estimator(arguments):\\n \\n numerical_indices = [1, 2, 4, 5,6,7,8,9,10,11,12,13,14]\\n categorical_indices = [0]\\n original_indices = list(set(range(59))-set(numerical_indices)-set(categorical_indices))\\n \\n p1 = make_pipeline(my_module.PositionalSelector(categorical_indices),OneHotEncoder())\\n p2 = make_pipeline(my_module.PositionalSelector(numerical_indices),StandardScaler())\\n p3 = make_pipeline(my_module.PositionalSelector(original_indices))\\n \\n feats = FeatureUnion([('categoricals', p1),\\n ('numericals', p2),\\n ('originals', p3),])\\n \\n # tolerance and C are expected to be passed as\\n # command line argument to task.py\\n pipeline = Pipeline([('pre', feats),\\n ('estimator', linear_model.LogisticRegression(penalty=\\\"l2\\\",\\n tol=arguments.tol,\\n C = arguments.C,\\n solver='lbfgs',\\n max_iter=10000))])\\n \\n # tolerance and C are expected to be passed as\\n # command line argument to task.py\\n #classifier = linear_model.LogisticRegression(\\n # penalty=\\\"l2\\\",\\n # tol=arguments.tol,\\n # C = arguments.C,\\n # solver='lbfgs',\\n # max_iter=1000\\n #)\\n \\n return pipeline\",\n \"def get_factory():\\n # Get config from Django settings\\n sdk_config = settings.SPLITIO\\n api_key = settings.SPLITIO.get('apiKey', '')\\n\\n return get_splitio_factory(\\n api_key,\\n config=sdk_config,\\n **{k: sdk_config[k] for k in ('sdk_api_base_url', 'events_api_base_url', 'auth_api_base_url', 'streaming_api_base_url') if k in sdk_config}\\n )\",\n \"def from_params(self, params):\\n raise NotImplementedError()\",\n \"def generate():\\n strategies = []\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy4))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeStrategy))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\\n\\n # Add HPS Dojo strategies\\n strategies.extend(\\n generate_meta_strategy_pair(HPSDojoStrategy))\\n\\n # Add testing please ignore strategies\\n strategies.extend(\\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\\n\\n # Add testimono strategy\\n strategies.extend(\\n generate_meta_strategy_pair(TestimonoStrategy))\\n\\n # Add RPS Geometry\\n strategies.extend(\\n generate_meta_strategy_pair(GeometryV4Strategy))\\n\\n # Add Iocaine Powder strategy\\n strategies.extend(\\n generate_meta_strategy_pair(IocanePowderStrategy))\\n\\n # Add are you a lucker strategies\\n strategies.extend(\\n generate_meta_strategy_pair(AreYouALuckerStrategy))\\n\\n # By default, rotate everything\\n do_rotations = [True for _ in strategies]\\n\\n # Anti Trivial\\n strategies.extend(\\n generate_meta_strategy_pair(\\n AntiTrivialStrategy, mirroring=False))\\n do_rotations.extend([False])\\n\\n return strategies, do_rotations\",\n \"def __init__(\\n self,\\n name: str,\\n createStepName: str,\\n surface: Region,\\n interactionProperty: str,\\n enforcement: SymbolicConstant = SURFACE_TO_SURFACE,\\n thickness: Boolean = ON,\\n smooth: float = 0,\\n contactControls: str = \\\"\\\",\\n ):\\n super().__init__()\\n pass\",\n \"def generate():\\n strategies = []\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy4))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeStrategy))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\\n\\n # Add HPS Dojo strategies\\n strategies.extend(\\n generate_meta_strategy_pair(HPSDojoStrategy))\\n\\n # Add testing please ignore strategies\\n strategies.extend(\\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\\n\\n # Add testimono strategy\\n strategies.extend(\\n generate_meta_strategy_pair(TestimonoStrategy))\\n\\n # Add RPS Geometry\\n strategies.extend(\\n generate_meta_strategy_pair(GeometryV4Strategy))\\n\\n # Add Iocaine Powder strategy\\n strategies.extend(\\n generate_meta_strategy_pair(IocanePowderStrategy))\\n\\n # Add are you a lucker strategies\\n strategies.extend(\\n generate_meta_strategy_pair(AreYouALuckerStrategy))\\n\\n # Add Greenberg strategies\\n strategies.extend(\\n generate_meta_strategy_pair(GreenbergStrategy))\\n\\n # Add RPS Meta Fix strategies\\n strategies.extend(\\n generate_meta_strategy_pair(RPSMetaFixStrategy))\\n\\n # By default, rotate everything\\n do_rotations = [True for _ in strategies]\\n\\n # Anti Trivial\\n strategies.extend(\\n generate_meta_strategy_pair(\\n AntiTrivialStrategy, mirroring=False))\\n do_rotations.extend([False])\\n\\n return strategies, do_rotations\",\n \"def generate():\\n strategies = []\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy4))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeStrategy))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\\n\\n # Add HPS Dojo strategies\\n strategies.extend(\\n generate_meta_strategy_pair(HPSDojoStrategy))\\n\\n # Add testing please ignore strategies\\n strategies.extend(\\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\\n\\n # Add testimono strategy\\n strategies.extend(\\n generate_meta_strategy_pair(TestimonoStrategy))\\n\\n # Add RPS Geometry\\n strategies.extend(\\n generate_meta_strategy_pair(GeometryV4Strategy))\\n\\n # Add Iocaine Powder strategy\\n strategies.extend(\\n generate_meta_strategy_pair(IocanePowderStrategy))\\n\\n # By default, rotate everything\\n do_rotations = [True for _ in strategies]\\n\\n # Anti Trivial\\n strategies.extend(\\n generate_meta_strategy_pair(\\n AntiTrivialStrategy, mirroring=False))\\n do_rotations.extend([False])\\n\\n return strategies, do_rotations\",\n \"def create_factory(cls, *args):\\n raise NotImplementedError\",\n \"def generate():\\n strategies = []\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy4))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeStrategy))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\\n\\n # Add HPS Dojo strategies\\n strategies.extend(\\n generate_meta_strategy_pair(HPSDojoStrategy))\\n\\n # Add testing please ignore strategies\\n strategies.extend(\\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\\n\\n # Add testimono strategy\\n strategies.extend(\\n generate_meta_strategy_pair(TestimonoStrategy))\\n\\n # Add RPS Geometry\\n strategies.extend(\\n generate_meta_strategy_pair(GeometryV4Strategy))\\n\\n # Add Iocaine Powder strategy\\n strategies.extend(\\n generate_meta_strategy_pair(IocanePowderStrategy))\\n\\n # Add are you a lucker strategies\\n strategies.extend(\\n generate_meta_strategy_pair(AreYouALuckerStrategy))\\n\\n # Add RPS Meta Fix strategies\\n strategies.extend(\\n generate_meta_strategy_pair(RPSMetaFixStrategy))\\n\\n # By default, rotate everything\\n do_rotations = [True for _ in strategies]\\n\\n # Anti Trivial\\n strategies.extend(\\n generate_meta_strategy_pair(\\n AntiTrivialStrategy, mirroring=False))\\n do_rotations.extend([False])\\n\\n return strategies, do_rotations\",\n \"def __init__(__self__, *,\\n accelerator_id: Optional[pulumi.Input[str]] = None,\\n basic_endpoint_group_name: Optional[pulumi.Input[str]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n endpoint_address: Optional[pulumi.Input[str]] = None,\\n endpoint_group_region: Optional[pulumi.Input[str]] = None,\\n endpoint_sub_address: Optional[pulumi.Input[str]] = None,\\n endpoint_type: Optional[pulumi.Input[str]] = None,\\n status: Optional[pulumi.Input[str]] = None):\\n if accelerator_id is not None:\\n pulumi.set(__self__, \\\"accelerator_id\\\", accelerator_id)\\n if basic_endpoint_group_name is not None:\\n pulumi.set(__self__, \\\"basic_endpoint_group_name\\\", basic_endpoint_group_name)\\n if description is not None:\\n pulumi.set(__self__, \\\"description\\\", description)\\n if endpoint_address is not None:\\n pulumi.set(__self__, \\\"endpoint_address\\\", endpoint_address)\\n if endpoint_group_region is not None:\\n pulumi.set(__self__, \\\"endpoint_group_region\\\", endpoint_group_region)\\n if endpoint_sub_address is not None:\\n pulumi.set(__self__, \\\"endpoint_sub_address\\\", endpoint_sub_address)\\n if endpoint_type is not None:\\n pulumi.set(__self__, \\\"endpoint_type\\\", endpoint_type)\\n if status is not None:\\n pulumi.set(__self__, \\\"status\\\", status)\",\n \"def create_endpoint(*args):\\n endpoint = ''\\n for arg in args:\\n endpoint = endpoint + str(arg) + \\\"/\\\"\\n endpoint = endpoint[:-1]\\n endpoint = endpoint + \\\".json\\\"\\n return endpoint\",\n \"def apply_hooks(\\n endpoint: Endpoint,\\n context: HookContext,\\n hooks: Optional[HookDispatcher],\\n strategy: st.SearchStrategy[Case],\\n location: str,\\n) -> st.SearchStrategy[Case]:\\n strategy = _apply_hooks(context, GLOBAL_HOOK_DISPATCHER, strategy, location)\\n strategy = _apply_hooks(context, endpoint.schema.hooks, strategy, location)\\n if hooks is not None:\\n strategy = _apply_hooks(context, hooks, strategy, location)\\n return strategy\",\n \"def buildProtocol(self,addr):\\r\\n p = self.protocol(self.server)\\r\\n p.factory = self\\r\\n return p\",\n \"def get_by_name(cls, context, name, eager=False):\\n\\n db_strategy = cls.dbapi.get_strategy_by_name(\\n context, name, eager=eager)\\n strategy = cls._from_db_object(cls(context), db_strategy, eager=eager)\\n return strategy\",\n \"def create_payment_strategy(platform=None, payer_id=None):\\n patron = create_patron(email=payer_id)\\n platform = PaymentStrategy.TRANSFER if platform is None else platform\\n payer_id = \\\"\\\" if payer_id is None else payer_id\\n return PaymentStrategy.objects.create(\\n platform=platform, id_in_platform=payer_id, patron=patron)\",\n \"def get_strategy(task_type: TaskType, **kwargs: Any) -> 'RepoBuildStrategy':\\n\\n build_strategies = {\\n TaskType.IFW_TASK_TYPE: IFWRepoBuildStrategy,\\n TaskType.QBSP_TASK_TYPE: QBSPRepoBuildStrategy,\\n }\\n return build_strategies[task_type](**kwargs)\",\n \"def factory(self):\\n raise NotImplementedError()\",\n \"def create(\\n cls: type[T],\\n parameter_handler: TP,\\n topology: \\\"Topology\\\",\\n ) -> T:\\n if type(parameter_handler) not in cls.allowed_parameter_handlers():\\n raise InvalidParameterHandlerError(type(parameter_handler))\\n\\n handler = cls()\\n if hasattr(handler, \\\"fractional_bondorder_method\\\"):\\n if getattr(parameter_handler, \\\"fractional_bondorder_method\\\", None):\\n handler.fractional_bond_order_method = ( # type: ignore[attr-defined]\\n parameter_handler.fractional_bondorder_method\\n )\\n handler.fractional_bond_order_interpolation = ( # type: ignore[attr-defined]\\n parameter_handler.fractional_bondorder_interpolation\\n )\\n handler.store_matches(parameter_handler=parameter_handler, topology=topology)\\n handler.store_potentials(parameter_handler=parameter_handler)\\n\\n return handler\",\n \"def create(cls, original_args, process_args, base_url, host_url, services):\\n return cls(original_args, process_args, base_url, host_url, services)\",\n \"def _create_impl(self):\",\n \"def _create_fixed(self, config: dict, light_model: LightModel) -> FixedStrategy:\\n fixed_config = config.get(CONF_FIXED)\\n if fixed_config is None and light_model is not None:\\n fixed_config = light_model.fixed_mode_config\\n\\n # BC compat\\n if fixed_config is None:\\n _LOGGER.warning(\\n \\\"watt is deprecated and will be removed in version 0.3, use fixed->power\\\"\\n )\\n fixed_config = {CONF_POWER: config.get(CONF_WATT)}\\n\\n return FixedStrategy(\\n fixed_config.get(CONF_POWER), fixed_config.get(CONF_STATES_POWER)\\n )\",\n \"def from_pipeline_spec_dict(cls, pipeline_spec_dict: Dict[str, Any],\\n component_name: str) -> 'Implementation':\\n executor_key = utils.sanitize_executor_label(component_name)\\n executor = pipeline_spec_dict['deploymentSpec']['executors'].get(\\n executor_key)\\n if executor is not None:\\n container_spec = ContainerSpecImplementation.from_container_dict(\\n executor['container']) if executor else None\\n return Implementation(container=container_spec)\\n else:\\n pipeline_spec = json_format.ParseDict(\\n pipeline_spec_dict, pipeline_spec_pb2.PipelineSpec())\\n return Implementation(graph=pipeline_spec)\",\n \"def generate():\\n strategies = []\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeStrategy))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\\n\\n # Add HPS Dojo strategies\\n strategies.extend(\\n generate_meta_strategy_pair(HPSDojoStrategy))\\n\\n # Add testing please ignore strategies\\n strategies.extend(\\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\\n\\n # Add testimono strategy\\n strategies.extend(\\n generate_meta_strategy_pair(TestimonoStrategy))\\n\\n # Add RPS Geometry\\n strategies.extend(\\n generate_meta_strategy_pair(GeometryV4Strategy))\\n\\n # Add Iocaine Powder strategy\\n strategies.extend(\\n generate_meta_strategy_pair(IocanePowderStrategy))\\n\\n # By default, rotate everything\\n do_rotations = [True for _ in strategies]\\n\\n # Anti Trivial\\n strategies.extend(\\n generate_meta_strategy_pair(\\n AntiTrivialStrategy, mirroring=False))\\n do_rotations.extend([False])\\n\\n return strategies, do_rotations\",\n \"async def connection_factory(*args, **kwargs):\\n if args[1] == \\\"5L\\\":\\n protocol.telegram = {\\n LUXEMBOURG_EQUIPMENT_IDENTIFIER: CosemObject(\\n [{\\\"value\\\": \\\"12345678\\\", \\\"unit\\\": \\\"\\\"}]\\n ),\\n EQUIPMENT_IDENTIFIER_GAS: CosemObject(\\n [{\\\"value\\\": \\\"123456789\\\", \\\"unit\\\": \\\"\\\"}]\\n ),\\n }\\n if args[1] == \\\"5S\\\":\\n protocol.telegram = {\\n P1_MESSAGE_TIMESTAMP: CosemObject([{\\\"value\\\": \\\"12345678\\\", \\\"unit\\\": \\\"\\\"}]),\\n }\\n if args[1] == \\\"Q3D\\\":\\n protocol.telegram = {\\n Q3D_EQUIPMENT_IDENTIFIER: CosemObject(\\n [{\\\"value\\\": \\\"12345678\\\", \\\"unit\\\": \\\"\\\"}]\\n ),\\n }\\n\\n return (transport, protocol)\",\n \"def get_by_id(cls, context, strategy_id, eager=False):\\n db_strategy = cls.dbapi.get_strategy_by_id(\\n context, strategy_id, eager=eager)\\n strategy = cls._from_db_object(cls(context), db_strategy, eager=eager)\\n return strategy\",\n \"def generate():\\n strategies = []\\n\\n # Add Centrifugal Bumblepuppy 16+H (RFind based)\\n strategies.extend(\\n generate_meta_strategy_pair(CentrifugalBumblepuppy16h))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeStrategy))\\n\\n # Add decision tree strategies\\n strategies.extend(\\n generate_meta_strategy_pair(DecisionTreeV10Strategy))\\n\\n # Add HPS Dojo strategies\\n strategies.extend(\\n generate_meta_strategy_pair(HPSDojoStrategy))\\n\\n # Add testing please ignore strategies\\n strategies.extend(\\n generate_meta_strategy_pair(TestingPlsIgnoreStrategy))\\n\\n # Add testimono strategy\\n strategies.extend(\\n generate_meta_strategy_pair(TestimonoStrategy))\\n\\n # Add RPS Geometry\\n strategies.extend(\\n generate_meta_strategy_pair(GeometryV4Strategy))\\n\\n # By default, rotate everything\\n do_rotations = [True for _ in strategies]\\n\\n # Anti Trivial\\n strategies.extend(\\n generate_meta_strategy_pair(\\n AntiTrivialStrategy, mirroring=False))\\n do_rotations.extend([False])\\n\\n return strategies, do_rotations\",\n \"def port_factory_method(self):\\n if self.is_secure:\\n return HTTPSSecurePort()\\n return HTTPPort()\",\n \"def factory_method(self):\\n pass\",\n \"def factory_method(self):\\n pass\",\n \"def endpoint_create(self, endpoint_name=None, config=None):\\n if config is None:\\n raise Exception(\\\"Config required!\\\")\\n if endpoint_name is None:\\n self.request('/v1.1/endpoint', 'PUT', body=config)\\n else:\\n self.request('/v1.1/endpoints/%s' % endpoint_name, 'PUT', body=config)\",\n \"def buildProtocol(self, addr):\\n protocol = PortalBot()\\n protocol.factory = self\\n protocol.nickname = self.nickname\\n protocol.channel = self.channel\\n protocol.network = self.network\\n protocol.port = self.port\\n protocol.ssl = self.ssl\\n protocol.nicklist = []\\n return protocol\",\n \"def register_factory(self, factory, from_protocol, to_protocol):\\n\\n from traits.adaptation.adaptation_offer import AdaptationOffer\\n\\n self.register_offer(\\n AdaptationOffer(\\n factory=factory,\\n from_protocol=from_protocol,\\n to_protocol=to_protocol,\\n )\\n )\\n\\n return\",\n \"def __init__(self, params):\\n\\n # set up logger\\n self.logger = logging.getLogger('sweeper')\\n\\n essential_keys = ['num_nodes']\\n for key in essential_keys:\\n if key not in params:\\n msg = 'need %s to instantiate step, only got %s' % (key, str(params.keys()))\\n self.logger.error(msg)\\n raise ParameterError(msg)\\n\\n if 'collocation_class' not in params:\\n params['collocation_class'] = CollBase\\n\\n # prepare random generator for initial guess\\n if params.get('initial_guess', 'spread') == 'random':\\n params['random_seed'] = params.get('random_seed', 1984)\\n self.rng = np.random.RandomState(params['random_seed'])\\n\\n self.params = _Pars(params)\\n\\n self.coll = params['collocation_class'](**params)\\n\\n if not self.coll.right_is_node and not self.params.do_coll_update:\\n self.logger.warning(\\n 'we need to do a collocation update here, since the right end point is not a node. Changing this!'\\n )\\n self.params.do_coll_update = True\\n\\n # This will be set as soon as the sweeper is instantiated at the level\\n self.__level = None\\n\\n self.parallelizable = False\",\n \"def __call__(self):\\n \\n p = self.protocol()\\n p.factory = self\\n return p\",\n \"def __init__(__self__, *,\\n endpoint_type: pulumi.Input[str],\\n resource_id: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"endpoint_type\\\", 'HybridConnection')\\n if resource_id is not None:\\n pulumi.set(__self__, \\\"resource_id\\\", resource_id)\",\n \"def factory(container, name, factory):\",\n \"def create_model_endpoint(\\n cls,\\n db_session: sqlalchemy.orm.Session,\\n model_endpoint: mlrun.common.schemas.ModelEndpoint,\\n ) -> mlrun.common.schemas.ModelEndpoint:\\n\\n if model_endpoint.spec.model_uri or model_endpoint.status.feature_stats:\\n logger.info(\\n \\\"Getting feature metadata\\\",\\n project=model_endpoint.metadata.project,\\n model=model_endpoint.spec.model,\\n function=model_endpoint.spec.function_uri,\\n model_uri=model_endpoint.spec.model_uri,\\n )\\n\\n # If model artifact was supplied, grab model metadata from artifact\\n if model_endpoint.spec.model_uri:\\n logger.info(\\n \\\"Getting model object, inferring column names and collecting feature stats\\\"\\n )\\n run_db = mlrun.api.api.utils.get_run_db_instance(db_session)\\n model_obj: mlrun.artifacts.ModelArtifact = (\\n mlrun.datastore.store_resources.get_store_resource(\\n model_endpoint.spec.model_uri, db=run_db\\n )\\n )\\n\\n # Get stats from model object if not found in model endpoint object\\n if not model_endpoint.status.feature_stats and hasattr(\\n model_obj, \\\"feature_stats\\\"\\n ):\\n if model_obj.spec.feature_stats:\\n mlrun.common.model_monitoring.helpers.pad_features_hist(\\n mlrun.common.model_monitoring.helpers.FeatureStats(\\n model_obj.spec.feature_stats\\n )\\n )\\n model_endpoint.status.feature_stats = model_obj.spec.feature_stats\\n # Get labels from model object if not found in model endpoint object\\n if not model_endpoint.spec.label_names and model_obj.spec.outputs:\\n model_label_names = [\\n mlrun.api.crud.model_monitoring.helpers.clean_feature_name(f.name)\\n for f in model_obj.spec.outputs\\n ]\\n model_endpoint.spec.label_names = model_label_names\\n\\n # Get algorithm from model object if not found in model endpoint object\\n if not model_endpoint.spec.algorithm and model_obj.spec.algorithm:\\n model_endpoint.spec.algorithm = model_obj.spec.algorithm\\n\\n # Create monitoring feature set if monitoring found in model endpoint object\\n if (\\n model_endpoint.spec.monitoring_mode\\n == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled.value\\n ):\\n monitoring_feature_set = cls.create_monitoring_feature_set(\\n model_endpoint, model_obj, db_session, run_db\\n )\\n # Link model endpoint object to feature set URI\\n model_endpoint.status.monitoring_feature_set_uri = (\\n monitoring_feature_set.uri\\n )\\n\\n # If feature_stats was either populated by model_uri or by manual input, make sure to keep the names\\n # of the features. If feature_names was supplied, replace the names set in feature_stats, otherwise - make\\n # sure to keep a clean version of the names\\n if model_endpoint.status.feature_stats:\\n logger.info(\\\"Feature stats found, cleaning feature names\\\")\\n if model_endpoint.spec.feature_names:\\n # Validate that the length of feature_stats is equal to the length of feature_names and label_names\\n cls._validate_length_features_and_labels(model_endpoint=model_endpoint)\\n\\n # Clean feature names in both feature_stats and feature_names\\n (\\n model_endpoint.status.feature_stats,\\n model_endpoint.spec.feature_names,\\n ) = cls._adjust_feature_names_and_stats(model_endpoint=model_endpoint)\\n\\n logger.info(\\n \\\"Done preparing feature names and stats\\\",\\n feature_names=model_endpoint.spec.feature_names,\\n )\\n\\n # If none of the above was supplied, feature names will be assigned on first contact with the model monitoring\\n # system\\n logger.info(\\\"Creating model endpoint\\\", endpoint_id=model_endpoint.metadata.uid)\\n\\n # Write the new model endpoint\\n model_endpoint_store = get_model_endpoint_store(\\n project=model_endpoint.metadata.project,\\n secret_provider=mlrun.api.crud.secrets.get_project_secret_provider(\\n project=model_endpoint.metadata.project\\n ),\\n )\\n model_endpoint_store.write_model_endpoint(endpoint=model_endpoint.flat_dict())\\n\\n logger.info(\\\"Model endpoint created\\\", endpoint_id=model_endpoint.metadata.uid)\\n\\n return model_endpoint\",\n \"def create_algorithm(AlgorithmName=None, AlgorithmDescription=None, TrainingSpecification=None, InferenceSpecification=None, ValidationSpecification=None, CertifyForMarketplace=None):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6418826","0.5800213","0.5728096","0.5714733","0.5632045","0.5582534","0.55530953","0.5522158","0.5477194","0.53526986","0.5237057","0.5194271","0.5176202","0.512805","0.5121639","0.5117651","0.51095563","0.510309","0.50945157","0.5078439","0.5024108","0.5020483","0.49993742","0.49968815","0.49939412","0.49939412","0.49849337","0.49824703","0.49660224","0.49624985","0.49588004","0.49588004","0.49390596","0.49369153","0.49268004","0.49226883","0.4919842","0.4892899","0.48808712","0.48748794","0.4873534","0.48636425","0.48614982","0.48592597","0.48550433","0.48397544","0.48183537","0.48134553","0.48044884","0.4798251","0.47892597","0.4784856","0.4782808","0.4773173","0.4770031","0.47603825","0.4758236","0.4755599","0.47542018","0.47494224","0.47433937","0.47379044","0.47336212","0.47326323","0.47318926","0.47256976","0.4721958","0.47077033","0.4707215","0.47029486","0.46925116","0.4692335","0.46872908","0.46846262","0.46782655","0.4678224","0.46760136","0.46735603","0.46714205","0.46712834","0.4670476","0.46662828","0.46611792","0.46541095","0.4650513","0.4648698","0.46420825","0.4636976","0.46351758","0.4627506","0.4627506","0.46264994","0.4623846","0.46213016","0.46183357","0.46150917","0.46083894","0.46079203","0.46052375","0.46048152"],"string":"[\n \"0.6418826\",\n \"0.5800213\",\n \"0.5728096\",\n \"0.5714733\",\n \"0.5632045\",\n \"0.5582534\",\n \"0.55530953\",\n \"0.5522158\",\n \"0.5477194\",\n \"0.53526986\",\n \"0.5237057\",\n \"0.5194271\",\n \"0.5176202\",\n \"0.512805\",\n \"0.5121639\",\n \"0.5117651\",\n \"0.51095563\",\n \"0.510309\",\n \"0.50945157\",\n \"0.5078439\",\n \"0.5024108\",\n \"0.5020483\",\n \"0.49993742\",\n \"0.49968815\",\n \"0.49939412\",\n \"0.49939412\",\n \"0.49849337\",\n \"0.49824703\",\n \"0.49660224\",\n \"0.49624985\",\n \"0.49588004\",\n \"0.49588004\",\n \"0.49390596\",\n \"0.49369153\",\n \"0.49268004\",\n \"0.49226883\",\n \"0.4919842\",\n \"0.4892899\",\n \"0.48808712\",\n \"0.48748794\",\n \"0.4873534\",\n \"0.48636425\",\n \"0.48614982\",\n \"0.48592597\",\n \"0.48550433\",\n \"0.48397544\",\n \"0.48183537\",\n \"0.48134553\",\n \"0.48044884\",\n \"0.4798251\",\n \"0.47892597\",\n \"0.4784856\",\n \"0.4782808\",\n \"0.4773173\",\n \"0.4770031\",\n \"0.47603825\",\n \"0.4758236\",\n \"0.4755599\",\n \"0.47542018\",\n \"0.47494224\",\n \"0.47433937\",\n \"0.47379044\",\n \"0.47336212\",\n \"0.47326323\",\n \"0.47318926\",\n \"0.47256976\",\n \"0.4721958\",\n \"0.47077033\",\n \"0.4707215\",\n \"0.47029486\",\n \"0.46925116\",\n \"0.4692335\",\n \"0.46872908\",\n \"0.46846262\",\n \"0.46782655\",\n \"0.4678224\",\n \"0.46760136\",\n \"0.46735603\",\n \"0.46714205\",\n \"0.46712834\",\n \"0.4670476\",\n \"0.46662828\",\n \"0.46611792\",\n \"0.46541095\",\n \"0.4650513\",\n \"0.4648698\",\n \"0.46420825\",\n \"0.4636976\",\n \"0.46351758\",\n \"0.4627506\",\n \"0.4627506\",\n \"0.46264994\",\n \"0.4623846\",\n \"0.46213016\",\n \"0.46183357\",\n \"0.46150917\",\n \"0.46083894\",\n \"0.46079203\",\n \"0.46052375\",\n \"0.46048152\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6061061"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":77687,"cells":{"query":{"kind":"string","value":"Single \".\" chars and empty strings \"\" are excluded from path by urllib3. A path containing to \"/\" or \"%2F\" will lead to ambiguous path resolution in many frameworks and libraries, such behaviour have been observed in both WSGI and ASGI applications. In this case one variable in the path template will be empty, which will lead to 404 in most of the cases. Because of it this case doesn't bring much value and might lead to false positives results of Schemathesis runs."},"document":{"kind":"string","value":"def is_valid_path(parameters: Dict[str, Any]) -> bool:\n\n path_parameter_blacklist = (\".\", SLASH, \"\")\n\n return not any(\n (value in path_parameter_blacklist or is_illegal_surrogate(value) or isinstance(value, str) and SLASH in value)\n for value in parameters.values()\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def default_path(path):\r\n while path[len(path) - 1] == '/' or path[len(path) - 1] == '\\\\':\r\n path = path[0:-1]\r\n\r\n return path","def _get_full_path(self, path, environ):\n if path.startswith('//'):\n path = path[1:]\n elif path.startswith('/'):\n path = environ.get('SCRIPT_NAME', '') + path\n return path","def test_path(self):\n urlpath = url.URL.fromString(\"http://example.com/foo/bar?baz=quux#foobar\")\n self.assertEqual(urlpath.path, \"foo/bar\")\n urlpath = url.URL.fromString(\"http://example.com/foo%2Fbar?baz=quux#foobar\")\n self.assertEqual(urlpath.path, \"foo%2Fbar\")\n urlpath = url.URL.fromString(\"http://example.com/-_.!*'()?baz=quux#foo\")\n self.assertEqual(urlpath.path, \"-_.!*'()\")","def noTrailingSlash(path):\n return path.split('/')[0]","def py38_translate_path(self, path):\n # abandon query parameters\n path = path.split('?', 1)[0]\n path = path.split('#', 1)[0]\n # Don't forget explicit trailing slash when normalizing. Issue17324\n trailing_slash = path.rstrip().endswith('/')\n try:\n path = urllib.parse.unquote(path, errors='surrogatepass')\n except UnicodeDecodeError:\n path = urllib.parse.unquote(path)\n path = posixpath.normpath(path)\n words = path.split('/')\n words = filter(None, words)\n # py38: self.directory\n # py36: os.getcwd()\n path = STATIC_DIR\n for word in words:\n if os.path.dirname(word) or word in (os.curdir, os.pardir):\n # Ignore components that are not a simple file/directory name\n continue\n path = os.path.join(path, word)\n if trailing_slash:\n path += '/'\n return path","def load_path_url():\n web.ctx.path_url = web.ctx.home + web.ctx.path","def strip_path(self):\n return self.path.replace('/', '')","def path_only(self):\n path = six.moves.urllib.parse.urlparse(self.path).path\n if path.endswith('/'):\n return path[:-1]\n else:\n return path","def url(self, path=\"/\"):\n return \"http://127.0.0.1:%d/%s\" % (\n self.server_address[1],\n path.lstrip(\"/\"),\n )","def get_return_to_from_path(req: web.Request) -> str:\n if req.path == \"/login\":\n return urllib.parse.quote(\"/\", safe=\"\")\n\n return urllib.parse.quote(req.path, safe=\"\")","def test_append_slash_disabled(self):\n request = self.rf.get(\"/slash\")\n self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)","def path_only(self):\r\n path = urlparse.urlparse(self.path).path\r\n if path.endswith('/'):\r\n return path[:-1]\r\n else:\r\n return path","def ensure_path(self, page):\n return page if page.startswith('/') else \"/{0}\".format(page)","def construct_url(self,*path):\n base = self.request.protocol+\"://\"+self.request.host+\"/\"\n return base+\"/\".join(path)","def clean_path(path):\n return resolved_path(path)","def test_normalize_path(self):\n self.assertEqual(normalize_path(\"//////\"), \"/\")\n self.assertEqual(normalize_path(\"//\"), \"/\")\n self.assertEqual(normalize_path(\"//foo/bar//baz\"), \"/foo/bar/baz\")\n self.assertEqual(normalize_path(\"//foo/bar//baz/\"), \"/foo/bar/baz/\")\n self.assertEqual(normalize_path(\"//f%20oo/bar\"), \"/f oo/bar\")","def clean_slashes(path):\n return path.strip(\"/\")","def serving_path_parameterized(self):\n return self.pod.path_format.format_static(\n self.path_format, locale=self.locale, parameterize=True)","def translate_path(self, path):\n # abandon query parameters\n path = path.split('?', 1)[0]\n path = path.split('#', 1)[0]\n # Don't forget explicit trailing slash when normalizing. Issue17324\n trailing_slash = path.rstrip().endswith('/')\n try:\n path = urllib.parse.unquote(path, errors='surrogatepass')\n except UnicodeDecodeError:\n path = urllib.parse.unquote(path)\n path = normpath(path)\n words = path.split('/')\n words = filter(None, words)\n path = self.serve_path # use own path here (no cwd)\n for word in words:\n if os.path.dirname(word) or word in (os.curdir, os.pardir):\n # Ignore components that are not a simple file/directory name\n continue\n path = os.path.join(path, word)\n if trailing_slash:\n path += '/'\n return path","def path_to_url(path):\r\n if os.sep == '/':\r\n return path\r\n else:\r\n return '/'.join(split_all(path))","def test_invalid_path_get(self):\n static_path = self.finder.find('file.ext')\n self.assertIsNone(static_path)","def format_path(path):\n if not path:\n return path\n\n path = re.sub(r'/+', '/', path)\n\n if path == '/':\n return (u\"\" if isinstance(path, unicode) else \"\")\n else:\n return '/' + path.strip('/')","def clean_url(app_server, base_path) -> str:\n if app_server.endswith('/'):\n base_url = f\"{app_server[:-1]}{base_path}\"\n else:\n base_url = f\"{app_server}/{base_path}\"\n return base_url","def get_template_from_path(path: str) -> str:\r\n path = path.replace(\"\\\\\", \"/\")\r\n return path","def _get_path(request):\n path = request.path\n try:\n match_info = request.match_info\n except sanic.exceptions.SanicException:\n return path\n for key, value in match_info.items():\n try:\n value = str(value)\n except Exception:\n # Best effort\n continue\n path = path.replace(value, f\"<{key}>\")\n return path","def url_clean(path):\n return path[path.find('/'+settings.URL_ADMIN_SEP):]","def test_00(self):\n result = resolve_path({'_id': '1'}, '')\n expected = '/index.html'\n self.assertEqual(result, expected)\n\n result = resolve_path({'_id': '1'}, '/')\n expected = '/index.html'\n self.assertEqual(result, expected)\n\n result = resolve_path({'_id': '1'}, 'foo.png')\n expected = '/foo.png'\n self.assertEqual(result, expected)\n\n result = resolve_path({'_id': '1'}, 'bar/foo.js')\n expected = '/bar/foo.js'\n self.assertEqual(result, expected)\n\n result = resolve_path({'_id': '1'}, 'main.js')\n expected = '/main.js'\n self.assertEqual(result, expected)","def _url(self, path):\n \n return self.url + path","def test_append_slash_slashless_unknown(self):\n request = self.rf.get(\"/unknown\")\n response = CommonMiddleware(get_response_404)(request)\n self.assertEqual(response.status_code, 404)","def full_url(resource):\r\n # if (url/resource == '127.0.0.1':)\r\n if resource == '/' or resource == ' ':\r\n url = \"{0}{1}\".format(ROOT_DIRECTORY, URL_TEST)\r\n # else (if url/resource == 'Specific resource')\r\n else:\r\n url = \"{0}{1}\".format(ROOT_DIRECTORY, str(resource).replace('/', '\\\\'))\r\n print(f'the client request = {url}')\r\n return url","def sendNotFound(self, path):\n prefix = self._getConfigParam(\"usenotfoundpath\", \"notfound\").strip('/')\n if not path.startswith(\"/\"): \n path = \"/%s\" % path\n notfound = \"/%s%s\" % (prefix, path)\n self.localRedirect(notfound)","def test_append_slash_have_slash(self):\n request = self.rf.get(\"/slash/\")\n self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))\n self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)","def test_remove_extra_slash():\n # TODO: Should we actually do this?\n # TODO: See https://webmasters.stackexchange.com/questions/8354/what-does-the-double-slash-mean-in-urls/8381#8381\n assert (normalize_url(\"http://www.example.com/foo//bar.html\") ==\n \"http://www.example.com/foo/bar.html\")\n assert(normalize_url(\"http://example.com///abc\") ==\n \"http://example.com/abc\")","def normalizePath(path):\n if path == None or len(path) == 0 or path == '/':\n return '/'\n buff = '/' + path if path[0] != '/' else path\n return buff.replace('//', '/')","def test_append_slash_opt_out(self):\n request = self.rf.get(\"/sensitive_fbv\")\n self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)\n\n request = self.rf.get(\"/sensitive_cbv\")\n self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)","def url(self, path):\n path = ensure_slash(path)\n return 'http://127.0.0.1:%d%s' % (self.server.server_port, path)","def path(self):\n\n if os.path.isabs(self._value):\n return pathlib.Path(self._value)\n raise RuntimeError('RequestString.path not supported.')","def qualify(path: str) -> str:\n if path.startswith(\"/\"):\n return f\"file://{path}\"\n else:\n return path","def test_append_slash_quoted(self):\n request = self.rf.get(quote(\"/needsquoting#\"))\n r = CommonMiddleware(get_response_404)(request)\n self.assertEqual(r.status_code, 301)\n self.assertEqual(r.url, \"/needsquoting%23/\")","def test_append_slash_leading_slashes(self):\n # Use 4 slashes because of RequestFactory behavior.\n request = self.rf.get(\"////evil.com/security\")\n r = CommonMiddleware(get_response_404).process_request(request)\n self.assertIsNone(r)\n response = HttpResponseNotFound()\n r = CommonMiddleware(get_response_404).process_response(request, response)\n self.assertEqual(r.status_code, 301)\n self.assertEqual(r.url, \"/%2Fevil.com/security/\")\n r = CommonMiddleware(get_response_404)(request)\n self.assertEqual(r.status_code, 301)\n self.assertEqual(r.url, \"/%2Fevil.com/security/\")","def format_path(path):\n return path if path.endswith('/') else path + '/'","def leadingSlash(path):\n if path == None or len(path) == 0 or path == '/':\n return '/'\n if path[0] == '/':\n return path\n else:\n return '/' + path","def _cleanup_path(path):\n return string.join(filter(None, string.split(path, '/')), '/')","def standard_path_from_server_root(self, arg: str) -> str:\n # Remove beginning and ending quotes\n arg = arg.strip(\"'\\\"\")\n\n # Standardize the include argument based on server root\n if not arg.startswith(\"/\"):\n # Normpath will condense ../\n arg = os.path.normpath(os.path.join(self.root, arg))\n else:\n arg = os.path.normpath(arg)\n return arg","def validate_short_path(short_path):","def fixpaths(d):\n if isinstance(d, dict):\n if \"path\" in d:\n if \":\" not in d[\"path\"]:\n local_path = os.path.normpath(\n os.path.join(os.getcwd(), basedir, d[\"path\"])\n )\n d[\"location\"] = pathname2url(local_path)\n else:\n d[\"location\"] = d[\"path\"]\n del d[\"path\"]","def urlpath( request, *args, **kwargs ):","def safepath(p):\n return p.replace('/', os.sep)","def full_url(self, path):\n if path[0] == '/':\n path = path[1:]\n return urljoin(self.absolute_root, path)","def response_path(path):\n path = \"webroot\" + path\n path = os.path.abspath(path)\n content = b\"not implemented\"\n mime_type = b\"not implemented\"\n if os.path.isdir(path):\n return return_directory(path)\n elif os.path.isfile(path):\n return return_file(path)\n else:\n raise NameError\n return content, mime_type","def clean_path(path):\n path = path.replace(\"~\", str(Path.home()))\n if path[-1] != \"/\":\n path += \"/\"\n return path","def api_path(self, path=\"\"):\n return \"https://{domain}/{path}\".format(\n domain=self.setting(\"DOMAIN\"), path=path\n )","def extract_path(path: str) -> str:\n return _RE_URL.sub(r'{\\1}', path)","def _get_path(self, uid: Optional[Union[UUID, str]] = None,\n ignore_dataset: Optional[bool] = False) -> str:\n subpath = format_escaped_url('/{}', uid) if uid else ''\n if ignore_dataset:\n return format_escaped_url(self._dataset_agnostic_path_template + subpath,\n **self.__dict__)\n else:\n return format_escaped_url(self._path_template + subpath,\n **self.__dict__)","def parse_url_path(url_path):\r\n\r\n m = re.match('^/([^/]+)/?$',url_path)\r\n if m:\r\n return (m.group(1),None)\r\n \r\n m = re.match('^/([^/]+)/(.+)$',url_path)\r\n if m:\r\n return (m.group(1),m.group(2).replace('%25','%'))\r\n \r\n return (None,None)","def _normalize_path(path):\n if path is None:\n directory = BASE_PATH\n path = ''\n else:\n path = op.normpath(path)\n directory = op.normpath(op.join(BASE_PATH, path))\n\n if not is_in_folder(BASE_PATH, directory):\n abort(404)\n\n if not op.exists(directory):\n abort(404)\n\n return BASE_PATH, directory, path","def serving_path(self):\n if self.source_pod_path != self.pod_path or not self.use_fallback:\n path = self.pod.path_format.format_static(\n self.path_format, locale=self.locale,\n fingerprint=self.fingerprint)\n else:\n # Fall back to use the default locale for the formatted path.\n path = self.pod.path_format.format_static(\n self.base_path_format, locale=self.pod.podspec.default_locale,\n fingerprint=self.fingerprint)\n\n if not self.fingerprinted:\n return path\n\n base, ext = os.path.splitext(path)\n # Special case to preserve \".min.<ext>\" extensions.\n if base.endswith('.min'):\n base = base[:-4]\n return '{}-{}.min{}'.format(base, self.fingerprint, ext)\n return '{}-{}{}'.format(base, self.fingerprint, ext)","def standardize_path(path):\n path.rstrip('/')\n if not path.startswith('.*'):\n path = '/' + path\n path = re.compile('/+').sub('/', path)\n return path","def _get_file_url(path):\n return urlparse.urljoin(BASE_URL, path)","def test_predicates_on_unsanitized_paths(self):\n self.mfs.add_entries({'/just/another/pythonista': ''})\n\n self.assertTrue(os.path.isdir('///just'))\n self.assertTrue(os.path.isdir('///just/////another'))\n self.assertTrue(os.path.exists('///just////another////////pythonista'))\n self.assertTrue(os.path.isfile('///just////another////////pythonista'))","def fix_url_path(url: str) -> str:\n return url if url.endswith(\"/\") else url + \"/\"","def empty_path(isolated_backends, backend_echo, proxy, backend_usages): # pylint: disable=unused-argument\n\n echo_metric = backend_echo.metrics.list()[0]\n\n backend_echo.mapping_rules.create(rawobj.Mapping(echo_metric, \"/anything/quotes/bar\"))\n\n backend_usages[0].update({\"path\": \"/\"})\n\n proxy.deploy()","def ensure_slash(text):\n if text.startswith('/'):\n return text\n return '/' + text","def filter_pathbase(val: Optional[str]) -> str:\n return os.path.basename(val or '')","def split_template_path(template):\n pieces = []\n for piece in template.split('/'):\n if path.sep in piece \\\n or (path.altsep and path.altsep in piece) or \\\n piece == path.pardir:\n raise TemplateNotFound(template)\n elif piece and piece != '.':\n pieces.append(piece)\n return pieces","def url(self, request_path=\"\"):\n return f\"{self.scheme}://{self.host}/{request_path}\"","def test_no_variables_in_uri(self):\n uri = \"https://api.github.com/users\"\n t = URITemplate(uri)\n self.assertEqual(t.expand(), uri)\n self.assertEqual(t.expand(users=\"foo\"), uri)","def handle_notfound( environ ):\n return 404, [], make_error( 'Not Found', environ[ 'PATH_INFO' ] )","def urlpath(self, url):\n\t\t# remove schema + hostname\n\t\turl = re.sub('^[^:]*://[^/]+', '/', url)\n\n\t\treturn self.canonicalize(url)","def split_template_path(template):\n pieces = []\n for piece in template.split('/'):\n if os.path.sep in piece \\\n or (os.path.altsep and os.path.altsep in piece) or \\\n piece == os.path.pardir:\n raise TemplateNotFound(template)\n elif piece and piece != '.':\n pieces.append(piece)\n return pieces","def test_path_percent_encoding():\n assert (normalize_url(\"http://example.com/hello world{}\") ==\n \"http://example.com/hello%20world%7B%7D\")","async def client_path_error() -> web.Response:\n html = get_client_file_error_template().render()\n return web.Response(body=html, content_type=\"text/html\")","def test_parse_url_path() -> None:\n assert indieauth._parse_url(\"http://ex.com\").path == \"/\"","def url_subpath(s):\n forbidden = forbidden_chars.intersection(s)\n if forbidden:\n forbidden = ''.join(sorted(forbidden))\n raise ValueError('%(s)r contains forbidden characters'\n ' (%(forbidden)r)'\n % locals())\n stripped = normpath(s).lstrip(sep)\n if stripped == curdir:\n return ''\n if sep != '/':\n return stripped.replace(sep, '/')\n return stripped","def get_url(domain, path):\n\n return f\"https://{domain}.freshservice.com/api/v2/{path}\"","def _trim_path(path):\n if path.endswith(\"/\"):\n path = path[:-1] # remove / at the end\n \n return path","def _git_path(request, wiki):\n\n path = request.path.split(u'/{0}/'.format(wiki))[1]\n\n # Remove slashes\n while path and path[0] == u'/':\n path = path[1:]\n\n while path and path[-1] == u'/':\n path = path[:-1]\n\n return path","def replacement_not_found(klass, environ, start_response):\n raise HTTP404('path not found')","def _cleanpath(self, path):\n \n slashes = self.remotepathsep*2\n while slashes in path:\n path = path.replace(slashes,self.remotepathsep)\n \n if path.endswith(self.remotepathsep):\n path = path[:-1]\n \n return path","def _cleanpath(self, path):\n \n slashes = self.remotepathsep*2\n while slashes in path:\n path = path.replace(slashes,self.remotepathsep)\n \n if path.endswith(self.remotepathsep):\n path = path[:-1]\n \n return path","def path2support(path):\n parts = path.split(os.path.sep)\n # return '{{ site.baseurl}}' + IPYTHON_STATIC_DIR + '/' + '/'.join(quote(part) for part in parts)\n return '/' + IPYTHON_STATIC_DIR + '/' + '/'.join(quote(part) for part in parts)","def pathfor( request, *args, **kwargs ):","def _format_default(s):\n return u'\"%s%s\"' % (BASE_URL, s.get_absolute_url())","def test_append_slash_redirect_querystring(self):\n request = self.rf.get(\"/slash?test=1\")\n resp = CommonMiddleware(get_response_404)(request)\n self.assertEqual(resp.url, \"/slash/?test=1\")","def containing_path(path: Union[str, os.PathLike]) -> str:\n if not path:\n return str(path)\n url = urlparse(str(path))\n if url.scheme:\n if url.path:\n return os.path.dirname(path)\n return url.scheme + \"://\"\n return os.path.dirname(os.path.realpath(path))","def path_validate(path):\n # functionality to be added later\n return path","def strip_path(path):\n name_re = re.compile(\"[^/]*\\.([a-z]+)$\")\n return name_re.search(path).group(0)","def fix_slash(environ, wantslash):\n from colubrid.exceptions import HttpMoved\n #FIXME\n # argh. never did something that supid\n # find a better solution for that problem.\n url = quote(environ.get('SCRIPT_NAME', ''))\n url += quote(environ.get('PATH_INFO', ''))\n query = environ.get('QUERY_STRING', '')\n oldurl = query and ('%s?%s' % (url, query)) or url\n \n if oldurl and oldurl != '/':\n if url.endswith('/'):\n if not wantslash:\n url = url[:-1]\n else:\n if wantslash:\n url += '/'\n \n newurl = query and ('%s?%s' % (url, query)) or url\n if oldurl != newurl:\n raise HttpMoved(newurl)","def translate_path(self, path):\r\n root_dir = self.server.config.get('root_dir')\r\n path = '{}{}'.format(root_dir, path)\r\n return path.split('?')[0]","def static_url(self, path):\n\t\tif not hasattr(self, \"_static_hashes\"):\n\t\t\tself._static_hashes = {}\n\t\thashes = self._static_hashes\n\t\tif path not in hashes:\n\t\t\timport hashlib\n\t\t\ttry:\n\t\t\t\tf = open(os.path.join(\n\t\t\t\t\tself.application.settings[\"static_path\"], path))\n\t\t\t\thashes[path] = hashlib.md5(f.read()).hexdigest()\n\t\t\t\tf.close()\n\t\t\texcept:\n\t\t\t\tprint \"Could not open static file %r\"%path\n\t\t\t\thashes[path] = None\n\t\tbase = \"http://static.\"+_config.get(\"varnish\", \"ovzcphost\") + \"/\"\n\t\tif hashes.get(path):\n\t\t\treturn base + path + \"?v=\" + hashes[path][:5]\n\t\telse:\n\t\t\treturn base + path","def base_url_path(self):\n path = urlsplit(self.base_url())[2]\n if path.endswith(\"/\"):\n path = path[:-1]\n return path","def _url(path, **kwargs):\n if kwargs:\n if isinstance(kwargs.get('owner'), users.User):\n kwargs['owner'] = kwargs['owner'].email()\n encoded_parameters = urllib.urlencode(kwargs)\n if path.endswith('?'):\n # Trailing ? on path. Append parameters to end.\n return '%s%s' % (path, encoded_parameters)\n elif '?' in path:\n # Append additional parameters to existing query parameters.\n return '%s&%s' % (path, encoded_parameters)\n else:\n # Add query parameters to path with no query parameters.\n return '%s?%s' % (path, encoded_parameters)\n else:\n return path","def translate_path(self, path):\n\t\t# abandon query parameters\n\t\tpath = path.split('?',1)[0]\n\t\tpath = path.split('#',1)[0]\n\t\tpath = posixpath.normpath(urllib.unquote(path))\n\t\twords = path.split('/')\n\t\twords = filter(None, words)\n\t\tpath = os.getcwd() + \"/\" + self.wwwroot\n\t\tfor word in words:\n\t\t\tdrive, word = os.path.splitdrive(word)\n\t\t\thead, word = os.path.split(word)\n\t\t\tif word in (os.curdir, os.pardir): continue\n\t\t\tpath = os.path.join(path, word)\n\t\treturn path","def strip_beginning_slashes(url):\n find = re.search(r\"^/+\", url)\n if find:\n url = re.sub(find.group(0), \"\", url)\n return url","def build_url(base_url, path):\n if absolute_http_url_regexp.match(path):\n return path\n elif base_url:\n return \"{}/{}\".format(base_url.rstrip(\"/\"), path.lstrip(\"/\"))\n else:\n raise exceptions.ParamsError(\"base url missed!\")","def ensureOneSlash(s):\n\treturn s.rstrip(\"/\")+\"/\"","def test_append_slash_slashless_resource(self):\n\n def get_response(req):\n return HttpResponse(\"Here's the text of the web page.\")\n\n request = self.rf.get(\"/noslash\")\n self.assertIsNone(CommonMiddleware(get_response).process_request(request))\n self.assertEqual(\n CommonMiddleware(get_response)(request).content,\n b\"Here's the text of the web page.\",\n )","def _FormHandlerURL(self, path):\n if path.endswith('/'):\n return path + 'edit.do'\n elif path.endswith('.do'):\n return path # This happens as part of PleaseCorrect().\n else:\n return path + '.do'","def _get_dir_url(endpoint, path, **kwargs):\n if not path:\n return url_for(endpoint)\n else:\n #if self._on_windows:\n # path = path.replace('\\\\', '/')\n\n kwargs['path'] = path\n\n return url_for(endpoint, **kwargs)","def testInvalidPath(self):\n status, _ = self._http_get(\"invalid_path\")\n self.assertEqual(status, 404)","def htmlpath(path):\n filelocation = f\"public/pages/{path}\"\n print(filelocation)\n\n return filelocation"],"string":"[\n \"def default_path(path):\\r\\n while path[len(path) - 1] == '/' or path[len(path) - 1] == '\\\\\\\\':\\r\\n path = path[0:-1]\\r\\n\\r\\n return path\",\n \"def _get_full_path(self, path, environ):\\n if path.startswith('//'):\\n path = path[1:]\\n elif path.startswith('/'):\\n path = environ.get('SCRIPT_NAME', '') + path\\n return path\",\n \"def test_path(self):\\n urlpath = url.URL.fromString(\\\"http://example.com/foo/bar?baz=quux#foobar\\\")\\n self.assertEqual(urlpath.path, \\\"foo/bar\\\")\\n urlpath = url.URL.fromString(\\\"http://example.com/foo%2Fbar?baz=quux#foobar\\\")\\n self.assertEqual(urlpath.path, \\\"foo%2Fbar\\\")\\n urlpath = url.URL.fromString(\\\"http://example.com/-_.!*'()?baz=quux#foo\\\")\\n self.assertEqual(urlpath.path, \\\"-_.!*'()\\\")\",\n \"def noTrailingSlash(path):\\n return path.split('/')[0]\",\n \"def py38_translate_path(self, path):\\n # abandon query parameters\\n path = path.split('?', 1)[0]\\n path = path.split('#', 1)[0]\\n # Don't forget explicit trailing slash when normalizing. Issue17324\\n trailing_slash = path.rstrip().endswith('/')\\n try:\\n path = urllib.parse.unquote(path, errors='surrogatepass')\\n except UnicodeDecodeError:\\n path = urllib.parse.unquote(path)\\n path = posixpath.normpath(path)\\n words = path.split('/')\\n words = filter(None, words)\\n # py38: self.directory\\n # py36: os.getcwd()\\n path = STATIC_DIR\\n for word in words:\\n if os.path.dirname(word) or word in (os.curdir, os.pardir):\\n # Ignore components that are not a simple file/directory name\\n continue\\n path = os.path.join(path, word)\\n if trailing_slash:\\n path += '/'\\n return path\",\n \"def load_path_url():\\n web.ctx.path_url = web.ctx.home + web.ctx.path\",\n \"def strip_path(self):\\n return self.path.replace('/', '')\",\n \"def path_only(self):\\n path = six.moves.urllib.parse.urlparse(self.path).path\\n if path.endswith('/'):\\n return path[:-1]\\n else:\\n return path\",\n \"def url(self, path=\\\"/\\\"):\\n return \\\"http://127.0.0.1:%d/%s\\\" % (\\n self.server_address[1],\\n path.lstrip(\\\"/\\\"),\\n )\",\n \"def get_return_to_from_path(req: web.Request) -> str:\\n if req.path == \\\"/login\\\":\\n return urllib.parse.quote(\\\"/\\\", safe=\\\"\\\")\\n\\n return urllib.parse.quote(req.path, safe=\\\"\\\")\",\n \"def test_append_slash_disabled(self):\\n request = self.rf.get(\\\"/slash\\\")\\n self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)\",\n \"def path_only(self):\\r\\n path = urlparse.urlparse(self.path).path\\r\\n if path.endswith('/'):\\r\\n return path[:-1]\\r\\n else:\\r\\n return path\",\n \"def ensure_path(self, page):\\n return page if page.startswith('/') else \\\"/{0}\\\".format(page)\",\n \"def construct_url(self,*path):\\n base = self.request.protocol+\\\"://\\\"+self.request.host+\\\"/\\\"\\n return base+\\\"/\\\".join(path)\",\n \"def clean_path(path):\\n return resolved_path(path)\",\n \"def test_normalize_path(self):\\n self.assertEqual(normalize_path(\\\"//////\\\"), \\\"/\\\")\\n self.assertEqual(normalize_path(\\\"//\\\"), \\\"/\\\")\\n self.assertEqual(normalize_path(\\\"//foo/bar//baz\\\"), \\\"/foo/bar/baz\\\")\\n self.assertEqual(normalize_path(\\\"//foo/bar//baz/\\\"), \\\"/foo/bar/baz/\\\")\\n self.assertEqual(normalize_path(\\\"//f%20oo/bar\\\"), \\\"/f oo/bar\\\")\",\n \"def clean_slashes(path):\\n return path.strip(\\\"/\\\")\",\n \"def serving_path_parameterized(self):\\n return self.pod.path_format.format_static(\\n self.path_format, locale=self.locale, parameterize=True)\",\n \"def translate_path(self, path):\\n # abandon query parameters\\n path = path.split('?', 1)[0]\\n path = path.split('#', 1)[0]\\n # Don't forget explicit trailing slash when normalizing. Issue17324\\n trailing_slash = path.rstrip().endswith('/')\\n try:\\n path = urllib.parse.unquote(path, errors='surrogatepass')\\n except UnicodeDecodeError:\\n path = urllib.parse.unquote(path)\\n path = normpath(path)\\n words = path.split('/')\\n words = filter(None, words)\\n path = self.serve_path # use own path here (no cwd)\\n for word in words:\\n if os.path.dirname(word) or word in (os.curdir, os.pardir):\\n # Ignore components that are not a simple file/directory name\\n continue\\n path = os.path.join(path, word)\\n if trailing_slash:\\n path += '/'\\n return path\",\n \"def path_to_url(path):\\r\\n if os.sep == '/':\\r\\n return path\\r\\n else:\\r\\n return '/'.join(split_all(path))\",\n \"def test_invalid_path_get(self):\\n static_path = self.finder.find('file.ext')\\n self.assertIsNone(static_path)\",\n \"def format_path(path):\\n if not path:\\n return path\\n\\n path = re.sub(r'/+', '/', path)\\n\\n if path == '/':\\n return (u\\\"\\\" if isinstance(path, unicode) else \\\"\\\")\\n else:\\n return '/' + path.strip('/')\",\n \"def clean_url(app_server, base_path) -> str:\\n if app_server.endswith('/'):\\n base_url = f\\\"{app_server[:-1]}{base_path}\\\"\\n else:\\n base_url = f\\\"{app_server}/{base_path}\\\"\\n return base_url\",\n \"def get_template_from_path(path: str) -> str:\\r\\n path = path.replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\r\\n return path\",\n \"def _get_path(request):\\n path = request.path\\n try:\\n match_info = request.match_info\\n except sanic.exceptions.SanicException:\\n return path\\n for key, value in match_info.items():\\n try:\\n value = str(value)\\n except Exception:\\n # Best effort\\n continue\\n path = path.replace(value, f\\\"<{key}>\\\")\\n return path\",\n \"def url_clean(path):\\n return path[path.find('/'+settings.URL_ADMIN_SEP):]\",\n \"def test_00(self):\\n result = resolve_path({'_id': '1'}, '')\\n expected = '/index.html'\\n self.assertEqual(result, expected)\\n\\n result = resolve_path({'_id': '1'}, '/')\\n expected = '/index.html'\\n self.assertEqual(result, expected)\\n\\n result = resolve_path({'_id': '1'}, 'foo.png')\\n expected = '/foo.png'\\n self.assertEqual(result, expected)\\n\\n result = resolve_path({'_id': '1'}, 'bar/foo.js')\\n expected = '/bar/foo.js'\\n self.assertEqual(result, expected)\\n\\n result = resolve_path({'_id': '1'}, 'main.js')\\n expected = '/main.js'\\n self.assertEqual(result, expected)\",\n \"def _url(self, path):\\n \\n return self.url + path\",\n \"def test_append_slash_slashless_unknown(self):\\n request = self.rf.get(\\\"/unknown\\\")\\n response = CommonMiddleware(get_response_404)(request)\\n self.assertEqual(response.status_code, 404)\",\n \"def full_url(resource):\\r\\n # if (url/resource == '127.0.0.1':)\\r\\n if resource == '/' or resource == ' ':\\r\\n url = \\\"{0}{1}\\\".format(ROOT_DIRECTORY, URL_TEST)\\r\\n # else (if url/resource == 'Specific resource')\\r\\n else:\\r\\n url = \\\"{0}{1}\\\".format(ROOT_DIRECTORY, str(resource).replace('/', '\\\\\\\\'))\\r\\n print(f'the client request = {url}')\\r\\n return url\",\n \"def sendNotFound(self, path):\\n prefix = self._getConfigParam(\\\"usenotfoundpath\\\", \\\"notfound\\\").strip('/')\\n if not path.startswith(\\\"/\\\"): \\n path = \\\"/%s\\\" % path\\n notfound = \\\"/%s%s\\\" % (prefix, path)\\n self.localRedirect(notfound)\",\n \"def test_append_slash_have_slash(self):\\n request = self.rf.get(\\\"/slash/\\\")\\n self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))\\n self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)\",\n \"def test_remove_extra_slash():\\n # TODO: Should we actually do this?\\n # TODO: See https://webmasters.stackexchange.com/questions/8354/what-does-the-double-slash-mean-in-urls/8381#8381\\n assert (normalize_url(\\\"http://www.example.com/foo//bar.html\\\") ==\\n \\\"http://www.example.com/foo/bar.html\\\")\\n assert(normalize_url(\\\"http://example.com///abc\\\") ==\\n \\\"http://example.com/abc\\\")\",\n \"def normalizePath(path):\\n if path == None or len(path) == 0 or path == '/':\\n return '/'\\n buff = '/' + path if path[0] != '/' else path\\n return buff.replace('//', '/')\",\n \"def test_append_slash_opt_out(self):\\n request = self.rf.get(\\\"/sensitive_fbv\\\")\\n self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)\\n\\n request = self.rf.get(\\\"/sensitive_cbv\\\")\\n self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)\",\n \"def url(self, path):\\n path = ensure_slash(path)\\n return 'http://127.0.0.1:%d%s' % (self.server.server_port, path)\",\n \"def path(self):\\n\\n if os.path.isabs(self._value):\\n return pathlib.Path(self._value)\\n raise RuntimeError('RequestString.path not supported.')\",\n \"def qualify(path: str) -> str:\\n if path.startswith(\\\"/\\\"):\\n return f\\\"file://{path}\\\"\\n else:\\n return path\",\n \"def test_append_slash_quoted(self):\\n request = self.rf.get(quote(\\\"/needsquoting#\\\"))\\n r = CommonMiddleware(get_response_404)(request)\\n self.assertEqual(r.status_code, 301)\\n self.assertEqual(r.url, \\\"/needsquoting%23/\\\")\",\n \"def test_append_slash_leading_slashes(self):\\n # Use 4 slashes because of RequestFactory behavior.\\n request = self.rf.get(\\\"////evil.com/security\\\")\\n r = CommonMiddleware(get_response_404).process_request(request)\\n self.assertIsNone(r)\\n response = HttpResponseNotFound()\\n r = CommonMiddleware(get_response_404).process_response(request, response)\\n self.assertEqual(r.status_code, 301)\\n self.assertEqual(r.url, \\\"/%2Fevil.com/security/\\\")\\n r = CommonMiddleware(get_response_404)(request)\\n self.assertEqual(r.status_code, 301)\\n self.assertEqual(r.url, \\\"/%2Fevil.com/security/\\\")\",\n \"def format_path(path):\\n return path if path.endswith('/') else path + '/'\",\n \"def leadingSlash(path):\\n if path == None or len(path) == 0 or path == '/':\\n return '/'\\n if path[0] == '/':\\n return path\\n else:\\n return '/' + path\",\n \"def _cleanup_path(path):\\n return string.join(filter(None, string.split(path, '/')), '/')\",\n \"def standard_path_from_server_root(self, arg: str) -> str:\\n # Remove beginning and ending quotes\\n arg = arg.strip(\\\"'\\\\\\\"\\\")\\n\\n # Standardize the include argument based on server root\\n if not arg.startswith(\\\"/\\\"):\\n # Normpath will condense ../\\n arg = os.path.normpath(os.path.join(self.root, arg))\\n else:\\n arg = os.path.normpath(arg)\\n return arg\",\n \"def validate_short_path(short_path):\",\n \"def fixpaths(d):\\n if isinstance(d, dict):\\n if \\\"path\\\" in d:\\n if \\\":\\\" not in d[\\\"path\\\"]:\\n local_path = os.path.normpath(\\n os.path.join(os.getcwd(), basedir, d[\\\"path\\\"])\\n )\\n d[\\\"location\\\"] = pathname2url(local_path)\\n else:\\n d[\\\"location\\\"] = d[\\\"path\\\"]\\n del d[\\\"path\\\"]\",\n \"def urlpath( request, *args, **kwargs ):\",\n \"def safepath(p):\\n return p.replace('/', os.sep)\",\n \"def full_url(self, path):\\n if path[0] == '/':\\n path = path[1:]\\n return urljoin(self.absolute_root, path)\",\n \"def response_path(path):\\n path = \\\"webroot\\\" + path\\n path = os.path.abspath(path)\\n content = b\\\"not implemented\\\"\\n mime_type = b\\\"not implemented\\\"\\n if os.path.isdir(path):\\n return return_directory(path)\\n elif os.path.isfile(path):\\n return return_file(path)\\n else:\\n raise NameError\\n return content, mime_type\",\n \"def clean_path(path):\\n path = path.replace(\\\"~\\\", str(Path.home()))\\n if path[-1] != \\\"/\\\":\\n path += \\\"/\\\"\\n return path\",\n \"def api_path(self, path=\\\"\\\"):\\n return \\\"https://{domain}/{path}\\\".format(\\n domain=self.setting(\\\"DOMAIN\\\"), path=path\\n )\",\n \"def extract_path(path: str) -> str:\\n return _RE_URL.sub(r'{\\\\1}', path)\",\n \"def _get_path(self, uid: Optional[Union[UUID, str]] = None,\\n ignore_dataset: Optional[bool] = False) -> str:\\n subpath = format_escaped_url('/{}', uid) if uid else ''\\n if ignore_dataset:\\n return format_escaped_url(self._dataset_agnostic_path_template + subpath,\\n **self.__dict__)\\n else:\\n return format_escaped_url(self._path_template + subpath,\\n **self.__dict__)\",\n \"def parse_url_path(url_path):\\r\\n\\r\\n m = re.match('^/([^/]+)/?$',url_path)\\r\\n if m:\\r\\n return (m.group(1),None)\\r\\n \\r\\n m = re.match('^/([^/]+)/(.+)$',url_path)\\r\\n if m:\\r\\n return (m.group(1),m.group(2).replace('%25','%'))\\r\\n \\r\\n return (None,None)\",\n \"def _normalize_path(path):\\n if path is None:\\n directory = BASE_PATH\\n path = ''\\n else:\\n path = op.normpath(path)\\n directory = op.normpath(op.join(BASE_PATH, path))\\n\\n if not is_in_folder(BASE_PATH, directory):\\n abort(404)\\n\\n if not op.exists(directory):\\n abort(404)\\n\\n return BASE_PATH, directory, path\",\n \"def serving_path(self):\\n if self.source_pod_path != self.pod_path or not self.use_fallback:\\n path = self.pod.path_format.format_static(\\n self.path_format, locale=self.locale,\\n fingerprint=self.fingerprint)\\n else:\\n # Fall back to use the default locale for the formatted path.\\n path = self.pod.path_format.format_static(\\n self.base_path_format, locale=self.pod.podspec.default_locale,\\n fingerprint=self.fingerprint)\\n\\n if not self.fingerprinted:\\n return path\\n\\n base, ext = os.path.splitext(path)\\n # Special case to preserve \\\".min.<ext>\\\" extensions.\\n if base.endswith('.min'):\\n base = base[:-4]\\n return '{}-{}.min{}'.format(base, self.fingerprint, ext)\\n return '{}-{}{}'.format(base, self.fingerprint, ext)\",\n \"def standardize_path(path):\\n path.rstrip('/')\\n if not path.startswith('.*'):\\n path = '/' + path\\n path = re.compile('/+').sub('/', path)\\n return path\",\n \"def _get_file_url(path):\\n return urlparse.urljoin(BASE_URL, path)\",\n \"def test_predicates_on_unsanitized_paths(self):\\n self.mfs.add_entries({'/just/another/pythonista': ''})\\n\\n self.assertTrue(os.path.isdir('///just'))\\n self.assertTrue(os.path.isdir('///just/////another'))\\n self.assertTrue(os.path.exists('///just////another////////pythonista'))\\n self.assertTrue(os.path.isfile('///just////another////////pythonista'))\",\n \"def fix_url_path(url: str) -> str:\\n return url if url.endswith(\\\"/\\\") else url + \\\"/\\\"\",\n \"def empty_path(isolated_backends, backend_echo, proxy, backend_usages): # pylint: disable=unused-argument\\n\\n echo_metric = backend_echo.metrics.list()[0]\\n\\n backend_echo.mapping_rules.create(rawobj.Mapping(echo_metric, \\\"/anything/quotes/bar\\\"))\\n\\n backend_usages[0].update({\\\"path\\\": \\\"/\\\"})\\n\\n proxy.deploy()\",\n \"def ensure_slash(text):\\n if text.startswith('/'):\\n return text\\n return '/' + text\",\n \"def filter_pathbase(val: Optional[str]) -> str:\\n return os.path.basename(val or '')\",\n \"def split_template_path(template):\\n pieces = []\\n for piece in template.split('/'):\\n if path.sep in piece \\\\\\n or (path.altsep and path.altsep in piece) or \\\\\\n piece == path.pardir:\\n raise TemplateNotFound(template)\\n elif piece and piece != '.':\\n pieces.append(piece)\\n return pieces\",\n \"def url(self, request_path=\\\"\\\"):\\n return f\\\"{self.scheme}://{self.host}/{request_path}\\\"\",\n \"def test_no_variables_in_uri(self):\\n uri = \\\"https://api.github.com/users\\\"\\n t = URITemplate(uri)\\n self.assertEqual(t.expand(), uri)\\n self.assertEqual(t.expand(users=\\\"foo\\\"), uri)\",\n \"def handle_notfound( environ ):\\n return 404, [], make_error( 'Not Found', environ[ 'PATH_INFO' ] )\",\n \"def urlpath(self, url):\\n\\t\\t# remove schema + hostname\\n\\t\\turl = re.sub('^[^:]*://[^/]+', '/', url)\\n\\n\\t\\treturn self.canonicalize(url)\",\n \"def split_template_path(template):\\n pieces = []\\n for piece in template.split('/'):\\n if os.path.sep in piece \\\\\\n or (os.path.altsep and os.path.altsep in piece) or \\\\\\n piece == os.path.pardir:\\n raise TemplateNotFound(template)\\n elif piece and piece != '.':\\n pieces.append(piece)\\n return pieces\",\n \"def test_path_percent_encoding():\\n assert (normalize_url(\\\"http://example.com/hello world{}\\\") ==\\n \\\"http://example.com/hello%20world%7B%7D\\\")\",\n \"async def client_path_error() -> web.Response:\\n html = get_client_file_error_template().render()\\n return web.Response(body=html, content_type=\\\"text/html\\\")\",\n \"def test_parse_url_path() -> None:\\n assert indieauth._parse_url(\\\"http://ex.com\\\").path == \\\"/\\\"\",\n \"def url_subpath(s):\\n forbidden = forbidden_chars.intersection(s)\\n if forbidden:\\n forbidden = ''.join(sorted(forbidden))\\n raise ValueError('%(s)r contains forbidden characters'\\n ' (%(forbidden)r)'\\n % locals())\\n stripped = normpath(s).lstrip(sep)\\n if stripped == curdir:\\n return ''\\n if sep != '/':\\n return stripped.replace(sep, '/')\\n return stripped\",\n \"def get_url(domain, path):\\n\\n return f\\\"https://{domain}.freshservice.com/api/v2/{path}\\\"\",\n \"def _trim_path(path):\\n if path.endswith(\\\"/\\\"):\\n path = path[:-1] # remove / at the end\\n \\n return path\",\n \"def _git_path(request, wiki):\\n\\n path = request.path.split(u'/{0}/'.format(wiki))[1]\\n\\n # Remove slashes\\n while path and path[0] == u'/':\\n path = path[1:]\\n\\n while path and path[-1] == u'/':\\n path = path[:-1]\\n\\n return path\",\n \"def replacement_not_found(klass, environ, start_response):\\n raise HTTP404('path not found')\",\n \"def _cleanpath(self, path):\\n \\n slashes = self.remotepathsep*2\\n while slashes in path:\\n path = path.replace(slashes,self.remotepathsep)\\n \\n if path.endswith(self.remotepathsep):\\n path = path[:-1]\\n \\n return path\",\n \"def _cleanpath(self, path):\\n \\n slashes = self.remotepathsep*2\\n while slashes in path:\\n path = path.replace(slashes,self.remotepathsep)\\n \\n if path.endswith(self.remotepathsep):\\n path = path[:-1]\\n \\n return path\",\n \"def path2support(path):\\n parts = path.split(os.path.sep)\\n # return '{{ site.baseurl}}' + IPYTHON_STATIC_DIR + '/' + '/'.join(quote(part) for part in parts)\\n return '/' + IPYTHON_STATIC_DIR + '/' + '/'.join(quote(part) for part in parts)\",\n \"def pathfor( request, *args, **kwargs ):\",\n \"def _format_default(s):\\n return u'\\\"%s%s\\\"' % (BASE_URL, s.get_absolute_url())\",\n \"def test_append_slash_redirect_querystring(self):\\n request = self.rf.get(\\\"/slash?test=1\\\")\\n resp = CommonMiddleware(get_response_404)(request)\\n self.assertEqual(resp.url, \\\"/slash/?test=1\\\")\",\n \"def containing_path(path: Union[str, os.PathLike]) -> str:\\n if not path:\\n return str(path)\\n url = urlparse(str(path))\\n if url.scheme:\\n if url.path:\\n return os.path.dirname(path)\\n return url.scheme + \\\"://\\\"\\n return os.path.dirname(os.path.realpath(path))\",\n \"def path_validate(path):\\n # functionality to be added later\\n return path\",\n \"def strip_path(path):\\n name_re = re.compile(\\\"[^/]*\\\\.([a-z]+)$\\\")\\n return name_re.search(path).group(0)\",\n \"def fix_slash(environ, wantslash):\\n from colubrid.exceptions import HttpMoved\\n #FIXME\\n # argh. never did something that supid\\n # find a better solution for that problem.\\n url = quote(environ.get('SCRIPT_NAME', ''))\\n url += quote(environ.get('PATH_INFO', ''))\\n query = environ.get('QUERY_STRING', '')\\n oldurl = query and ('%s?%s' % (url, query)) or url\\n \\n if oldurl and oldurl != '/':\\n if url.endswith('/'):\\n if not wantslash:\\n url = url[:-1]\\n else:\\n if wantslash:\\n url += '/'\\n \\n newurl = query and ('%s?%s' % (url, query)) or url\\n if oldurl != newurl:\\n raise HttpMoved(newurl)\",\n \"def translate_path(self, path):\\r\\n root_dir = self.server.config.get('root_dir')\\r\\n path = '{}{}'.format(root_dir, path)\\r\\n return path.split('?')[0]\",\n \"def static_url(self, path):\\n\\t\\tif not hasattr(self, \\\"_static_hashes\\\"):\\n\\t\\t\\tself._static_hashes = {}\\n\\t\\thashes = self._static_hashes\\n\\t\\tif path not in hashes:\\n\\t\\t\\timport hashlib\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tf = open(os.path.join(\\n\\t\\t\\t\\t\\tself.application.settings[\\\"static_path\\\"], path))\\n\\t\\t\\t\\thashes[path] = hashlib.md5(f.read()).hexdigest()\\n\\t\\t\\t\\tf.close()\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tprint \\\"Could not open static file %r\\\"%path\\n\\t\\t\\t\\thashes[path] = None\\n\\t\\tbase = \\\"http://static.\\\"+_config.get(\\\"varnish\\\", \\\"ovzcphost\\\") + \\\"/\\\"\\n\\t\\tif hashes.get(path):\\n\\t\\t\\treturn base + path + \\\"?v=\\\" + hashes[path][:5]\\n\\t\\telse:\\n\\t\\t\\treturn base + path\",\n \"def base_url_path(self):\\n path = urlsplit(self.base_url())[2]\\n if path.endswith(\\\"/\\\"):\\n path = path[:-1]\\n return path\",\n \"def _url(path, **kwargs):\\n if kwargs:\\n if isinstance(kwargs.get('owner'), users.User):\\n kwargs['owner'] = kwargs['owner'].email()\\n encoded_parameters = urllib.urlencode(kwargs)\\n if path.endswith('?'):\\n # Trailing ? on path. Append parameters to end.\\n return '%s%s' % (path, encoded_parameters)\\n elif '?' in path:\\n # Append additional parameters to existing query parameters.\\n return '%s&%s' % (path, encoded_parameters)\\n else:\\n # Add query parameters to path with no query parameters.\\n return '%s?%s' % (path, encoded_parameters)\\n else:\\n return path\",\n \"def translate_path(self, path):\\n\\t\\t# abandon query parameters\\n\\t\\tpath = path.split('?',1)[0]\\n\\t\\tpath = path.split('#',1)[0]\\n\\t\\tpath = posixpath.normpath(urllib.unquote(path))\\n\\t\\twords = path.split('/')\\n\\t\\twords = filter(None, words)\\n\\t\\tpath = os.getcwd() + \\\"/\\\" + self.wwwroot\\n\\t\\tfor word in words:\\n\\t\\t\\tdrive, word = os.path.splitdrive(word)\\n\\t\\t\\thead, word = os.path.split(word)\\n\\t\\t\\tif word in (os.curdir, os.pardir): continue\\n\\t\\t\\tpath = os.path.join(path, word)\\n\\t\\treturn path\",\n \"def strip_beginning_slashes(url):\\n find = re.search(r\\\"^/+\\\", url)\\n if find:\\n url = re.sub(find.group(0), \\\"\\\", url)\\n return url\",\n \"def build_url(base_url, path):\\n if absolute_http_url_regexp.match(path):\\n return path\\n elif base_url:\\n return \\\"{}/{}\\\".format(base_url.rstrip(\\\"/\\\"), path.lstrip(\\\"/\\\"))\\n else:\\n raise exceptions.ParamsError(\\\"base url missed!\\\")\",\n \"def ensureOneSlash(s):\\n\\treturn s.rstrip(\\\"/\\\")+\\\"/\\\"\",\n \"def test_append_slash_slashless_resource(self):\\n\\n def get_response(req):\\n return HttpResponse(\\\"Here's the text of the web page.\\\")\\n\\n request = self.rf.get(\\\"/noslash\\\")\\n self.assertIsNone(CommonMiddleware(get_response).process_request(request))\\n self.assertEqual(\\n CommonMiddleware(get_response)(request).content,\\n b\\\"Here's the text of the web page.\\\",\\n )\",\n \"def _FormHandlerURL(self, path):\\n if path.endswith('/'):\\n return path + 'edit.do'\\n elif path.endswith('.do'):\\n return path # This happens as part of PleaseCorrect().\\n else:\\n return path + '.do'\",\n \"def _get_dir_url(endpoint, path, **kwargs):\\n if not path:\\n return url_for(endpoint)\\n else:\\n #if self._on_windows:\\n # path = path.replace('\\\\\\\\', '/')\\n\\n kwargs['path'] = path\\n\\n return url_for(endpoint, **kwargs)\",\n \"def testInvalidPath(self):\\n status, _ = self._http_get(\\\"invalid_path\\\")\\n self.assertEqual(status, 404)\",\n \"def htmlpath(path):\\n filelocation = f\\\"public/pages/{path}\\\"\\n print(filelocation)\\n\\n return filelocation\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6272722","0.6118131","0.59735245","0.5902947","0.5849248","0.58329684","0.57983935","0.57708544","0.57563895","0.5733279","0.5692304","0.5686826","0.5673544","0.5606747","0.55980134","0.559067","0.55775833","0.5570223","0.55601454","0.55497587","0.55495584","0.5547405","0.5538418","0.5538111","0.5532774","0.55210763","0.55133706","0.54988754","0.54843116","0.5473754","0.54736257","0.54721713","0.54702955","0.54652584","0.5460534","0.5459599","0.54315966","0.54280883","0.5389254","0.5385289","0.5379878","0.53703654","0.5367277","0.53386784","0.5331698","0.5315068","0.5311768","0.53095436","0.5306767","0.5305558","0.5303536","0.5294534","0.5291816","0.52909464","0.52886033","0.5284145","0.5282945","0.5272241","0.5269508","0.52694273","0.5267875","0.52342427","0.5233108","0.5224354","0.5222417","0.52194905","0.5216746","0.5212651","0.52123815","0.5207948","0.5205953","0.5205486","0.52052885","0.51817787","0.5179516","0.5178042","0.5178037","0.5174906","0.5173422","0.5173422","0.51731056","0.5170575","0.5169939","0.5167894","0.5167286","0.5166796","0.5164412","0.5159275","0.5158305","0.5144182","0.5140257","0.5139125","0.51306415","0.5129489","0.51284933","0.5127006","0.51243806","0.51232946","0.51168","0.51159096","0.5115704"],"string":"[\n \"0.6272722\",\n \"0.6118131\",\n \"0.59735245\",\n \"0.5902947\",\n \"0.5849248\",\n \"0.58329684\",\n \"0.57983935\",\n \"0.57708544\",\n \"0.57563895\",\n \"0.5733279\",\n \"0.5692304\",\n \"0.5686826\",\n \"0.5673544\",\n \"0.5606747\",\n \"0.55980134\",\n \"0.559067\",\n \"0.55775833\",\n \"0.5570223\",\n \"0.55601454\",\n \"0.55497587\",\n \"0.55495584\",\n \"0.5547405\",\n \"0.5538418\",\n \"0.5538111\",\n \"0.5532774\",\n \"0.55210763\",\n \"0.55133706\",\n \"0.54988754\",\n \"0.54843116\",\n \"0.5473754\",\n \"0.54736257\",\n \"0.54721713\",\n \"0.54702955\",\n \"0.54652584\",\n \"0.5460534\",\n \"0.5459599\",\n \"0.54315966\",\n \"0.54280883\",\n \"0.5389254\",\n \"0.5385289\",\n \"0.5379878\",\n \"0.53703654\",\n \"0.5367277\",\n \"0.53386784\",\n \"0.5331698\",\n \"0.5315068\",\n \"0.5311768\",\n \"0.53095436\",\n \"0.5306767\",\n \"0.5305558\",\n \"0.5303536\",\n \"0.5294534\",\n \"0.5291816\",\n \"0.52909464\",\n \"0.52886033\",\n \"0.5284145\",\n \"0.5282945\",\n \"0.5272241\",\n \"0.5269508\",\n \"0.52694273\",\n \"0.5267875\",\n \"0.52342427\",\n \"0.5233108\",\n \"0.5224354\",\n \"0.5222417\",\n \"0.52194905\",\n \"0.5216746\",\n \"0.5212651\",\n \"0.52123815\",\n \"0.5207948\",\n \"0.5205953\",\n \"0.5205486\",\n \"0.52052885\",\n \"0.51817787\",\n \"0.5179516\",\n \"0.5178042\",\n \"0.5178037\",\n \"0.5174906\",\n \"0.5173422\",\n \"0.5173422\",\n \"0.51731056\",\n \"0.5170575\",\n \"0.5169939\",\n \"0.5167894\",\n \"0.5167286\",\n \"0.5166796\",\n \"0.5164412\",\n \"0.5159275\",\n \"0.5158305\",\n \"0.5144182\",\n \"0.5140257\",\n \"0.5139125\",\n \"0.51306415\",\n \"0.5129489\",\n \"0.51284933\",\n \"0.5127006\",\n \"0.51243806\",\n \"0.51232946\",\n \"0.51168\",\n \"0.51159096\",\n \"0.5115704\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":77688,"cells":{"query":{"kind":"string","value":"Apply URL quotation for all values in a dictionary."},"document":{"kind":"string","value":"def quote_all(parameters: Dict[str, Any]) -> Dict[str, Any]:\n return {key: quote_plus(value) if isinstance(value, str) else value for key, value in parameters.items()}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def urllib_quote_parameters(inputdictionary):\r\n if type(inputdictionary) is not dict:\r\n raise TypeError(\"urllib_quote_parameters' inputstringdictionary parameter must be a dict, not '\"+str(type(inputstring))+\"'\")\r\n\r\n quoted_keyvals = []\r\n for key, val in inputdictionary.items():\r\n quoted_keyvals.append(\"%s=%s\" % (urllib_quote(key), urllib_quote(val)))\r\n\r\n return \"&\".join(quoted_keyvals)","def sanitize(self, _input):\n sanitized = {}\n for key, inp in _input.items():\n try:\n key = html.escape(key).strip()\n except AttributeError:\n pass\n # try:\n # inp = html.escape(inp).strip()\n # except (AttributeError, TypeError):\n # pass\n\n sanitized[key] = inp\n \n return sanitized","def aws_urlquote(value):\n if isinstance(value, unicode):\n value = value.encode(\"utf-8\")\n return quote(value, \"/\")","def obfuscate_dict(\n parameters: Dict[str, Any], urlencoded: bool = False, max_len: int = MAX_CHAR_LEN\n) -> Dict[str, Any]:\n\n if not isinstance(parameters, dict):\n return parameters\n\n output = {}\n for key, value in parameters.items():\n if key in OBSCURED_FIELDS:\n value = OBSCURE_VALUE\n elif urlencoded and isinstance(value, list):\n # urllib.parse.parse_qs converts all elements in single-elements lists...\n # converting back to the original element\n if len(value) == 1:\n value = value[0]\n else:\n value = str(value)\n try:\n if len(value) > max_len:\n value = value[:max_len] + \"...\"\n except IndexError: # pragma: no cover\n pass\n\n output[key] = value\n\n return output","def urlencode(\n query, doseq=False, safe=\"\", encoding=None, errors=None, quote_via=quote_plus\n ):\n\n if hasattr(query, \"items\"):\n query = query.items()\n else:\n # It's a bother at times that strings and string-like objects are\n # sequences.\n try:\n # non-sequence items should not work with len()\n # non-empty strings will fail this\n if len(query) and not isinstance(query[0], tuple):\n raise TypeError\n # Zero-length sequences of all types will get here and succeed,\n # but that's a minor nit. Since the original implementation\n # allowed empty dicts that type of behavior probably should be\n # preserved for consistency\n except TypeError:\n ty, va, tb = sys.exc_info()\n raise TypeError(\n \"not a valid non-string sequence \" \"or mapping object\"\n ).with_traceback(tb)\n\n l = [] # noqa\n if not doseq:\n for k, v in query:\n if isinstance(k, bytes):\n k = quote_via(k, safe)\n else:\n k = quote_via(str(k), safe)\n\n if isinstance(v, bytes):\n v = quote_via(v, safe)\n else:\n v = quote_via(str(v), safe)\n l.append(k + \"=\" + v)\n else:\n for k, v in query:\n if isinstance(k, bytes):\n k = quote_via(k, safe)\n else:\n k = quote_via(str(k), safe)\n\n if isinstance(v, bytes):\n v = quote_via(v, safe)\n l.append(k + \"=\" + v)\n elif isinstance(v, six.string_types):\n v = quote_via(v, safe)\n l.append(k + \"=\" + v)\n else:\n try:\n # Is this a sufficient test for sequence-ness?\n x = len(v) # noqa\n except TypeError:\n # not a sequence\n v = quote_via(str(v), safe)\n l.append(k + \"=\" + v)\n else:\n # loop over the sequence\n for elt in v:\n if isinstance(elt, bytes):\n elt = quote_via(elt, safe)\n else:\n elt = quote_via(str(elt), safe)\n l.append(k + \"=\" + elt)\n return \"&\".join(l)","def urlencode(query):\n\n if hasattr(query, 'items'):\n # mapping objects\n query = query.items()\n l = []\n for k, v in query:\n k = quote_plus(k)\n if isinstance(v, basestring):\n v = quote_plus(v)\n l.append(k + '=' + v)\n else:\n v = quote_plus(unicode(v))\n l.append(k + '=' + v)\n return '&'.join(l)","def encode_dict(d):\n return \"&\".join([\"%s=%s\" % (align, score) for align, score in d.items() if '_' not in align])","def urlencode(\n query,\n doseq=False,\n safe=\"\",\n encoding=None,\n errors=None,\n quote_via=quote_plus,\n ): # noqa\n\n if hasattr(query, \"items\"):\n query = query.items()\n else:\n # It's a bother at times that strings and string-like objects are\n # sequences.\n try:\n # non-sequence items should not work with len()\n # non-empty strings will fail this\n if len(query) and not isinstance(query[0], tuple):\n raise TypeError\n # Zero-length sequences of all types will get here and succeed,\n # but that's a minor nit. Since the original implementation\n # allowed empty dicts that type of behavior probably should be\n # preserved for consistency\n except TypeError:\n ty, va, tb = sys.exc_info()\n raise TypeError(\n \"not a valid non-string sequence \" \"or mapping object\"\n ).with_traceback(tb)\n\n l = [] # noqa\n if not doseq:\n for k, v in query:\n if isinstance(k, bytes):\n k = quote_via(k, safe)\n else:\n k = quote_via(str(k), safe, encoding, errors)\n\n if isinstance(v, bytes):\n v = quote_via(v, safe)\n else:\n v = quote_via(str(v), safe, encoding, errors)\n l.append(k + \"=\" + v)\n else:\n for k, v in query:\n if isinstance(k, bytes):\n k = quote_via(k, safe)\n else:\n k = quote_via(str(k), safe, encoding, errors)\n\n if isinstance(v, bytes):\n v = quote_via(v, safe)\n l.append(k + \"=\" + v)\n elif isinstance(v, str):\n v = quote_via(v, safe, encoding, errors)\n l.append(k + \"=\" + v)\n else:\n try:\n # Is this a sufficient test for sequence-ness?\n x = len(v) # noqa\n except TypeError:\n # not a sequence\n v = quote_via(str(v), safe, encoding, errors)\n l.append(k + \"=\" + v)\n else:\n # loop over the sequence\n for elt in v:\n if isinstance(elt, bytes):\n elt = quote_via(elt, safe)\n else:\n elt = quote_via(str(elt), safe, encoding, errors)\n l.append(k + \"=\" + elt)\n return \"&\".join(l)","def append_to_query_string(url, key, value) -> str:\n url = list(urlparse(url))\n query = dict(parse_qsl(url[4]))\n query[key] = value\n url[4] = '&'.join(f'{p}={v}' for p, v in query.items())\n\n return urlunparse(url)","def urlencode(query, doseq=0):\r\n if hasattr(query, 'items'):\r\n query = query.items()\r\n\r\n return original_urlencode(\r\n [(force_str(k),\r\n [force_str(i) for i in v] if isinstance(v, (list,tuple)) else force_str(v))\r\n for k, v in query],\r\n doseq)","def nor_api_url(i, b=\"\"):\n result = i[\"url\"]\n\n for term in findall(PARAM_NAME, result):\n try:\n t = i[term]\n except KeyError:\n t = \"str(.+)\"\n result = result.replace(\n \"{%s}\" % term, \"%s\" % sub(\"^[^\\(]+(\\(.+\\))$\", \"\\\\1\", t)\n )\n\n return \"%s%s\" % (b, result)","def query_options_to_url(self):\n return '&'.join(['$%s=%s' % (key, value) for (key, value) in self.query_options.items()])","def html_dict(dict_esc: dict) -> str:\n items = (f\"<li>{k}={v}</li>\" for k, v in dict_esc.items())\n return \"<ul>\\n\" + \"\\n\".join(items) + \"\\n</ul>\"","def urlencode_any(d):\r\n try:\r\n d = d.items()\r\n except AttributeError:\r\n pass\r\n as_bytes = tuple((port.to_b(key), port.to_b(value)) for key, value in d)\r\n return port.urlencode(as_bytes)","def make_url_safe(self, url):\n return url.replace(' ', '%20')\\\n .replace('(', '%28')\\\n .replace(')', '%29')\\\n .replace('\"', '%22')","def form_cur_quotes_property_url_str(self):\n start_str = '&f='\n self.cur_quotes_property_portion_url = start_str + self.cur_quotes_property_str","def str_replace(data):\n for key, value in data.items():\n if isinstance(value, (str, unicode)):\n data[key] = value.format(**data)","def _generate_query_string(self):\n \n query_items = {}\n \n for key, val in self.__dict__.iteritems():\n if not key.startswith('_'):\n query_items[key] = val.encode('utf-8')\n \n return urllib.urlencode(query_items)","def querystring(data, exclude=(), **kwargs):\n items = reduce(operator.add, (\n list((k, v) for v in values)\n for k, values in data.lists() if k not in exclude\n ), [])\n\n for key, value in kwargs.items():\n items.append((key, force_text(value)))\n\n return urlencode(sorted(items))","def str_dict(d):\n return \", \".join(\"%s=%s\" % (k, d[k]) for k in d)","def urlify(e):\n if isinstance(e, dict):\n try:\n iteritems = e.iteritems()\n except AttributeError:\n iteritems = e.items()\n\n return dict((k, urlify(v)) for k, v in iteritems)\n elif isinstance(e, (list, tuple)):\n return json.dumps(e, cls=CustomJSONEncoder)\n elif isinstance(e, bool):\n return 'true' if e else 'false'\n else:\n return encode(e)","def clean_url(url: str, keys: List[str]) -> str:\n u = urlparse(url)\n query = parse_qs(u.query, keep_blank_values=True)\n\n for key in keys:\n query.pop(key, None)\n\n u = u._replace(query=urlencode(query, True))\n \n return urlunparse(u)","def _sanitize_query(self, uri=None, querydict=None):\n # import pdb; pdb.set_trace()\n if querydict is None:\n query = urisplit(uri).getquerydict()\n else:\n query = querydict\n result = {}\n for (key, values) in query.items():\n logger.debug('sanitize_query 1 %s:%s',key,values)\n result_values = []\n for value in values:\n if key == 'date':\n year = self._sanitize_year(str(value))\n if year:\n result_values.append(year)\n # we possibly could introduce query['year'],\n # query['month'] etc.\n # Maybe later\n elif value:\n result_values.append(value)\n if result_values:\n result[key] = result_values\n return result","def _check_values(self, values):\n mod = []\n for k, v in values.items():\n if isinstance(v, str) and \"'\" in v:\n mod.append(k)\n if len(mod) == 0:\n return values\n else:\n values = copy.copy(values)\n for k in mod:\n values[k] = values[k].replace(\"'\", \"''\")\n return values","def dict2argstr(d: Dict[str, Any]) -> str:\n return \",\".join(\"{!s}={!r}\".format(key, val) for (key, val) in d.items())","def FormatUrl(params):\n input_list = []\n for item in sorted(params.iteritems(), key=lambda x: x[0]):\n input_list.append('%s=%s' % (item[0], UrlEscape(item[1])))\n return '&'.join(input_list)","def url_replace(context, **kwargs):\n query = context['request'].GET.dict()\n query.update(kwargs)\n return urlencode(query)","def url_replace(context, **kwargs):\n query = context['request'].GET.dict()\n query.update(kwargs)\n return urlencode(query)","def modify_query(**values):\n args = request.args.copy()\n\n for attr, new_value in values.items():\n if new_value is not None:\n args[attr] = new_value\n elif attr in args:\n del args[attr]\n\n if args:\n return request.base_url + \"?\" + url_encode(args)\n else:\n return request.base_url","def create_query_sting(param_dict):\n params = \"&\".join([f\"{key}={value}\" for key, value in param_dict.items()])\n return params.replace(\"#\", \"%23\")","def url_replace(request, field, value):\n _dict = request.GET.copy()\n _dict[field] = value\n return _dict.urlencode()","def format_arguments(data: Dict) -> str:\n\n def prep(key: str, value: Any) -> str:\n if isinstance(value, str):\n value = f'''\"{value.replace('\"', \"'\")}\"'''\n if key == \"pattern\":\n value = f\"r{value}\"\n return f\"{key}={value}\"\n\n return \",\\n\".join([prep(key, value) for key, value in data.items()])","def url_to_string(cls, v, values, **kwargs):\n return str(v)","def make_args(self, args):\n result_str = \"?\"\n for k, v in args.iteritems():\n result_str = result_str + k + \"=\" + v + \"&\"\n return result_str","def urlsafe(self):\n return urllib.quote(self.normalized())","def do_urlencode(value):\n return urllib.quote(value.encode('utf8'))","def test_escape_value_as_list(self):\r\n testdict = escapeddict.EscapedDict({'key1': 'value1', 'key2': ['value2', '${key1}']})\r\n for key in testdict.keys():\r\n print testdict[key]\r\n assert testdict['key1'] == 'value1'\r\n assert testdict['key2'] == ['value2', 'value1']","def generate_link_attr(d: Dict):\n d.update({\"link\": urljoin(\"https://vdb-kasf1i23nr1kl2j4.rapid7.com/v1/content/\", d.get(\"identifier\"))})","def urlencode_sl(query_params, allow_func=None):\n query_params = query_params or {}\n encoded_pairs = []\n for k, v in query_params.items():\n # Keys are also percent-encoded according to OAuth spec.\n k = percent_encode(unicode_to_utf8(k))\n if allow_func and not allow_func(k, v):\n continue\n elif is_bytes_or_unicode(v):\n encoded_pairs.append((k, percent_encode(v),))\n else:\n if is_sequence(v):\n # Loop over the sequence.\n if len(v) > 0:\n for i in v:\n encoded_pairs.append((k, percent_encode(i), ))\n # ``urllib.urlencode()`` doesn't preserve blank lists.\n # Therefore, we're discarding them.\n #else:\n # # Preserve blank list values.\n # encoded_pairs.append((k, \"\", ))\n else:\n encoded_pairs.append((k, percent_encode(v),))\n # Sort after encoding according to the OAuth spec.\n return sorted(encoded_pairs)","def url_filter(val):\n if isinstance(val, Undefined):\n return UNDEFINED_LABEL\n return quote(str(val))","def multiple_replace(dict, text): \n\n # Create a regular expression from the dictionary keys\n regex = re.compile(\"(%s)\" % \"|\".join(map(re.escape, dict.keys())))\n\n # For each match, look-up corresponding value in dictionary\n return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)","def _reprOfStringToValueMap (stringMap : Map) -> String:\n\n entrySeparator = u\"§\"\n entryTemplate = \"%s: %s\"\n keyList = sorted(list(stringMap.keys()))\n result = \"\"\n \n for key in keyList:\n value = stringMap[key] \n result += (iif(result == \"\", \"\", entrySeparator)\n + entryTemplate % (key, value))\n \n result = \"{\" + result + \"}\";\n return result","def _extend_url(self, url, params):\n # filter out None parameters\n params = {k:v for k,v in params.items() if v is not None}\n for key in params:\n url = url + \"&{}={}\".format(key, params[key])\n return url","def url_Keyword(self,key):\n url=key.replace('www','mbasic')\n #url=key.replace(\"%20\",\"+\")\n \n return url","def as_html(self):\r\n return mark_safe(' '.join(['%s=\"%s\"' % (k, escape(v if not callable(v) else v()))\r\n for k, v in six.iteritems(self)]))","def _sanitize(data_dict):\n return data_dict","def _unicode_urlencode(params):\r\n if isinstance(params, dict):\r\n params = params.items()\r\n return urllib.parse.urlencode([(k, v.encode('utf-8') or v) for k, v in params])","def url_escape(value, plus=True):\r\n quote = urllib_parse.quote_plus if plus else urllib_parse.quote\r\n return quote(utf8(value))","def format_url(search_terms):\n print(search_terms)\n base_url = 'https://www.gofundme.com/s?q='\n\n if isinstance(search_terms, str):\n base_url += search_terms.replace(' ', '+')\n else:\n base_url += '+'.join(search_terms)\n\n return base_url","def _unicode_urlencode(params):\n if isinstance(params, dict):\n params = list(params.items())\n for i, param in enumerate(params):\n if isinstance(param[1], list):\n params[i] = (param[0], json.dumps(param[1]),)\n\n result = urllib.parse.urlencode([(k, isinstance(v, str) and v.encode('utf-8') or v) for k, v in params])\n return result","def convert_values_to_strings(dict,list_sep=', '):\n d=dict.copy()\n for key in dict.keys():\n if not isinstance(dict[key],str):\n try:\n d[key]=list_sep.join(dict[key])\n except:\n del d[key]\n return d","def form_cur_quotes_property_url_str_fr_excel(self):\n from xls_table_extract_module import XlsExtractor\n self.xls_property_data = XlsExtractor(fname = self.properties_excel_table, sheetname= 'Sheet1',\n param_start_key = 'stock_property//', param_end_key = 'stock_property_end//',\n header_key = '', col_len = 2)\n\n self.xls_property_data.open_excel_and_process_block_data()\n\n ## form the header\n self.cur_quotes_parm_headers = [n.encode().strip() for n in self.xls_property_data.data_label_list]\n\n ## form the url str\n start_str = '&f='\n target_properties = ''.join([n[0].encode().strip() for n in self.xls_property_data.data_value_list])\n self.cur_quotes_property_portion_url = start_str + target_properties","def clean_dict(self,dict_to_clean):\n for i in dict_to_clean: \n try:\n float( dict_to_clean[i] ) \n except:\n dict_to_clean[ i ] = \"'%s'\"%( dict_to_clean[i ].replace(\"'\",\"\").replace('\"',\"\") )","def _dict_to_args(self, arg_dict):\n if arg_dict:\n yield \"--{}=data:application/json;charset=utf-8,{}\".format(\n self._CONFIG_FLAG.name,\n urllib.parse.quote(json_encode(arg_dict, pretty=False), encoding=\"utf-8\")\n )","def urlQuote(string):\r\n return quote(string.encode(\"utf-8\"))","def append_query_param(url: str, key: str, value: str) -> str:\n template = '?' in url and '{}&{}={}' or '{}?{}={}'\n return template.format(url, key, value)","def _render_dict(input_dict: Dict[str, Any]) -> Dict[str, Any]:\n output_dict = {}\n\n for key, value in input_dict.items():\n if isinstance(value, str):\n new_value = string.Template(value).substitute(_mapping)\n output_dict[key] = new_value\n elif isinstance(value, dict):\n output_dict[key] = _render_dict(value) # type: ignore\n else:\n output_dict[key] = value\n\n return output_dict","def dict(dict: Dict[str, Pin], /) -> None:","def _create_param_url(self, paramsDic):\n url = sys.argv[ 0 ]\n sep = '?'\n print paramsDic\n try:\n for param in paramsDic:\n #TODO: solve error on name with non ascii char (generate exception)\n url = url + sep + urllib.quote_plus( param ) + '=' + urllib.quote_plus( paramsDic[param] )\n sep = '&'\n except:\n url = None\n print_exc()\n return url","def DictFunction():\r\n print \"{name} is from {city}, and he likes {cake} cake, {fruit} fruit, {salad} salad and {pasta} pasta\".format(**food_prefs)","def _filterDictToStr(self, filterDict):\n values = []\n for key, vals in filterDict.items():\n if key not in ('contentRating', 'label', 'contentRating!', 'label!'):\n raise BadRequest(f'Unknown filter key: {key}')\n values.append(f\"{key}={'%2C'.join(vals)}\")\n return '|'.join(values)","def unicode_urlencode(self, params):\n if isinstance(params, dict):\n params = params.items()\n for i, param in enumerate(params):\n if isinstance(param[1], list):\n params[i] = (param[0], json.dumps(param[1]),)\n\n return urllib.urlencode(\n [(k, isinstance(v, unicode) and v.encode('utf-8') or v) for k, v in params]\n )","def render_dict(dict):\n\t\treturn str.encode(str(dict))","def format_query(query, option=''):\n q_tmp = []\n for s in query:\n if option != 'url' or s.isalnum():\n q_tmp.append(s)\n else:\n q_tmp.append('\\\"' + s.lower() + '\\\"')\n\n if option == 'file':\n sep = '_'\n else:\n sep = ' '\n q = sep.join(q_tmp)\n if option == 'url':\n q = urllib2.quote('\\'' + q + '\\'')\n return q","def __apply_filters(url, dataset_code):\n if '?' not in url:\n url += '?'\n else:\n url += '&'\n for key in dataset_code.FILTERS:\n if isinstance(dataset_code.FILTERS[key], list):\n for value in dataset_code.FILTERS[key]:\n url += key + '=' + str(value) + '&'\n else:\n url += key + '=' + str(dataset_code.FILTERS[key]) + '&'\n url = url[0:-1]\n return url","def form_url_str(self, type = 'cur_quotes'):\n if type == 'cur_quotes':\n self.form_cur_quotes_stock_url_str()\n \n # form the property. 2 methods enabled.\n if self.enable_form_properties_fr_exceltable:\n self.form_cur_quotes_property_url_str_fr_excel()\n else:\n self.form_cur_quotes_property_url_str()\n \n self.cur_quotes_full_url = self.cur_quotes_start_url + self.cur_quotes_stock_portion_url +\\\n self.cur_quotes_property_portion_url + self.cur_quotes_end_url","def _create_query_str(data):\n params = []\n for name, value in data.items():\n params.append(name + '=' + str(value))\n\n return '?' + '&'.join(params)","def form_cur_quotes_stock_url_str(self):\n self.cur_quotes_stock_portion_url = ''\n for n in self.target_stocks:\n self.cur_quotes_stock_portion_url = self.cur_quotes_stock_portion_url + n +\\\n self.cur_quotes_stock_portion_additional_url + ','\n \n self.cur_quotes_stock_portion_url =self.cur_quotes_stock_portion_url[:-1]","def _clean_and_encode_params(params: Mapping):\n # Keep only the parameters that were given a value\n params = {k: v for k, v in params.items() if v is not None}\n\n # All query parameters are later urlencoded - for projection, comma-separated\n # list is supported only on literal comma; convert comma-separated list\n # to a list of values which will be encoded to multiple query parameters\n try:\n params[\"projection\"] = [x.strip() for x in params[\"projection\"].split(\",\")]\n except KeyError:\n pass\n return params","def _encode_url(data: str) -> str:\n return urllib.parse.quote(data, safe=\"\")","def _encode(dictionary):\n # Strip ugly base64 padding.\n byteStr = bytearray(json.dumps(dictionary).encode())\n encodedStr = base64.urlsafe_b64encode(byteStr)\n return encodedStr.rstrip('='.encode())","def smart_encode(**kwargs):\r\n args = dict(kwargs)\r\n for k, v in args.items():\r\n if v is None:\r\n del args[k]\r\n if not args:\r\n return ''\r\n return urlencode(args)","def produce_link_qwant(self, value_search:str) -> str:\n # https://www.qwant.com/?q=a%24ap+rocky&t=web\n for replace, replaced in [(' ', '+'), \n ('$', '%24')]:\n value_search = value_search.replace(replace, replaced)\n return f'https://www.qwant.com/?q={value_search}&t=web'","def dictreplace(self, string, keydict):\n for old, new in keydict.items():\n string = string.replace(old, new)\n return string","def convert_conn_params(conn_dict):\n conn_list = []\n for (param, val) in iteritems(conn_dict):\n conn_list.append('%s=%s' % (param, val))\n\n return ' '.join(conn_list)","def param_replace(context, **kwargs):\n d = context['request'].GET.copy()\n for k,v in kwargs.items():\n d[k] = v\n for k in [k for k,v in d.items() if not v]:\n del d[k]\n return d.urlencode()","def percent_encode(data, safe=None):\n if data is None:\n return None\n if isinstance(data, (tuple, list, set)):\n return b\"&\".join(\n percent_encode(value, safe=safe)\n for value in data\n )\n if isinstance(data, dict):\n return b\"&\".join(\n bstr(key) + b\"=\" + percent_encode(value, safe=safe)\n for key, value in data.items()\n )\n return quote(bstr(data), safe or b\"\").encode(\"utf-8\")","def sanitize_quotes(quotes):\n return [\n collections.OrderedDict([\n ('s/n', idx),\n ('id', quote['ID']),\n ('content', escape_html_entity(\n remove_html_tags(\n quote['content']\n )).strip('\\n ')),\n ('link', quote['link']),\n ('title', quote['title']),\n ('source', extract_url_from_anchor_tag(\n quote.get('custom_meta', {}).get('Source', '')))\n ]) for idx, quote in enumerate(quotes, 1)\n ]","def queryparams(*args, **kwargs):\n args = dict(args)\n args.update(kwargs)\n return urllib.urlencode(args)","def urlencode(query, doseq=False):\n if isinstance(query, MultiValueDict):\n query = query.lists()\n elif hasattr(query, \"items\"):\n query = query.items()\n query_params = []\n for key, value in query:\n if value is None:\n raise TypeError(\n \"Cannot encode None for key '%s' in a query string. Did you \"\n \"mean to pass an empty string or omit the value?\" % key\n )\n elif not doseq or isinstance(value, (str, bytes)):\n query_val = value\n else:\n try:\n itr = iter(value)\n except TypeError:\n query_val = value\n else:\n # Consume generators and iterators, when doseq=True, to\n # work around https://bugs.python.org/issue31706.\n query_val = []\n for item in itr:\n if item is None:\n raise TypeError(\n \"Cannot encode None for key '%s' in a query \"\n \"string. Did you mean to pass an empty string or \"\n \"omit the value?\" % key\n )\n elif not isinstance(item, bytes):\n item = str(item)\n query_val.append(item)\n query_params.append((key, query_val))\n return original_urlencode(query_params, doseq)","def urlencode_s(query_params, allow_func=None):\n return \"&\".join([k + \"=\" + v for k, v in\n urlencode_sl(query_params, allow_func=allow_func)])","def _concatenate_url(self, response: Dict[str, Any], url_field: str = 'url') -> None:\n split_url_field = url_field.split('.')\n if len(split_url_field) > 1:\n self._concatenate_url(response.get(split_url_field[0], {}), '.'.join(split_url_field[1:]))\n\n elif url_field in response:\n url = urljoin(self._base_url, response[url_field]).replace('https://api', 'https://app')\n response[url_field] = url","def replace_in_string(s, args_dict):\n for key, value in args_dict.items():\n s = s.replace(key, value)\n for key, value in args_dict.items():\n s = s.replace(key, value)\n for key, value in args_dict.items():\n s = s.replace(key, value)\n return s","def form_com_data_stock_url_str(self):\n self.com_data_stock_portion_url = ''\n for n in self.target_stocks:\n self.com_data_stock_portion_url = self.com_data_stock_portion_url +'%22' + n +\\\n self.com_data_stock_portion_additional_url + '%22%2C'\n \n self.com_data_stock_portion_url = self.com_data_stock_portion_url[:-3]","def _set_query_params(query, key, value):\n query.update({str(key): str(value)})","def _assemble_kw_url(self, keywords):\n search_params = self._build_param_request()\n include = self._build_field_request()\n\n keywords = '+'.join(keywords)\n request_url = \\\n self.nsf_api + 'keyword=' + keywords + include + search_params\n\n return request_url","def urlquote(text):\n if op.sep == \"\\\\\":\n return urllib.quote(text.replace(\"\\\\\", \"/\"))\n else:\n return urllib.quote(text)","def _quote(v):\n return '\"' + v + '\"' if ' ' in v else v","def _url_encode(self, text):\n try:\n return (urllib.quote(text.replace(u'and', u'&'), safe='')\n .replace(u'%20', u'+'))\n except:\n print('Using python3')\n return (urllib.parse.quote(text.replace(u'and', u'&'), safe='')\n .replace(u'%20', u'+'))","def quote_json(_json: dict) -> str:\n stringified = json.dumps(_json)\n return quote(stringified)","def make_paths_safe(params):\n for key in params.keys():\n if isinstance(params[key], str):\n params[key] = params[key].replace(\"/\", os.sep)\n params[key] = params[key].replace(\"\\\\\", os.sep)\n\n return params","def format_key(self, key):\n if self.in_quotes(key):\n key = self.format_value(key) \n else:\n if key.lower() in ALL_KEYWORDS:\n key = self.format_value(key.upper())\n else:\n key = self.format_value(self.add_quotes(key.lower()))\n\n return key","def multi_replace(text, dictobj):\n for k, v in dictobj.iteritems():\n text = text.replace(k, v)\n return text","def replacer(s,replace_dict):\n for k,v in replace_dict.items(): s = s.replace(k,v)\n return s","def standardise_quotes(self, val):\n if val.startswith(self.altquote) and val.endswith(self.altquote):\n middle = val[1:-1]\n val = \"%s%s%s\" % (self.quote, middle, self.quote)\n\n val = self.escape_quotes(val)\n\n return val","def str_map(values, formatting):\n return [formatting % v for v in values]","def sanitize(key, value):\n \n # We do special handling for response keys\n # list (str was delimited by commas)\n if key == 'txn_refs':\n return value.split(',')\n \n # datetime\n elif key in ('date', 'expiry'):\n return str_to_date(value, key=key)\n\n # int\n elif key in ('split_count', 'duration', 'talktime', 'entries_count', 'total_entries_count'):\n return int(value)\n\n # float\n elif key in ('rate', 'total_cost', 'debit', 'balance', 'points', 'bonus'):\n return float(value)\n\n # bool\n elif key in ('auto_extend_status',):\n if value == 'disabled':\n return True\n else:\n return False\n\n # list of objects\n elif key == 'entries':\n # Turns each entry (a dict) into an object\n i = 0\n for entry in value:\n obj = obj_dic(entry)\n value[i] = obj\n i += 1\n return value\n\n else:\n return value","def replace_query_params(cls, url: str, **params: Mapping[str, str]) -> str:\n url, _ = cls.separate_query_params(url, params.keys())\n return cls.add_query_params(url, **params)","def url_with_query_str(url, *args, **kwargs):\n if len(args):\n d = args[0]\n elif len(kwargs):\n d = kwargs\n else:\n raise Exception('not found dict')\n if any(\"%\" in k for k in d.keys()):\n query = \"&\".join([\"{}={}\".format(k, v) for k, v in d.items()])\n else:\n query = urlencode(d)\n url = url.split('?')[0]\n return \"{}?{}\".format(url, query)","def _build_url_exact(self, q: str, **kwargs: Dict) -> str:\n url = f\"{self._URL}?where=\"\n if kwargs.get('doi'):\n input_doi = kwargs.get('doi')\n url += f'''{{\"doi\":\"{input_doi}\"}}'''\n return url"],"string":"[\n \"def urllib_quote_parameters(inputdictionary):\\r\\n if type(inputdictionary) is not dict:\\r\\n raise TypeError(\\\"urllib_quote_parameters' inputstringdictionary parameter must be a dict, not '\\\"+str(type(inputstring))+\\\"'\\\")\\r\\n\\r\\n quoted_keyvals = []\\r\\n for key, val in inputdictionary.items():\\r\\n quoted_keyvals.append(\\\"%s=%s\\\" % (urllib_quote(key), urllib_quote(val)))\\r\\n\\r\\n return \\\"&\\\".join(quoted_keyvals)\",\n \"def sanitize(self, _input):\\n sanitized = {}\\n for key, inp in _input.items():\\n try:\\n key = html.escape(key).strip()\\n except AttributeError:\\n pass\\n # try:\\n # inp = html.escape(inp).strip()\\n # except (AttributeError, TypeError):\\n # pass\\n\\n sanitized[key] = inp\\n \\n return sanitized\",\n \"def aws_urlquote(value):\\n if isinstance(value, unicode):\\n value = value.encode(\\\"utf-8\\\")\\n return quote(value, \\\"/\\\")\",\n \"def obfuscate_dict(\\n parameters: Dict[str, Any], urlencoded: bool = False, max_len: int = MAX_CHAR_LEN\\n) -> Dict[str, Any]:\\n\\n if not isinstance(parameters, dict):\\n return parameters\\n\\n output = {}\\n for key, value in parameters.items():\\n if key in OBSCURED_FIELDS:\\n value = OBSCURE_VALUE\\n elif urlencoded and isinstance(value, list):\\n # urllib.parse.parse_qs converts all elements in single-elements lists...\\n # converting back to the original element\\n if len(value) == 1:\\n value = value[0]\\n else:\\n value = str(value)\\n try:\\n if len(value) > max_len:\\n value = value[:max_len] + \\\"...\\\"\\n except IndexError: # pragma: no cover\\n pass\\n\\n output[key] = value\\n\\n return output\",\n \"def urlencode(\\n query, doseq=False, safe=\\\"\\\", encoding=None, errors=None, quote_via=quote_plus\\n ):\\n\\n if hasattr(query, \\\"items\\\"):\\n query = query.items()\\n else:\\n # It's a bother at times that strings and string-like objects are\\n # sequences.\\n try:\\n # non-sequence items should not work with len()\\n # non-empty strings will fail this\\n if len(query) and not isinstance(query[0], tuple):\\n raise TypeError\\n # Zero-length sequences of all types will get here and succeed,\\n # but that's a minor nit. Since the original implementation\\n # allowed empty dicts that type of behavior probably should be\\n # preserved for consistency\\n except TypeError:\\n ty, va, tb = sys.exc_info()\\n raise TypeError(\\n \\\"not a valid non-string sequence \\\" \\\"or mapping object\\\"\\n ).with_traceback(tb)\\n\\n l = [] # noqa\\n if not doseq:\\n for k, v in query:\\n if isinstance(k, bytes):\\n k = quote_via(k, safe)\\n else:\\n k = quote_via(str(k), safe)\\n\\n if isinstance(v, bytes):\\n v = quote_via(v, safe)\\n else:\\n v = quote_via(str(v), safe)\\n l.append(k + \\\"=\\\" + v)\\n else:\\n for k, v in query:\\n if isinstance(k, bytes):\\n k = quote_via(k, safe)\\n else:\\n k = quote_via(str(k), safe)\\n\\n if isinstance(v, bytes):\\n v = quote_via(v, safe)\\n l.append(k + \\\"=\\\" + v)\\n elif isinstance(v, six.string_types):\\n v = quote_via(v, safe)\\n l.append(k + \\\"=\\\" + v)\\n else:\\n try:\\n # Is this a sufficient test for sequence-ness?\\n x = len(v) # noqa\\n except TypeError:\\n # not a sequence\\n v = quote_via(str(v), safe)\\n l.append(k + \\\"=\\\" + v)\\n else:\\n # loop over the sequence\\n for elt in v:\\n if isinstance(elt, bytes):\\n elt = quote_via(elt, safe)\\n else:\\n elt = quote_via(str(elt), safe)\\n l.append(k + \\\"=\\\" + elt)\\n return \\\"&\\\".join(l)\",\n \"def urlencode(query):\\n\\n if hasattr(query, 'items'):\\n # mapping objects\\n query = query.items()\\n l = []\\n for k, v in query:\\n k = quote_plus(k)\\n if isinstance(v, basestring):\\n v = quote_plus(v)\\n l.append(k + '=' + v)\\n else:\\n v = quote_plus(unicode(v))\\n l.append(k + '=' + v)\\n return '&'.join(l)\",\n \"def encode_dict(d):\\n return \\\"&\\\".join([\\\"%s=%s\\\" % (align, score) for align, score in d.items() if '_' not in align])\",\n \"def urlencode(\\n query,\\n doseq=False,\\n safe=\\\"\\\",\\n encoding=None,\\n errors=None,\\n quote_via=quote_plus,\\n ): # noqa\\n\\n if hasattr(query, \\\"items\\\"):\\n query = query.items()\\n else:\\n # It's a bother at times that strings and string-like objects are\\n # sequences.\\n try:\\n # non-sequence items should not work with len()\\n # non-empty strings will fail this\\n if len(query) and not isinstance(query[0], tuple):\\n raise TypeError\\n # Zero-length sequences of all types will get here and succeed,\\n # but that's a minor nit. Since the original implementation\\n # allowed empty dicts that type of behavior probably should be\\n # preserved for consistency\\n except TypeError:\\n ty, va, tb = sys.exc_info()\\n raise TypeError(\\n \\\"not a valid non-string sequence \\\" \\\"or mapping object\\\"\\n ).with_traceback(tb)\\n\\n l = [] # noqa\\n if not doseq:\\n for k, v in query:\\n if isinstance(k, bytes):\\n k = quote_via(k, safe)\\n else:\\n k = quote_via(str(k), safe, encoding, errors)\\n\\n if isinstance(v, bytes):\\n v = quote_via(v, safe)\\n else:\\n v = quote_via(str(v), safe, encoding, errors)\\n l.append(k + \\\"=\\\" + v)\\n else:\\n for k, v in query:\\n if isinstance(k, bytes):\\n k = quote_via(k, safe)\\n else:\\n k = quote_via(str(k), safe, encoding, errors)\\n\\n if isinstance(v, bytes):\\n v = quote_via(v, safe)\\n l.append(k + \\\"=\\\" + v)\\n elif isinstance(v, str):\\n v = quote_via(v, safe, encoding, errors)\\n l.append(k + \\\"=\\\" + v)\\n else:\\n try:\\n # Is this a sufficient test for sequence-ness?\\n x = len(v) # noqa\\n except TypeError:\\n # not a sequence\\n v = quote_via(str(v), safe, encoding, errors)\\n l.append(k + \\\"=\\\" + v)\\n else:\\n # loop over the sequence\\n for elt in v:\\n if isinstance(elt, bytes):\\n elt = quote_via(elt, safe)\\n else:\\n elt = quote_via(str(elt), safe, encoding, errors)\\n l.append(k + \\\"=\\\" + elt)\\n return \\\"&\\\".join(l)\",\n \"def append_to_query_string(url, key, value) -> str:\\n url = list(urlparse(url))\\n query = dict(parse_qsl(url[4]))\\n query[key] = value\\n url[4] = '&'.join(f'{p}={v}' for p, v in query.items())\\n\\n return urlunparse(url)\",\n \"def urlencode(query, doseq=0):\\r\\n if hasattr(query, 'items'):\\r\\n query = query.items()\\r\\n\\r\\n return original_urlencode(\\r\\n [(force_str(k),\\r\\n [force_str(i) for i in v] if isinstance(v, (list,tuple)) else force_str(v))\\r\\n for k, v in query],\\r\\n doseq)\",\n \"def nor_api_url(i, b=\\\"\\\"):\\n result = i[\\\"url\\\"]\\n\\n for term in findall(PARAM_NAME, result):\\n try:\\n t = i[term]\\n except KeyError:\\n t = \\\"str(.+)\\\"\\n result = result.replace(\\n \\\"{%s}\\\" % term, \\\"%s\\\" % sub(\\\"^[^\\\\(]+(\\\\(.+\\\\))$\\\", \\\"\\\\\\\\1\\\", t)\\n )\\n\\n return \\\"%s%s\\\" % (b, result)\",\n \"def query_options_to_url(self):\\n return '&'.join(['$%s=%s' % (key, value) for (key, value) in self.query_options.items()])\",\n \"def html_dict(dict_esc: dict) -> str:\\n items = (f\\\"<li>{k}={v}</li>\\\" for k, v in dict_esc.items())\\n return \\\"<ul>\\\\n\\\" + \\\"\\\\n\\\".join(items) + \\\"\\\\n</ul>\\\"\",\n \"def urlencode_any(d):\\r\\n try:\\r\\n d = d.items()\\r\\n except AttributeError:\\r\\n pass\\r\\n as_bytes = tuple((port.to_b(key), port.to_b(value)) for key, value in d)\\r\\n return port.urlencode(as_bytes)\",\n \"def make_url_safe(self, url):\\n return url.replace(' ', '%20')\\\\\\n .replace('(', '%28')\\\\\\n .replace(')', '%29')\\\\\\n .replace('\\\"', '%22')\",\n \"def form_cur_quotes_property_url_str(self):\\n start_str = '&f='\\n self.cur_quotes_property_portion_url = start_str + self.cur_quotes_property_str\",\n \"def str_replace(data):\\n for key, value in data.items():\\n if isinstance(value, (str, unicode)):\\n data[key] = value.format(**data)\",\n \"def _generate_query_string(self):\\n \\n query_items = {}\\n \\n for key, val in self.__dict__.iteritems():\\n if not key.startswith('_'):\\n query_items[key] = val.encode('utf-8')\\n \\n return urllib.urlencode(query_items)\",\n \"def querystring(data, exclude=(), **kwargs):\\n items = reduce(operator.add, (\\n list((k, v) for v in values)\\n for k, values in data.lists() if k not in exclude\\n ), [])\\n\\n for key, value in kwargs.items():\\n items.append((key, force_text(value)))\\n\\n return urlencode(sorted(items))\",\n \"def str_dict(d):\\n return \\\", \\\".join(\\\"%s=%s\\\" % (k, d[k]) for k in d)\",\n \"def urlify(e):\\n if isinstance(e, dict):\\n try:\\n iteritems = e.iteritems()\\n except AttributeError:\\n iteritems = e.items()\\n\\n return dict((k, urlify(v)) for k, v in iteritems)\\n elif isinstance(e, (list, tuple)):\\n return json.dumps(e, cls=CustomJSONEncoder)\\n elif isinstance(e, bool):\\n return 'true' if e else 'false'\\n else:\\n return encode(e)\",\n \"def clean_url(url: str, keys: List[str]) -> str:\\n u = urlparse(url)\\n query = parse_qs(u.query, keep_blank_values=True)\\n\\n for key in keys:\\n query.pop(key, None)\\n\\n u = u._replace(query=urlencode(query, True))\\n \\n return urlunparse(u)\",\n \"def _sanitize_query(self, uri=None, querydict=None):\\n # import pdb; pdb.set_trace()\\n if querydict is None:\\n query = urisplit(uri).getquerydict()\\n else:\\n query = querydict\\n result = {}\\n for (key, values) in query.items():\\n logger.debug('sanitize_query 1 %s:%s',key,values)\\n result_values = []\\n for value in values:\\n if key == 'date':\\n year = self._sanitize_year(str(value))\\n if year:\\n result_values.append(year)\\n # we possibly could introduce query['year'],\\n # query['month'] etc.\\n # Maybe later\\n elif value:\\n result_values.append(value)\\n if result_values:\\n result[key] = result_values\\n return result\",\n \"def _check_values(self, values):\\n mod = []\\n for k, v in values.items():\\n if isinstance(v, str) and \\\"'\\\" in v:\\n mod.append(k)\\n if len(mod) == 0:\\n return values\\n else:\\n values = copy.copy(values)\\n for k in mod:\\n values[k] = values[k].replace(\\\"'\\\", \\\"''\\\")\\n return values\",\n \"def dict2argstr(d: Dict[str, Any]) -> str:\\n return \\\",\\\".join(\\\"{!s}={!r}\\\".format(key, val) for (key, val) in d.items())\",\n \"def FormatUrl(params):\\n input_list = []\\n for item in sorted(params.iteritems(), key=lambda x: x[0]):\\n input_list.append('%s=%s' % (item[0], UrlEscape(item[1])))\\n return '&'.join(input_list)\",\n \"def url_replace(context, **kwargs):\\n query = context['request'].GET.dict()\\n query.update(kwargs)\\n return urlencode(query)\",\n \"def url_replace(context, **kwargs):\\n query = context['request'].GET.dict()\\n query.update(kwargs)\\n return urlencode(query)\",\n \"def modify_query(**values):\\n args = request.args.copy()\\n\\n for attr, new_value in values.items():\\n if new_value is not None:\\n args[attr] = new_value\\n elif attr in args:\\n del args[attr]\\n\\n if args:\\n return request.base_url + \\\"?\\\" + url_encode(args)\\n else:\\n return request.base_url\",\n \"def create_query_sting(param_dict):\\n params = \\\"&\\\".join([f\\\"{key}={value}\\\" for key, value in param_dict.items()])\\n return params.replace(\\\"#\\\", \\\"%23\\\")\",\n \"def url_replace(request, field, value):\\n _dict = request.GET.copy()\\n _dict[field] = value\\n return _dict.urlencode()\",\n \"def format_arguments(data: Dict) -> str:\\n\\n def prep(key: str, value: Any) -> str:\\n if isinstance(value, str):\\n value = f'''\\\"{value.replace('\\\"', \\\"'\\\")}\\\"'''\\n if key == \\\"pattern\\\":\\n value = f\\\"r{value}\\\"\\n return f\\\"{key}={value}\\\"\\n\\n return \\\",\\\\n\\\".join([prep(key, value) for key, value in data.items()])\",\n \"def url_to_string(cls, v, values, **kwargs):\\n return str(v)\",\n \"def make_args(self, args):\\n result_str = \\\"?\\\"\\n for k, v in args.iteritems():\\n result_str = result_str + k + \\\"=\\\" + v + \\\"&\\\"\\n return result_str\",\n \"def urlsafe(self):\\n return urllib.quote(self.normalized())\",\n \"def do_urlencode(value):\\n return urllib.quote(value.encode('utf8'))\",\n \"def test_escape_value_as_list(self):\\r\\n testdict = escapeddict.EscapedDict({'key1': 'value1', 'key2': ['value2', '${key1}']})\\r\\n for key in testdict.keys():\\r\\n print testdict[key]\\r\\n assert testdict['key1'] == 'value1'\\r\\n assert testdict['key2'] == ['value2', 'value1']\",\n \"def generate_link_attr(d: Dict):\\n d.update({\\\"link\\\": urljoin(\\\"https://vdb-kasf1i23nr1kl2j4.rapid7.com/v1/content/\\\", d.get(\\\"identifier\\\"))})\",\n \"def urlencode_sl(query_params, allow_func=None):\\n query_params = query_params or {}\\n encoded_pairs = []\\n for k, v in query_params.items():\\n # Keys are also percent-encoded according to OAuth spec.\\n k = percent_encode(unicode_to_utf8(k))\\n if allow_func and not allow_func(k, v):\\n continue\\n elif is_bytes_or_unicode(v):\\n encoded_pairs.append((k, percent_encode(v),))\\n else:\\n if is_sequence(v):\\n # Loop over the sequence.\\n if len(v) > 0:\\n for i in v:\\n encoded_pairs.append((k, percent_encode(i), ))\\n # ``urllib.urlencode()`` doesn't preserve blank lists.\\n # Therefore, we're discarding them.\\n #else:\\n # # Preserve blank list values.\\n # encoded_pairs.append((k, \\\"\\\", ))\\n else:\\n encoded_pairs.append((k, percent_encode(v),))\\n # Sort after encoding according to the OAuth spec.\\n return sorted(encoded_pairs)\",\n \"def url_filter(val):\\n if isinstance(val, Undefined):\\n return UNDEFINED_LABEL\\n return quote(str(val))\",\n \"def multiple_replace(dict, text): \\n\\n # Create a regular expression from the dictionary keys\\n regex = re.compile(\\\"(%s)\\\" % \\\"|\\\".join(map(re.escape, dict.keys())))\\n\\n # For each match, look-up corresponding value in dictionary\\n return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)\",\n \"def _reprOfStringToValueMap (stringMap : Map) -> String:\\n\\n entrySeparator = u\\\"§\\\"\\n entryTemplate = \\\"%s: %s\\\"\\n keyList = sorted(list(stringMap.keys()))\\n result = \\\"\\\"\\n \\n for key in keyList:\\n value = stringMap[key] \\n result += (iif(result == \\\"\\\", \\\"\\\", entrySeparator)\\n + entryTemplate % (key, value))\\n \\n result = \\\"{\\\" + result + \\\"}\\\";\\n return result\",\n \"def _extend_url(self, url, params):\\n # filter out None parameters\\n params = {k:v for k,v in params.items() if v is not None}\\n for key in params:\\n url = url + \\\"&{}={}\\\".format(key, params[key])\\n return url\",\n \"def url_Keyword(self,key):\\n url=key.replace('www','mbasic')\\n #url=key.replace(\\\"%20\\\",\\\"+\\\")\\n \\n return url\",\n \"def as_html(self):\\r\\n return mark_safe(' '.join(['%s=\\\"%s\\\"' % (k, escape(v if not callable(v) else v()))\\r\\n for k, v in six.iteritems(self)]))\",\n \"def _sanitize(data_dict):\\n return data_dict\",\n \"def _unicode_urlencode(params):\\r\\n if isinstance(params, dict):\\r\\n params = params.items()\\r\\n return urllib.parse.urlencode([(k, v.encode('utf-8') or v) for k, v in params])\",\n \"def url_escape(value, plus=True):\\r\\n quote = urllib_parse.quote_plus if plus else urllib_parse.quote\\r\\n return quote(utf8(value))\",\n \"def format_url(search_terms):\\n print(search_terms)\\n base_url = 'https://www.gofundme.com/s?q='\\n\\n if isinstance(search_terms, str):\\n base_url += search_terms.replace(' ', '+')\\n else:\\n base_url += '+'.join(search_terms)\\n\\n return base_url\",\n \"def _unicode_urlencode(params):\\n if isinstance(params, dict):\\n params = list(params.items())\\n for i, param in enumerate(params):\\n if isinstance(param[1], list):\\n params[i] = (param[0], json.dumps(param[1]),)\\n\\n result = urllib.parse.urlencode([(k, isinstance(v, str) and v.encode('utf-8') or v) for k, v in params])\\n return result\",\n \"def convert_values_to_strings(dict,list_sep=', '):\\n d=dict.copy()\\n for key in dict.keys():\\n if not isinstance(dict[key],str):\\n try:\\n d[key]=list_sep.join(dict[key])\\n except:\\n del d[key]\\n return d\",\n \"def form_cur_quotes_property_url_str_fr_excel(self):\\n from xls_table_extract_module import XlsExtractor\\n self.xls_property_data = XlsExtractor(fname = self.properties_excel_table, sheetname= 'Sheet1',\\n param_start_key = 'stock_property//', param_end_key = 'stock_property_end//',\\n header_key = '', col_len = 2)\\n\\n self.xls_property_data.open_excel_and_process_block_data()\\n\\n ## form the header\\n self.cur_quotes_parm_headers = [n.encode().strip() for n in self.xls_property_data.data_label_list]\\n\\n ## form the url str\\n start_str = '&f='\\n target_properties = ''.join([n[0].encode().strip() for n in self.xls_property_data.data_value_list])\\n self.cur_quotes_property_portion_url = start_str + target_properties\",\n \"def clean_dict(self,dict_to_clean):\\n for i in dict_to_clean: \\n try:\\n float( dict_to_clean[i] ) \\n except:\\n dict_to_clean[ i ] = \\\"'%s'\\\"%( dict_to_clean[i ].replace(\\\"'\\\",\\\"\\\").replace('\\\"',\\\"\\\") )\",\n \"def _dict_to_args(self, arg_dict):\\n if arg_dict:\\n yield \\\"--{}=data:application/json;charset=utf-8,{}\\\".format(\\n self._CONFIG_FLAG.name,\\n urllib.parse.quote(json_encode(arg_dict, pretty=False), encoding=\\\"utf-8\\\")\\n )\",\n \"def urlQuote(string):\\r\\n return quote(string.encode(\\\"utf-8\\\"))\",\n \"def append_query_param(url: str, key: str, value: str) -> str:\\n template = '?' in url and '{}&{}={}' or '{}?{}={}'\\n return template.format(url, key, value)\",\n \"def _render_dict(input_dict: Dict[str, Any]) -> Dict[str, Any]:\\n output_dict = {}\\n\\n for key, value in input_dict.items():\\n if isinstance(value, str):\\n new_value = string.Template(value).substitute(_mapping)\\n output_dict[key] = new_value\\n elif isinstance(value, dict):\\n output_dict[key] = _render_dict(value) # type: ignore\\n else:\\n output_dict[key] = value\\n\\n return output_dict\",\n \"def dict(dict: Dict[str, Pin], /) -> None:\",\n \"def _create_param_url(self, paramsDic):\\n url = sys.argv[ 0 ]\\n sep = '?'\\n print paramsDic\\n try:\\n for param in paramsDic:\\n #TODO: solve error on name with non ascii char (generate exception)\\n url = url + sep + urllib.quote_plus( param ) + '=' + urllib.quote_plus( paramsDic[param] )\\n sep = '&'\\n except:\\n url = None\\n print_exc()\\n return url\",\n \"def DictFunction():\\r\\n print \\\"{name} is from {city}, and he likes {cake} cake, {fruit} fruit, {salad} salad and {pasta} pasta\\\".format(**food_prefs)\",\n \"def _filterDictToStr(self, filterDict):\\n values = []\\n for key, vals in filterDict.items():\\n if key not in ('contentRating', 'label', 'contentRating!', 'label!'):\\n raise BadRequest(f'Unknown filter key: {key}')\\n values.append(f\\\"{key}={'%2C'.join(vals)}\\\")\\n return '|'.join(values)\",\n \"def unicode_urlencode(self, params):\\n if isinstance(params, dict):\\n params = params.items()\\n for i, param in enumerate(params):\\n if isinstance(param[1], list):\\n params[i] = (param[0], json.dumps(param[1]),)\\n\\n return urllib.urlencode(\\n [(k, isinstance(v, unicode) and v.encode('utf-8') or v) for k, v in params]\\n )\",\n \"def render_dict(dict):\\n\\t\\treturn str.encode(str(dict))\",\n \"def format_query(query, option=''):\\n q_tmp = []\\n for s in query:\\n if option != 'url' or s.isalnum():\\n q_tmp.append(s)\\n else:\\n q_tmp.append('\\\\\\\"' + s.lower() + '\\\\\\\"')\\n\\n if option == 'file':\\n sep = '_'\\n else:\\n sep = ' '\\n q = sep.join(q_tmp)\\n if option == 'url':\\n q = urllib2.quote('\\\\'' + q + '\\\\'')\\n return q\",\n \"def __apply_filters(url, dataset_code):\\n if '?' not in url:\\n url += '?'\\n else:\\n url += '&'\\n for key in dataset_code.FILTERS:\\n if isinstance(dataset_code.FILTERS[key], list):\\n for value in dataset_code.FILTERS[key]:\\n url += key + '=' + str(value) + '&'\\n else:\\n url += key + '=' + str(dataset_code.FILTERS[key]) + '&'\\n url = url[0:-1]\\n return url\",\n \"def form_url_str(self, type = 'cur_quotes'):\\n if type == 'cur_quotes':\\n self.form_cur_quotes_stock_url_str()\\n \\n # form the property. 2 methods enabled.\\n if self.enable_form_properties_fr_exceltable:\\n self.form_cur_quotes_property_url_str_fr_excel()\\n else:\\n self.form_cur_quotes_property_url_str()\\n \\n self.cur_quotes_full_url = self.cur_quotes_start_url + self.cur_quotes_stock_portion_url +\\\\\\n self.cur_quotes_property_portion_url + self.cur_quotes_end_url\",\n \"def _create_query_str(data):\\n params = []\\n for name, value in data.items():\\n params.append(name + '=' + str(value))\\n\\n return '?' + '&'.join(params)\",\n \"def form_cur_quotes_stock_url_str(self):\\n self.cur_quotes_stock_portion_url = ''\\n for n in self.target_stocks:\\n self.cur_quotes_stock_portion_url = self.cur_quotes_stock_portion_url + n +\\\\\\n self.cur_quotes_stock_portion_additional_url + ','\\n \\n self.cur_quotes_stock_portion_url =self.cur_quotes_stock_portion_url[:-1]\",\n \"def _clean_and_encode_params(params: Mapping):\\n # Keep only the parameters that were given a value\\n params = {k: v for k, v in params.items() if v is not None}\\n\\n # All query parameters are later urlencoded - for projection, comma-separated\\n # list is supported only on literal comma; convert comma-separated list\\n # to a list of values which will be encoded to multiple query parameters\\n try:\\n params[\\\"projection\\\"] = [x.strip() for x in params[\\\"projection\\\"].split(\\\",\\\")]\\n except KeyError:\\n pass\\n return params\",\n \"def _encode_url(data: str) -> str:\\n return urllib.parse.quote(data, safe=\\\"\\\")\",\n \"def _encode(dictionary):\\n # Strip ugly base64 padding.\\n byteStr = bytearray(json.dumps(dictionary).encode())\\n encodedStr = base64.urlsafe_b64encode(byteStr)\\n return encodedStr.rstrip('='.encode())\",\n \"def smart_encode(**kwargs):\\r\\n args = dict(kwargs)\\r\\n for k, v in args.items():\\r\\n if v is None:\\r\\n del args[k]\\r\\n if not args:\\r\\n return ''\\r\\n return urlencode(args)\",\n \"def produce_link_qwant(self, value_search:str) -> str:\\n # https://www.qwant.com/?q=a%24ap+rocky&t=web\\n for replace, replaced in [(' ', '+'), \\n ('$', '%24')]:\\n value_search = value_search.replace(replace, replaced)\\n return f'https://www.qwant.com/?q={value_search}&t=web'\",\n \"def dictreplace(self, string, keydict):\\n for old, new in keydict.items():\\n string = string.replace(old, new)\\n return string\",\n \"def convert_conn_params(conn_dict):\\n conn_list = []\\n for (param, val) in iteritems(conn_dict):\\n conn_list.append('%s=%s' % (param, val))\\n\\n return ' '.join(conn_list)\",\n \"def param_replace(context, **kwargs):\\n d = context['request'].GET.copy()\\n for k,v in kwargs.items():\\n d[k] = v\\n for k in [k for k,v in d.items() if not v]:\\n del d[k]\\n return d.urlencode()\",\n \"def percent_encode(data, safe=None):\\n if data is None:\\n return None\\n if isinstance(data, (tuple, list, set)):\\n return b\\\"&\\\".join(\\n percent_encode(value, safe=safe)\\n for value in data\\n )\\n if isinstance(data, dict):\\n return b\\\"&\\\".join(\\n bstr(key) + b\\\"=\\\" + percent_encode(value, safe=safe)\\n for key, value in data.items()\\n )\\n return quote(bstr(data), safe or b\\\"\\\").encode(\\\"utf-8\\\")\",\n \"def sanitize_quotes(quotes):\\n return [\\n collections.OrderedDict([\\n ('s/n', idx),\\n ('id', quote['ID']),\\n ('content', escape_html_entity(\\n remove_html_tags(\\n quote['content']\\n )).strip('\\\\n ')),\\n ('link', quote['link']),\\n ('title', quote['title']),\\n ('source', extract_url_from_anchor_tag(\\n quote.get('custom_meta', {}).get('Source', '')))\\n ]) for idx, quote in enumerate(quotes, 1)\\n ]\",\n \"def queryparams(*args, **kwargs):\\n args = dict(args)\\n args.update(kwargs)\\n return urllib.urlencode(args)\",\n \"def urlencode(query, doseq=False):\\n if isinstance(query, MultiValueDict):\\n query = query.lists()\\n elif hasattr(query, \\\"items\\\"):\\n query = query.items()\\n query_params = []\\n for key, value in query:\\n if value is None:\\n raise TypeError(\\n \\\"Cannot encode None for key '%s' in a query string. Did you \\\"\\n \\\"mean to pass an empty string or omit the value?\\\" % key\\n )\\n elif not doseq or isinstance(value, (str, bytes)):\\n query_val = value\\n else:\\n try:\\n itr = iter(value)\\n except TypeError:\\n query_val = value\\n else:\\n # Consume generators and iterators, when doseq=True, to\\n # work around https://bugs.python.org/issue31706.\\n query_val = []\\n for item in itr:\\n if item is None:\\n raise TypeError(\\n \\\"Cannot encode None for key '%s' in a query \\\"\\n \\\"string. Did you mean to pass an empty string or \\\"\\n \\\"omit the value?\\\" % key\\n )\\n elif not isinstance(item, bytes):\\n item = str(item)\\n query_val.append(item)\\n query_params.append((key, query_val))\\n return original_urlencode(query_params, doseq)\",\n \"def urlencode_s(query_params, allow_func=None):\\n return \\\"&\\\".join([k + \\\"=\\\" + v for k, v in\\n urlencode_sl(query_params, allow_func=allow_func)])\",\n \"def _concatenate_url(self, response: Dict[str, Any], url_field: str = 'url') -> None:\\n split_url_field = url_field.split('.')\\n if len(split_url_field) > 1:\\n self._concatenate_url(response.get(split_url_field[0], {}), '.'.join(split_url_field[1:]))\\n\\n elif url_field in response:\\n url = urljoin(self._base_url, response[url_field]).replace('https://api', 'https://app')\\n response[url_field] = url\",\n \"def replace_in_string(s, args_dict):\\n for key, value in args_dict.items():\\n s = s.replace(key, value)\\n for key, value in args_dict.items():\\n s = s.replace(key, value)\\n for key, value in args_dict.items():\\n s = s.replace(key, value)\\n return s\",\n \"def form_com_data_stock_url_str(self):\\n self.com_data_stock_portion_url = ''\\n for n in self.target_stocks:\\n self.com_data_stock_portion_url = self.com_data_stock_portion_url +'%22' + n +\\\\\\n self.com_data_stock_portion_additional_url + '%22%2C'\\n \\n self.com_data_stock_portion_url = self.com_data_stock_portion_url[:-3]\",\n \"def _set_query_params(query, key, value):\\n query.update({str(key): str(value)})\",\n \"def _assemble_kw_url(self, keywords):\\n search_params = self._build_param_request()\\n include = self._build_field_request()\\n\\n keywords = '+'.join(keywords)\\n request_url = \\\\\\n self.nsf_api + 'keyword=' + keywords + include + search_params\\n\\n return request_url\",\n \"def urlquote(text):\\n if op.sep == \\\"\\\\\\\\\\\":\\n return urllib.quote(text.replace(\\\"\\\\\\\\\\\", \\\"/\\\"))\\n else:\\n return urllib.quote(text)\",\n \"def _quote(v):\\n return '\\\"' + v + '\\\"' if ' ' in v else v\",\n \"def _url_encode(self, text):\\n try:\\n return (urllib.quote(text.replace(u'and', u'&'), safe='')\\n .replace(u'%20', u'+'))\\n except:\\n print('Using python3')\\n return (urllib.parse.quote(text.replace(u'and', u'&'), safe='')\\n .replace(u'%20', u'+'))\",\n \"def quote_json(_json: dict) -> str:\\n stringified = json.dumps(_json)\\n return quote(stringified)\",\n \"def make_paths_safe(params):\\n for key in params.keys():\\n if isinstance(params[key], str):\\n params[key] = params[key].replace(\\\"/\\\", os.sep)\\n params[key] = params[key].replace(\\\"\\\\\\\\\\\", os.sep)\\n\\n return params\",\n \"def format_key(self, key):\\n if self.in_quotes(key):\\n key = self.format_value(key) \\n else:\\n if key.lower() in ALL_KEYWORDS:\\n key = self.format_value(key.upper())\\n else:\\n key = self.format_value(self.add_quotes(key.lower()))\\n\\n return key\",\n \"def multi_replace(text, dictobj):\\n for k, v in dictobj.iteritems():\\n text = text.replace(k, v)\\n return text\",\n \"def replacer(s,replace_dict):\\n for k,v in replace_dict.items(): s = s.replace(k,v)\\n return s\",\n \"def standardise_quotes(self, val):\\n if val.startswith(self.altquote) and val.endswith(self.altquote):\\n middle = val[1:-1]\\n val = \\\"%s%s%s\\\" % (self.quote, middle, self.quote)\\n\\n val = self.escape_quotes(val)\\n\\n return val\",\n \"def str_map(values, formatting):\\n return [formatting % v for v in values]\",\n \"def sanitize(key, value):\\n \\n # We do special handling for response keys\\n # list (str was delimited by commas)\\n if key == 'txn_refs':\\n return value.split(',')\\n \\n # datetime\\n elif key in ('date', 'expiry'):\\n return str_to_date(value, key=key)\\n\\n # int\\n elif key in ('split_count', 'duration', 'talktime', 'entries_count', 'total_entries_count'):\\n return int(value)\\n\\n # float\\n elif key in ('rate', 'total_cost', 'debit', 'balance', 'points', 'bonus'):\\n return float(value)\\n\\n # bool\\n elif key in ('auto_extend_status',):\\n if value == 'disabled':\\n return True\\n else:\\n return False\\n\\n # list of objects\\n elif key == 'entries':\\n # Turns each entry (a dict) into an object\\n i = 0\\n for entry in value:\\n obj = obj_dic(entry)\\n value[i] = obj\\n i += 1\\n return value\\n\\n else:\\n return value\",\n \"def replace_query_params(cls, url: str, **params: Mapping[str, str]) -> str:\\n url, _ = cls.separate_query_params(url, params.keys())\\n return cls.add_query_params(url, **params)\",\n \"def url_with_query_str(url, *args, **kwargs):\\n if len(args):\\n d = args[0]\\n elif len(kwargs):\\n d = kwargs\\n else:\\n raise Exception('not found dict')\\n if any(\\\"%\\\" in k for k in d.keys()):\\n query = \\\"&\\\".join([\\\"{}={}\\\".format(k, v) for k, v in d.items()])\\n else:\\n query = urlencode(d)\\n url = url.split('?')[0]\\n return \\\"{}?{}\\\".format(url, query)\",\n \"def _build_url_exact(self, q: str, **kwargs: Dict) -> str:\\n url = f\\\"{self._URL}?where=\\\"\\n if kwargs.get('doi'):\\n input_doi = kwargs.get('doi')\\n url += f'''{{\\\"doi\\\":\\\"{input_doi}\\\"}}'''\\n return url\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62306243","0.5637293","0.5618359","0.55986035","0.555752","0.55488056","0.5539878","0.5492487","0.548568","0.54376","0.5426715","0.5394386","0.53836554","0.53630733","0.5343481","0.5332934","0.5330379","0.53290695","0.5296179","0.5293168","0.5288468","0.52861863","0.5240477","0.5230314","0.5229958","0.52053994","0.5196728","0.5196728","0.51896507","0.5184986","0.51738733","0.51611626","0.5150393","0.5140368","0.51327795","0.5126704","0.5112697","0.509971","0.5099297","0.5091433","0.50684524","0.5062479","0.50553364","0.50506586","0.5047393","0.5014762","0.4972746","0.49698207","0.4963633","0.49621055","0.4952901","0.49464303","0.49053437","0.49043584","0.4896252","0.48913163","0.48831394","0.48786807","0.48784658","0.4874109","0.4866083","0.48646384","0.48625714","0.48580083","0.48574108","0.4842648","0.48414743","0.48399493","0.48384938","0.48240906","0.4823352","0.4820952","0.48204446","0.48003024","0.4800063","0.4791507","0.4791482","0.47881812","0.47807828","0.47799686","0.47694167","0.4766833","0.47570202","0.47552413","0.475231","0.47430536","0.47408605","0.47386402","0.47202605","0.47139418","0.47138408","0.4712625","0.4710619","0.47001287","0.46973473","0.4682983","0.4681043","0.46793172","0.46780255","0.46767724"],"string":"[\n \"0.62306243\",\n \"0.5637293\",\n \"0.5618359\",\n \"0.55986035\",\n \"0.555752\",\n \"0.55488056\",\n \"0.5539878\",\n \"0.5492487\",\n \"0.548568\",\n \"0.54376\",\n \"0.5426715\",\n \"0.5394386\",\n \"0.53836554\",\n \"0.53630733\",\n \"0.5343481\",\n \"0.5332934\",\n \"0.5330379\",\n \"0.53290695\",\n \"0.5296179\",\n \"0.5293168\",\n \"0.5288468\",\n \"0.52861863\",\n \"0.5240477\",\n \"0.5230314\",\n \"0.5229958\",\n \"0.52053994\",\n \"0.5196728\",\n \"0.5196728\",\n \"0.51896507\",\n \"0.5184986\",\n \"0.51738733\",\n \"0.51611626\",\n \"0.5150393\",\n \"0.5140368\",\n \"0.51327795\",\n \"0.5126704\",\n \"0.5112697\",\n \"0.509971\",\n \"0.5099297\",\n \"0.5091433\",\n \"0.50684524\",\n \"0.5062479\",\n \"0.50553364\",\n \"0.50506586\",\n \"0.5047393\",\n \"0.5014762\",\n \"0.4972746\",\n \"0.49698207\",\n \"0.4963633\",\n \"0.49621055\",\n \"0.4952901\",\n \"0.49464303\",\n \"0.49053437\",\n \"0.49043584\",\n \"0.4896252\",\n \"0.48913163\",\n \"0.48831394\",\n \"0.48786807\",\n \"0.48784658\",\n \"0.4874109\",\n \"0.4866083\",\n \"0.48646384\",\n \"0.48625714\",\n \"0.48580083\",\n \"0.48574108\",\n \"0.4842648\",\n \"0.48414743\",\n \"0.48399493\",\n \"0.48384938\",\n \"0.48240906\",\n \"0.4823352\",\n \"0.4820952\",\n \"0.48204446\",\n \"0.48003024\",\n \"0.4800063\",\n \"0.4791507\",\n \"0.4791482\",\n \"0.47881812\",\n \"0.47807828\",\n \"0.47799686\",\n \"0.47694167\",\n \"0.4766833\",\n \"0.47570202\",\n \"0.47552413\",\n \"0.475231\",\n \"0.47430536\",\n \"0.47408605\",\n \"0.47386402\",\n \"0.47202605\",\n \"0.47139418\",\n \"0.47138408\",\n \"0.4712625\",\n \"0.4710619\",\n \"0.47001287\",\n \"0.46973473\",\n \"0.4682983\",\n \"0.4681043\",\n \"0.46793172\",\n \"0.46780255\",\n \"0.46767724\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5998401"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":77689,"cells":{"query":{"kind":"string","value":"Apply all `before_generate_` hooks related to the given location."},"document":{"kind":"string","value":"def apply_hooks(\n endpoint: Endpoint,\n context: HookContext,\n hooks: Optional[HookDispatcher],\n strategy: st.SearchStrategy[Case],\n location: str,\n) -> st.SearchStrategy[Case]:\n strategy = _apply_hooks(context, GLOBAL_HOOK_DISPATCHER, strategy, location)\n strategy = _apply_hooks(context, endpoint.schema.hooks, strategy, location)\n if hooks is not None:\n strategy = _apply_hooks(context, hooks, strategy, location)\n return strategy"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _apply_hooks(\n context: HookContext, hooks: HookDispatcher, strategy: st.SearchStrategy[Case], location: str\n) -> st.SearchStrategy[Case]:\n container = LOCATION_TO_CONTAINER[location]\n for hook in hooks.get_all_by_name(f\"before_generate_{container}\"):\n strategy = hook(context, strategy)\n return strategy","def process_before_request_hooks(self):\n\n hooks = []\n\n if self.resource:\n hooks.extend(self.resource.api.before_all_hooks)\n hooks.extend(self.resource.before_all_hooks)\n\n hooks.extend(self.before_all_hooks)\n hooks.extend(\n getattr(\n self,\n 'before_{method}_hooks'.format(method=self.meth),\n []\n )\n )\n\n for hook in chain(hooks):\n hook(self)","def setup_hooks(self):\n pass","def setup(self, registers):\n \"\"\" tasks before any generation functions are called \"\"\"\n pass","def _post_hooks(self):","def before(self, location=None):\n side_effect = SideEffect(self.f, location)\n dataflow = inject_before(self.container, side_effect, location)\n return self._construct(dataflow)","def post_setup(self, context):\n pass","def run_before(self):\n\n for path in self.hooks.get('before', []):\n self.run_module(path)","def on_before_execution(self):\n pass","def before(hook_name, methods, kwargs):\n for hookimpl in methods:\n self._plugin2calls[hookimpl.plugin].add(hook_name)","def pre_hook():\n _logger.warning(\"PRE Gen hook executed\")\n\n try:\n\n # Default value = Volt\n theme = \"{{cookiecutter.theme}}\"\n repo = 'https://github.com/app-generator/flask-dashboard-volt.git'\n\n if 'material-dashboard' == theme:\n repo = 'https://github.com/app-generator/flask-material-dashboard.git'\n\n if 'soft-ui' == theme:\n repo = 'https://github.com/app-generator/flask-soft-ui-dashboard.git'\n\n if 'datta-able' == theme:\n repo = 'https://github.com/app-generator/flask-datta-able.git'\n\n if 'star-admin' == theme:\n repo = 'https://github.com/app-generator/flask-star-admin.git' \n\n print(' Cloning theme: <' + theme + '>, REPO: ' + repo )\n\n repo = git.Repo.clone_from( repo, TMP_DIR, branch='master')\n print(' ...done')\n \n except OSError as e:\n _logger.warning(f\"Error: {e}\")\n sys.exit(0)\n\n # Exit with success\n sys.exit(0)","def setup_hooks(self) -> None:\n install_hooks(self.record_interaction)","def hook_server_before_exec(self, request_event):\r\n\r\n for functor in self._hooks['server_before_exec']:\r\n functor(request_event)","def create_default_hooks(self):\n\n self.create_hooks(\"commands\")\n self.create_hooks(\"commands_out\")\n self.create_hooks(\"hooks\")","def post_start_hook(self):\n\n LOG.debug(_('XManager post_start_hook...'))\n\n pass","def pre_build_hook(self):","def pre_start_hook(self):\n\n LOG.debug(_('XManager pre_start_hook...'))\n\n pass","def on_setup(self, request, trigger_context):\n raise NotImplementedError","def prepare_locations(requests):\n\tlocation = StringIO.StringIO()\n\tlocation.write('# Do not modify - this file is maintained by nginx_updater.py\\n')\n\tfor service in requests:\n\t\tlocation.write('\\nlocation {0} {{\\n'.format(service))\n\t\tlocation.write('\\tproxy_pass http://{0}/;\\n'.format(upstream_name(service)))\n\t\tlocation.write('\\tproxy_redirect off;\\n')\n\t\tlocation.write('\\tproxy_next_upstream error timeout invalid_header http_500\\n')\n\t\tlocation.write('\\tproxy_connect_timeout 1s;\\n')\n\t\tlocation.write('}\\n')\n\t\n\treturn location","def prepare_locations(requests):\r\n\tlocation = StringIO.StringIO()\r\n\tlocation.write('# Do not modify - this file is maintained by nginx_updater.py\\n')\r\n\tfor service in requests:\r\n\t\tlocation.write('\\nlocation {0} {{\\n'.format(service))\r\n\t\tlocation.write('\\tproxy_pass http://{0}/;\\n'.format(upstream_name(service)))\r\n\t\tlocation.write('\\tproxy_redirect off;\\n')\r\n\t\tlocation.write('\\tproxy_next_upstream error timeout invalid_header http_500\\n')\r\n\t\tlocation.write('\\tproxy_connect_timeout 1s;\\n')\r\n\t\tlocation.write('}\\n')\r\n\t\r\n\treturn location","def before(self, context):\n raise NotImplementedError","def before(self, before: Route.Decorator):\n pass","def post_hook(self):\n self.mk_rg1()\n self.mk_rg2()\n self.mk_rg3()","def create_hooks(self, action):\n for folder in (\n \"{0}_{1}\".format(time, action)\n for time in [\"before\", \"after\"]\n ):\n test_filename = \"/tmp/{0}_{1}\".format(PREFIX, folder)\n file_content = \"#!/bin/bash\\n\\ntouch {0}\\n\".format(\n test_filename\n )\n hook_path = \"{0}/{1}/{2}\".format(\n GA_HOOKS_FOLDER, folder, HOOK_NAME\n )\n testflow.step(\n \"Create hook file %s with content: %s\",\n hook_path, file_content\n )\n self.machine.fs.create_script(file_content, hook_path)","def do_before(self):\r\n pass","def process_after_request_hooks(self, resp):\n\n hooks = []\n meth_hooks = getattr(\n self,\n 'after_{method}_hooks'.format(method=self.meth),\n []\n )\n\n hooks.extend(meth_hooks)\n hooks.extend(self.after_all_hooks)\n\n if self.resource:\n hooks.extend(self.resource.after_all_hooks)\n hooks.extend(self.resource.api.after_all_hooks)\n\n for hook in chain(hooks):\n resp = hook(self, resp)\n\n return resp","def _instantiate_attributes_before_function(self, context=None):\n self._instantiate_pathway(context=context)\n # super(Process_Base, self)._instantiate_function(context=context)","def set_asyncgen_hooks(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__\n pass","def _timestep_before_hook(self, *args, **kwargs):\n pass","def prep_logging_decorator(func):\n filename = filename_regexp.match(inspect.getmodule(inspect.stack()[1][0]).__file__).group(1)\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n logger.info('{}: Start preparation'.format(filename))\n func(*args, **kwargs)\n logger.info('{}: Finished preparation'.format(filename))\n return wrapper","def pre_process(self):\n refs = self.collect_references()\n for ref in refs:\n self._add_reference(ref)\n if (not cls_is_relocatable) and cls_is_referenced:\n register_spritegroup(self)","def _instantiate_attributes_before_function(self, context=None):\n\n super()._instantiate_attributes_before_function(context=context)","def extension_hooks(self, global_step):\n return []","def extension_hooks(self, global_step):\n return []","def test_hookregistry_module_should_have_global_hook_decorators():\n # given & when\n from radish.hookregistry import before, after\n\n # then\n assert callable(before.all)\n assert callable(before.each_feature)\n assert callable(before.each_rule)\n assert callable(before.each_scenario)\n assert callable(before.each_step)\n assert callable(after.all)\n assert callable(after.each_feature)\n assert callable(after.each_rule)\n assert callable(after.each_scenario)\n assert callable(after.each_step)","def post_build_hook(self):","def before_request(self, f):\n self.before_request_handlers.append(f)\n return f","def before_scenario(context, scenario):\n context.resource_manager = contextlib.ExitStack()","def callable_hooks(self):\n for hook in self.custom_hooks:\n options = rh.hooks.HookOptions(hook,\n self.custom_hook(hook),\n self.tool_paths)\n yield (hook, functools.partial(rh.hooks.check_custom,\n options=options))\n\n for hook in self.builtin_hooks:\n options = rh.hooks.HookOptions(hook,\n self.builtin_hook_option(hook),\n self.tool_paths)\n yield (hook, functools.partial(rh.hooks.BUILTIN_HOOKS[hook],\n options=options))","def hook_client_before_request(self, event):\r\n for functor in self._hooks['client_before_request']:\r\n functor(event)","def register_before_first(app):\n app.before_first_request_funcs.append(\n partial(admin.utils.create_root_user, app))\n app.before_first_request_funcs.append(\n partial(admin.utils.load_messenger_config, app))\n app.before_first_request_funcs.append(\n partial(admin.utils.load_site_config, app))","def dynamic_hook(self, hook):\n assert callable(hook)\n self._dynamic_hooks.append(hook)\n try:\n yield\n finally:\n self._dynamic_hooks.remove(hook)","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def before_request(self, func: typing.Callable):\n return self.add_hook(type_=\"pre\", hook=func)","def registerSetup(categories, stackoffset=0):\n\n\tcategories = frozenset(to_stringlist(categories))\n\tdoctext = 'This handler is registered as setup for categories ``%s``.' % (list(categories),)\n\n\tif BUILDING_DOCS:\n\t\treturn lambda x: _addDoc(x, doctext)\n\n\tdef deco(func):\n\t\tcaller = inspect.stack()[1 + stackoffset][1]\n\n\t\tlis = SetupListener(func, categories)\n\t\tlis.caller = caller\n\t\tCONNECTOR.addListener(categories, lis)\n\n\t\t_addDoc(func, doctext)\n\n\t\treturn func\n\n\treturn deco","def __location_handler(self, update, context):\n trigger = Constructor.LOCATION_TRIGGER\n self.__handler(context, update, trigger)","def locations_fixture(location):\n return [location, _create_location()]","def initialize_location_strategies(self):\n locator_manager.register_locators(\"sf\", lex_locators)\n locator_manager.register_locators(\"text\", \"Salesforce.Locate Element by Text\")\n locator_manager.register_locators(\"title\", \"Salesforce.Locate Element by Title\")\n\n # This does the work of actually adding all of the above-registered\n # location strategies, plus any that were registered by keyword\n # libraries.\n locator_manager.add_location_strategies()","def setup_before_migration(self, apps):","def refresh_entity_hooks(self):\n for hook_name in HOOK_NAMES:\n hooks = []\n for entity in self._task.root_entity.iter_entities():\n entity_hook = getattr(entity, hook_name)\n # Ignore any hook that is a no-op to avoid function call overhead.\n if not _callable_is_trivial(entity_hook):\n hooks.append(entity_hook)\n getattr(self, '_' + hook_name).entity_hooks = hooks","def preRunSetup(self):\n self.logDesc(\"Pre Run Setup\")\n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=self.templateName)","def on_start(self):\n\n def decorator(coro):\n self._hooks.append((\"start\", coro))\n return coro\n\n return decorator","def context_processors(self):\n return [\n 'leonardo.module.web.processors.page.add_page_if_missing',\n 'leonardo.module.web.processors.config.leonardo',\n 'leonardo.module.web.processors.font.webfont_cookie',\n ]","def before_feature(context, feature):\n context.pctl.create_and_set_output_directory(feature.name)","def addResetHooks(self, before, after):\n self._beforeResetHook = before\n self._afterResetHook = after","def on_hook(self) -> None:","def pre_processor(self):","def after_all(self) -> None:","def pre_process(self):\n pass","def pre_process(self):\n pass","def pre_process(self):\n pass","def pre_process(self):\n pass","def pre_process(self):\n pass","def before_request(self, f):\n self.before_request_funcs.append(f)\n return f","def after(self, location=None):\n side_effect = SideEffect(self.f, location)\n dataflow = inject_after(self.container, side_effect, location)\n return self._construct(dataflow)","def configure_before_request_funcs(app):\n @app.before_request\n def conf_set_user_cookie_id():\n return set_user_cookie_id()\n \n @app.before_request\n def check_for_maintenance():\n if config.DOWN_FOR_MAINTENANCE:\n return 'Sorry, we\\'re down momentarily for a teensey bit of maintenance!', 503\n \n @app.before_request\n def count_uniques():\n return\n statsd.set('unique_users', g.user_cookie_id)\n statsd.set('unique_ips', request.remote_addr)\n \n @app.before_request\n def set_statsd_context():\n g.statsd_context = \"%s.%s\" % (request.endpoint, request.method)\n g.total_request_timer = statsd.timer(g.statsd_context + \".response_time\")\n g.total_request_timer.start()","def map_to_app_lifecycle_hooks(self, app):\n app['lifecycle_hooks'] = {}\n form_lifecycle_hooks = self.lifecycle_hooks\n if form_lifecycle_hooks.pre_buildimage.data:\n app['lifecycle_hooks']['pre_buildimage'] = b64encode_utf8(\n form_lifecycle_hooks.pre_buildimage.data.replace('\\r\\n', '\\n'))\n else:\n app['lifecycle_hooks']['pre_buildimage'] = ''\n\n if form_lifecycle_hooks.post_buildimage.data:\n app['lifecycle_hooks']['post_buildimage'] = b64encode_utf8(\n form_lifecycle_hooks.post_buildimage.data.replace('\\r\\n', '\\n'))\n else:\n app['lifecycle_hooks']['post_buildimage'] = ''\n\n if form_lifecycle_hooks.pre_bootstrap.data:\n app['lifecycle_hooks']['pre_bootstrap'] = b64encode_utf8(\n form_lifecycle_hooks.pre_bootstrap.data.replace('\\r\\n', '\\n'))\n else:\n app['lifecycle_hooks']['pre_bootstrap'] = ''\n\n if form_lifecycle_hooks.post_bootstrap.data:\n app['lifecycle_hooks']['post_bootstrap'] = b64encode_utf8(\n form_lifecycle_hooks.post_bootstrap.data.replace('\\r\\n', '\\n'))\n else:\n app['lifecycle_hooks']['post_bootstrap'] = ''","def define_log_pre_format_hooks(self):\n return []","def initialize(self):\n logger.debug(\"Begin Generation\")\n self.events.begin_generation()","def test_add_processor_override(caplog):\n\n testapp = holocron.Application()\n marker = None\n\n def processor_a(app, items):\n nonlocal marker\n marker = 42\n yield from items\n\n def processor_b(app, items):\n nonlocal marker\n marker = 13\n yield from items\n\n testapp.add_processor(\"processor\", processor_a)\n testapp.add_processor(\"processor\", processor_b)\n\n for _ in testapp.invoke([{\"name\": \"processor\"}]):\n pass\n\n assert marker == 13\n\n assert len(caplog.records) == 1\n assert caplog.records[0].message == \"processor override: 'processor'\"","def setup(self):\n for gen in self._feature_stats_generators:\n gen.setup()","def register(self, api, prefix: str) -> None:\n route = api.route(prefix + self._pattern, *self._args, **self._kwargs)(\n self._view\n )\n\n # Hooks registered via @before and/or @after on top of the @route\n # decorator need to be manually registered with @api.before, @api.after.\n def _register_hook(hook, hook_decorator):\n nonlocal self, route\n if self.hooks.get(hook) is None:\n return\n hook_function = self.hooks[hook]\n route = hook_decorator(hook_function)(route)\n\n _register_hook(\"before\", api.before)\n _register_hook(\"after\", api.after)","def adjust_line_numbers(self, code):\n store_lines = set()\n make_function_lines = set()\n for opcode in itertools.chain.from_iterable(_collect_bytecode(code)):\n if opcode.name.startswith(\"STORE_\"):\n store_lines.add(opcode.line)\n elif opcode.name == \"MAKE_FUNCTION\":\n make_function_lines.add(opcode.line)\n\n def adjust(line, allowed_lines, min_line=1):\n adjusted_line = line\n while adjusted_line not in allowed_lines and adjusted_line >= min_line:\n adjusted_line -= 1\n return adjusted_line if adjusted_line >= min_line else None\n\n # Process type comments.\n for type_comment_set in self._type_comments:\n for line, comment in sorted(type_comment_set.type_comments.items()):\n adjusted_line = adjust(line, store_lines, type_comment_set.start_line)\n if not adjusted_line:\n # vm._FindIgnoredTypeComments will take care of error reporting.\n continue\n if line != type_comment_set.end_line:\n self._errorlog.ignored_type_comment(self._filename, line, comment)\n del type_comment_set.type_comments[line]\n elif adjusted_line != line:\n type_comment_set.type_comments[adjusted_line] = comment\n del type_comment_set.type_comments[line]\n\n # Process decorators.\n for line in sorted(self._decorators):\n adjusted_line = adjust(line, make_function_lines)\n if not adjusted_line:\n log.error(\n \"No MAKE_FUNCTION opcode found for decorator on line %d\", line)\n elif adjusted_line != line:\n self._decorators.add(adjusted_line)\n self._decorators.remove(line)\n\n # Process variable annotations.\n for line, annot in sorted(self._variable_annotations.items()):\n adjusted_line = adjust(line, store_lines)\n if not adjusted_line:\n log.error(\n \"No STORE_* opcode found for annotation %r on line %d\", annot, line)\n del self._variable_annotations[line]\n elif adjusted_line != line:\n self._variable_annotations[adjusted_line] = annot\n del self._variable_annotations[line]","def _after_serve_actions(self):\n pass","def pre_build(self):","def do_before_dump(self):\n self.checksummer.prepare_checksums()","def pre_customer_attachment_create(self, resource_dict):\n pass","def onRegister(setup_state):\n\tblueprint = setup_state.blueprint\n\t#if setup_state.options.get('auth') == True:\n\tif setup_state.url_prefix.startswith('/ext/'): #not really used right now\n\t\t#inside here, 'route' works but not 'before_request'\n\t\t#maybe use to register authentication-specific routes?\n\t\tprint(\"Authenticated API on {}\".format(setup_state.url_prefix))","def before_request():\r\n\r\n\tinit_classes()","def _hook(self):","def test_add_processor_wrapper_override(caplog):\n\n testapp = holocron.Application()\n marker = None\n\n def processor(app, items):\n yield from items\n\n def processor_wrapper_a(app, items, processor):\n nonlocal marker\n marker = 42\n yield from app.invoke([processor])\n\n def processor_wrapper_b(app, items, processor):\n nonlocal marker\n marker = 13\n yield from app.invoke([processor])\n\n testapp.add_processor(\"processor\", processor)\n testapp.add_processor_wrapper(\"wrapper\", processor_wrapper_a)\n testapp.add_processor_wrapper(\"wrapper\", processor_wrapper_b)\n\n for _ in testapp.invoke([{\"name\": \"processor\", \"wrapper\": {}}]):\n pass\n\n assert marker == 13\n\n assert len(caplog.records) == 1\n assert caplog.records[0].message == \"processor override: 'wrapper'\"","def pre_execute(self):","def pytest_addhooks(pluginmanager):\n pluginmanager.add_hookspecs(hooks)","def _build(self, *args, **kwargs):\n for directive in self.directives:\n alias, ip, port, server_name, location = directive[\"signature\"].split(\":\")\n\n if location not in self.locations.keys():\n handle_location = Location(**{\n \"location\" : location,\n }\n )\n self.locations = handle_location\n self.locations[location].directives = directive","def pre_build(self):\n pass","def post_process():\n for route in os.listdir(GFR_ROUTES_LOCATION):\n if os.path.isfile(MISSING_LOCATION + route):\n # If the route is missing, output the reference data with correct OSM tags.\n\n copyfile(MISSING_LOCATION + route, OUTPUT_LOCATION + route)\n add_property(OUTPUT_LOCATION + route, 'error_type', 'missing')\n elif os.path.isfile(DIFF_MISSING_LOCATION + route) and os.path.isfile(DIFF_WRONG_LOCATION + route) \\\n and merge_differences(route, DIFF_MISSING_LOCATION + route, DIFF_WRONG_LOCATION + route,\n OUTPUT_LOCATION + route):\n # If there's a geometrical difference, combine the two difference files and output it.\n\n add_property(OUTPUT_LOCATION + route, 'error_type', 'difference')\n elif os.path.isfile(TAGS_LOCATION + route):\n # When there's no geometrical difference, output the OSM data possibly containing missing tags.\n\n copyfile(TAGS_LOCATION + route, OUTPUT_LOCATION + route)\n else:\n raise Exception(\"No output file could be generated for route: \" + route)\n\n copy_to_site()\n\n # Export a last updated timestamp\n with open('last_updated', 'w') as fp:\n fp.write(str(int(time.time() * 1000)))","def before_all(context):\n set_services(context)\n context.api = {}\n context.repositories = {}\n\n for service, location in context.services.items():\n url = urlparse.urlparse(location)\n api = API(url.scheme + '://' + url.netloc, async=False)\n try:\n context.api[service] = getattr(api, url.path.split('/')[2])\n except:\n context.api[service] = getattr(api, service)","def _pre_hook(\n state_dict,\n prefix,\n local_metadata,\n strict,\n missing_keys,\n unexpected_keys,\n error_msgs,\n):\n k = prefix + \"pe\"\n if k in state_dict:\n state_dict.pop(k)","def inject_decorator_namespace(self) -> None:\n self.student_code.mod.turn_left = self.karel_action_decorator(\n self.karel.turn_left\n )\n self.student_code.mod.move = self.karel_action_decorator(\n self.karel.move\n )\n self.student_code.mod.put_beeper = self.beeper_action_decorator(\n self.karel.put_beeper\n )\n self.student_code.mod.pick_beeper = self.beeper_action_decorator(\n self.karel.pick_beeper\n )\n self.student_code.mod.paint_corner = self.corner_action_decorator(\n self.karel.paint_corner\n )\n self.student_code.mod.put_block = self.block_action_decorator(\n self.karel.put_block\n )\n self.student_code.mod.destroy_block = self.karel_action_decorator(\n self.karel.destroy_block\n )\n self.student_code.mod.remove_paint = self.karel_action_decorator(\n self.karel.remove_paint\n )","def register_request_hooks(app):\n\n @app.before_request\n def before_request():\n g.db = open_db()\n\n @app.teardown_request\n def after_request(exc):\n g.db.__exit__(type(exc), exc, None)","def exec_hooks(f):\n global hooks\n if f in hooks:\n for h in hooks[f]:\n h()","def before(self) -> None:\n pass","def setup_early(self):\n\n # create all helper/manager components first\n self.create_allcomponents()\n\n # set up config stuff\n self.setup_confighelper()\n\n # settings\n self.add_earlydefault_settings()\n self.add_settings_early()\n self.add_latesettings_aliases()\n\n # other stuff\n self.add_loggers()\n self.add_routes()\n self.add_navnodes()\n\n # site addons\n self.add_addons()\n\n # we add fallback loggers at END, after user-site added loggers\n self.add_fallback_loggers()\n\n # now update site state (log manager should catch this)\n self.set_statelabel(mconst.DEF_SITESTATE_INITIALIZE_END)","def run_after(self):\n\n for path in self.hooks.get('after', []):\n self.run_module(path)","def pytest_addhooks(pluginmanager):\n from . import newhooks\n\n pluginmanager.add_hookspecs(newhooks)","def _before_render_event(self, *args, **kwargs):\n for chart in self._charts:\n chart._render_event(*args, **kwargs)","def make_processing_functions(self):\n return"],"string":"[\n \"def _apply_hooks(\\n context: HookContext, hooks: HookDispatcher, strategy: st.SearchStrategy[Case], location: str\\n) -> st.SearchStrategy[Case]:\\n container = LOCATION_TO_CONTAINER[location]\\n for hook in hooks.get_all_by_name(f\\\"before_generate_{container}\\\"):\\n strategy = hook(context, strategy)\\n return strategy\",\n \"def process_before_request_hooks(self):\\n\\n hooks = []\\n\\n if self.resource:\\n hooks.extend(self.resource.api.before_all_hooks)\\n hooks.extend(self.resource.before_all_hooks)\\n\\n hooks.extend(self.before_all_hooks)\\n hooks.extend(\\n getattr(\\n self,\\n 'before_{method}_hooks'.format(method=self.meth),\\n []\\n )\\n )\\n\\n for hook in chain(hooks):\\n hook(self)\",\n \"def setup_hooks(self):\\n pass\",\n \"def setup(self, registers):\\n \\\"\\\"\\\" tasks before any generation functions are called \\\"\\\"\\\"\\n pass\",\n \"def _post_hooks(self):\",\n \"def before(self, location=None):\\n side_effect = SideEffect(self.f, location)\\n dataflow = inject_before(self.container, side_effect, location)\\n return self._construct(dataflow)\",\n \"def post_setup(self, context):\\n pass\",\n \"def run_before(self):\\n\\n for path in self.hooks.get('before', []):\\n self.run_module(path)\",\n \"def on_before_execution(self):\\n pass\",\n \"def before(hook_name, methods, kwargs):\\n for hookimpl in methods:\\n self._plugin2calls[hookimpl.plugin].add(hook_name)\",\n \"def pre_hook():\\n _logger.warning(\\\"PRE Gen hook executed\\\")\\n\\n try:\\n\\n # Default value = Volt\\n theme = \\\"{{cookiecutter.theme}}\\\"\\n repo = 'https://github.com/app-generator/flask-dashboard-volt.git'\\n\\n if 'material-dashboard' == theme:\\n repo = 'https://github.com/app-generator/flask-material-dashboard.git'\\n\\n if 'soft-ui' == theme:\\n repo = 'https://github.com/app-generator/flask-soft-ui-dashboard.git'\\n\\n if 'datta-able' == theme:\\n repo = 'https://github.com/app-generator/flask-datta-able.git'\\n\\n if 'star-admin' == theme:\\n repo = 'https://github.com/app-generator/flask-star-admin.git' \\n\\n print(' Cloning theme: <' + theme + '>, REPO: ' + repo )\\n\\n repo = git.Repo.clone_from( repo, TMP_DIR, branch='master')\\n print(' ...done')\\n \\n except OSError as e:\\n _logger.warning(f\\\"Error: {e}\\\")\\n sys.exit(0)\\n\\n # Exit with success\\n sys.exit(0)\",\n \"def setup_hooks(self) -> None:\\n install_hooks(self.record_interaction)\",\n \"def hook_server_before_exec(self, request_event):\\r\\n\\r\\n for functor in self._hooks['server_before_exec']:\\r\\n functor(request_event)\",\n \"def create_default_hooks(self):\\n\\n self.create_hooks(\\\"commands\\\")\\n self.create_hooks(\\\"commands_out\\\")\\n self.create_hooks(\\\"hooks\\\")\",\n \"def post_start_hook(self):\\n\\n LOG.debug(_('XManager post_start_hook...'))\\n\\n pass\",\n \"def pre_build_hook(self):\",\n \"def pre_start_hook(self):\\n\\n LOG.debug(_('XManager pre_start_hook...'))\\n\\n pass\",\n \"def on_setup(self, request, trigger_context):\\n raise NotImplementedError\",\n \"def prepare_locations(requests):\\n\\tlocation = StringIO.StringIO()\\n\\tlocation.write('# Do not modify - this file is maintained by nginx_updater.py\\\\n')\\n\\tfor service in requests:\\n\\t\\tlocation.write('\\\\nlocation {0} {{\\\\n'.format(service))\\n\\t\\tlocation.write('\\\\tproxy_pass http://{0}/;\\\\n'.format(upstream_name(service)))\\n\\t\\tlocation.write('\\\\tproxy_redirect off;\\\\n')\\n\\t\\tlocation.write('\\\\tproxy_next_upstream error timeout invalid_header http_500\\\\n')\\n\\t\\tlocation.write('\\\\tproxy_connect_timeout 1s;\\\\n')\\n\\t\\tlocation.write('}\\\\n')\\n\\t\\n\\treturn location\",\n \"def prepare_locations(requests):\\r\\n\\tlocation = StringIO.StringIO()\\r\\n\\tlocation.write('# Do not modify - this file is maintained by nginx_updater.py\\\\n')\\r\\n\\tfor service in requests:\\r\\n\\t\\tlocation.write('\\\\nlocation {0} {{\\\\n'.format(service))\\r\\n\\t\\tlocation.write('\\\\tproxy_pass http://{0}/;\\\\n'.format(upstream_name(service)))\\r\\n\\t\\tlocation.write('\\\\tproxy_redirect off;\\\\n')\\r\\n\\t\\tlocation.write('\\\\tproxy_next_upstream error timeout invalid_header http_500\\\\n')\\r\\n\\t\\tlocation.write('\\\\tproxy_connect_timeout 1s;\\\\n')\\r\\n\\t\\tlocation.write('}\\\\n')\\r\\n\\t\\r\\n\\treturn location\",\n \"def before(self, context):\\n raise NotImplementedError\",\n \"def before(self, before: Route.Decorator):\\n pass\",\n \"def post_hook(self):\\n self.mk_rg1()\\n self.mk_rg2()\\n self.mk_rg3()\",\n \"def create_hooks(self, action):\\n for folder in (\\n \\\"{0}_{1}\\\".format(time, action)\\n for time in [\\\"before\\\", \\\"after\\\"]\\n ):\\n test_filename = \\\"/tmp/{0}_{1}\\\".format(PREFIX, folder)\\n file_content = \\\"#!/bin/bash\\\\n\\\\ntouch {0}\\\\n\\\".format(\\n test_filename\\n )\\n hook_path = \\\"{0}/{1}/{2}\\\".format(\\n GA_HOOKS_FOLDER, folder, HOOK_NAME\\n )\\n testflow.step(\\n \\\"Create hook file %s with content: %s\\\",\\n hook_path, file_content\\n )\\n self.machine.fs.create_script(file_content, hook_path)\",\n \"def do_before(self):\\r\\n pass\",\n \"def process_after_request_hooks(self, resp):\\n\\n hooks = []\\n meth_hooks = getattr(\\n self,\\n 'after_{method}_hooks'.format(method=self.meth),\\n []\\n )\\n\\n hooks.extend(meth_hooks)\\n hooks.extend(self.after_all_hooks)\\n\\n if self.resource:\\n hooks.extend(self.resource.after_all_hooks)\\n hooks.extend(self.resource.api.after_all_hooks)\\n\\n for hook in chain(hooks):\\n resp = hook(self, resp)\\n\\n return resp\",\n \"def _instantiate_attributes_before_function(self, context=None):\\n self._instantiate_pathway(context=context)\\n # super(Process_Base, self)._instantiate_function(context=context)\",\n \"def set_asyncgen_hooks(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__\\n pass\",\n \"def _timestep_before_hook(self, *args, **kwargs):\\n pass\",\n \"def prep_logging_decorator(func):\\n filename = filename_regexp.match(inspect.getmodule(inspect.stack()[1][0]).__file__).group(1)\\n\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n logger.info('{}: Start preparation'.format(filename))\\n func(*args, **kwargs)\\n logger.info('{}: Finished preparation'.format(filename))\\n return wrapper\",\n \"def pre_process(self):\\n refs = self.collect_references()\\n for ref in refs:\\n self._add_reference(ref)\\n if (not cls_is_relocatable) and cls_is_referenced:\\n register_spritegroup(self)\",\n \"def _instantiate_attributes_before_function(self, context=None):\\n\\n super()._instantiate_attributes_before_function(context=context)\",\n \"def extension_hooks(self, global_step):\\n return []\",\n \"def extension_hooks(self, global_step):\\n return []\",\n \"def test_hookregistry_module_should_have_global_hook_decorators():\\n # given & when\\n from radish.hookregistry import before, after\\n\\n # then\\n assert callable(before.all)\\n assert callable(before.each_feature)\\n assert callable(before.each_rule)\\n assert callable(before.each_scenario)\\n assert callable(before.each_step)\\n assert callable(after.all)\\n assert callable(after.each_feature)\\n assert callable(after.each_rule)\\n assert callable(after.each_scenario)\\n assert callable(after.each_step)\",\n \"def post_build_hook(self):\",\n \"def before_request(self, f):\\n self.before_request_handlers.append(f)\\n return f\",\n \"def before_scenario(context, scenario):\\n context.resource_manager = contextlib.ExitStack()\",\n \"def callable_hooks(self):\\n for hook in self.custom_hooks:\\n options = rh.hooks.HookOptions(hook,\\n self.custom_hook(hook),\\n self.tool_paths)\\n yield (hook, functools.partial(rh.hooks.check_custom,\\n options=options))\\n\\n for hook in self.builtin_hooks:\\n options = rh.hooks.HookOptions(hook,\\n self.builtin_hook_option(hook),\\n self.tool_paths)\\n yield (hook, functools.partial(rh.hooks.BUILTIN_HOOKS[hook],\\n options=options))\",\n \"def hook_client_before_request(self, event):\\r\\n for functor in self._hooks['client_before_request']:\\r\\n functor(event)\",\n \"def register_before_first(app):\\n app.before_first_request_funcs.append(\\n partial(admin.utils.create_root_user, app))\\n app.before_first_request_funcs.append(\\n partial(admin.utils.load_messenger_config, app))\\n app.before_first_request_funcs.append(\\n partial(admin.utils.load_site_config, app))\",\n \"def dynamic_hook(self, hook):\\n assert callable(hook)\\n self._dynamic_hooks.append(hook)\\n try:\\n yield\\n finally:\\n self._dynamic_hooks.remove(hook)\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def before_request(self, func: typing.Callable):\\n return self.add_hook(type_=\\\"pre\\\", hook=func)\",\n \"def registerSetup(categories, stackoffset=0):\\n\\n\\tcategories = frozenset(to_stringlist(categories))\\n\\tdoctext = 'This handler is registered as setup for categories ``%s``.' % (list(categories),)\\n\\n\\tif BUILDING_DOCS:\\n\\t\\treturn lambda x: _addDoc(x, doctext)\\n\\n\\tdef deco(func):\\n\\t\\tcaller = inspect.stack()[1 + stackoffset][1]\\n\\n\\t\\tlis = SetupListener(func, categories)\\n\\t\\tlis.caller = caller\\n\\t\\tCONNECTOR.addListener(categories, lis)\\n\\n\\t\\t_addDoc(func, doctext)\\n\\n\\t\\treturn func\\n\\n\\treturn deco\",\n \"def __location_handler(self, update, context):\\n trigger = Constructor.LOCATION_TRIGGER\\n self.__handler(context, update, trigger)\",\n \"def locations_fixture(location):\\n return [location, _create_location()]\",\n \"def initialize_location_strategies(self):\\n locator_manager.register_locators(\\\"sf\\\", lex_locators)\\n locator_manager.register_locators(\\\"text\\\", \\\"Salesforce.Locate Element by Text\\\")\\n locator_manager.register_locators(\\\"title\\\", \\\"Salesforce.Locate Element by Title\\\")\\n\\n # This does the work of actually adding all of the above-registered\\n # location strategies, plus any that were registered by keyword\\n # libraries.\\n locator_manager.add_location_strategies()\",\n \"def setup_before_migration(self, apps):\",\n \"def refresh_entity_hooks(self):\\n for hook_name in HOOK_NAMES:\\n hooks = []\\n for entity in self._task.root_entity.iter_entities():\\n entity_hook = getattr(entity, hook_name)\\n # Ignore any hook that is a no-op to avoid function call overhead.\\n if not _callable_is_trivial(entity_hook):\\n hooks.append(entity_hook)\\n getattr(self, '_' + hook_name).entity_hooks = hooks\",\n \"def preRunSetup(self):\\n self.logDesc(\\\"Pre Run Setup\\\")\\n #Check for current logged in user\\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\\n #Creates Sample Template if not exists\\n self.createSampleTemplate(templateName=self.templateName)\",\n \"def on_start(self):\\n\\n def decorator(coro):\\n self._hooks.append((\\\"start\\\", coro))\\n return coro\\n\\n return decorator\",\n \"def context_processors(self):\\n return [\\n 'leonardo.module.web.processors.page.add_page_if_missing',\\n 'leonardo.module.web.processors.config.leonardo',\\n 'leonardo.module.web.processors.font.webfont_cookie',\\n ]\",\n \"def before_feature(context, feature):\\n context.pctl.create_and_set_output_directory(feature.name)\",\n \"def addResetHooks(self, before, after):\\n self._beforeResetHook = before\\n self._afterResetHook = after\",\n \"def on_hook(self) -> None:\",\n \"def pre_processor(self):\",\n \"def after_all(self) -> None:\",\n \"def pre_process(self):\\n pass\",\n \"def pre_process(self):\\n pass\",\n \"def pre_process(self):\\n pass\",\n \"def pre_process(self):\\n pass\",\n \"def pre_process(self):\\n pass\",\n \"def before_request(self, f):\\n self.before_request_funcs.append(f)\\n return f\",\n \"def after(self, location=None):\\n side_effect = SideEffect(self.f, location)\\n dataflow = inject_after(self.container, side_effect, location)\\n return self._construct(dataflow)\",\n \"def configure_before_request_funcs(app):\\n @app.before_request\\n def conf_set_user_cookie_id():\\n return set_user_cookie_id()\\n \\n @app.before_request\\n def check_for_maintenance():\\n if config.DOWN_FOR_MAINTENANCE:\\n return 'Sorry, we\\\\'re down momentarily for a teensey bit of maintenance!', 503\\n \\n @app.before_request\\n def count_uniques():\\n return\\n statsd.set('unique_users', g.user_cookie_id)\\n statsd.set('unique_ips', request.remote_addr)\\n \\n @app.before_request\\n def set_statsd_context():\\n g.statsd_context = \\\"%s.%s\\\" % (request.endpoint, request.method)\\n g.total_request_timer = statsd.timer(g.statsd_context + \\\".response_time\\\")\\n g.total_request_timer.start()\",\n \"def map_to_app_lifecycle_hooks(self, app):\\n app['lifecycle_hooks'] = {}\\n form_lifecycle_hooks = self.lifecycle_hooks\\n if form_lifecycle_hooks.pre_buildimage.data:\\n app['lifecycle_hooks']['pre_buildimage'] = b64encode_utf8(\\n form_lifecycle_hooks.pre_buildimage.data.replace('\\\\r\\\\n', '\\\\n'))\\n else:\\n app['lifecycle_hooks']['pre_buildimage'] = ''\\n\\n if form_lifecycle_hooks.post_buildimage.data:\\n app['lifecycle_hooks']['post_buildimage'] = b64encode_utf8(\\n form_lifecycle_hooks.post_buildimage.data.replace('\\\\r\\\\n', '\\\\n'))\\n else:\\n app['lifecycle_hooks']['post_buildimage'] = ''\\n\\n if form_lifecycle_hooks.pre_bootstrap.data:\\n app['lifecycle_hooks']['pre_bootstrap'] = b64encode_utf8(\\n form_lifecycle_hooks.pre_bootstrap.data.replace('\\\\r\\\\n', '\\\\n'))\\n else:\\n app['lifecycle_hooks']['pre_bootstrap'] = ''\\n\\n if form_lifecycle_hooks.post_bootstrap.data:\\n app['lifecycle_hooks']['post_bootstrap'] = b64encode_utf8(\\n form_lifecycle_hooks.post_bootstrap.data.replace('\\\\r\\\\n', '\\\\n'))\\n else:\\n app['lifecycle_hooks']['post_bootstrap'] = ''\",\n \"def define_log_pre_format_hooks(self):\\n return []\",\n \"def initialize(self):\\n logger.debug(\\\"Begin Generation\\\")\\n self.events.begin_generation()\",\n \"def test_add_processor_override(caplog):\\n\\n testapp = holocron.Application()\\n marker = None\\n\\n def processor_a(app, items):\\n nonlocal marker\\n marker = 42\\n yield from items\\n\\n def processor_b(app, items):\\n nonlocal marker\\n marker = 13\\n yield from items\\n\\n testapp.add_processor(\\\"processor\\\", processor_a)\\n testapp.add_processor(\\\"processor\\\", processor_b)\\n\\n for _ in testapp.invoke([{\\\"name\\\": \\\"processor\\\"}]):\\n pass\\n\\n assert marker == 13\\n\\n assert len(caplog.records) == 1\\n assert caplog.records[0].message == \\\"processor override: 'processor'\\\"\",\n \"def setup(self):\\n for gen in self._feature_stats_generators:\\n gen.setup()\",\n \"def register(self, api, prefix: str) -> None:\\n route = api.route(prefix + self._pattern, *self._args, **self._kwargs)(\\n self._view\\n )\\n\\n # Hooks registered via @before and/or @after on top of the @route\\n # decorator need to be manually registered with @api.before, @api.after.\\n def _register_hook(hook, hook_decorator):\\n nonlocal self, route\\n if self.hooks.get(hook) is None:\\n return\\n hook_function = self.hooks[hook]\\n route = hook_decorator(hook_function)(route)\\n\\n _register_hook(\\\"before\\\", api.before)\\n _register_hook(\\\"after\\\", api.after)\",\n \"def adjust_line_numbers(self, code):\\n store_lines = set()\\n make_function_lines = set()\\n for opcode in itertools.chain.from_iterable(_collect_bytecode(code)):\\n if opcode.name.startswith(\\\"STORE_\\\"):\\n store_lines.add(opcode.line)\\n elif opcode.name == \\\"MAKE_FUNCTION\\\":\\n make_function_lines.add(opcode.line)\\n\\n def adjust(line, allowed_lines, min_line=1):\\n adjusted_line = line\\n while adjusted_line not in allowed_lines and adjusted_line >= min_line:\\n adjusted_line -= 1\\n return adjusted_line if adjusted_line >= min_line else None\\n\\n # Process type comments.\\n for type_comment_set in self._type_comments:\\n for line, comment in sorted(type_comment_set.type_comments.items()):\\n adjusted_line = adjust(line, store_lines, type_comment_set.start_line)\\n if not adjusted_line:\\n # vm._FindIgnoredTypeComments will take care of error reporting.\\n continue\\n if line != type_comment_set.end_line:\\n self._errorlog.ignored_type_comment(self._filename, line, comment)\\n del type_comment_set.type_comments[line]\\n elif adjusted_line != line:\\n type_comment_set.type_comments[adjusted_line] = comment\\n del type_comment_set.type_comments[line]\\n\\n # Process decorators.\\n for line in sorted(self._decorators):\\n adjusted_line = adjust(line, make_function_lines)\\n if not adjusted_line:\\n log.error(\\n \\\"No MAKE_FUNCTION opcode found for decorator on line %d\\\", line)\\n elif adjusted_line != line:\\n self._decorators.add(adjusted_line)\\n self._decorators.remove(line)\\n\\n # Process variable annotations.\\n for line, annot in sorted(self._variable_annotations.items()):\\n adjusted_line = adjust(line, store_lines)\\n if not adjusted_line:\\n log.error(\\n \\\"No STORE_* opcode found for annotation %r on line %d\\\", annot, line)\\n del self._variable_annotations[line]\\n elif adjusted_line != line:\\n self._variable_annotations[adjusted_line] = annot\\n del self._variable_annotations[line]\",\n \"def _after_serve_actions(self):\\n pass\",\n \"def pre_build(self):\",\n \"def do_before_dump(self):\\n self.checksummer.prepare_checksums()\",\n \"def pre_customer_attachment_create(self, resource_dict):\\n pass\",\n \"def onRegister(setup_state):\\n\\tblueprint = setup_state.blueprint\\n\\t#if setup_state.options.get('auth') == True:\\n\\tif setup_state.url_prefix.startswith('/ext/'): #not really used right now\\n\\t\\t#inside here, 'route' works but not 'before_request'\\n\\t\\t#maybe use to register authentication-specific routes?\\n\\t\\tprint(\\\"Authenticated API on {}\\\".format(setup_state.url_prefix))\",\n \"def before_request():\\r\\n\\r\\n\\tinit_classes()\",\n \"def _hook(self):\",\n \"def test_add_processor_wrapper_override(caplog):\\n\\n testapp = holocron.Application()\\n marker = None\\n\\n def processor(app, items):\\n yield from items\\n\\n def processor_wrapper_a(app, items, processor):\\n nonlocal marker\\n marker = 42\\n yield from app.invoke([processor])\\n\\n def processor_wrapper_b(app, items, processor):\\n nonlocal marker\\n marker = 13\\n yield from app.invoke([processor])\\n\\n testapp.add_processor(\\\"processor\\\", processor)\\n testapp.add_processor_wrapper(\\\"wrapper\\\", processor_wrapper_a)\\n testapp.add_processor_wrapper(\\\"wrapper\\\", processor_wrapper_b)\\n\\n for _ in testapp.invoke([{\\\"name\\\": \\\"processor\\\", \\\"wrapper\\\": {}}]):\\n pass\\n\\n assert marker == 13\\n\\n assert len(caplog.records) == 1\\n assert caplog.records[0].message == \\\"processor override: 'wrapper'\\\"\",\n \"def pre_execute(self):\",\n \"def pytest_addhooks(pluginmanager):\\n pluginmanager.add_hookspecs(hooks)\",\n \"def _build(self, *args, **kwargs):\\n for directive in self.directives:\\n alias, ip, port, server_name, location = directive[\\\"signature\\\"].split(\\\":\\\")\\n\\n if location not in self.locations.keys():\\n handle_location = Location(**{\\n \\\"location\\\" : location,\\n }\\n )\\n self.locations = handle_location\\n self.locations[location].directives = directive\",\n \"def pre_build(self):\\n pass\",\n \"def post_process():\\n for route in os.listdir(GFR_ROUTES_LOCATION):\\n if os.path.isfile(MISSING_LOCATION + route):\\n # If the route is missing, output the reference data with correct OSM tags.\\n\\n copyfile(MISSING_LOCATION + route, OUTPUT_LOCATION + route)\\n add_property(OUTPUT_LOCATION + route, 'error_type', 'missing')\\n elif os.path.isfile(DIFF_MISSING_LOCATION + route) and os.path.isfile(DIFF_WRONG_LOCATION + route) \\\\\\n and merge_differences(route, DIFF_MISSING_LOCATION + route, DIFF_WRONG_LOCATION + route,\\n OUTPUT_LOCATION + route):\\n # If there's a geometrical difference, combine the two difference files and output it.\\n\\n add_property(OUTPUT_LOCATION + route, 'error_type', 'difference')\\n elif os.path.isfile(TAGS_LOCATION + route):\\n # When there's no geometrical difference, output the OSM data possibly containing missing tags.\\n\\n copyfile(TAGS_LOCATION + route, OUTPUT_LOCATION + route)\\n else:\\n raise Exception(\\\"No output file could be generated for route: \\\" + route)\\n\\n copy_to_site()\\n\\n # Export a last updated timestamp\\n with open('last_updated', 'w') as fp:\\n fp.write(str(int(time.time() * 1000)))\",\n \"def before_all(context):\\n set_services(context)\\n context.api = {}\\n context.repositories = {}\\n\\n for service, location in context.services.items():\\n url = urlparse.urlparse(location)\\n api = API(url.scheme + '://' + url.netloc, async=False)\\n try:\\n context.api[service] = getattr(api, url.path.split('/')[2])\\n except:\\n context.api[service] = getattr(api, service)\",\n \"def _pre_hook(\\n state_dict,\\n prefix,\\n local_metadata,\\n strict,\\n missing_keys,\\n unexpected_keys,\\n error_msgs,\\n):\\n k = prefix + \\\"pe\\\"\\n if k in state_dict:\\n state_dict.pop(k)\",\n \"def inject_decorator_namespace(self) -> None:\\n self.student_code.mod.turn_left = self.karel_action_decorator(\\n self.karel.turn_left\\n )\\n self.student_code.mod.move = self.karel_action_decorator(\\n self.karel.move\\n )\\n self.student_code.mod.put_beeper = self.beeper_action_decorator(\\n self.karel.put_beeper\\n )\\n self.student_code.mod.pick_beeper = self.beeper_action_decorator(\\n self.karel.pick_beeper\\n )\\n self.student_code.mod.paint_corner = self.corner_action_decorator(\\n self.karel.paint_corner\\n )\\n self.student_code.mod.put_block = self.block_action_decorator(\\n self.karel.put_block\\n )\\n self.student_code.mod.destroy_block = self.karel_action_decorator(\\n self.karel.destroy_block\\n )\\n self.student_code.mod.remove_paint = self.karel_action_decorator(\\n self.karel.remove_paint\\n )\",\n \"def register_request_hooks(app):\\n\\n @app.before_request\\n def before_request():\\n g.db = open_db()\\n\\n @app.teardown_request\\n def after_request(exc):\\n g.db.__exit__(type(exc), exc, None)\",\n \"def exec_hooks(f):\\n global hooks\\n if f in hooks:\\n for h in hooks[f]:\\n h()\",\n \"def before(self) -> None:\\n pass\",\n \"def setup_early(self):\\n\\n # create all helper/manager components first\\n self.create_allcomponents()\\n\\n # set up config stuff\\n self.setup_confighelper()\\n\\n # settings\\n self.add_earlydefault_settings()\\n self.add_settings_early()\\n self.add_latesettings_aliases()\\n\\n # other stuff\\n self.add_loggers()\\n self.add_routes()\\n self.add_navnodes()\\n\\n # site addons\\n self.add_addons()\\n\\n # we add fallback loggers at END, after user-site added loggers\\n self.add_fallback_loggers()\\n\\n # now update site state (log manager should catch this)\\n self.set_statelabel(mconst.DEF_SITESTATE_INITIALIZE_END)\",\n \"def run_after(self):\\n\\n for path in self.hooks.get('after', []):\\n self.run_module(path)\",\n \"def pytest_addhooks(pluginmanager):\\n from . import newhooks\\n\\n pluginmanager.add_hookspecs(newhooks)\",\n \"def _before_render_event(self, *args, **kwargs):\\n for chart in self._charts:\\n chart._render_event(*args, **kwargs)\",\n \"def make_processing_functions(self):\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66052645","0.54367757","0.5335337","0.5200875","0.514125","0.5092376","0.50201553","0.49951658","0.49630007","0.49584186","0.4955014","0.49404222","0.491867","0.4910777","0.48239407","0.4786473","0.4785765","0.47504947","0.47237763","0.47235417","0.47108424","0.46838936","0.46758425","0.46690124","0.463337","0.46139172","0.4598949","0.45947784","0.45926893","0.45878246","0.4579732","0.45775133","0.45597047","0.45597047","0.45401067","0.45398998","0.45351908","0.45324254","0.4524824","0.45221198","0.45087674","0.45069584","0.45041314","0.45041314","0.45041314","0.45041314","0.45017356","0.44844463","0.44763264","0.4472119","0.44705206","0.44588336","0.44399294","0.44285664","0.44131505","0.44115615","0.44047722","0.4404016","0.44029722","0.44001204","0.43901134","0.4389689","0.4389689","0.4389689","0.4389689","0.4389689","0.4387032","0.43705603","0.4355333","0.43546253","0.43528378","0.4339696","0.43241793","0.4317335","0.43160453","0.43083075","0.43071753","0.43050113","0.43020234","0.42940518","0.42931303","0.4292946","0.42867243","0.42856798","0.4280698","0.42771217","0.42753553","0.42634353","0.42609856","0.42605308","0.4257123","0.42530283","0.42430207","0.42404497","0.4223513","0.42232648","0.4220909","0.4219822","0.4218705","0.4217968"],"string":"[\n \"0.66052645\",\n \"0.54367757\",\n \"0.5335337\",\n \"0.5200875\",\n \"0.514125\",\n \"0.5092376\",\n \"0.50201553\",\n \"0.49951658\",\n \"0.49630007\",\n \"0.49584186\",\n \"0.4955014\",\n \"0.49404222\",\n \"0.491867\",\n \"0.4910777\",\n \"0.48239407\",\n \"0.4786473\",\n \"0.4785765\",\n \"0.47504947\",\n \"0.47237763\",\n \"0.47235417\",\n \"0.47108424\",\n \"0.46838936\",\n \"0.46758425\",\n \"0.46690124\",\n \"0.463337\",\n \"0.46139172\",\n \"0.4598949\",\n \"0.45947784\",\n \"0.45926893\",\n \"0.45878246\",\n \"0.4579732\",\n \"0.45775133\",\n \"0.45597047\",\n \"0.45597047\",\n \"0.45401067\",\n \"0.45398998\",\n \"0.45351908\",\n \"0.45324254\",\n \"0.4524824\",\n \"0.45221198\",\n \"0.45087674\",\n \"0.45069584\",\n \"0.45041314\",\n \"0.45041314\",\n \"0.45041314\",\n \"0.45041314\",\n \"0.45017356\",\n \"0.44844463\",\n \"0.44763264\",\n \"0.4472119\",\n \"0.44705206\",\n \"0.44588336\",\n \"0.44399294\",\n \"0.44285664\",\n \"0.44131505\",\n \"0.44115615\",\n \"0.44047722\",\n \"0.4404016\",\n \"0.44029722\",\n \"0.44001204\",\n \"0.43901134\",\n \"0.4389689\",\n \"0.4389689\",\n \"0.4389689\",\n \"0.4389689\",\n \"0.4389689\",\n \"0.4387032\",\n \"0.43705603\",\n \"0.4355333\",\n \"0.43546253\",\n \"0.43528378\",\n \"0.4339696\",\n \"0.43241793\",\n \"0.4317335\",\n \"0.43160453\",\n \"0.43083075\",\n \"0.43071753\",\n \"0.43050113\",\n \"0.43020234\",\n \"0.42940518\",\n \"0.42931303\",\n \"0.4292946\",\n \"0.42867243\",\n \"0.42856798\",\n \"0.4280698\",\n \"0.42771217\",\n \"0.42753553\",\n \"0.42634353\",\n \"0.42609856\",\n \"0.42605308\",\n \"0.4257123\",\n \"0.42530283\",\n \"0.42430207\",\n \"0.42404497\",\n \"0.4223513\",\n \"0.42232648\",\n \"0.4220909\",\n \"0.4219822\",\n \"0.4218705\",\n \"0.4217968\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.42714888"},"document_rank":{"kind":"string","value":"87"}}},{"rowIdx":77690,"cells":{"query":{"kind":"string","value":"Apply all `before_generate_` hooks related to the given location & dispatcher."},"document":{"kind":"string","value":"def _apply_hooks(\n context: HookContext, hooks: HookDispatcher, strategy: st.SearchStrategy[Case], location: str\n) -> st.SearchStrategy[Case]:\n container = LOCATION_TO_CONTAINER[location]\n for hook in hooks.get_all_by_name(f\"before_generate_{container}\"):\n strategy = hook(context, strategy)\n return strategy"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def setup_hooks(self):\n pass","def process_before_request_hooks(self):\n\n hooks = []\n\n if self.resource:\n hooks.extend(self.resource.api.before_all_hooks)\n hooks.extend(self.resource.before_all_hooks)\n\n hooks.extend(self.before_all_hooks)\n hooks.extend(\n getattr(\n self,\n 'before_{method}_hooks'.format(method=self.meth),\n []\n )\n )\n\n for hook in chain(hooks):\n hook(self)","def before(hook_name, methods, kwargs):\n for hookimpl in methods:\n self._plugin2calls[hookimpl.plugin].add(hook_name)","def _post_hooks(self):","def setup_hooks(self) -> None:\n install_hooks(self.record_interaction)","def registerSetup(categories, stackoffset=0):\n\n\tcategories = frozenset(to_stringlist(categories))\n\tdoctext = 'This handler is registered as setup for categories ``%s``.' % (list(categories),)\n\n\tif BUILDING_DOCS:\n\t\treturn lambda x: _addDoc(x, doctext)\n\n\tdef deco(func):\n\t\tcaller = inspect.stack()[1 + stackoffset][1]\n\n\t\tlis = SetupListener(func, categories)\n\t\tlis.caller = caller\n\t\tCONNECTOR.addListener(categories, lis)\n\n\t\t_addDoc(func, doctext)\n\n\t\treturn func\n\n\treturn deco","def setup(self, registers):\n \"\"\" tasks before any generation functions are called \"\"\"\n pass","def set_asyncgen_hooks(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__\n pass","def create_default_hooks(self):\n\n self.create_hooks(\"commands\")\n self.create_hooks(\"commands_out\")\n self.create_hooks(\"hooks\")","def process_after_request_hooks(self, resp):\n\n hooks = []\n meth_hooks = getattr(\n self,\n 'after_{method}_hooks'.format(method=self.meth),\n []\n )\n\n hooks.extend(meth_hooks)\n hooks.extend(self.after_all_hooks)\n\n if self.resource:\n hooks.extend(self.resource.after_all_hooks)\n hooks.extend(self.resource.api.after_all_hooks)\n\n for hook in chain(hooks):\n resp = hook(self, resp)\n\n return resp","def run_before(self):\n\n for path in self.hooks.get('before', []):\n self.run_module(path)","def test_hookregistry_module_should_have_global_hook_decorators():\n # given & when\n from radish.hookregistry import before, after\n\n # then\n assert callable(before.all)\n assert callable(before.each_feature)\n assert callable(before.each_rule)\n assert callable(before.each_scenario)\n assert callable(before.each_step)\n assert callable(after.all)\n assert callable(after.each_feature)\n assert callable(after.each_rule)\n assert callable(after.each_scenario)\n assert callable(after.each_step)","def hook_server_before_exec(self, request_event):\r\n\r\n for functor in self._hooks['server_before_exec']:\r\n functor(request_event)","def _pre_dispatch(self, request, *args, **kwargs):\n pass","def includeme(config):\n config.add_subscriber(add_renderer_globals, BeforeRender)\n config.add_subscriber(add_localizer, NewRequest)\n config.add_subscriber(add_csrf_validation, NewRequest)\n config.add_subscriber(add_resources, NewRequest)","def callable_hooks(self):\n for hook in self.custom_hooks:\n options = rh.hooks.HookOptions(hook,\n self.custom_hook(hook),\n self.tool_paths)\n yield (hook, functools.partial(rh.hooks.check_custom,\n options=options))\n\n for hook in self.builtin_hooks:\n options = rh.hooks.HookOptions(hook,\n self.builtin_hook_option(hook),\n self.tool_paths)\n yield (hook, functools.partial(rh.hooks.BUILTIN_HOOKS[hook],\n options=options))","def pre_start_hook(self):\n\n LOG.debug(_('XManager pre_start_hook...'))\n\n pass","def post_setup(self, context):\n pass","def post_start_hook(self):\n\n LOG.debug(_('XManager post_start_hook...'))\n\n pass","def add_renderer_globals(event):\n def fake_url(controller=None, action=None, **kwargs):\n if action == \"css\":\n return \"/css\"\n if action and controller:\n path = {}\n for key in 'name', 'pocket', 'subpath':\n if key in kwargs:\n path[key] = kwargs.pop(key)\n path['_query'] = dict((k,v) for k,v in kwargs.items() if v is not None)\n return request.route_path(controller+\"/\"+action, **path)\n if controller and controller.startswith(\"/\"):\n return controller\n return \"/unknown\"\n\n def fake_url_current(**kwargs):\n path = {}\n # XXX request.matchdict?\n if 'name' in kwargs:\n path['name'] = kwargs.pop('name')\n if 'action' in kwargs:\n path['_route_name'] = 'dex/'+kwargs.pop('action')\n path['_query'] = dict((k,v) for k,v in kwargs.items() if v is not None)\n return request.current_route_path(**path)\n\n def fake_translate(message, plural=None, n=None, context=None, comment=None):\n return unicode(message)\n\n renderer_globals = event\n request = event.get(\"request\") #or threadlocal.get_current_request()\n if not request:\n return\n config = request.registry.settings\n renderer_globals[\"config\"] = config\n renderer_globals[\"h\"] = splinehelpers\n renderer_globals[\"r\"] = request\n renderer_globals[\"c\"] = request.tmpl_context\n #renderer_globals[\"url\"] = request.url_generator\n renderer_globals[\"url\"] = fake_url\n fake_url.current = fake_url_current\n renderer_globals[\"_\"] = fake_translate\n renderer_globals[\"flash\"] = lib.Flash(request.session)\n\n request.tmpl_context.links = config['spline.plugins.links']\n\n # start timer\n request.tmpl_context.timer = lib.ResponseTimer()","def inject_decorator_namespace(self) -> None:\n self.student_code.mod.turn_left = self.karel_action_decorator(\n self.karel.turn_left\n )\n self.student_code.mod.move = self.karel_action_decorator(\n self.karel.move\n )\n self.student_code.mod.put_beeper = self.beeper_action_decorator(\n self.karel.put_beeper\n )\n self.student_code.mod.pick_beeper = self.beeper_action_decorator(\n self.karel.pick_beeper\n )\n self.student_code.mod.paint_corner = self.corner_action_decorator(\n self.karel.paint_corner\n )\n self.student_code.mod.put_block = self.block_action_decorator(\n self.karel.put_block\n )\n self.student_code.mod.destroy_block = self.karel_action_decorator(\n self.karel.destroy_block\n )\n self.student_code.mod.remove_paint = self.karel_action_decorator(\n self.karel.remove_paint\n )","def hook_client_before_request(self, event):\r\n for functor in self._hooks['client_before_request']:\r\n functor(event)","def test_add_processor_wrapper_override(caplog):\n\n testapp = holocron.Application()\n marker = None\n\n def processor(app, items):\n yield from items\n\n def processor_wrapper_a(app, items, processor):\n nonlocal marker\n marker = 42\n yield from app.invoke([processor])\n\n def processor_wrapper_b(app, items, processor):\n nonlocal marker\n marker = 13\n yield from app.invoke([processor])\n\n testapp.add_processor(\"processor\", processor)\n testapp.add_processor_wrapper(\"wrapper\", processor_wrapper_a)\n testapp.add_processor_wrapper(\"wrapper\", processor_wrapper_b)\n\n for _ in testapp.invoke([{\"name\": \"processor\", \"wrapper\": {}}]):\n pass\n\n assert marker == 13\n\n assert len(caplog.records) == 1\n assert caplog.records[0].message == \"processor override: 'wrapper'\"","def on_before_execution(self):\n pass","def before(self, location=None):\n side_effect = SideEffect(self.f, location)\n dataflow = inject_before(self.container, side_effect, location)\n return self._construct(dataflow)","def pre_build_hook(self):","def before_request(self, f):\n self.before_request_handlers.append(f)\n return f","def configure_before_request_funcs(app):\n @app.before_request\n def conf_set_user_cookie_id():\n return set_user_cookie_id()\n \n @app.before_request\n def check_for_maintenance():\n if config.DOWN_FOR_MAINTENANCE:\n return 'Sorry, we\\'re down momentarily for a teensey bit of maintenance!', 503\n \n @app.before_request\n def count_uniques():\n return\n statsd.set('unique_users', g.user_cookie_id)\n statsd.set('unique_ips', request.remote_addr)\n \n @app.before_request\n def set_statsd_context():\n g.statsd_context = \"%s.%s\" % (request.endpoint, request.method)\n g.total_request_timer = statsd.timer(g.statsd_context + \".response_time\")\n g.total_request_timer.start()","def map_to_app_lifecycle_hooks(self, app):\n app['lifecycle_hooks'] = {}\n form_lifecycle_hooks = self.lifecycle_hooks\n if form_lifecycle_hooks.pre_buildimage.data:\n app['lifecycle_hooks']['pre_buildimage'] = b64encode_utf8(\n form_lifecycle_hooks.pre_buildimage.data.replace('\\r\\n', '\\n'))\n else:\n app['lifecycle_hooks']['pre_buildimage'] = ''\n\n if form_lifecycle_hooks.post_buildimage.data:\n app['lifecycle_hooks']['post_buildimage'] = b64encode_utf8(\n form_lifecycle_hooks.post_buildimage.data.replace('\\r\\n', '\\n'))\n else:\n app['lifecycle_hooks']['post_buildimage'] = ''\n\n if form_lifecycle_hooks.pre_bootstrap.data:\n app['lifecycle_hooks']['pre_bootstrap'] = b64encode_utf8(\n form_lifecycle_hooks.pre_bootstrap.data.replace('\\r\\n', '\\n'))\n else:\n app['lifecycle_hooks']['pre_bootstrap'] = ''\n\n if form_lifecycle_hooks.post_bootstrap.data:\n app['lifecycle_hooks']['post_bootstrap'] = b64encode_utf8(\n form_lifecycle_hooks.post_bootstrap.data.replace('\\r\\n', '\\n'))\n else:\n app['lifecycle_hooks']['post_bootstrap'] = ''","def before(self, context):\n raise NotImplementedError","def register(self, api, prefix: str) -> None:\n route = api.route(prefix + self._pattern, *self._args, **self._kwargs)(\n self._view\n )\n\n # Hooks registered via @before and/or @after on top of the @route\n # decorator need to be manually registered with @api.before, @api.after.\n def _register_hook(hook, hook_decorator):\n nonlocal self, route\n if self.hooks.get(hook) is None:\n return\n hook_function = self.hooks[hook]\n route = hook_decorator(hook_function)(route)\n\n _register_hook(\"before\", api.before)\n _register_hook(\"after\", api.after)","def pre_processor(self):","def register_pre_exec_callback(action_logger):\n logging.debug(\"Adding %s to pre execution callback\", action_logger)\n __pre_exec_callbacks.append(action_logger)","def register_before_first(app):\n app.before_first_request_funcs.append(\n partial(admin.utils.create_root_user, app))\n app.before_first_request_funcs.append(\n partial(admin.utils.load_messenger_config, app))\n app.before_first_request_funcs.append(\n partial(admin.utils.load_site_config, app))","def _hook(self):","def _register_handlers(self):\n DBG(\"\\nregister handlers\")\n for hook, handler in self.handlers:\n g.registerHandler(hook, handler)\n\n signal_manager.connect(self.c, 'body_changed', self._after_body_key)","def context_processors(self):\n return [\n 'leonardo.module.web.processors.page.add_page_if_missing',\n 'leonardo.module.web.processors.config.leonardo',\n 'leonardo.module.web.processors.font.webfont_cookie',\n ]","def post_preprocessing_action(actions):\n act_id = actions[1]\n target = actions[0]\n target_point = [\n int(target % SIZE),\n int(target // SIZE)\n ] # (x, y)\n\n act_args = []\n for arg in Actions.FUNCTIONS[act_id].args:\n if arg.name in ('screen', 'minimap', 'screen2'):\n act_args.append(target_point)\n else:\n act_args.append([0])\n return Actions.FunctionCall(act_id, act_args)","def exec_hooks(f):\n global hooks\n if f in hooks:\n for h in hooks[f]:\n h()","def get_asyncgen_hooks(): # real signature unknown; restored from __doc__\n pass","def addResetHooks(self, before, after):\n self._beforeResetHook = before\n self._afterResetHook = after","def extension_hooks(self, global_step):\n return []","def extension_hooks(self, global_step):\n return []","def post_processor(self):","def _apply_post_render_hooks(self, data, obj, fmt):\n hooks = self.post_render_hooks.get(fmt,[])\n for hook in hooks:\n try:\n data = hook(data, obj)\n except Exception as e:\n self.param.warning(f\"The post_render_hook {hook!r} could not \"\n f\"be applied:\\n\\n {e}\")\n return data","def before(self, before: Route.Decorator):\n pass","def dispatcher(self):\n pass # pragma: no cover","def before_all(context):\n set_services(context)\n context.api = {}\n context.repositories = {}\n\n for service, location in context.services.items():\n url = urlparse.urlparse(location)\n api = API(url.scheme + '://' + url.netloc, async=False)\n try:\n context.api[service] = getattr(api, url.path.split('/')[2])\n except:\n context.api[service] = getattr(api, service)","def on_setup(self, request, trigger_context):\n raise NotImplementedError","def register_request_hooks(app):\n\n @app.before_request\n def before_request():\n g.db = open_db()\n\n @app.teardown_request\n def after_request(exc):\n g.db.__exit__(type(exc), exc, None)","def context_processor(self, f):\n self.template_context_processors.append(f)\n return f","def pre_hook():\n _logger.warning(\"PRE Gen hook executed\")\n\n try:\n\n # Default value = Volt\n theme = \"{{cookiecutter.theme}}\"\n repo = 'https://github.com/app-generator/flask-dashboard-volt.git'\n\n if 'material-dashboard' == theme:\n repo = 'https://github.com/app-generator/flask-material-dashboard.git'\n\n if 'soft-ui' == theme:\n repo = 'https://github.com/app-generator/flask-soft-ui-dashboard.git'\n\n if 'datta-able' == theme:\n repo = 'https://github.com/app-generator/flask-datta-able.git'\n\n if 'star-admin' == theme:\n repo = 'https://github.com/app-generator/flask-star-admin.git' \n\n print(' Cloning theme: <' + theme + '>, REPO: ' + repo )\n\n repo = git.Repo.clone_from( repo, TMP_DIR, branch='master')\n print(' ...done')\n \n except OSError as e:\n _logger.warning(f\"Error: {e}\")\n sys.exit(0)\n\n # Exit with success\n sys.exit(0)","def prepare(self):\n self.uri = self.request.uri\n self.path = self.request.uri.split('?')[0]\n self.method = self.path.split('/')[-1]\n self.default_methods = {}\n #\n # You can use the before_handler in a local controller to\n # process your own prepare stuff.\n # a common use case is to call: self.print_debug_info().\n # which then applies only to this specific handler.\n # \n before_handler = getattr(self, \"before_handler\", None)\n print(\"calling before_handler for \" + str(self.__class__))\n if callable(before_handler):\n before_handler()","def test_add_processor_override(caplog):\n\n testapp = holocron.Application()\n marker = None\n\n def processor_a(app, items):\n nonlocal marker\n marker = 42\n yield from items\n\n def processor_b(app, items):\n nonlocal marker\n marker = 13\n yield from items\n\n testapp.add_processor(\"processor\", processor_a)\n testapp.add_processor(\"processor\", processor_b)\n\n for _ in testapp.invoke([{\"name\": \"processor\"}]):\n pass\n\n assert marker == 13\n\n assert len(caplog.records) == 1\n assert caplog.records[0].message == \"processor override: 'processor'\"","def before_request():\r\n\r\n\tinit_classes()","def before_request(self, func: typing.Callable):\n return self.add_hook(type_=\"pre\", hook=func)","def available_hooks(self):\n return [RoutesDevHandlerHook]","def make_processing_functions(self):\n return","def collect_handlers(log, base_url, validation):\n base_bookstore_pattern = url_path_join(base_url, '/bookstore')\n base_bookstore_api_pattern = url_path_join(base_url, '/api/bookstore')\n\n handlers = []\n # Always enable the version handler for the API\n handlers.append((base_bookstore_api_pattern, BookstoreVersionHandler))\n\n if validation['publish_valid']:\n log.info(f\"[bookstore] Enabling bookstore publishing, version: {version}\")\n handlers.append(\n (\n url_path_join(base_bookstore_api_pattern, r\"/publish%s\" % path_regex),\n BookstorePublishAPIHandler,\n )\n )\n else:\n log.info(\"[bookstore] Publishing disabled. s3_bucket or endpoint are not configured.\")\n\n if validation['s3_clone_valid']:\n log.info(f\"[bookstore] Enabling bookstore cloning, version: {version}\")\n handlers.append(\n (url_path_join(base_bookstore_api_pattern, r\"/clone(?:/?)*\"), BookstoreCloneAPIHandler)\n ),\n handlers.append(\n (url_path_join(base_bookstore_pattern, r\"/clone(?:/?)*\"), BookstoreCloneHandler)\n )\n else:\n log.info(f\"[bookstore] bookstore cloning disabled, version: {version}\")\n\n if validation['fs_clone_valid']:\n log.info(f\"[bookstore] Enabling filesystem cloning, version: {version}\")\n handlers.append(\n (url_path_join(base_bookstore_pattern, r\"/fs-clone(?:/?)*\"), BookstoreFSCloneHandler)\n )\n handlers.append(\n (\n url_path_join(base_bookstore_api_pattern, r\"/fs-clone(?:/?)*\"),\n BookstoreFSCloneAPIHandler,\n )\n ),\n else:\n log.info(f\"[bookstore] bookstore cloning disabled, version: {version}\")\n return handlers","def pre_process(self):\n refs = self.collect_references()\n for ref in refs:\n self._add_reference(ref)\n if (not cls_is_relocatable) and cls_is_referenced:\n register_spritegroup(self)","def apply_hooks(\n endpoint: Endpoint,\n context: HookContext,\n hooks: Optional[HookDispatcher],\n strategy: st.SearchStrategy[Case],\n location: str,\n) -> st.SearchStrategy[Case]:\n strategy = _apply_hooks(context, GLOBAL_HOOK_DISPATCHER, strategy, location)\n strategy = _apply_hooks(context, endpoint.schema.hooks, strategy, location)\n if hooks is not None:\n strategy = _apply_hooks(context, hooks, strategy, location)\n return strategy","def available_hooks(self):\n return [HtmlMinPostRenderHook]","def post_build_hook(self):","def on_hook(self) -> None:","def makeHandlers(self):\n\n yield self.loadGrids.start(funcSelf=self)\n yield self.updateClientWatchedGrids.start(funcSelf=self)\n logger.debug(\"RPCs started\")","def prepare_locations(requests):\n\tlocation = StringIO.StringIO()\n\tlocation.write('# Do not modify - this file is maintained by nginx_updater.py\\n')\n\tfor service in requests:\n\t\tlocation.write('\\nlocation {0} {{\\n'.format(service))\n\t\tlocation.write('\\tproxy_pass http://{0}/;\\n'.format(upstream_name(service)))\n\t\tlocation.write('\\tproxy_redirect off;\\n')\n\t\tlocation.write('\\tproxy_next_upstream error timeout invalid_header http_500\\n')\n\t\tlocation.write('\\tproxy_connect_timeout 1s;\\n')\n\t\tlocation.write('}\\n')\n\t\n\treturn location","def before_request(self, f):\n self.before_request_funcs.append(f)\n return f","def refresh_entity_hooks(self):\n for hook_name in HOOK_NAMES:\n hooks = []\n for entity in self._task.root_entity.iter_entities():\n entity_hook = getattr(entity, hook_name)\n # Ignore any hook that is a no-op to avoid function call overhead.\n if not _callable_is_trivial(entity_hook):\n hooks.append(entity_hook)\n getattr(self, '_' + hook_name).entity_hooks = hooks","def _timestep_before_hook(self, *args, **kwargs):\n pass","def do_before(self):\r\n pass","def prepare_locations(requests):\r\n\tlocation = StringIO.StringIO()\r\n\tlocation.write('# Do not modify - this file is maintained by nginx_updater.py\\n')\r\n\tfor service in requests:\r\n\t\tlocation.write('\\nlocation {0} {{\\n'.format(service))\r\n\t\tlocation.write('\\tproxy_pass http://{0}/;\\n'.format(upstream_name(service)))\r\n\t\tlocation.write('\\tproxy_redirect off;\\n')\r\n\t\tlocation.write('\\tproxy_next_upstream error timeout invalid_header http_500\\n')\r\n\t\tlocation.write('\\tproxy_connect_timeout 1s;\\n')\r\n\t\tlocation.write('}\\n')\r\n\t\r\n\treturn location","def define_log_pre_format_hooks(self):\n return []","def _after_serve_actions(self):\n pass","def post_hook(self):\n self.mk_rg1()\n self.mk_rg2()\n self.mk_rg3()","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def dynamic_hook(self, hook):\n assert callable(hook)\n self._dynamic_hooks.append(hook)\n try:\n yield\n finally:\n self._dynamic_hooks.remove(hook)","def test_render_all_templates():\n assert templates.xhook__initialize({})\n assert templates.xhook__handlers({})\n assert templates.xhook__enable()\n assert templates.xhook__release()\n assert templates.asserts__call_count({})\n assert templates.asserts__calls({})","def dispatcher(handlers):\n\n # Transforms wsgi_env, start_response args into request\n @wrappers.Request.application\n def dispatch(request):\n \"\"\"Handle one request.\"\"\"\n for url_re, app in handlers:\n matcher = re.match(url_re, request.path)\n if matcher and matcher.end() == len(request.path):\n if app is not None:\n # Send a response via the app specified in the handler.\n return app\n else:\n # The import must have failed. This will have been logged\n # at import time. Send a 500 error response.\n return response_for_error(httplib.INTERNAL_SERVER_ERROR)\n logging.error('No handler found for %s', request.path)\n return response_for_error(httplib.NOT_FOUND)\n\n return dispatch","def mount(self, subapp, url_prefix=''):\n for methods, pattern, handler in subapp.url_map:\n self.url_map.append(\n (methods, URLPattern(url_prefix + pattern.url_pattern),\n handler))\n for handler in subapp.before_request_handlers:\n self.before_request_handlers.append(handler)\n for handler in subapp.after_request_handlers:\n self.after_request_handlers.append(handler)\n for handler in subapp.after_error_request_handlers:\n self.after_error_request_handlers.append(handler)\n for status_code, handler in subapp.error_handlers.items():\n self.error_handlers[status_code] = handler","def register_main_hook(callback):\n main_hooks.append(callback)","def setup(logger):\n # It's important to use the same context in the callback _dispatcher\n # as the main thread, otherwise not-so-savvy users will be very\n # confused\n global _dispatcher\n\n if _dispatcher is not None:\n logger.debug(\"ophyd already setup\")\n return\n\n pyepics_compat._get_pv = pyepics_compat.get_pv\n pyepics_compat.get_pv = get_pv\n\n def _cleanup():\n \"\"\"Clean up the ophyd session\"\"\"\n global _dispatcher\n if _dispatcher is None:\n return\n\n pyepics_compat.get_pv = pyepics_compat._get_pv\n\n if _dispatcher.is_alive():\n _dispatcher.stop()\n\n _dispatcher = None\n\n logger.debug(\"Installing event dispatcher\")\n context = PV._default_context.broadcaster\n _dispatcher = EventDispatcher(\n thread_class=CaprotoCallbackThread, context=context, logger=logger\n )\n atexit.register(_cleanup)\n return _dispatcher","def before_map(self, map):\n map.connect('/about/terms-and-conditions',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='toc')\n map.connect('/about/accessibility',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='accessibility')\n map.connect('/about/code-of-conduct',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='coc')\n map.connect('/about/moderation-policy',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='moderation')\n map.connect('/about/faq',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='faq')\n map.connect('/about/privacy',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='privacy')\n map.connect('/about/contact-us',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='contact')\n map.connect('/about/suggest-a-dataset',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='suggest_a_dataset')\n map.connect('/atlas-for-africa',\n controller='ckanext.syngenta.controller:CustomPageController',\n action='atlas')\n return map","def dispatch(self, context, consumed, handler, is_endpoint):\n\t\t\n\t\trequest = context.request\n\t\t\n\t\tif __debug__:\n\t\t\tlog.debug(\"Handling dispatch event.\", extra=dict(\n\t\t\t\t\trequest = id(context),\n\t\t\t\t\tconsumed = consumed,\n\t\t\t\t\thandler = safe_name(handler),\n\t\t\t\t\tendpoint = is_endpoint\n\t\t\t\t))\n\t\t\n\t\t# The leading path element (leading slash) requires special treatment.\n\t\tif not consumed and context.request.path_info_peek() == '':\n\t\t\tconsumed = ['']\n\t\t\n\t\tnConsumed = 0\n\t\tif consumed:\n\t\t\t# Migrate path elements consumed from the `PATH_INFO` to `SCRIPT_NAME` WSGI environment variables.\n\t\t\tif not isinstance(consumed, (list, tuple)):\n\t\t\t\tconsumed = consumed.split('/')\n\t\t\t\n\t\t\tfor element in consumed:\n\t\t\t\tif element == context.request.path_info_peek():\n\t\t\t\t\tcontext.request.path_info_pop()\n\t\t\t\t\tnConsumed += 1\n\t\t\t\telse:\n\t\t\t\t\tbreak\n\t\t\n\t\t# Update the breadcrumb list.\n\t\tcontext.path.append(Crumb(handler, Path(request.script_name)))\n\t\t\n\t\tif consumed: # Lastly, update the remaining path element list.\n\t\t\trequest.remainder = request.remainder[nConsumed:]","def map_from_app_lifecycle_hooks(self, app):\n return self.lifecycle_hooks.form.map_from_app(app)","def onRegister(setup_state):\n\tblueprint = setup_state.blueprint\n\t#if setup_state.options.get('auth') == True:\n\tif setup_state.url_prefix.startswith('/ext/'): #not really used right now\n\t\t#inside here, 'route' works but not 'before_request'\n\t\t#maybe use to register authentication-specific routes?\n\t\tprint(\"Authenticated API on {}\".format(setup_state.url_prefix))","def create_hooks(self, hclass):\n for extension in self.db.values():\n self.events.register_callbacks_from_inst(hclass, extension)","def initialize_location_strategies(self):\n locator_manager.register_locators(\"sf\", lex_locators)\n locator_manager.register_locators(\"text\", \"Salesforce.Locate Element by Text\")\n locator_manager.register_locators(\"title\", \"Salesforce.Locate Element by Title\")\n\n # This does the work of actually adding all of the above-registered\n # location strategies, plus any that were registered by keyword\n # libraries.\n locator_manager.add_location_strategies()","def hookregistry():\n registry = HookRegistry()\n yield registry","def define_log_pre_format_hooks(self):\n hooks = super(Server, self).define_log_pre_format_hooks()\n # NOTE enabling logs only on debug mode\n if self.args.func == self.run and self.args.debug:\n hooks.append(self._send_log_to_ws)\n\n return hooks","def on_pre_execution(**kwargs):\n logging.debug(\"Calling callbacks: %s\", __pre_exec_callbacks)\n for callback in __pre_exec_callbacks:\n try:\n callback(**kwargs)\n except Exception:\n logging.exception(\"Failed on pre-execution callback using %s\", callback)","def set_functions(self, scenario, bodies):\n\n return","def DebugMenuProviderMixin_on_setup(self):\n pass","def prep_logging_decorator(func):\n filename = filename_regexp.match(inspect.getmodule(inspect.stack()[1][0]).__file__).group(1)\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n logger.info('{}: Start preparation'.format(filename))\n func(*args, **kwargs)\n logger.info('{}: Finished preparation'.format(filename))\n return wrapper","def _pre_call_handlers(self) -> tuple:\n return self._handlers[0]","def __init__(self):\n super().__init__()\n TemplateEngineFactory.register_factory('Jinja2Engine', Jinja2Engine.Factory)\n\n step1 = PrepareAppConfTransfiguration()\n step2 = ConfReaderToContextTransfiguration()\n step3 = ValidateCollectionTags()\n step4 = AttributeChainedTransfiguration('mbean')\n step5 = AttributeChainedTransfiguration('connection')\n\n self.add(step1)\n self.add(step2)\n self.add(step3)\n self.add(step4)\n self.add(step5)","def before_request():\n pass","def declare_hook(self, fct_name, fct):\r\n self._hooks_fct[fct_name] = fct"],"string":"[\n \"def setup_hooks(self):\\n pass\",\n \"def process_before_request_hooks(self):\\n\\n hooks = []\\n\\n if self.resource:\\n hooks.extend(self.resource.api.before_all_hooks)\\n hooks.extend(self.resource.before_all_hooks)\\n\\n hooks.extend(self.before_all_hooks)\\n hooks.extend(\\n getattr(\\n self,\\n 'before_{method}_hooks'.format(method=self.meth),\\n []\\n )\\n )\\n\\n for hook in chain(hooks):\\n hook(self)\",\n \"def before(hook_name, methods, kwargs):\\n for hookimpl in methods:\\n self._plugin2calls[hookimpl.plugin].add(hook_name)\",\n \"def _post_hooks(self):\",\n \"def setup_hooks(self) -> None:\\n install_hooks(self.record_interaction)\",\n \"def registerSetup(categories, stackoffset=0):\\n\\n\\tcategories = frozenset(to_stringlist(categories))\\n\\tdoctext = 'This handler is registered as setup for categories ``%s``.' % (list(categories),)\\n\\n\\tif BUILDING_DOCS:\\n\\t\\treturn lambda x: _addDoc(x, doctext)\\n\\n\\tdef deco(func):\\n\\t\\tcaller = inspect.stack()[1 + stackoffset][1]\\n\\n\\t\\tlis = SetupListener(func, categories)\\n\\t\\tlis.caller = caller\\n\\t\\tCONNECTOR.addListener(categories, lis)\\n\\n\\t\\t_addDoc(func, doctext)\\n\\n\\t\\treturn func\\n\\n\\treturn deco\",\n \"def setup(self, registers):\\n \\\"\\\"\\\" tasks before any generation functions are called \\\"\\\"\\\"\\n pass\",\n \"def set_asyncgen_hooks(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__\\n pass\",\n \"def create_default_hooks(self):\\n\\n self.create_hooks(\\\"commands\\\")\\n self.create_hooks(\\\"commands_out\\\")\\n self.create_hooks(\\\"hooks\\\")\",\n \"def process_after_request_hooks(self, resp):\\n\\n hooks = []\\n meth_hooks = getattr(\\n self,\\n 'after_{method}_hooks'.format(method=self.meth),\\n []\\n )\\n\\n hooks.extend(meth_hooks)\\n hooks.extend(self.after_all_hooks)\\n\\n if self.resource:\\n hooks.extend(self.resource.after_all_hooks)\\n hooks.extend(self.resource.api.after_all_hooks)\\n\\n for hook in chain(hooks):\\n resp = hook(self, resp)\\n\\n return resp\",\n \"def run_before(self):\\n\\n for path in self.hooks.get('before', []):\\n self.run_module(path)\",\n \"def test_hookregistry_module_should_have_global_hook_decorators():\\n # given & when\\n from radish.hookregistry import before, after\\n\\n # then\\n assert callable(before.all)\\n assert callable(before.each_feature)\\n assert callable(before.each_rule)\\n assert callable(before.each_scenario)\\n assert callable(before.each_step)\\n assert callable(after.all)\\n assert callable(after.each_feature)\\n assert callable(after.each_rule)\\n assert callable(after.each_scenario)\\n assert callable(after.each_step)\",\n \"def hook_server_before_exec(self, request_event):\\r\\n\\r\\n for functor in self._hooks['server_before_exec']:\\r\\n functor(request_event)\",\n \"def _pre_dispatch(self, request, *args, **kwargs):\\n pass\",\n \"def includeme(config):\\n config.add_subscriber(add_renderer_globals, BeforeRender)\\n config.add_subscriber(add_localizer, NewRequest)\\n config.add_subscriber(add_csrf_validation, NewRequest)\\n config.add_subscriber(add_resources, NewRequest)\",\n \"def callable_hooks(self):\\n for hook in self.custom_hooks:\\n options = rh.hooks.HookOptions(hook,\\n self.custom_hook(hook),\\n self.tool_paths)\\n yield (hook, functools.partial(rh.hooks.check_custom,\\n options=options))\\n\\n for hook in self.builtin_hooks:\\n options = rh.hooks.HookOptions(hook,\\n self.builtin_hook_option(hook),\\n self.tool_paths)\\n yield (hook, functools.partial(rh.hooks.BUILTIN_HOOKS[hook],\\n options=options))\",\n \"def pre_start_hook(self):\\n\\n LOG.debug(_('XManager pre_start_hook...'))\\n\\n pass\",\n \"def post_setup(self, context):\\n pass\",\n \"def post_start_hook(self):\\n\\n LOG.debug(_('XManager post_start_hook...'))\\n\\n pass\",\n \"def add_renderer_globals(event):\\n def fake_url(controller=None, action=None, **kwargs):\\n if action == \\\"css\\\":\\n return \\\"/css\\\"\\n if action and controller:\\n path = {}\\n for key in 'name', 'pocket', 'subpath':\\n if key in kwargs:\\n path[key] = kwargs.pop(key)\\n path['_query'] = dict((k,v) for k,v in kwargs.items() if v is not None)\\n return request.route_path(controller+\\\"/\\\"+action, **path)\\n if controller and controller.startswith(\\\"/\\\"):\\n return controller\\n return \\\"/unknown\\\"\\n\\n def fake_url_current(**kwargs):\\n path = {}\\n # XXX request.matchdict?\\n if 'name' in kwargs:\\n path['name'] = kwargs.pop('name')\\n if 'action' in kwargs:\\n path['_route_name'] = 'dex/'+kwargs.pop('action')\\n path['_query'] = dict((k,v) for k,v in kwargs.items() if v is not None)\\n return request.current_route_path(**path)\\n\\n def fake_translate(message, plural=None, n=None, context=None, comment=None):\\n return unicode(message)\\n\\n renderer_globals = event\\n request = event.get(\\\"request\\\") #or threadlocal.get_current_request()\\n if not request:\\n return\\n config = request.registry.settings\\n renderer_globals[\\\"config\\\"] = config\\n renderer_globals[\\\"h\\\"] = splinehelpers\\n renderer_globals[\\\"r\\\"] = request\\n renderer_globals[\\\"c\\\"] = request.tmpl_context\\n #renderer_globals[\\\"url\\\"] = request.url_generator\\n renderer_globals[\\\"url\\\"] = fake_url\\n fake_url.current = fake_url_current\\n renderer_globals[\\\"_\\\"] = fake_translate\\n renderer_globals[\\\"flash\\\"] = lib.Flash(request.session)\\n\\n request.tmpl_context.links = config['spline.plugins.links']\\n\\n # start timer\\n request.tmpl_context.timer = lib.ResponseTimer()\",\n \"def inject_decorator_namespace(self) -> None:\\n self.student_code.mod.turn_left = self.karel_action_decorator(\\n self.karel.turn_left\\n )\\n self.student_code.mod.move = self.karel_action_decorator(\\n self.karel.move\\n )\\n self.student_code.mod.put_beeper = self.beeper_action_decorator(\\n self.karel.put_beeper\\n )\\n self.student_code.mod.pick_beeper = self.beeper_action_decorator(\\n self.karel.pick_beeper\\n )\\n self.student_code.mod.paint_corner = self.corner_action_decorator(\\n self.karel.paint_corner\\n )\\n self.student_code.mod.put_block = self.block_action_decorator(\\n self.karel.put_block\\n )\\n self.student_code.mod.destroy_block = self.karel_action_decorator(\\n self.karel.destroy_block\\n )\\n self.student_code.mod.remove_paint = self.karel_action_decorator(\\n self.karel.remove_paint\\n )\",\n \"def hook_client_before_request(self, event):\\r\\n for functor in self._hooks['client_before_request']:\\r\\n functor(event)\",\n \"def test_add_processor_wrapper_override(caplog):\\n\\n testapp = holocron.Application()\\n marker = None\\n\\n def processor(app, items):\\n yield from items\\n\\n def processor_wrapper_a(app, items, processor):\\n nonlocal marker\\n marker = 42\\n yield from app.invoke([processor])\\n\\n def processor_wrapper_b(app, items, processor):\\n nonlocal marker\\n marker = 13\\n yield from app.invoke([processor])\\n\\n testapp.add_processor(\\\"processor\\\", processor)\\n testapp.add_processor_wrapper(\\\"wrapper\\\", processor_wrapper_a)\\n testapp.add_processor_wrapper(\\\"wrapper\\\", processor_wrapper_b)\\n\\n for _ in testapp.invoke([{\\\"name\\\": \\\"processor\\\", \\\"wrapper\\\": {}}]):\\n pass\\n\\n assert marker == 13\\n\\n assert len(caplog.records) == 1\\n assert caplog.records[0].message == \\\"processor override: 'wrapper'\\\"\",\n \"def on_before_execution(self):\\n pass\",\n \"def before(self, location=None):\\n side_effect = SideEffect(self.f, location)\\n dataflow = inject_before(self.container, side_effect, location)\\n return self._construct(dataflow)\",\n \"def pre_build_hook(self):\",\n \"def before_request(self, f):\\n self.before_request_handlers.append(f)\\n return f\",\n \"def configure_before_request_funcs(app):\\n @app.before_request\\n def conf_set_user_cookie_id():\\n return set_user_cookie_id()\\n \\n @app.before_request\\n def check_for_maintenance():\\n if config.DOWN_FOR_MAINTENANCE:\\n return 'Sorry, we\\\\'re down momentarily for a teensey bit of maintenance!', 503\\n \\n @app.before_request\\n def count_uniques():\\n return\\n statsd.set('unique_users', g.user_cookie_id)\\n statsd.set('unique_ips', request.remote_addr)\\n \\n @app.before_request\\n def set_statsd_context():\\n g.statsd_context = \\\"%s.%s\\\" % (request.endpoint, request.method)\\n g.total_request_timer = statsd.timer(g.statsd_context + \\\".response_time\\\")\\n g.total_request_timer.start()\",\n \"def map_to_app_lifecycle_hooks(self, app):\\n app['lifecycle_hooks'] = {}\\n form_lifecycle_hooks = self.lifecycle_hooks\\n if form_lifecycle_hooks.pre_buildimage.data:\\n app['lifecycle_hooks']['pre_buildimage'] = b64encode_utf8(\\n form_lifecycle_hooks.pre_buildimage.data.replace('\\\\r\\\\n', '\\\\n'))\\n else:\\n app['lifecycle_hooks']['pre_buildimage'] = ''\\n\\n if form_lifecycle_hooks.post_buildimage.data:\\n app['lifecycle_hooks']['post_buildimage'] = b64encode_utf8(\\n form_lifecycle_hooks.post_buildimage.data.replace('\\\\r\\\\n', '\\\\n'))\\n else:\\n app['lifecycle_hooks']['post_buildimage'] = ''\\n\\n if form_lifecycle_hooks.pre_bootstrap.data:\\n app['lifecycle_hooks']['pre_bootstrap'] = b64encode_utf8(\\n form_lifecycle_hooks.pre_bootstrap.data.replace('\\\\r\\\\n', '\\\\n'))\\n else:\\n app['lifecycle_hooks']['pre_bootstrap'] = ''\\n\\n if form_lifecycle_hooks.post_bootstrap.data:\\n app['lifecycle_hooks']['post_bootstrap'] = b64encode_utf8(\\n form_lifecycle_hooks.post_bootstrap.data.replace('\\\\r\\\\n', '\\\\n'))\\n else:\\n app['lifecycle_hooks']['post_bootstrap'] = ''\",\n \"def before(self, context):\\n raise NotImplementedError\",\n \"def register(self, api, prefix: str) -> None:\\n route = api.route(prefix + self._pattern, *self._args, **self._kwargs)(\\n self._view\\n )\\n\\n # Hooks registered via @before and/or @after on top of the @route\\n # decorator need to be manually registered with @api.before, @api.after.\\n def _register_hook(hook, hook_decorator):\\n nonlocal self, route\\n if self.hooks.get(hook) is None:\\n return\\n hook_function = self.hooks[hook]\\n route = hook_decorator(hook_function)(route)\\n\\n _register_hook(\\\"before\\\", api.before)\\n _register_hook(\\\"after\\\", api.after)\",\n \"def pre_processor(self):\",\n \"def register_pre_exec_callback(action_logger):\\n logging.debug(\\\"Adding %s to pre execution callback\\\", action_logger)\\n __pre_exec_callbacks.append(action_logger)\",\n \"def register_before_first(app):\\n app.before_first_request_funcs.append(\\n partial(admin.utils.create_root_user, app))\\n app.before_first_request_funcs.append(\\n partial(admin.utils.load_messenger_config, app))\\n app.before_first_request_funcs.append(\\n partial(admin.utils.load_site_config, app))\",\n \"def _hook(self):\",\n \"def _register_handlers(self):\\n DBG(\\\"\\\\nregister handlers\\\")\\n for hook, handler in self.handlers:\\n g.registerHandler(hook, handler)\\n\\n signal_manager.connect(self.c, 'body_changed', self._after_body_key)\",\n \"def context_processors(self):\\n return [\\n 'leonardo.module.web.processors.page.add_page_if_missing',\\n 'leonardo.module.web.processors.config.leonardo',\\n 'leonardo.module.web.processors.font.webfont_cookie',\\n ]\",\n \"def post_preprocessing_action(actions):\\n act_id = actions[1]\\n target = actions[0]\\n target_point = [\\n int(target % SIZE),\\n int(target // SIZE)\\n ] # (x, y)\\n\\n act_args = []\\n for arg in Actions.FUNCTIONS[act_id].args:\\n if arg.name in ('screen', 'minimap', 'screen2'):\\n act_args.append(target_point)\\n else:\\n act_args.append([0])\\n return Actions.FunctionCall(act_id, act_args)\",\n \"def exec_hooks(f):\\n global hooks\\n if f in hooks:\\n for h in hooks[f]:\\n h()\",\n \"def get_asyncgen_hooks(): # real signature unknown; restored from __doc__\\n pass\",\n \"def addResetHooks(self, before, after):\\n self._beforeResetHook = before\\n self._afterResetHook = after\",\n \"def extension_hooks(self, global_step):\\n return []\",\n \"def extension_hooks(self, global_step):\\n return []\",\n \"def post_processor(self):\",\n \"def _apply_post_render_hooks(self, data, obj, fmt):\\n hooks = self.post_render_hooks.get(fmt,[])\\n for hook in hooks:\\n try:\\n data = hook(data, obj)\\n except Exception as e:\\n self.param.warning(f\\\"The post_render_hook {hook!r} could not \\\"\\n f\\\"be applied:\\\\n\\\\n {e}\\\")\\n return data\",\n \"def before(self, before: Route.Decorator):\\n pass\",\n \"def dispatcher(self):\\n pass # pragma: no cover\",\n \"def before_all(context):\\n set_services(context)\\n context.api = {}\\n context.repositories = {}\\n\\n for service, location in context.services.items():\\n url = urlparse.urlparse(location)\\n api = API(url.scheme + '://' + url.netloc, async=False)\\n try:\\n context.api[service] = getattr(api, url.path.split('/')[2])\\n except:\\n context.api[service] = getattr(api, service)\",\n \"def on_setup(self, request, trigger_context):\\n raise NotImplementedError\",\n \"def register_request_hooks(app):\\n\\n @app.before_request\\n def before_request():\\n g.db = open_db()\\n\\n @app.teardown_request\\n def after_request(exc):\\n g.db.__exit__(type(exc), exc, None)\",\n \"def context_processor(self, f):\\n self.template_context_processors.append(f)\\n return f\",\n \"def pre_hook():\\n _logger.warning(\\\"PRE Gen hook executed\\\")\\n\\n try:\\n\\n # Default value = Volt\\n theme = \\\"{{cookiecutter.theme}}\\\"\\n repo = 'https://github.com/app-generator/flask-dashboard-volt.git'\\n\\n if 'material-dashboard' == theme:\\n repo = 'https://github.com/app-generator/flask-material-dashboard.git'\\n\\n if 'soft-ui' == theme:\\n repo = 'https://github.com/app-generator/flask-soft-ui-dashboard.git'\\n\\n if 'datta-able' == theme:\\n repo = 'https://github.com/app-generator/flask-datta-able.git'\\n\\n if 'star-admin' == theme:\\n repo = 'https://github.com/app-generator/flask-star-admin.git' \\n\\n print(' Cloning theme: <' + theme + '>, REPO: ' + repo )\\n\\n repo = git.Repo.clone_from( repo, TMP_DIR, branch='master')\\n print(' ...done')\\n \\n except OSError as e:\\n _logger.warning(f\\\"Error: {e}\\\")\\n sys.exit(0)\\n\\n # Exit with success\\n sys.exit(0)\",\n \"def prepare(self):\\n self.uri = self.request.uri\\n self.path = self.request.uri.split('?')[0]\\n self.method = self.path.split('/')[-1]\\n self.default_methods = {}\\n #\\n # You can use the before_handler in a local controller to\\n # process your own prepare stuff.\\n # a common use case is to call: self.print_debug_info().\\n # which then applies only to this specific handler.\\n # \\n before_handler = getattr(self, \\\"before_handler\\\", None)\\n print(\\\"calling before_handler for \\\" + str(self.__class__))\\n if callable(before_handler):\\n before_handler()\",\n \"def test_add_processor_override(caplog):\\n\\n testapp = holocron.Application()\\n marker = None\\n\\n def processor_a(app, items):\\n nonlocal marker\\n marker = 42\\n yield from items\\n\\n def processor_b(app, items):\\n nonlocal marker\\n marker = 13\\n yield from items\\n\\n testapp.add_processor(\\\"processor\\\", processor_a)\\n testapp.add_processor(\\\"processor\\\", processor_b)\\n\\n for _ in testapp.invoke([{\\\"name\\\": \\\"processor\\\"}]):\\n pass\\n\\n assert marker == 13\\n\\n assert len(caplog.records) == 1\\n assert caplog.records[0].message == \\\"processor override: 'processor'\\\"\",\n \"def before_request():\\r\\n\\r\\n\\tinit_classes()\",\n \"def before_request(self, func: typing.Callable):\\n return self.add_hook(type_=\\\"pre\\\", hook=func)\",\n \"def available_hooks(self):\\n return [RoutesDevHandlerHook]\",\n \"def make_processing_functions(self):\\n return\",\n \"def collect_handlers(log, base_url, validation):\\n base_bookstore_pattern = url_path_join(base_url, '/bookstore')\\n base_bookstore_api_pattern = url_path_join(base_url, '/api/bookstore')\\n\\n handlers = []\\n # Always enable the version handler for the API\\n handlers.append((base_bookstore_api_pattern, BookstoreVersionHandler))\\n\\n if validation['publish_valid']:\\n log.info(f\\\"[bookstore] Enabling bookstore publishing, version: {version}\\\")\\n handlers.append(\\n (\\n url_path_join(base_bookstore_api_pattern, r\\\"/publish%s\\\" % path_regex),\\n BookstorePublishAPIHandler,\\n )\\n )\\n else:\\n log.info(\\\"[bookstore] Publishing disabled. s3_bucket or endpoint are not configured.\\\")\\n\\n if validation['s3_clone_valid']:\\n log.info(f\\\"[bookstore] Enabling bookstore cloning, version: {version}\\\")\\n handlers.append(\\n (url_path_join(base_bookstore_api_pattern, r\\\"/clone(?:/?)*\\\"), BookstoreCloneAPIHandler)\\n ),\\n handlers.append(\\n (url_path_join(base_bookstore_pattern, r\\\"/clone(?:/?)*\\\"), BookstoreCloneHandler)\\n )\\n else:\\n log.info(f\\\"[bookstore] bookstore cloning disabled, version: {version}\\\")\\n\\n if validation['fs_clone_valid']:\\n log.info(f\\\"[bookstore] Enabling filesystem cloning, version: {version}\\\")\\n handlers.append(\\n (url_path_join(base_bookstore_pattern, r\\\"/fs-clone(?:/?)*\\\"), BookstoreFSCloneHandler)\\n )\\n handlers.append(\\n (\\n url_path_join(base_bookstore_api_pattern, r\\\"/fs-clone(?:/?)*\\\"),\\n BookstoreFSCloneAPIHandler,\\n )\\n ),\\n else:\\n log.info(f\\\"[bookstore] bookstore cloning disabled, version: {version}\\\")\\n return handlers\",\n \"def pre_process(self):\\n refs = self.collect_references()\\n for ref in refs:\\n self._add_reference(ref)\\n if (not cls_is_relocatable) and cls_is_referenced:\\n register_spritegroup(self)\",\n \"def apply_hooks(\\n endpoint: Endpoint,\\n context: HookContext,\\n hooks: Optional[HookDispatcher],\\n strategy: st.SearchStrategy[Case],\\n location: str,\\n) -> st.SearchStrategy[Case]:\\n strategy = _apply_hooks(context, GLOBAL_HOOK_DISPATCHER, strategy, location)\\n strategy = _apply_hooks(context, endpoint.schema.hooks, strategy, location)\\n if hooks is not None:\\n strategy = _apply_hooks(context, hooks, strategy, location)\\n return strategy\",\n \"def available_hooks(self):\\n return [HtmlMinPostRenderHook]\",\n \"def post_build_hook(self):\",\n \"def on_hook(self) -> None:\",\n \"def makeHandlers(self):\\n\\n yield self.loadGrids.start(funcSelf=self)\\n yield self.updateClientWatchedGrids.start(funcSelf=self)\\n logger.debug(\\\"RPCs started\\\")\",\n \"def prepare_locations(requests):\\n\\tlocation = StringIO.StringIO()\\n\\tlocation.write('# Do not modify - this file is maintained by nginx_updater.py\\\\n')\\n\\tfor service in requests:\\n\\t\\tlocation.write('\\\\nlocation {0} {{\\\\n'.format(service))\\n\\t\\tlocation.write('\\\\tproxy_pass http://{0}/;\\\\n'.format(upstream_name(service)))\\n\\t\\tlocation.write('\\\\tproxy_redirect off;\\\\n')\\n\\t\\tlocation.write('\\\\tproxy_next_upstream error timeout invalid_header http_500\\\\n')\\n\\t\\tlocation.write('\\\\tproxy_connect_timeout 1s;\\\\n')\\n\\t\\tlocation.write('}\\\\n')\\n\\t\\n\\treturn location\",\n \"def before_request(self, f):\\n self.before_request_funcs.append(f)\\n return f\",\n \"def refresh_entity_hooks(self):\\n for hook_name in HOOK_NAMES:\\n hooks = []\\n for entity in self._task.root_entity.iter_entities():\\n entity_hook = getattr(entity, hook_name)\\n # Ignore any hook that is a no-op to avoid function call overhead.\\n if not _callable_is_trivial(entity_hook):\\n hooks.append(entity_hook)\\n getattr(self, '_' + hook_name).entity_hooks = hooks\",\n \"def _timestep_before_hook(self, *args, **kwargs):\\n pass\",\n \"def do_before(self):\\r\\n pass\",\n \"def prepare_locations(requests):\\r\\n\\tlocation = StringIO.StringIO()\\r\\n\\tlocation.write('# Do not modify - this file is maintained by nginx_updater.py\\\\n')\\r\\n\\tfor service in requests:\\r\\n\\t\\tlocation.write('\\\\nlocation {0} {{\\\\n'.format(service))\\r\\n\\t\\tlocation.write('\\\\tproxy_pass http://{0}/;\\\\n'.format(upstream_name(service)))\\r\\n\\t\\tlocation.write('\\\\tproxy_redirect off;\\\\n')\\r\\n\\t\\tlocation.write('\\\\tproxy_next_upstream error timeout invalid_header http_500\\\\n')\\r\\n\\t\\tlocation.write('\\\\tproxy_connect_timeout 1s;\\\\n')\\r\\n\\t\\tlocation.write('}\\\\n')\\r\\n\\t\\r\\n\\treturn location\",\n \"def define_log_pre_format_hooks(self):\\n return []\",\n \"def _after_serve_actions(self):\\n pass\",\n \"def post_hook(self):\\n self.mk_rg1()\\n self.mk_rg2()\\n self.mk_rg3()\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def dynamic_hook(self, hook):\\n assert callable(hook)\\n self._dynamic_hooks.append(hook)\\n try:\\n yield\\n finally:\\n self._dynamic_hooks.remove(hook)\",\n \"def test_render_all_templates():\\n assert templates.xhook__initialize({})\\n assert templates.xhook__handlers({})\\n assert templates.xhook__enable()\\n assert templates.xhook__release()\\n assert templates.asserts__call_count({})\\n assert templates.asserts__calls({})\",\n \"def dispatcher(handlers):\\n\\n # Transforms wsgi_env, start_response args into request\\n @wrappers.Request.application\\n def dispatch(request):\\n \\\"\\\"\\\"Handle one request.\\\"\\\"\\\"\\n for url_re, app in handlers:\\n matcher = re.match(url_re, request.path)\\n if matcher and matcher.end() == len(request.path):\\n if app is not None:\\n # Send a response via the app specified in the handler.\\n return app\\n else:\\n # The import must have failed. This will have been logged\\n # at import time. Send a 500 error response.\\n return response_for_error(httplib.INTERNAL_SERVER_ERROR)\\n logging.error('No handler found for %s', request.path)\\n return response_for_error(httplib.NOT_FOUND)\\n\\n return dispatch\",\n \"def mount(self, subapp, url_prefix=''):\\n for methods, pattern, handler in subapp.url_map:\\n self.url_map.append(\\n (methods, URLPattern(url_prefix + pattern.url_pattern),\\n handler))\\n for handler in subapp.before_request_handlers:\\n self.before_request_handlers.append(handler)\\n for handler in subapp.after_request_handlers:\\n self.after_request_handlers.append(handler)\\n for handler in subapp.after_error_request_handlers:\\n self.after_error_request_handlers.append(handler)\\n for status_code, handler in subapp.error_handlers.items():\\n self.error_handlers[status_code] = handler\",\n \"def register_main_hook(callback):\\n main_hooks.append(callback)\",\n \"def setup(logger):\\n # It's important to use the same context in the callback _dispatcher\\n # as the main thread, otherwise not-so-savvy users will be very\\n # confused\\n global _dispatcher\\n\\n if _dispatcher is not None:\\n logger.debug(\\\"ophyd already setup\\\")\\n return\\n\\n pyepics_compat._get_pv = pyepics_compat.get_pv\\n pyepics_compat.get_pv = get_pv\\n\\n def _cleanup():\\n \\\"\\\"\\\"Clean up the ophyd session\\\"\\\"\\\"\\n global _dispatcher\\n if _dispatcher is None:\\n return\\n\\n pyepics_compat.get_pv = pyepics_compat._get_pv\\n\\n if _dispatcher.is_alive():\\n _dispatcher.stop()\\n\\n _dispatcher = None\\n\\n logger.debug(\\\"Installing event dispatcher\\\")\\n context = PV._default_context.broadcaster\\n _dispatcher = EventDispatcher(\\n thread_class=CaprotoCallbackThread, context=context, logger=logger\\n )\\n atexit.register(_cleanup)\\n return _dispatcher\",\n \"def before_map(self, map):\\n map.connect('/about/terms-and-conditions',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='toc')\\n map.connect('/about/accessibility',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='accessibility')\\n map.connect('/about/code-of-conduct',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='coc')\\n map.connect('/about/moderation-policy',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='moderation')\\n map.connect('/about/faq',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='faq')\\n map.connect('/about/privacy',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='privacy')\\n map.connect('/about/contact-us',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='contact')\\n map.connect('/about/suggest-a-dataset',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='suggest_a_dataset')\\n map.connect('/atlas-for-africa',\\n controller='ckanext.syngenta.controller:CustomPageController',\\n action='atlas')\\n return map\",\n \"def dispatch(self, context, consumed, handler, is_endpoint):\\n\\t\\t\\n\\t\\trequest = context.request\\n\\t\\t\\n\\t\\tif __debug__:\\n\\t\\t\\tlog.debug(\\\"Handling dispatch event.\\\", extra=dict(\\n\\t\\t\\t\\t\\trequest = id(context),\\n\\t\\t\\t\\t\\tconsumed = consumed,\\n\\t\\t\\t\\t\\thandler = safe_name(handler),\\n\\t\\t\\t\\t\\tendpoint = is_endpoint\\n\\t\\t\\t\\t))\\n\\t\\t\\n\\t\\t# The leading path element (leading slash) requires special treatment.\\n\\t\\tif not consumed and context.request.path_info_peek() == '':\\n\\t\\t\\tconsumed = ['']\\n\\t\\t\\n\\t\\tnConsumed = 0\\n\\t\\tif consumed:\\n\\t\\t\\t# Migrate path elements consumed from the `PATH_INFO` to `SCRIPT_NAME` WSGI environment variables.\\n\\t\\t\\tif not isinstance(consumed, (list, tuple)):\\n\\t\\t\\t\\tconsumed = consumed.split('/')\\n\\t\\t\\t\\n\\t\\t\\tfor element in consumed:\\n\\t\\t\\t\\tif element == context.request.path_info_peek():\\n\\t\\t\\t\\t\\tcontext.request.path_info_pop()\\n\\t\\t\\t\\t\\tnConsumed += 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\n\\t\\t# Update the breadcrumb list.\\n\\t\\tcontext.path.append(Crumb(handler, Path(request.script_name)))\\n\\t\\t\\n\\t\\tif consumed: # Lastly, update the remaining path element list.\\n\\t\\t\\trequest.remainder = request.remainder[nConsumed:]\",\n \"def map_from_app_lifecycle_hooks(self, app):\\n return self.lifecycle_hooks.form.map_from_app(app)\",\n \"def onRegister(setup_state):\\n\\tblueprint = setup_state.blueprint\\n\\t#if setup_state.options.get('auth') == True:\\n\\tif setup_state.url_prefix.startswith('/ext/'): #not really used right now\\n\\t\\t#inside here, 'route' works but not 'before_request'\\n\\t\\t#maybe use to register authentication-specific routes?\\n\\t\\tprint(\\\"Authenticated API on {}\\\".format(setup_state.url_prefix))\",\n \"def create_hooks(self, hclass):\\n for extension in self.db.values():\\n self.events.register_callbacks_from_inst(hclass, extension)\",\n \"def initialize_location_strategies(self):\\n locator_manager.register_locators(\\\"sf\\\", lex_locators)\\n locator_manager.register_locators(\\\"text\\\", \\\"Salesforce.Locate Element by Text\\\")\\n locator_manager.register_locators(\\\"title\\\", \\\"Salesforce.Locate Element by Title\\\")\\n\\n # This does the work of actually adding all of the above-registered\\n # location strategies, plus any that were registered by keyword\\n # libraries.\\n locator_manager.add_location_strategies()\",\n \"def hookregistry():\\n registry = HookRegistry()\\n yield registry\",\n \"def define_log_pre_format_hooks(self):\\n hooks = super(Server, self).define_log_pre_format_hooks()\\n # NOTE enabling logs only on debug mode\\n if self.args.func == self.run and self.args.debug:\\n hooks.append(self._send_log_to_ws)\\n\\n return hooks\",\n \"def on_pre_execution(**kwargs):\\n logging.debug(\\\"Calling callbacks: %s\\\", __pre_exec_callbacks)\\n for callback in __pre_exec_callbacks:\\n try:\\n callback(**kwargs)\\n except Exception:\\n logging.exception(\\\"Failed on pre-execution callback using %s\\\", callback)\",\n \"def set_functions(self, scenario, bodies):\\n\\n return\",\n \"def DebugMenuProviderMixin_on_setup(self):\\n pass\",\n \"def prep_logging_decorator(func):\\n filename = filename_regexp.match(inspect.getmodule(inspect.stack()[1][0]).__file__).group(1)\\n\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n logger.info('{}: Start preparation'.format(filename))\\n func(*args, **kwargs)\\n logger.info('{}: Finished preparation'.format(filename))\\n return wrapper\",\n \"def _pre_call_handlers(self) -> tuple:\\n return self._handlers[0]\",\n \"def __init__(self):\\n super().__init__()\\n TemplateEngineFactory.register_factory('Jinja2Engine', Jinja2Engine.Factory)\\n\\n step1 = PrepareAppConfTransfiguration()\\n step2 = ConfReaderToContextTransfiguration()\\n step3 = ValidateCollectionTags()\\n step4 = AttributeChainedTransfiguration('mbean')\\n step5 = AttributeChainedTransfiguration('connection')\\n\\n self.add(step1)\\n self.add(step2)\\n self.add(step3)\\n self.add(step4)\\n self.add(step5)\",\n \"def before_request():\\n pass\",\n \"def declare_hook(self, fct_name, fct):\\r\\n self._hooks_fct[fct_name] = fct\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56037354","0.5500859","0.5223152","0.52164966","0.5215929","0.5108552","0.5066924","0.5015762","0.49975643","0.4935562","0.49342433","0.49167737","0.48724824","0.48304024","0.48257065","0.48113218","0.48091397","0.4805462","0.47963923","0.47690478","0.47643247","0.47457838","0.4719113","0.4717151","0.47072297","0.4704226","0.4684988","0.467664","0.46677566","0.46579865","0.464393","0.464209","0.46263963","0.4613074","0.46102542","0.45947748","0.45940852","0.4576674","0.4572592","0.45725688","0.45652303","0.45614177","0.45614177","0.4560935","0.45548928","0.4551065","0.45419717","0.45341533","0.4531257","0.4528133","0.45104855","0.4509807","0.45094723","0.45077613","0.4507175","0.44978222","0.44798705","0.4472909","0.4470054","0.44599128","0.4453574","0.4448386","0.44472858","0.4440411","0.44403666","0.4437367","0.4436474","0.44350305","0.44280678","0.44231436","0.44185624","0.44164965","0.44148806","0.44118425","0.44063482","0.44063482","0.44063482","0.44063482","0.4393267","0.43917668","0.43893507","0.43866524","0.4384483","0.43828368","0.4376887","0.436012","0.4343463","0.43243065","0.43218434","0.4320517","0.4317586","0.43126214","0.4303961","0.42927998","0.42872697","0.4286292","0.4281995","0.42791796","0.42791542","0.42748004"],"string":"[\n \"0.56037354\",\n \"0.5500859\",\n \"0.5223152\",\n \"0.52164966\",\n \"0.5215929\",\n \"0.5108552\",\n \"0.5066924\",\n \"0.5015762\",\n \"0.49975643\",\n \"0.4935562\",\n \"0.49342433\",\n \"0.49167737\",\n \"0.48724824\",\n \"0.48304024\",\n \"0.48257065\",\n \"0.48113218\",\n \"0.48091397\",\n \"0.4805462\",\n \"0.47963923\",\n \"0.47690478\",\n \"0.47643247\",\n \"0.47457838\",\n \"0.4719113\",\n \"0.4717151\",\n \"0.47072297\",\n \"0.4704226\",\n \"0.4684988\",\n \"0.467664\",\n \"0.46677566\",\n \"0.46579865\",\n \"0.464393\",\n \"0.464209\",\n \"0.46263963\",\n \"0.4613074\",\n \"0.46102542\",\n \"0.45947748\",\n \"0.45940852\",\n \"0.4576674\",\n \"0.4572592\",\n \"0.45725688\",\n \"0.45652303\",\n \"0.45614177\",\n \"0.45614177\",\n \"0.4560935\",\n \"0.45548928\",\n \"0.4551065\",\n \"0.45419717\",\n \"0.45341533\",\n \"0.4531257\",\n \"0.4528133\",\n \"0.45104855\",\n \"0.4509807\",\n \"0.45094723\",\n \"0.45077613\",\n \"0.4507175\",\n \"0.44978222\",\n \"0.44798705\",\n \"0.4472909\",\n \"0.4470054\",\n \"0.44599128\",\n \"0.4453574\",\n \"0.4448386\",\n \"0.44472858\",\n \"0.4440411\",\n \"0.44403666\",\n \"0.4437367\",\n \"0.4436474\",\n \"0.44350305\",\n \"0.44280678\",\n \"0.44231436\",\n \"0.44185624\",\n \"0.44164965\",\n \"0.44148806\",\n \"0.44118425\",\n \"0.44063482\",\n \"0.44063482\",\n \"0.44063482\",\n \"0.44063482\",\n \"0.4393267\",\n \"0.43917668\",\n \"0.43893507\",\n \"0.43866524\",\n \"0.4384483\",\n \"0.43828368\",\n \"0.4376887\",\n \"0.436012\",\n \"0.4343463\",\n \"0.43243065\",\n \"0.43218434\",\n \"0.4320517\",\n \"0.4317586\",\n \"0.43126214\",\n \"0.4303961\",\n \"0.42927998\",\n \"0.42872697\",\n \"0.4286292\",\n \"0.4281995\",\n \"0.42791796\",\n \"0.42791542\",\n \"0.42748004\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6157746"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":77691,"cells":{"query":{"kind":"string","value":"Enables enriching test items with more properties to be used for grouping or other purposes. The goal is for whoever needs to be able to add item.test_group field"},"document":{"kind":"string","value":"def pytest_before_group_items(session, config, items):"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_test_inline_additional_properties(self):\n pass","def pytest_after_group_items(session, config, items):","def pytest_collection_modifyitems(config, items):\n # check if studio tests myst be skipped\n run_study = config.getoption(\"--runstudy\")\n # 'all' will match all studies, '' will not match anything\n run_study = {'': '(?!x)x', 'all': '.*'}.get(run_study, run_study)\n # --runstudy given in cli: do not skip study tests and\n test_selected = list()\n test_skipped = list()\n groups = dict()\n incremental = pytest.mark.incremental()\n\n def add():\n \"helper for gathering test info\"\n marker = item.get_marker(mark)\n kwargs = parse_args(marker.args, marker.kwargs)\n group_name = kwargs['name']\n group = groups.setdefault(group_name, dict())\n group.setdefault(mark, list()).append((kwargs, item))\n item.add_marker(incremental)\n\n # place every test in regular, prerequisite and studies\n # group by name\n for item in items:\n for mark in set(item.keywords.keys()).intersection(MARKS):\n add()\n break\n else:\n test_selected.append(item)\n\n def sort(a, b):\n \"Sort two items by order priority\"\n return cmp(a[0]['order'], b[0]['order'])\n\n # use studies precedence to built the global sequence order\n mandatory = 'study' # mandatory mark for global sorting: study\n studies = list()\n for name, info in groups.items():\n studies.extend(info.get(mandatory, []))\n studies.sort(sort)\n\n def append(tests, where):\n \"helper to add the test item from info structure\"\n for test in tests:\n test = test[1]\n if test not in where:\n where.append(test)\n\n # select only the test that are going to be launched\n width = 0\n regexp = re.compile(run_study, re.I | re.DOTALL)\n for study in studies:\n group_name = study[0]['name']\n width = max(width, len(group_name))\n where = test_selected if regexp.search(group_name) else test_skipped\n for mark, seq in groups[group_name].items():\n if mark == mandatory:\n continue\n seq.sort(sort)\n append(seq, where)\n append([study], where)\n\n if config.getoption(\"--show_order\") or config.getoption(\"--debug\"):\n fmt = \"{0:>3d} [{1:>%s}] {2}\" % width\n for i, item in enumerate(test_selected + test_skipped):\n study = get_study_name(item)\n fqn = get_FQN(item)\n line = fmt.format(i, study, fqn)\n if item in test_selected:\n line = term.green('+' + line)\n else:\n line = term.yellow('-' + line)\n print(line)\n\n # we make the --runstudy check at the end to be able to show\n # test order with --show_order or --debig options\n # reorder tests by group name and replace items IN-PLACE\n if run_study:\n items[:] = test_selected\n return\n\n skip_test = pytest.mark.skip(reason=\"need --runstudy option to run\")\n for item in items:\n if set(item.keywords.keys()).intersection(MARKS):\n item.add_marker(skip_test)","def test_add_group(self):\n pass","def add_test_group(self, test_group):\n self.test_groups[test_group.name] = test_group","def pytest_collection_modifyitems(items, config):\n from . import tagging\n\n remaining = []\n deselected = []\n for item in items:\n # Get all tags for this test (includes tags on class level if present)\n tags = item.get_marker(\"tags\")\n\n if config.option.collectonly:\n info = item.parent.name.split(\"/\")\n print({\"name\": item.name, \"folder\": info[3],\n \"module\": info[4][:-3], \"tags\": tags.args})\n\n # This line fills two purposes. Handle the cases where '--tags'\n # 1) was omitted, this will run all tests except 'not active' and\n # 'awaiting_fix' ones.\n # 2) has no arguments (a case that can occur when running in Docker).\n tags = tags.args + ('all',) if tags else ['all']\n\n # Create a list of the tags\n tags_list = tagging.TagsCollection.build_tags_list(tags)\n\n # Determine if test should be run depending on the parameter tags\n # See also: pytest_configure hook\n if config.parameter_tags.should_pick_up(tags_list):\n remaining.append(item)\n else:\n deselected.append(item)\n\n if deselected:\n config.hook.pytest_deselected(items=deselected)\n items[:] = remaining","def pytest_collection_modifyitems(session, config, items):\n\n test_scenarios = DefaultDict(TestSuite)\n\n config_scenarios = config.option.scenarios\n filter_scenarios = config_scenarios is not None\n skip_setup = config.option.no_setup\n\n if skip_setup and (not filter_scenarios or len(config_scenarios) > 1):\n raise RuntimeWarning(\n \"Configured no setup and teardown but more then one scenario is configured\")\n\n # Group tests by scenario in to TestSuite objects\n for test in items:\n scenario = scenario_re.match(test.name).groups()[0]\n\n if filter_scenarios and should_skip_scenario(scenario, config_scenarios):\n continue\n\n if test.originalname == \"test_setup\":\n test_scenarios[scenario].setup = test\n elif test.originalname == \"test_teardown\":\n test_scenarios[scenario].teardown = test\n else:\n test_scenarios[scenario].tests.append(test)\n\n # Clear all pytest tests\n items.clear()\n\n # Order tests\n for scenario in test_scenarios.values():\n if len(scenario.tests) != 0:\n suite = scenario.tests\n if not skip_setup:\n suite.insert(0, scenario.setup)\n suite.append(scenario.teardown)\n\n items.extend(suite)","def tests_ti_document_add_attribute(self, request: FixtureRequest):\n super().group_add_attribute(request)","def test_patch_group(self):\n pass","def test_patch_group(self):\n pass","def test_000_add_group(self):\n # This case is always passed because it's tested in setup_module,\n # If setup module fails, this case will never run\n pass","def test_grouping(self):\n s = self.create(ComponentItem, UML.Component)\n uc1 = self.create(UseCaseItem, UML.UseCase)\n uc2 = self.create(UseCaseItem, UML.UseCase)\n\n self.group(s, uc1)\n assert 1 == len(uc1.subject.subject)\n self.group(s, uc2)\n assert 1 == len(uc2.subject.subject)\n\n # Classifier.useCase is not navigable to UseCase\n # self.assertEqual(2, len(s.subject.useCase))","def test_test_group_parameters(self):\n pass","def test_list_group(self):\n pass","def enable_meta_data(item) : \n assert(has_value(item))\n\n if not item_has_meta(item) : \n \n # Wrap simple types to allow attributes to be added to them.\n if isinstance(item, str) : item = str_wrapper(item)\n elif isinstance(item, float) : item = float_wrapper(item)\n elif isinstance(item, int) : item = int_wrapper(item)\n elif isinstance(item, list) : item = list_wrapper(item)\n elif isinstance(item, dict) : item = dict_wrapper(item)\n \n setattr(item, META_ATTRIBUTE, Properties())\n \n return item","def test_patchorganizations_item(self):\n pass","def pytest_collection_modifyitems(config, items):\n execute_mssql_tests = ensure_mssql_ready_for_tests(config)\n skip_mssql = pytest.mark.skip(reason=\"requires SQL Server\")\n for item in items:\n if \"mssql\" in item.keywords:\n if execute_mssql_tests:\n # Add 'mssql_setup_and_teardown' as FIRST in fixture list\n fixtures = ['mssql_setup_and_teardown'] + item.fixturenames\n item.fixturenames = fixtures\n else:\n item.add_marker(skip_mssql)\n if \"http_server\" in item.keywords:\n item.fixturenames.append('http_server_setup_and_teardown')","def define_group_properties(self):\n\n # PropertyGroup\n self.propertygroup['debug']['x86'] = get_propertygroup(\n 'debug', 'x86', ' and @Label=\"Configuration\"'\n )\n self.propertygroup['debug']['x64'] = get_propertygroup(\n 'debug', 'x64', ' and @Label=\"Configuration\"'\n )\n self.propertygroup['release']['x86'] = get_propertygroup(\n 'release', 'x86', ' and @Label=\"Configuration\"'\n )\n self.propertygroup['release']['x64'] = get_propertygroup(\n 'release', 'x64', ' and @Label=\"Configuration\"'\n )\n\n # ItemDefinitionGroup\n self.definitiongroups['debug']['x86'] = get_definitiongroup('debug', 'x86')\n self.definitiongroups['debug']['x64'] = get_definitiongroup('debug', 'x64')\n self.definitiongroups['release']['x86'] = get_definitiongroup('release', 'x86')\n self.definitiongroups['release']['x64'] = get_definitiongroup('release', 'x64')","def test_properties_stats_group_by_group_by_and_sub_group_by_get(self):\n pass","def add_item(self):\n item = models.Item(item_name=self.test_item,\n list_id=1,\n description=self.test_item_desc)\n item.add()","def test_properties_stats_group_by_group_by_get(self):\n pass","def pytest_collection_modifyitems(config, items):\n if config.getoption(\"--slurm\"):\n return ## run all\n skip_slurm = pytest.mark.skip(reason=\"need --slurm option to run\")\n for item in items:\n if \"slurm\" in item.keywords:\n item.add_marker(skip_slurm)\n if config.getoption(\"--long\"):\n return\n skip_long = pytest.mark.skip(reason=\"need --long option to run\")\n for item in items:\n if \"long\" in item.keywords:\n item.add_marker(skip_long)\n # no --long no --slurm or only --long","def addCustomTests(self, tests):\n pass","def add_to_group(self,item):\n self.items.append(item)\n self.n += 1","def test_update_group(self):\n pass","def pytest_itemcollected(item):\n item.name = item.name.split('[', 1)[1][:-1]\n # pylint: disable=protected-access\n item._nodeid = item.name","def pytest_runtest_setup(item):\n if hasattr(item, 'fixturenames') and LOOP_KEY not in item.fixturenames:\n item.fixturenames.append(LOOP_KEY)","def _create_test_dict(cls, test_item):\n test_dict = {TEST_ID_KEY: test_item.identifier,\n TEST_NAME_KEY: test_item.data.name}\n\n test_dict[TEST_CLASS_CODE_KEY] = type(test_item.data)\n\n if test_item.IS_COMPLEX:\n subtests = [cls._create_test_dict(sub_test)\n for sub_test in test_item]\n\n test_dict[TEST_SUBTESTS_KEY] = subtests\n\n return test_dict","def test_replace_groups(self):\n pass","def start_composite(self, test_item):\n msg = messages.StartComposite(test_id=test_item.identifier)\n self._request(msg)","def setUp(self):\n self.item = ElectricAppliances('10', 'test', '4', '5', 'GE', '110')","def setUp(self):\n self.new_inv_item = ['1', 'Knife Set', 10, 'n', 'n']\n self.new_furn_item = ['2', 'Couch', 25, 'y', 'Cloth', 'L']\n self.new_elec_item = ['3', 'Dryer', 100, 'n', 'y', 'Samsung', 12]","def persist_test_group(self, obj: object, group: str) -> str:","def pytest_runtest_makereport(item):\n # execute all other hooks to obtain the report object\n outcome = yield\n rep = outcome.get_result()\n\n # set a report attribute for each phase of a call, which can\n # be \"setup\", \"call\", \"teardown\"\n\n setattr(item, \"rep_\" + rep.when, rep)","def create_TestGroup(test_case, # type: AnyMagpieTestCaseType\n override_group_name=null, # type: Optional[Str]\n override_discoverable=null, # type: Optional[bool]\n override_data=null, # type: Optional[JSON]\n override_headers=null, # type: Optional[HeadersType]\n override_cookies=null, # type: Optional[CookiesType]\n ): # type: (...) -> JSON\n app_or_url = get_app_or_url(test_case)\n data = override_data\n if override_data is null:\n data = {\"group_name\": override_group_name if override_group_name is not null else test_case.test_group_name}\n # only add 'discoverable' if explicitly provided here to preserve original behaviour of 'no value provided'\n if override_discoverable is not null:\n data[\"discoverable\"] = override_discoverable\n grp_name = (data or {}).get(\"group_name\")\n if grp_name:\n test_case.extra_group_names.add(grp_name) # indicate potential removal at a later point\n resp = test_request(app_or_url, \"POST\", \"/groups\", json=data,\n headers=override_headers if override_headers is not null else test_case.json_headers,\n cookies=override_cookies if override_cookies is not null else test_case.cookies)\n return check_response_basic_info(resp, 201, expected_method=\"POST\")","def get_existing_test_group(self, obj: object) -> str:","def group_by(self, key):\n ret = {}\n for test in self._testset():\n if hastag(test, key):\n ret.setdefault(gettag(test, key), []).append(test)\n continue\n ret.setdefault(\"others\", []).append(test)\n for k in ret:\n ret[k] = self.__class__(ret[k])\n return ret","def test_products_ref_groups_put(self):\n pass","def setup(self, ds: PetscDocStringImpl, parameter_list_prefix_check: Optional[Callable[[ParameterList, PetscDocString, ItemsType], ItemsType]] = None) -> None:\n groups: collections.defaultdict[\n int,\n list[tuple[SourceRange, DescribableItem, int]]\n ] = collections.defaultdict(list)\n subheading = 0\n\n def inspector(ds: PetscDocStringImpl, loc: SourceRange, line: str, verdict: Verdict) -> None:\n if not line or line.isspace():\n return\n\n if verdict > 0 and len(groups.keys()):\n nonlocal subheading\n subheading += 1\n lstp = line.lstrip()\n # .ve and .vb might trip up the prefix detection since they start with '.'\n if lstp.startswith(self.prefixes) and not lstp.startswith(('.vb', '.ve')):\n item = DescribableItem(line, prefixes=self.prefixes)\n groups[subheading].append((loc, item, item.arglen()))\n return\n\n super()._do_setup(ds, inspector)\n items = dict(groups)\n if parameter_list_prefix_check is not None:\n assert callable(parameter_list_prefix_check)\n items = parameter_list_prefix_check(self, ds, items)\n self.items = items\n return","def test_patchhardwares_item(self):\n pass","def setUp(self) -> None:\n super().setUp()\n\n self.learner_group_model = learner_group_models.LearnerGroupModel(\n id='learner_group_32',\n title='title',\n description='description',\n facilitator_user_ids=['facilitator_1', 'facilitator_2'],\n learner_user_ids=['learner_1', 'learner_2', 'learner_3'],\n invited_learner_user_ids=['invited_user_1', 'invited_user_2'],\n subtopic_page_ids=['subtopic_1', 'subtopic_2'],\n story_ids=['story_1', 'story_2'])\n self.learner_group_model.update_timestamps()\n self.learner_group_model.put()","def test_add_item(self):\n self.inv.add_item(self.item_helmet)\n str_inventory = self.inv.pretty\n str_item = self.item_helmet.pretty\n\n self.rebuild_instance()\n str_unequipped = self.inv.unequipped[0].pretty\n\n assert str_inventory == self.inv.pretty\n assert str_item == str_unequipped","def test_properties_count_group_by_group_by_and_sub_group_by_get(self):\n pass","def pytest_collection_modifyitems(config, items):\n if config.getoption(\"--run-slow\"):\n # --run-slow given in cli: do not skip slow tests\n return\n\n skip_slow = pytest.mark.skip(reason=\"need --run-slow option to run\")\n for item in items:\n if \"slow\" in item.keywords:\n item.add_marker(skip_slow)","def test_update_inline_discussion_settings(self):\n config_course_cohorts(self.course, is_cohorted=True)\n self._login_as_staff()\n expected_response = self._get_expected_response()\n self._assert_current_settings(expected_response)\n\n now = datetime.now()\n ItemFactory.create(\n parent_location=self.course.location,\n category='discussion',\n discussion_id='Topic_A',\n discussion_category='Chapter',\n discussion_target='Discussion',\n start=now\n )\n expected_response['divided_inline_discussions'] = ['Topic_A', ]\n self._assert_patched_settings({'divided_inline_discussions': ['Topic_A']}, expected_response)\n\n expected_response['divided_inline_discussions'] = []\n self._assert_patched_settings({'divided_inline_discussions': []}, expected_response)","def extend(self, item: Any) -> BaseList:\n super().extend(item)\n return self","def setUp(self):\r\n super(TestDuplicateItem, self).setUp()\r\n # Create a parent chapter (for testing children of children).\r\n resp = self.create_xblock(parent_usage_key=self.usage_key, category='chapter')\r\n self.chapter_usage_key = self.response_usage_key(resp)\r\n\r\n # create a sequential containing a problem and an html component\r\n resp = self.create_xblock(parent_usage_key=self.chapter_usage_key, category='sequential')\r\n self.seq_usage_key = self.response_usage_key(resp)\r\n\r\n # create problem and an html component\r\n resp = self.create_xblock(parent_usage_key=self.seq_usage_key, category='problem', boilerplate='multiplechoice.yaml')\r\n self.problem_usage_key = self.response_usage_key(resp)\r\n\r\n resp = self.create_xblock(parent_usage_key=self.seq_usage_key, category='html')\r\n self.html_usage_key = self.response_usage_key(resp)\r\n\r\n # Create a second sequential just (testing children of children)\r\n self.create_xblock(parent_usage_key=self.chapter_usage_key, category='sequential2')","def test_replace_group(self):\n pass","def setUp(self):\n self.item_id = \"mss37820001\"","def test_get_groups(self):\n pass","def test_get_groups(self):\n pass","def setUp_extra(self):\n pass","def test_grouping(self):\n n = self.create(NodeItem, UML.Node)\n a = self.create(ArtifactItem, UML.Artifact)\n\n self.group(n, a)\n\n assert 1 == len(n.subject.deployment)\n assert n.subject.deployment[0].deployedArtifact[0] is a.subject","def test_groups_post(self):\n pass","def test_properties_count_group_by_group_by_get(self):\n pass","def SetItemHasChildren(self, item, has=True):\r\n \r\n item.SetHasPlus(has)\r\n self.RefreshLine(item)","def setUpClass(cls):\n super().setUpClass()\n cls.group = Group.objects.create(\n title=TEST_GROUP_NAME,\n slug=TEST_GROUP_SLUG\n )","def test_groups_get(self):\n pass","def test_groups_get(self):\n pass","def setUp(self):\n self.portal = self.layer['portal']\n self.workflow = api.portal.get_tool('portal_workflow')\n\n # in tests we have to manually map content types to workflows\n self.workflow.setChainForPortalTypes(\n ['eestec.portal.event'],\n 'event_workflow'\n )\n\n # add test item\n self.lc = api.content.create(\n type='eestec.portal.lc',\n title=u'lc',\n container=self.portal,\n )\n\n self.event = api.content.create(\n type='eestec.portal.event',\n title=u'Tést event',\n container=self.lc\n )\n\n self.event = self.portal.lc['test-event']","def test_create_group(self):\n pass","def test_create_group(self):\n pass","def test_read_group(self):\n pass","def _itemAdded(self, item):\n group = self.item()\n if group is None:\n return\n\n row = group.getItems().index(item)\n self.addRow(nodeFromItem(item), row + self._CHILDREN_ROW_OFFSET)","def gen_inventory(self):\n if isinstance(self.resource, list):\n self.my_add_group(self.resource, 'default_group')\n elif isinstance(self.resource, dict):\n for groupname, hosts_and_vars in self.resource.iteritems():\n self.my_add_group(hosts_and_vars.get(\"hosts\"), groupname, hosts_and_vars.get(\"vars\"))","def update_meta_property(self, property, item, iteration):\n try:\n property[iteration].append(item)\n except:\n property[iteration] = [item]","def setUp(self):\n super(ItemTest, self).setUp()\n \n self.ct = ContentType(app_label=\"po\")\n self.ct.save()\n self.p = Permission(codename=\"add_purchaseorder\", content_type=self.ct)\n self.p.save()\n self.p2 = Permission(codename=\"change_purchaseorder\", content_type=self.ct)\n self.p2.save()\n \n #Create the user\n self.username = 'tester'\n self.password = 'pass'\n self.user = User.objects.create_user(self.username, 'charliep@dellarobbiathailand.com', self.password)\n self.user.save()\n self.user.user_permissions.add(self.p)\n self.user.user_permissions.add(self.p2)\n self.client.login(username=self.username, password=self.password)\n \n \n self.supplier = Supplier(**base_supplier)\n self.supplier.save()\n self.address = Address(**base_address)\n self.address.contact = self.supplier\n self.address.save()\n self.contact = SupplierContact(name='test', email='test@yahoo.com', telephone=1234, primary=True)\n self.contact.supplier = self.supplier\n self.contact.save()\n \n \n self.supply = Fabric.create(**base_fabric)\n \n #self.supply.units = \"m^2\"\n self.supply.save()\n \n self.po = PurchaseOrder()\n self.po.employee = self.user\n self.po.supplier = self.supplier\n self.po.terms = self.supplier.terms\n self.po.vat = 7\n self.po.order_date = datetime.datetime(2014, 3, 2)\n self.po.save()\n \n self.item = Item(unit_cost=Decimal('13.55'), quantity=Decimal('10'), supply=self.supply)\n self.item.description = self.supply.description\n self.item.purchase_order = self.po\n self.item.save()","def preset_items(self):\r\n\r\n raise NotImplementedError","def insert(self, item, **kwargs) -> None:\n for entry in item.get_entries():\n self.client.insert(\n entry[\"feature\"],\n entry[\"label\"].encode(),\n group_label=entry[\"group_label\"].encode(),\n **kwargs\n )","def test_custom_features():\n\n group = Group({\n \"a\": CustomSized(),\n \"b\": CustomNamed(),\n \"c\": CustomDynamic(),\n \"d\": CustomSlotList(),\n \"e\": CustomSlotDict(),\n })\n\n for _ in range(10):\n for x in range(4):\n group.set_a(x)\n for x in \"abcd\":\n group.set_b(x)\n group.set_c(\"blub\")\n group.set_d()\n group.set_e()\n group.push()\n\n array = group.array()\n assert array.shape == (10, 15)","def addTest(self, test):\r\n self.tests.append(test)\r\n return","def configure_test(self, test, config_json):\n pass","def test_new_group(self, inventoryloader):\n inventoryloader.add_group(u'newgroup')\n assert 'newgroup' in inventoryloader.groups","def test_update_entry_groups(self):\r\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\r\n pass","def set_add_dispute_line_item_group(self, line_item_group):\n self.set_value_into_input_field(self.add_dispute_line_item_group_textbox_locator, line_item_group)","def test_csv_partial_status_add_service_group(self):\n\n successful_rows = [row for row in csv_reader\n if row['Status'] == STATUS_PARTIAL and\n row['Netscaler Command'] == 'add serviceGroup']\n for row in successful_rows:\n avi_object = self.format_string_to_json(row['AVI Object'])\n skipped_settings = \\\n self.format_string_to_list(row['Skipped settings'])\n avi_pool_object = json.loads(avi_object)\n avi_pool = [cs_vs for cs_vs in aviconfig['Pool']\n if cs_vs['name'] == avi_pool_object['name']]\n self.assertTrue(len(avi_pool) == 1)\n self.assertFalse(len(skipped_settings) == 0)\n for skipped_attribute in skipped_settings:\n self.assertIn(skipped_attribute, row['Full Command'])","def print_item(group):\n print(\"\\tName: {}\".format(group.name))\n print(\"\\tId: {}\".format(group.id))\n print(\"\\tLocation: {}\".format(group.location))\n print(\"\\tTags: {}\".format(group.tags))\n if hasattr(group, 'properties'):\n print_properties(group.properties)","def test_patch_resource_group(self):\n pass","def enable(self, item_id):\n pass","def pytest_collection_modifyitems(session, items, config):\n if config.option.remote_status != \"no\":\n if config.option.remote_status == \"only\":\n # deselect all other tests if ``--remote-status=only``\n items[:] = []\n report_module = config.hook.pytest_pycollect_makemodule(\n path=py.path.local(remote_status.__file__), parent=session\n )\n _remote_test_functions = [\n remote_status.test_urls_urllib,\n remote_status.test_urls_requests,\n remote_status.test_urls_socket,\n ]\n\n remote_tests = []\n for testfunc in _remote_test_functions:\n remote_tests.extend(\n config.hook.pytest_pycollect_makeitem(\n collector=report_module, name=testfunc.__name__, obj=testfunc\n )\n )\n\n items.extend(remote_tests)\n return","def test_contribute(self):\n pass","def tests_ti_document_add_label(self):\n super().group_add_label()","def add_test(self,test):\n l = test.id.split('.')\n s_obj = self\n while len(l) > 0:\n s_name = l.pop(0)\n if len(l) > 0:\n if s_name in s_obj.suites:\n s_obj = s_obj.suites[s_name]\n else:\n new_suite = Suite(s_name,parent=s_obj)\n s_obj.suites[s_name] = new_suite\n s_obj = new_suite\n s_obj.tests.append(test)","def tests_ti_document_add_tag(self, request: FixtureRequest):\n super().group_add_tag(request)","def test_register_item(self, init_event, mocker):\n mock_map = {}\n\n mocker.patch.object(\n houdini_toolbox.events.event.HoudiniEvent,\n \"item_map\",\n new_callable=mocker.PropertyMock(return_value=mock_map),\n )\n\n # Mock the item via the reference in the module so that the isinstance()\n # test is more reliable vs mocking houdini_toolbox.events.item.HoudiniEventItem\n mock_item = mocker.MagicMock(spec=houdini_toolbox.events.event.HoudiniEventItem)\n\n event = init_event()\n event.register_item(mock_item)\n\n assert mock_map == {mock_item.priority: [mock_item]}","def setUp(self):\n\n if self.id().split('.')[-1] == 'test_singleLine':\n self.testParams = [\n {'csvfile': 'F',\n 'expectedLinkograph': [({'F'},set(),set())],\n 'expectedLabels': ['F']},\n {'csvfile': 'F ',\n 'expectedLinkograph': [({'F'},set(),set())],\n 'expectedLabels': ['F']}]\n\n elif self.id().split('.')[-1] == 'test_twoLines':\n self.testParams = [\n {'csvfile': 'F,\\nBs',\n 'expectedLinkograph': [({'F'},set(),set()),\n ({'Bs'}, set(), set())],\n 'expectedLabels': ['Bs', 'F']},\n {'csvfile': 'F,1\\nBs',\n 'expectedLinkograph': [({'F'},set(),{1}),\n ({'Bs'}, {0}, set())],\n 'expectedLabels': ['Bs', 'F']}]\n\n elif self.id().split('.')[-1] == 'test_threeLines':\n self.testParams = [\n {'csvfile': 'F\\nBs,2\\nBe',\n 'expectedLinkograph': [({'F'},set(),set()),\n ({'Bs'},set(),{2}),\n ({'Be'},{1},set())],\n 'expectedLabels': ['Be', 'Bs', 'F']},\n {'csvfile': 'F,1,2\\nBs,2\\nBe',\n 'expectedLinkograph': [({'F'},set(),{1,2}),\n ({'Bs'}, {0}, {2}),\n ({'Be'}, {0,1}, set())],\n 'expectedLabels': ['Be', 'Bs', 'F']}]","def test_exclude_include_overlapping_resolved_with_include_for_configitem():\n\n @mc_config(ef, load_now=True)\n def config(rt):\n with ItemWithAA() as cr:\n cr.aa = 1\n with item(mc_include=[g_dev12, pp, dev2], mc_exclude=[g_dev23]) as it:\n it.setattr('anattr', pp=1, g_dev12_3=2)\n it.setattr('b', pp=1, dev2=0)\n it.setattr('anotherattr', default=111)\n return cr\n\n cr = config(prod).ItemWithAA\n assert not cr.item\n assert compare_json(cr, _include_exclude_for_configitem_expected_json, test_excluded=True)\n\n cr = config(dev1).ItemWithAA\n assert cr.item\n\n cr = config(dev2).ItemWithAA\n assert cr.item\n assert cr.item.b == 0\n\n cr = config(dev3).ItemWithAA\n assert not cr.item\n\n cr = config(pp).ItemWithAA\n assert cr.item\n assert cr.item.anattr == 1\n assert cr.item.b == 1\n assert cr.item.anotherattr == 111","def test_reorder_in_group(self):\r\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty, self.group_b]},\r\n {self.group_a: [self.group_a_item_2, self.group_a_item_1]},\r\n {self.group_b: [self.group_b_item_1, self.group_b_item_2]},\r\n {self.group_empty: []}]\r\n self.drag_and_verify(self.group_a_item_2_handle, self.group_a_item_1_handle, expected_ordering)","def test_get_scenarios_expanded(self):\n pass","def test_add_with_new_item(self):\n settings.TEST_SETTING_LIST = []\n wrapper = SettingListWrapper('TEST_SETTING_LIST', 'test setting list')\n wrapper.add('item1')\n\n self.assertEqual(settings.TEST_SETTING_LIST, ['item1'])\n self.assertEqual(wrapper.ref_counts.get('item1'), 1)","def testItemsIncludeNode(self):\n self.stream_start(mode='client',\n plugins=['xep_0030'])\n\n\n self.xmpp['xep_0030'].static.add_node(node='testing')\n\n self.recv(\"\"\"\n <iq to=\"tester@localhost/resource\" type=\"get\" id=\"test\">\n <query xmlns=\"http://jabber.org/protocol/disco#items\"\n node=\"testing\" />\n </iq>\n \"\"\")\n\n self.send(\"\"\"\n <iq type=\"result\" id=\"test\">\n <query xmlns=\"http://jabber.org/protocol/disco#items\"\n node=\"testing\">\n </query>\n </iq>\"\"\",\n method='mask')","def test_exclude_include_overlapping_for_configitem(capsys):\n\n @mc_config(ef, load_now=True)\n def config(rt):\n with ItemWithAA() as cr:\n cr.aa = 1\n with item(mc_include=[g_dev12_3, pp], mc_exclude=[g_dev12]) as it:\n it.setattr('anattr', pp=1, g_dev12_3=2)\n it.setattr('b', pp=1, dev3=0)\n it.setattr('anotherattr', default=111)\n return cr\n\n cr = config(prod).ItemWithAA\n assert cr.aa == 1\n assert not cr.item\n assert compare_json(cr, _include_exclude_for_configitem_expected_json, test_excluded=True)\n\n cr = config(dev1).ItemWithAA\n assert cr.aa == 1\n assert not cr.item\n\n cr = config(dev2).ItemWithAA\n assert cr.aa == 1\n assert not cr.item\n\n cr = config(dev3).ItemWithAA\n assert cr.aa == 1\n assert cr.item\n assert cr.item.anattr == 2\n assert cr.item.b == 0\n assert cr.item.anotherattr == 111\n\n cr = config(pp).ItemWithAA\n assert cr.aa == 1\n assert cr.item\n assert cr.item.anattr == 1\n assert cr.item.b == 1\n assert cr.item.anotherattr == 111","def test_group_by_roles_and_hardware_info(self):\n self._test_group_by('Roles and hardware info', [1, 2, 1, 1, 1])","def pytest_runtest_makereport(item, call):\n # execute all other hooks to obtain the report object\n outcome = yield\n rep = outcome.get_result()\n\n # set a report attribute for each phase of a call, which can\n # be \"setup\", \"call\", \"teardown\"\n # used to e.g. during browser tests to take screenshot on failure\n setattr(item, \"rep_\" + rep.when, rep)","def test_add_one_more_test(self):\n self.assertTrue(True)","def tests_ti_document_update(self, request: FixtureRequest):\n super().group_update(request)","def setUp(self):\r\n super(TestEditItem, self).setUp()\r\n # create a chapter\r\n display_name = 'chapter created'\r\n resp = self.create_xblock(display_name=display_name, category='chapter')\r\n chap_usage_key = self.response_usage_key(resp)\r\n resp = self.create_xblock(parent_usage_key=chap_usage_key, category='sequential')\r\n self.seq_usage_key = self.response_usage_key(resp)\r\n self.seq_update_url = reverse_usage_url(\"xblock_handler\", self.seq_usage_key)\r\n\r\n # create problem w/ boilerplate\r\n template_id = 'multiplechoice.yaml'\r\n resp = self.create_xblock(parent_usage_key=self.seq_usage_key, category='problem', boilerplate=template_id)\r\n self.problem_usage_key = self.response_usage_key(resp)\r\n self.problem_update_url = reverse_usage_url(\"xblock_handler\", self.problem_usage_key)\r\n\r\n self.course_update_url = reverse_usage_url(\"xblock_handler\", self.usage_key)","def testAddToggleProperty(self):\n chris = self.users['chris']\n alice = self.users['alice']\n like = ToggleProperty.objects.create_toggleproperty(\"like\", chris, alice)\n\n self.assertEquals(like.user, chris)\n self.assertEquals(like.content_object, alice)\n\n meta_like = ToggleProperty.objects.create_toggleproperty(\"like\", alice, like)\n\n self.assertEquals(meta_like.user, alice)\n self.assertEquals(meta_like.content_object, like)","def add_test(self, id):\n id = int(id)\n workflow = Workflow.get(id)\n scufl = Scufl(workflow.data)\n match_types = [\"exact\", \"ignore\", \"regex\"]\n \n return dict(id=None, workflow_id=id, name=workflow.name,\n description=workflow.description, scufl=scufl,\n workflow_test=None, sources={},\n match_types = match_types,\n out_types = {},\n sinks={})","def groupInputItem(name,items=[],**kargs):\n kargs['name'] = name\n kargs['items'] = items\n kargs['itemtype'] = 'group'\n return kargs"],"string":"[\n \"def test_test_inline_additional_properties(self):\\n pass\",\n \"def pytest_after_group_items(session, config, items):\",\n \"def pytest_collection_modifyitems(config, items):\\n # check if studio tests myst be skipped\\n run_study = config.getoption(\\\"--runstudy\\\")\\n # 'all' will match all studies, '' will not match anything\\n run_study = {'': '(?!x)x', 'all': '.*'}.get(run_study, run_study)\\n # --runstudy given in cli: do not skip study tests and\\n test_selected = list()\\n test_skipped = list()\\n groups = dict()\\n incremental = pytest.mark.incremental()\\n\\n def add():\\n \\\"helper for gathering test info\\\"\\n marker = item.get_marker(mark)\\n kwargs = parse_args(marker.args, marker.kwargs)\\n group_name = kwargs['name']\\n group = groups.setdefault(group_name, dict())\\n group.setdefault(mark, list()).append((kwargs, item))\\n item.add_marker(incremental)\\n\\n # place every test in regular, prerequisite and studies\\n # group by name\\n for item in items:\\n for mark in set(item.keywords.keys()).intersection(MARKS):\\n add()\\n break\\n else:\\n test_selected.append(item)\\n\\n def sort(a, b):\\n \\\"Sort two items by order priority\\\"\\n return cmp(a[0]['order'], b[0]['order'])\\n\\n # use studies precedence to built the global sequence order\\n mandatory = 'study' # mandatory mark for global sorting: study\\n studies = list()\\n for name, info in groups.items():\\n studies.extend(info.get(mandatory, []))\\n studies.sort(sort)\\n\\n def append(tests, where):\\n \\\"helper to add the test item from info structure\\\"\\n for test in tests:\\n test = test[1]\\n if test not in where:\\n where.append(test)\\n\\n # select only the test that are going to be launched\\n width = 0\\n regexp = re.compile(run_study, re.I | re.DOTALL)\\n for study in studies:\\n group_name = study[0]['name']\\n width = max(width, len(group_name))\\n where = test_selected if regexp.search(group_name) else test_skipped\\n for mark, seq in groups[group_name].items():\\n if mark == mandatory:\\n continue\\n seq.sort(sort)\\n append(seq, where)\\n append([study], where)\\n\\n if config.getoption(\\\"--show_order\\\") or config.getoption(\\\"--debug\\\"):\\n fmt = \\\"{0:>3d} [{1:>%s}] {2}\\\" % width\\n for i, item in enumerate(test_selected + test_skipped):\\n study = get_study_name(item)\\n fqn = get_FQN(item)\\n line = fmt.format(i, study, fqn)\\n if item in test_selected:\\n line = term.green('+' + line)\\n else:\\n line = term.yellow('-' + line)\\n print(line)\\n\\n # we make the --runstudy check at the end to be able to show\\n # test order with --show_order or --debig options\\n # reorder tests by group name and replace items IN-PLACE\\n if run_study:\\n items[:] = test_selected\\n return\\n\\n skip_test = pytest.mark.skip(reason=\\\"need --runstudy option to run\\\")\\n for item in items:\\n if set(item.keywords.keys()).intersection(MARKS):\\n item.add_marker(skip_test)\",\n \"def test_add_group(self):\\n pass\",\n \"def add_test_group(self, test_group):\\n self.test_groups[test_group.name] = test_group\",\n \"def pytest_collection_modifyitems(items, config):\\n from . import tagging\\n\\n remaining = []\\n deselected = []\\n for item in items:\\n # Get all tags for this test (includes tags on class level if present)\\n tags = item.get_marker(\\\"tags\\\")\\n\\n if config.option.collectonly:\\n info = item.parent.name.split(\\\"/\\\")\\n print({\\\"name\\\": item.name, \\\"folder\\\": info[3],\\n \\\"module\\\": info[4][:-3], \\\"tags\\\": tags.args})\\n\\n # This line fills two purposes. Handle the cases where '--tags'\\n # 1) was omitted, this will run all tests except 'not active' and\\n # 'awaiting_fix' ones.\\n # 2) has no arguments (a case that can occur when running in Docker).\\n tags = tags.args + ('all',) if tags else ['all']\\n\\n # Create a list of the tags\\n tags_list = tagging.TagsCollection.build_tags_list(tags)\\n\\n # Determine if test should be run depending on the parameter tags\\n # See also: pytest_configure hook\\n if config.parameter_tags.should_pick_up(tags_list):\\n remaining.append(item)\\n else:\\n deselected.append(item)\\n\\n if deselected:\\n config.hook.pytest_deselected(items=deselected)\\n items[:] = remaining\",\n \"def pytest_collection_modifyitems(session, config, items):\\n\\n test_scenarios = DefaultDict(TestSuite)\\n\\n config_scenarios = config.option.scenarios\\n filter_scenarios = config_scenarios is not None\\n skip_setup = config.option.no_setup\\n\\n if skip_setup and (not filter_scenarios or len(config_scenarios) > 1):\\n raise RuntimeWarning(\\n \\\"Configured no setup and teardown but more then one scenario is configured\\\")\\n\\n # Group tests by scenario in to TestSuite objects\\n for test in items:\\n scenario = scenario_re.match(test.name).groups()[0]\\n\\n if filter_scenarios and should_skip_scenario(scenario, config_scenarios):\\n continue\\n\\n if test.originalname == \\\"test_setup\\\":\\n test_scenarios[scenario].setup = test\\n elif test.originalname == \\\"test_teardown\\\":\\n test_scenarios[scenario].teardown = test\\n else:\\n test_scenarios[scenario].tests.append(test)\\n\\n # Clear all pytest tests\\n items.clear()\\n\\n # Order tests\\n for scenario in test_scenarios.values():\\n if len(scenario.tests) != 0:\\n suite = scenario.tests\\n if not skip_setup:\\n suite.insert(0, scenario.setup)\\n suite.append(scenario.teardown)\\n\\n items.extend(suite)\",\n \"def tests_ti_document_add_attribute(self, request: FixtureRequest):\\n super().group_add_attribute(request)\",\n \"def test_patch_group(self):\\n pass\",\n \"def test_patch_group(self):\\n pass\",\n \"def test_000_add_group(self):\\n # This case is always passed because it's tested in setup_module,\\n # If setup module fails, this case will never run\\n pass\",\n \"def test_grouping(self):\\n s = self.create(ComponentItem, UML.Component)\\n uc1 = self.create(UseCaseItem, UML.UseCase)\\n uc2 = self.create(UseCaseItem, UML.UseCase)\\n\\n self.group(s, uc1)\\n assert 1 == len(uc1.subject.subject)\\n self.group(s, uc2)\\n assert 1 == len(uc2.subject.subject)\\n\\n # Classifier.useCase is not navigable to UseCase\\n # self.assertEqual(2, len(s.subject.useCase))\",\n \"def test_test_group_parameters(self):\\n pass\",\n \"def test_list_group(self):\\n pass\",\n \"def enable_meta_data(item) : \\n assert(has_value(item))\\n\\n if not item_has_meta(item) : \\n \\n # Wrap simple types to allow attributes to be added to them.\\n if isinstance(item, str) : item = str_wrapper(item)\\n elif isinstance(item, float) : item = float_wrapper(item)\\n elif isinstance(item, int) : item = int_wrapper(item)\\n elif isinstance(item, list) : item = list_wrapper(item)\\n elif isinstance(item, dict) : item = dict_wrapper(item)\\n \\n setattr(item, META_ATTRIBUTE, Properties())\\n \\n return item\",\n \"def test_patchorganizations_item(self):\\n pass\",\n \"def pytest_collection_modifyitems(config, items):\\n execute_mssql_tests = ensure_mssql_ready_for_tests(config)\\n skip_mssql = pytest.mark.skip(reason=\\\"requires SQL Server\\\")\\n for item in items:\\n if \\\"mssql\\\" in item.keywords:\\n if execute_mssql_tests:\\n # Add 'mssql_setup_and_teardown' as FIRST in fixture list\\n fixtures = ['mssql_setup_and_teardown'] + item.fixturenames\\n item.fixturenames = fixtures\\n else:\\n item.add_marker(skip_mssql)\\n if \\\"http_server\\\" in item.keywords:\\n item.fixturenames.append('http_server_setup_and_teardown')\",\n \"def define_group_properties(self):\\n\\n # PropertyGroup\\n self.propertygroup['debug']['x86'] = get_propertygroup(\\n 'debug', 'x86', ' and @Label=\\\"Configuration\\\"'\\n )\\n self.propertygroup['debug']['x64'] = get_propertygroup(\\n 'debug', 'x64', ' and @Label=\\\"Configuration\\\"'\\n )\\n self.propertygroup['release']['x86'] = get_propertygroup(\\n 'release', 'x86', ' and @Label=\\\"Configuration\\\"'\\n )\\n self.propertygroup['release']['x64'] = get_propertygroup(\\n 'release', 'x64', ' and @Label=\\\"Configuration\\\"'\\n )\\n\\n # ItemDefinitionGroup\\n self.definitiongroups['debug']['x86'] = get_definitiongroup('debug', 'x86')\\n self.definitiongroups['debug']['x64'] = get_definitiongroup('debug', 'x64')\\n self.definitiongroups['release']['x86'] = get_definitiongroup('release', 'x86')\\n self.definitiongroups['release']['x64'] = get_definitiongroup('release', 'x64')\",\n \"def test_properties_stats_group_by_group_by_and_sub_group_by_get(self):\\n pass\",\n \"def add_item(self):\\n item = models.Item(item_name=self.test_item,\\n list_id=1,\\n description=self.test_item_desc)\\n item.add()\",\n \"def test_properties_stats_group_by_group_by_get(self):\\n pass\",\n \"def pytest_collection_modifyitems(config, items):\\n if config.getoption(\\\"--slurm\\\"):\\n return ## run all\\n skip_slurm = pytest.mark.skip(reason=\\\"need --slurm option to run\\\")\\n for item in items:\\n if \\\"slurm\\\" in item.keywords:\\n item.add_marker(skip_slurm)\\n if config.getoption(\\\"--long\\\"):\\n return\\n skip_long = pytest.mark.skip(reason=\\\"need --long option to run\\\")\\n for item in items:\\n if \\\"long\\\" in item.keywords:\\n item.add_marker(skip_long)\\n # no --long no --slurm or only --long\",\n \"def addCustomTests(self, tests):\\n pass\",\n \"def add_to_group(self,item):\\n self.items.append(item)\\n self.n += 1\",\n \"def test_update_group(self):\\n pass\",\n \"def pytest_itemcollected(item):\\n item.name = item.name.split('[', 1)[1][:-1]\\n # pylint: disable=protected-access\\n item._nodeid = item.name\",\n \"def pytest_runtest_setup(item):\\n if hasattr(item, 'fixturenames') and LOOP_KEY not in item.fixturenames:\\n item.fixturenames.append(LOOP_KEY)\",\n \"def _create_test_dict(cls, test_item):\\n test_dict = {TEST_ID_KEY: test_item.identifier,\\n TEST_NAME_KEY: test_item.data.name}\\n\\n test_dict[TEST_CLASS_CODE_KEY] = type(test_item.data)\\n\\n if test_item.IS_COMPLEX:\\n subtests = [cls._create_test_dict(sub_test)\\n for sub_test in test_item]\\n\\n test_dict[TEST_SUBTESTS_KEY] = subtests\\n\\n return test_dict\",\n \"def test_replace_groups(self):\\n pass\",\n \"def start_composite(self, test_item):\\n msg = messages.StartComposite(test_id=test_item.identifier)\\n self._request(msg)\",\n \"def setUp(self):\\n self.item = ElectricAppliances('10', 'test', '4', '5', 'GE', '110')\",\n \"def setUp(self):\\n self.new_inv_item = ['1', 'Knife Set', 10, 'n', 'n']\\n self.new_furn_item = ['2', 'Couch', 25, 'y', 'Cloth', 'L']\\n self.new_elec_item = ['3', 'Dryer', 100, 'n', 'y', 'Samsung', 12]\",\n \"def persist_test_group(self, obj: object, group: str) -> str:\",\n \"def pytest_runtest_makereport(item):\\n # execute all other hooks to obtain the report object\\n outcome = yield\\n rep = outcome.get_result()\\n\\n # set a report attribute for each phase of a call, which can\\n # be \\\"setup\\\", \\\"call\\\", \\\"teardown\\\"\\n\\n setattr(item, \\\"rep_\\\" + rep.when, rep)\",\n \"def create_TestGroup(test_case, # type: AnyMagpieTestCaseType\\n override_group_name=null, # type: Optional[Str]\\n override_discoverable=null, # type: Optional[bool]\\n override_data=null, # type: Optional[JSON]\\n override_headers=null, # type: Optional[HeadersType]\\n override_cookies=null, # type: Optional[CookiesType]\\n ): # type: (...) -> JSON\\n app_or_url = get_app_or_url(test_case)\\n data = override_data\\n if override_data is null:\\n data = {\\\"group_name\\\": override_group_name if override_group_name is not null else test_case.test_group_name}\\n # only add 'discoverable' if explicitly provided here to preserve original behaviour of 'no value provided'\\n if override_discoverable is not null:\\n data[\\\"discoverable\\\"] = override_discoverable\\n grp_name = (data or {}).get(\\\"group_name\\\")\\n if grp_name:\\n test_case.extra_group_names.add(grp_name) # indicate potential removal at a later point\\n resp = test_request(app_or_url, \\\"POST\\\", \\\"/groups\\\", json=data,\\n headers=override_headers if override_headers is not null else test_case.json_headers,\\n cookies=override_cookies if override_cookies is not null else test_case.cookies)\\n return check_response_basic_info(resp, 201, expected_method=\\\"POST\\\")\",\n \"def get_existing_test_group(self, obj: object) -> str:\",\n \"def group_by(self, key):\\n ret = {}\\n for test in self._testset():\\n if hastag(test, key):\\n ret.setdefault(gettag(test, key), []).append(test)\\n continue\\n ret.setdefault(\\\"others\\\", []).append(test)\\n for k in ret:\\n ret[k] = self.__class__(ret[k])\\n return ret\",\n \"def test_products_ref_groups_put(self):\\n pass\",\n \"def setup(self, ds: PetscDocStringImpl, parameter_list_prefix_check: Optional[Callable[[ParameterList, PetscDocString, ItemsType], ItemsType]] = None) -> None:\\n groups: collections.defaultdict[\\n int,\\n list[tuple[SourceRange, DescribableItem, int]]\\n ] = collections.defaultdict(list)\\n subheading = 0\\n\\n def inspector(ds: PetscDocStringImpl, loc: SourceRange, line: str, verdict: Verdict) -> None:\\n if not line or line.isspace():\\n return\\n\\n if verdict > 0 and len(groups.keys()):\\n nonlocal subheading\\n subheading += 1\\n lstp = line.lstrip()\\n # .ve and .vb might trip up the prefix detection since they start with '.'\\n if lstp.startswith(self.prefixes) and not lstp.startswith(('.vb', '.ve')):\\n item = DescribableItem(line, prefixes=self.prefixes)\\n groups[subheading].append((loc, item, item.arglen()))\\n return\\n\\n super()._do_setup(ds, inspector)\\n items = dict(groups)\\n if parameter_list_prefix_check is not None:\\n assert callable(parameter_list_prefix_check)\\n items = parameter_list_prefix_check(self, ds, items)\\n self.items = items\\n return\",\n \"def test_patchhardwares_item(self):\\n pass\",\n \"def setUp(self) -> None:\\n super().setUp()\\n\\n self.learner_group_model = learner_group_models.LearnerGroupModel(\\n id='learner_group_32',\\n title='title',\\n description='description',\\n facilitator_user_ids=['facilitator_1', 'facilitator_2'],\\n learner_user_ids=['learner_1', 'learner_2', 'learner_3'],\\n invited_learner_user_ids=['invited_user_1', 'invited_user_2'],\\n subtopic_page_ids=['subtopic_1', 'subtopic_2'],\\n story_ids=['story_1', 'story_2'])\\n self.learner_group_model.update_timestamps()\\n self.learner_group_model.put()\",\n \"def test_add_item(self):\\n self.inv.add_item(self.item_helmet)\\n str_inventory = self.inv.pretty\\n str_item = self.item_helmet.pretty\\n\\n self.rebuild_instance()\\n str_unequipped = self.inv.unequipped[0].pretty\\n\\n assert str_inventory == self.inv.pretty\\n assert str_item == str_unequipped\",\n \"def test_properties_count_group_by_group_by_and_sub_group_by_get(self):\\n pass\",\n \"def pytest_collection_modifyitems(config, items):\\n if config.getoption(\\\"--run-slow\\\"):\\n # --run-slow given in cli: do not skip slow tests\\n return\\n\\n skip_slow = pytest.mark.skip(reason=\\\"need --run-slow option to run\\\")\\n for item in items:\\n if \\\"slow\\\" in item.keywords:\\n item.add_marker(skip_slow)\",\n \"def test_update_inline_discussion_settings(self):\\n config_course_cohorts(self.course, is_cohorted=True)\\n self._login_as_staff()\\n expected_response = self._get_expected_response()\\n self._assert_current_settings(expected_response)\\n\\n now = datetime.now()\\n ItemFactory.create(\\n parent_location=self.course.location,\\n category='discussion',\\n discussion_id='Topic_A',\\n discussion_category='Chapter',\\n discussion_target='Discussion',\\n start=now\\n )\\n expected_response['divided_inline_discussions'] = ['Topic_A', ]\\n self._assert_patched_settings({'divided_inline_discussions': ['Topic_A']}, expected_response)\\n\\n expected_response['divided_inline_discussions'] = []\\n self._assert_patched_settings({'divided_inline_discussions': []}, expected_response)\",\n \"def extend(self, item: Any) -> BaseList:\\n super().extend(item)\\n return self\",\n \"def setUp(self):\\r\\n super(TestDuplicateItem, self).setUp()\\r\\n # Create a parent chapter (for testing children of children).\\r\\n resp = self.create_xblock(parent_usage_key=self.usage_key, category='chapter')\\r\\n self.chapter_usage_key = self.response_usage_key(resp)\\r\\n\\r\\n # create a sequential containing a problem and an html component\\r\\n resp = self.create_xblock(parent_usage_key=self.chapter_usage_key, category='sequential')\\r\\n self.seq_usage_key = self.response_usage_key(resp)\\r\\n\\r\\n # create problem and an html component\\r\\n resp = self.create_xblock(parent_usage_key=self.seq_usage_key, category='problem', boilerplate='multiplechoice.yaml')\\r\\n self.problem_usage_key = self.response_usage_key(resp)\\r\\n\\r\\n resp = self.create_xblock(parent_usage_key=self.seq_usage_key, category='html')\\r\\n self.html_usage_key = self.response_usage_key(resp)\\r\\n\\r\\n # Create a second sequential just (testing children of children)\\r\\n self.create_xblock(parent_usage_key=self.chapter_usage_key, category='sequential2')\",\n \"def test_replace_group(self):\\n pass\",\n \"def setUp(self):\\n self.item_id = \\\"mss37820001\\\"\",\n \"def test_get_groups(self):\\n pass\",\n \"def test_get_groups(self):\\n pass\",\n \"def setUp_extra(self):\\n pass\",\n \"def test_grouping(self):\\n n = self.create(NodeItem, UML.Node)\\n a = self.create(ArtifactItem, UML.Artifact)\\n\\n self.group(n, a)\\n\\n assert 1 == len(n.subject.deployment)\\n assert n.subject.deployment[0].deployedArtifact[0] is a.subject\",\n \"def test_groups_post(self):\\n pass\",\n \"def test_properties_count_group_by_group_by_get(self):\\n pass\",\n \"def SetItemHasChildren(self, item, has=True):\\r\\n \\r\\n item.SetHasPlus(has)\\r\\n self.RefreshLine(item)\",\n \"def setUpClass(cls):\\n super().setUpClass()\\n cls.group = Group.objects.create(\\n title=TEST_GROUP_NAME,\\n slug=TEST_GROUP_SLUG\\n )\",\n \"def test_groups_get(self):\\n pass\",\n \"def test_groups_get(self):\\n pass\",\n \"def setUp(self):\\n self.portal = self.layer['portal']\\n self.workflow = api.portal.get_tool('portal_workflow')\\n\\n # in tests we have to manually map content types to workflows\\n self.workflow.setChainForPortalTypes(\\n ['eestec.portal.event'],\\n 'event_workflow'\\n )\\n\\n # add test item\\n self.lc = api.content.create(\\n type='eestec.portal.lc',\\n title=u'lc',\\n container=self.portal,\\n )\\n\\n self.event = api.content.create(\\n type='eestec.portal.event',\\n title=u'Tést event',\\n container=self.lc\\n )\\n\\n self.event = self.portal.lc['test-event']\",\n \"def test_create_group(self):\\n pass\",\n \"def test_create_group(self):\\n pass\",\n \"def test_read_group(self):\\n pass\",\n \"def _itemAdded(self, item):\\n group = self.item()\\n if group is None:\\n return\\n\\n row = group.getItems().index(item)\\n self.addRow(nodeFromItem(item), row + self._CHILDREN_ROW_OFFSET)\",\n \"def gen_inventory(self):\\n if isinstance(self.resource, list):\\n self.my_add_group(self.resource, 'default_group')\\n elif isinstance(self.resource, dict):\\n for groupname, hosts_and_vars in self.resource.iteritems():\\n self.my_add_group(hosts_and_vars.get(\\\"hosts\\\"), groupname, hosts_and_vars.get(\\\"vars\\\"))\",\n \"def update_meta_property(self, property, item, iteration):\\n try:\\n property[iteration].append(item)\\n except:\\n property[iteration] = [item]\",\n \"def setUp(self):\\n super(ItemTest, self).setUp()\\n \\n self.ct = ContentType(app_label=\\\"po\\\")\\n self.ct.save()\\n self.p = Permission(codename=\\\"add_purchaseorder\\\", content_type=self.ct)\\n self.p.save()\\n self.p2 = Permission(codename=\\\"change_purchaseorder\\\", content_type=self.ct)\\n self.p2.save()\\n \\n #Create the user\\n self.username = 'tester'\\n self.password = 'pass'\\n self.user = User.objects.create_user(self.username, 'charliep@dellarobbiathailand.com', self.password)\\n self.user.save()\\n self.user.user_permissions.add(self.p)\\n self.user.user_permissions.add(self.p2)\\n self.client.login(username=self.username, password=self.password)\\n \\n \\n self.supplier = Supplier(**base_supplier)\\n self.supplier.save()\\n self.address = Address(**base_address)\\n self.address.contact = self.supplier\\n self.address.save()\\n self.contact = SupplierContact(name='test', email='test@yahoo.com', telephone=1234, primary=True)\\n self.contact.supplier = self.supplier\\n self.contact.save()\\n \\n \\n self.supply = Fabric.create(**base_fabric)\\n \\n #self.supply.units = \\\"m^2\\\"\\n self.supply.save()\\n \\n self.po = PurchaseOrder()\\n self.po.employee = self.user\\n self.po.supplier = self.supplier\\n self.po.terms = self.supplier.terms\\n self.po.vat = 7\\n self.po.order_date = datetime.datetime(2014, 3, 2)\\n self.po.save()\\n \\n self.item = Item(unit_cost=Decimal('13.55'), quantity=Decimal('10'), supply=self.supply)\\n self.item.description = self.supply.description\\n self.item.purchase_order = self.po\\n self.item.save()\",\n \"def preset_items(self):\\r\\n\\r\\n raise NotImplementedError\",\n \"def insert(self, item, **kwargs) -> None:\\n for entry in item.get_entries():\\n self.client.insert(\\n entry[\\\"feature\\\"],\\n entry[\\\"label\\\"].encode(),\\n group_label=entry[\\\"group_label\\\"].encode(),\\n **kwargs\\n )\",\n \"def test_custom_features():\\n\\n group = Group({\\n \\\"a\\\": CustomSized(),\\n \\\"b\\\": CustomNamed(),\\n \\\"c\\\": CustomDynamic(),\\n \\\"d\\\": CustomSlotList(),\\n \\\"e\\\": CustomSlotDict(),\\n })\\n\\n for _ in range(10):\\n for x in range(4):\\n group.set_a(x)\\n for x in \\\"abcd\\\":\\n group.set_b(x)\\n group.set_c(\\\"blub\\\")\\n group.set_d()\\n group.set_e()\\n group.push()\\n\\n array = group.array()\\n assert array.shape == (10, 15)\",\n \"def addTest(self, test):\\r\\n self.tests.append(test)\\r\\n return\",\n \"def configure_test(self, test, config_json):\\n pass\",\n \"def test_new_group(self, inventoryloader):\\n inventoryloader.add_group(u'newgroup')\\n assert 'newgroup' in inventoryloader.groups\",\n \"def test_update_entry_groups(self):\\r\\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\\r\\n pass\",\n \"def set_add_dispute_line_item_group(self, line_item_group):\\n self.set_value_into_input_field(self.add_dispute_line_item_group_textbox_locator, line_item_group)\",\n \"def test_csv_partial_status_add_service_group(self):\\n\\n successful_rows = [row for row in csv_reader\\n if row['Status'] == STATUS_PARTIAL and\\n row['Netscaler Command'] == 'add serviceGroup']\\n for row in successful_rows:\\n avi_object = self.format_string_to_json(row['AVI Object'])\\n skipped_settings = \\\\\\n self.format_string_to_list(row['Skipped settings'])\\n avi_pool_object = json.loads(avi_object)\\n avi_pool = [cs_vs for cs_vs in aviconfig['Pool']\\n if cs_vs['name'] == avi_pool_object['name']]\\n self.assertTrue(len(avi_pool) == 1)\\n self.assertFalse(len(skipped_settings) == 0)\\n for skipped_attribute in skipped_settings:\\n self.assertIn(skipped_attribute, row['Full Command'])\",\n \"def print_item(group):\\n print(\\\"\\\\tName: {}\\\".format(group.name))\\n print(\\\"\\\\tId: {}\\\".format(group.id))\\n print(\\\"\\\\tLocation: {}\\\".format(group.location))\\n print(\\\"\\\\tTags: {}\\\".format(group.tags))\\n if hasattr(group, 'properties'):\\n print_properties(group.properties)\",\n \"def test_patch_resource_group(self):\\n pass\",\n \"def enable(self, item_id):\\n pass\",\n \"def pytest_collection_modifyitems(session, items, config):\\n if config.option.remote_status != \\\"no\\\":\\n if config.option.remote_status == \\\"only\\\":\\n # deselect all other tests if ``--remote-status=only``\\n items[:] = []\\n report_module = config.hook.pytest_pycollect_makemodule(\\n path=py.path.local(remote_status.__file__), parent=session\\n )\\n _remote_test_functions = [\\n remote_status.test_urls_urllib,\\n remote_status.test_urls_requests,\\n remote_status.test_urls_socket,\\n ]\\n\\n remote_tests = []\\n for testfunc in _remote_test_functions:\\n remote_tests.extend(\\n config.hook.pytest_pycollect_makeitem(\\n collector=report_module, name=testfunc.__name__, obj=testfunc\\n )\\n )\\n\\n items.extend(remote_tests)\\n return\",\n \"def test_contribute(self):\\n pass\",\n \"def tests_ti_document_add_label(self):\\n super().group_add_label()\",\n \"def add_test(self,test):\\n l = test.id.split('.')\\n s_obj = self\\n while len(l) > 0:\\n s_name = l.pop(0)\\n if len(l) > 0:\\n if s_name in s_obj.suites:\\n s_obj = s_obj.suites[s_name]\\n else:\\n new_suite = Suite(s_name,parent=s_obj)\\n s_obj.suites[s_name] = new_suite\\n s_obj = new_suite\\n s_obj.tests.append(test)\",\n \"def tests_ti_document_add_tag(self, request: FixtureRequest):\\n super().group_add_tag(request)\",\n \"def test_register_item(self, init_event, mocker):\\n mock_map = {}\\n\\n mocker.patch.object(\\n houdini_toolbox.events.event.HoudiniEvent,\\n \\\"item_map\\\",\\n new_callable=mocker.PropertyMock(return_value=mock_map),\\n )\\n\\n # Mock the item via the reference in the module so that the isinstance()\\n # test is more reliable vs mocking houdini_toolbox.events.item.HoudiniEventItem\\n mock_item = mocker.MagicMock(spec=houdini_toolbox.events.event.HoudiniEventItem)\\n\\n event = init_event()\\n event.register_item(mock_item)\\n\\n assert mock_map == {mock_item.priority: [mock_item]}\",\n \"def setUp(self):\\n\\n if self.id().split('.')[-1] == 'test_singleLine':\\n self.testParams = [\\n {'csvfile': 'F',\\n 'expectedLinkograph': [({'F'},set(),set())],\\n 'expectedLabels': ['F']},\\n {'csvfile': 'F ',\\n 'expectedLinkograph': [({'F'},set(),set())],\\n 'expectedLabels': ['F']}]\\n\\n elif self.id().split('.')[-1] == 'test_twoLines':\\n self.testParams = [\\n {'csvfile': 'F,\\\\nBs',\\n 'expectedLinkograph': [({'F'},set(),set()),\\n ({'Bs'}, set(), set())],\\n 'expectedLabels': ['Bs', 'F']},\\n {'csvfile': 'F,1\\\\nBs',\\n 'expectedLinkograph': [({'F'},set(),{1}),\\n ({'Bs'}, {0}, set())],\\n 'expectedLabels': ['Bs', 'F']}]\\n\\n elif self.id().split('.')[-1] == 'test_threeLines':\\n self.testParams = [\\n {'csvfile': 'F\\\\nBs,2\\\\nBe',\\n 'expectedLinkograph': [({'F'},set(),set()),\\n ({'Bs'},set(),{2}),\\n ({'Be'},{1},set())],\\n 'expectedLabels': ['Be', 'Bs', 'F']},\\n {'csvfile': 'F,1,2\\\\nBs,2\\\\nBe',\\n 'expectedLinkograph': [({'F'},set(),{1,2}),\\n ({'Bs'}, {0}, {2}),\\n ({'Be'}, {0,1}, set())],\\n 'expectedLabels': ['Be', 'Bs', 'F']}]\",\n \"def test_exclude_include_overlapping_resolved_with_include_for_configitem():\\n\\n @mc_config(ef, load_now=True)\\n def config(rt):\\n with ItemWithAA() as cr:\\n cr.aa = 1\\n with item(mc_include=[g_dev12, pp, dev2], mc_exclude=[g_dev23]) as it:\\n it.setattr('anattr', pp=1, g_dev12_3=2)\\n it.setattr('b', pp=1, dev2=0)\\n it.setattr('anotherattr', default=111)\\n return cr\\n\\n cr = config(prod).ItemWithAA\\n assert not cr.item\\n assert compare_json(cr, _include_exclude_for_configitem_expected_json, test_excluded=True)\\n\\n cr = config(dev1).ItemWithAA\\n assert cr.item\\n\\n cr = config(dev2).ItemWithAA\\n assert cr.item\\n assert cr.item.b == 0\\n\\n cr = config(dev3).ItemWithAA\\n assert not cr.item\\n\\n cr = config(pp).ItemWithAA\\n assert cr.item\\n assert cr.item.anattr == 1\\n assert cr.item.b == 1\\n assert cr.item.anotherattr == 111\",\n \"def test_reorder_in_group(self):\\r\\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty, self.group_b]},\\r\\n {self.group_a: [self.group_a_item_2, self.group_a_item_1]},\\r\\n {self.group_b: [self.group_b_item_1, self.group_b_item_2]},\\r\\n {self.group_empty: []}]\\r\\n self.drag_and_verify(self.group_a_item_2_handle, self.group_a_item_1_handle, expected_ordering)\",\n \"def test_get_scenarios_expanded(self):\\n pass\",\n \"def test_add_with_new_item(self):\\n settings.TEST_SETTING_LIST = []\\n wrapper = SettingListWrapper('TEST_SETTING_LIST', 'test setting list')\\n wrapper.add('item1')\\n\\n self.assertEqual(settings.TEST_SETTING_LIST, ['item1'])\\n self.assertEqual(wrapper.ref_counts.get('item1'), 1)\",\n \"def testItemsIncludeNode(self):\\n self.stream_start(mode='client',\\n plugins=['xep_0030'])\\n\\n\\n self.xmpp['xep_0030'].static.add_node(node='testing')\\n\\n self.recv(\\\"\\\"\\\"\\n <iq to=\\\"tester@localhost/resource\\\" type=\\\"get\\\" id=\\\"test\\\">\\n <query xmlns=\\\"http://jabber.org/protocol/disco#items\\\"\\n node=\\\"testing\\\" />\\n </iq>\\n \\\"\\\"\\\")\\n\\n self.send(\\\"\\\"\\\"\\n <iq type=\\\"result\\\" id=\\\"test\\\">\\n <query xmlns=\\\"http://jabber.org/protocol/disco#items\\\"\\n node=\\\"testing\\\">\\n </query>\\n </iq>\\\"\\\"\\\",\\n method='mask')\",\n \"def test_exclude_include_overlapping_for_configitem(capsys):\\n\\n @mc_config(ef, load_now=True)\\n def config(rt):\\n with ItemWithAA() as cr:\\n cr.aa = 1\\n with item(mc_include=[g_dev12_3, pp], mc_exclude=[g_dev12]) as it:\\n it.setattr('anattr', pp=1, g_dev12_3=2)\\n it.setattr('b', pp=1, dev3=0)\\n it.setattr('anotherattr', default=111)\\n return cr\\n\\n cr = config(prod).ItemWithAA\\n assert cr.aa == 1\\n assert not cr.item\\n assert compare_json(cr, _include_exclude_for_configitem_expected_json, test_excluded=True)\\n\\n cr = config(dev1).ItemWithAA\\n assert cr.aa == 1\\n assert not cr.item\\n\\n cr = config(dev2).ItemWithAA\\n assert cr.aa == 1\\n assert not cr.item\\n\\n cr = config(dev3).ItemWithAA\\n assert cr.aa == 1\\n assert cr.item\\n assert cr.item.anattr == 2\\n assert cr.item.b == 0\\n assert cr.item.anotherattr == 111\\n\\n cr = config(pp).ItemWithAA\\n assert cr.aa == 1\\n assert cr.item\\n assert cr.item.anattr == 1\\n assert cr.item.b == 1\\n assert cr.item.anotherattr == 111\",\n \"def test_group_by_roles_and_hardware_info(self):\\n self._test_group_by('Roles and hardware info', [1, 2, 1, 1, 1])\",\n \"def pytest_runtest_makereport(item, call):\\n # execute all other hooks to obtain the report object\\n outcome = yield\\n rep = outcome.get_result()\\n\\n # set a report attribute for each phase of a call, which can\\n # be \\\"setup\\\", \\\"call\\\", \\\"teardown\\\"\\n # used to e.g. during browser tests to take screenshot on failure\\n setattr(item, \\\"rep_\\\" + rep.when, rep)\",\n \"def test_add_one_more_test(self):\\n self.assertTrue(True)\",\n \"def tests_ti_document_update(self, request: FixtureRequest):\\n super().group_update(request)\",\n \"def setUp(self):\\r\\n super(TestEditItem, self).setUp()\\r\\n # create a chapter\\r\\n display_name = 'chapter created'\\r\\n resp = self.create_xblock(display_name=display_name, category='chapter')\\r\\n chap_usage_key = self.response_usage_key(resp)\\r\\n resp = self.create_xblock(parent_usage_key=chap_usage_key, category='sequential')\\r\\n self.seq_usage_key = self.response_usage_key(resp)\\r\\n self.seq_update_url = reverse_usage_url(\\\"xblock_handler\\\", self.seq_usage_key)\\r\\n\\r\\n # create problem w/ boilerplate\\r\\n template_id = 'multiplechoice.yaml'\\r\\n resp = self.create_xblock(parent_usage_key=self.seq_usage_key, category='problem', boilerplate=template_id)\\r\\n self.problem_usage_key = self.response_usage_key(resp)\\r\\n self.problem_update_url = reverse_usage_url(\\\"xblock_handler\\\", self.problem_usage_key)\\r\\n\\r\\n self.course_update_url = reverse_usage_url(\\\"xblock_handler\\\", self.usage_key)\",\n \"def testAddToggleProperty(self):\\n chris = self.users['chris']\\n alice = self.users['alice']\\n like = ToggleProperty.objects.create_toggleproperty(\\\"like\\\", chris, alice)\\n\\n self.assertEquals(like.user, chris)\\n self.assertEquals(like.content_object, alice)\\n\\n meta_like = ToggleProperty.objects.create_toggleproperty(\\\"like\\\", alice, like)\\n\\n self.assertEquals(meta_like.user, alice)\\n self.assertEquals(meta_like.content_object, like)\",\n \"def add_test(self, id):\\n id = int(id)\\n workflow = Workflow.get(id)\\n scufl = Scufl(workflow.data)\\n match_types = [\\\"exact\\\", \\\"ignore\\\", \\\"regex\\\"]\\n \\n return dict(id=None, workflow_id=id, name=workflow.name,\\n description=workflow.description, scufl=scufl,\\n workflow_test=None, sources={},\\n match_types = match_types,\\n out_types = {},\\n sinks={})\",\n \"def groupInputItem(name,items=[],**kargs):\\n kargs['name'] = name\\n kargs['items'] = items\\n kargs['itemtype'] = 'group'\\n return kargs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5947742","0.5900158","0.5774352","0.573061","0.5615433","0.55916494","0.5568033","0.5543221","0.55160785","0.55160785","0.55108106","0.54705465","0.5394397","0.5350562","0.5348308","0.5344149","0.52992165","0.5255538","0.52473474","0.5215013","0.52096534","0.5158549","0.51427746","0.5131177","0.5095684","0.5077799","0.5048955","0.50477105","0.5033805","0.5033776","0.50004375","0.49977612","0.4978219","0.49364534","0.49291897","0.49277872","0.49124235","0.4895549","0.488314","0.48496616","0.48412707","0.48314714","0.48306143","0.48215783","0.4818026","0.4815899","0.48108575","0.4800958","0.47960073","0.47890285","0.47890285","0.47831056","0.47730184","0.47698313","0.4763213","0.4753319","0.47518927","0.4749937","0.4749937","0.47448808","0.4739649","0.4739649","0.47353613","0.47263002","0.4725965","0.47218865","0.4718242","0.47138613","0.47088322","0.470763","0.470753","0.46986967","0.46882072","0.4678628","0.46765304","0.46742615","0.46729624","0.4669195","0.4663971","0.46636152","0.4662797","0.46601832","0.46539605","0.46514186","0.465084","0.46469432","0.46465698","0.46445498","0.4640211","0.46236262","0.46134079","0.46073228","0.45986477","0.45970926","0.4593566","0.4590645","0.4589287","0.45821306","0.45819184","0.45815128"],"string":"[\n \"0.5947742\",\n \"0.5900158\",\n \"0.5774352\",\n \"0.573061\",\n \"0.5615433\",\n \"0.55916494\",\n \"0.5568033\",\n \"0.5543221\",\n \"0.55160785\",\n \"0.55160785\",\n \"0.55108106\",\n \"0.54705465\",\n \"0.5394397\",\n \"0.5350562\",\n \"0.5348308\",\n \"0.5344149\",\n \"0.52992165\",\n \"0.5255538\",\n \"0.52473474\",\n \"0.5215013\",\n \"0.52096534\",\n \"0.5158549\",\n \"0.51427746\",\n \"0.5131177\",\n \"0.5095684\",\n \"0.5077799\",\n \"0.5048955\",\n \"0.50477105\",\n \"0.5033805\",\n \"0.5033776\",\n \"0.50004375\",\n \"0.49977612\",\n \"0.4978219\",\n \"0.49364534\",\n \"0.49291897\",\n \"0.49277872\",\n \"0.49124235\",\n \"0.4895549\",\n \"0.488314\",\n \"0.48496616\",\n \"0.48412707\",\n \"0.48314714\",\n \"0.48306143\",\n \"0.48215783\",\n \"0.4818026\",\n \"0.4815899\",\n \"0.48108575\",\n \"0.4800958\",\n \"0.47960073\",\n \"0.47890285\",\n \"0.47890285\",\n \"0.47831056\",\n \"0.47730184\",\n \"0.47698313\",\n \"0.4763213\",\n \"0.4753319\",\n \"0.47518927\",\n \"0.4749937\",\n \"0.4749937\",\n \"0.47448808\",\n \"0.4739649\",\n \"0.4739649\",\n \"0.47353613\",\n \"0.47263002\",\n \"0.4725965\",\n \"0.47218865\",\n \"0.4718242\",\n \"0.47138613\",\n \"0.47088322\",\n \"0.470763\",\n \"0.470753\",\n \"0.46986967\",\n \"0.46882072\",\n \"0.4678628\",\n \"0.46765304\",\n \"0.46742615\",\n \"0.46729624\",\n \"0.4669195\",\n \"0.4663971\",\n \"0.46636152\",\n \"0.4662797\",\n \"0.46601832\",\n \"0.46539605\",\n \"0.46514186\",\n \"0.465084\",\n \"0.46469432\",\n \"0.46465698\",\n \"0.46445498\",\n \"0.4640211\",\n \"0.46236262\",\n \"0.46134079\",\n \"0.46073228\",\n \"0.45986477\",\n \"0.45970926\",\n \"0.4593566\",\n \"0.4590645\",\n \"0.4589287\",\n \"0.45821306\",\n \"0.45819184\",\n \"0.45815128\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.668921"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":77692,"cells":{"query":{"kind":"string","value":"receives 2 items and decides if they can run together. returns bool"},"document":{"kind":"string","value":"def pytest_can_run_together(item1, item2):"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def got_both(self):\r\n if Item.A in self.items and Item.B in self.items:\r\n return True","def valid_multiple_in_request(self):\n return self._repeatable[0] is True","def adaptable( item1, item2 ) :\n\n if( item2 is None ) : return( True )\n return re.fullmatch(item2, item1) is not None","def can_combine(self, first, second):\n # Need to check out of order issues as\n # blocks are sorted by where they start in a\n mismatch_ab = (first.a_end <= second.a\n and second.b_end <= first.b)\n mismatch_ba = (second.a_end <= first.a\n and first.b_end <= second.b)\n out_of_order = mismatch_ab or mismatch_ba\n return not out_of_order and self.jump_gap(second)","def is_satisfied(self, item: Any) -> bool:","def mutexActions(a1, a2, mutexProps):\n if Pair(a1, a2) not in PlanGraphLevel.independentActions:\n return True\n\n for x in [Pair(y, z) for y in a1.getPre() for z in a2.getPre()]:\n if x in mutexProps:\n return True\n return False","def valid_multiple_in_response(self):\n return self._repeatable[1] is True","def mutexPropositions(prop1, prop2, mutexActions):\n for a1 in prop1.getProducers():\n for a2 in prop2.getProducers():\n if Pair(a1, a2) not in mutexActions:\n return False\n return True","def is_same_set(self, item1, item2):\n res = False\n for s in self._data:\n if item1 in s and item2 in s:\n res = True\n break\n return res","def can_split(self) -> bool:\n if len(self.cards) == 2 and self.cards[0].value == self.cards[1].value:\n return True\n else:\n return False","def shouldMergeRequests(self, builder, req1, req2):\n if self.mergeRequests is not None:\n if callable(self.mergeRequests):\n return self.mergeRequests(builder, req1, req2)\n elif self.mergeRequests == False:\n # To save typing, this allows c['mergeRequests'] = False\n return False\n return req1.canBeMergedWith(req2)","def test_and_multichain(self) -> None:\n assert Ok(2).and_(Ok(3)).and_(Ok(4)).and_(Ok(5)) == Ok(5)","def activity_pair_matches(self, trace, activity1, activity2) -> bool:\n raise NotImplementedError","def take_item(self, item):\r\n if len(self.items) <= 2:\r\n self.items.append(item)\r\n if self.got_both():\r\n self.working = True","def test_allow_multiples(self):\r\n o1 = self.b1.get(self.key)\r\n o2 = self.b2.get(self.key)\r\n\r\n o1.set_data(\"object-1\")\r\n o1.store()\r\n o2.set_data(\"object-2\")\r\n o2.store()\r\n\r\n conflicted = self.b1.get(self.key)\r\n siblings = filter(bool, (s.get_data() for s in conflicted.get_siblings()))\r\n self.assertEqual(len(siblings), 2)","def is_multi_commands(args: list) -> bool:\n for arg in args:\n if not isinstance(arg, list):\n return False\n # all elements must be lists\n return True","def has_both(self) -> bool:\n return self.has_required() and self.has_optional()","def is_satisfied(self, item):\n return all(map(\n # we go through every single item in self.args and check if the specks are satisfied.\n lambda spec: spec.is_satisfied(item), self.args\n ))","def verified_connection_ft2(self, id1, id2):\n if id1 in self.users.keys():\n return id2 in self.users.keys() and len(self.users[id1] & self.users[id2]) != 0\n return False","def activity_pair_matches(self, trace, activity1, activity2) -> bool:\n return self.subtrace_count(trace, [activity1, activity2]) > 0","def check_inputs(self, item_data):\n if not item_data[0] in self.data['pizza']:\n print('Error: ' + item_data[0] + ' pizza does not exist.')\n return False\n\n if not item_data[1] in self.data['pizza'][item_data[0]]:\n print('Error: ' + item_data[1] + ' size does not exist for '\n + item_data[0] + ' pizza.')\n return False\n\n for topping in item_data[2]:\n if not topping in self.data['topping']:\n print('Error: Pizza topping ' + topping + ' does not exist.')\n return False\n return True","def OnCompareItems(self, item1, item2):\r\n\r\n # do the comparison here, and not delegate to self._main_win, in order\r\n # to let the user override it\r\n\r\n return self.GetItemText(item1) == self.GetItemText(item2)","def done(poles):\n if len(poles[0]) == 0 and len(poles[1]) == 0:\n return True\n else:\n return False","def is_allergic_to(self, item):\n if item in self.list:\n return True\n else:\n return False","def can_overlap(self):\n return False","def can_act(self, **kwargs):\n return True","def compatible_sequences(self, seq1, seq2):\n return (len(seq1) == len(seq1)\n and all(self.compatible_elements(e1, e2) for e1, e2 in zip(seq1, seq2)))","def both_events(self, Rover, name1, name2):\n func1 = self.event.get(name1)\n func2 = self.event.get(name2)\n return func1(Rover) and func2(Rover)","def _check_items(cls, sequence):\n all([cls._check_item(x) for x in sequence])","async def pair(self, *args, **kwargs) -> bool:\n return await self._backend.pair(*args, **kwargs)","def check(iters):\n\treturn check_hypernet(iters[0]) and check_other(iters[1])","def __or__(p1, p2):\n return p1.isparallel(p2)","def hasConflicts(self):\n partners = {}\n for first, second in self:\n #print >>sys.stderr, \"first:\", first, \"second:\", second\n if first is None:\n if second is None:\n continue #no pairing info\n else:\n first, second = second, first #swap order so None is 2nd\n if second is None: #check first isn't paired\n if partners.get(first, None) is not None:\n print >>sys.stderr, \"here1\"\n print >>sys.stderr, \"first:\", first, \"second:\", second\n return True\n else:\n partners[first] = None\n else: #first and second were both non-empty: check partners\n if first in partners:\n if partners[first] != second:\n print >>sys.stderr, \"here2\"\n print >>sys.stderr, \"first:\", first, \"second:\", second, \"partners[first]\", partners[first]\n print \"partners:\", partners\n return True\n if second in partners:\n if partners[second] != first:\n print >>sys.stderr, \"here3\"\n print >>sys.stderr, \"first:\", first, \"second:\", second, \"partners[second]:\", partners[second]\n return True\n #add current pair to the list of constraints\n partners[first] = second\n partners[second] = first\n #can only get here if there weren't conflicts\n return False","def items_intersect(self):\n for a, b in combinations(self.items, 2):\n if a.intersects_with(b):\n return True\n\n return False","def batched(self) -> bool:\n return False","def checker(self, product):\n for item in self.instock:\n if item == product:\n return True\n return False","def check_items(self, items):\n for item in items:\n if item['user'] in self.required_list and item['user'] not in self.approved_required_list:\n if item['result'] is True or item['result'] == 'approved':\n logger.info(\"%s approved\", item['user'])\n self.approved_required_list.append(item['user'])\n else:\n logger.info(\"%s declined\", item['user'])\n error_msg = \"Since {} is a required member for approval, this approval step fails. \".format(item['user'])\n logger.error(error_msg)\n self.exit(rc=2, detail=error_msg)\n if item['user'] in self.optional_list and item['user'] not in self.approved_optional_list:\n if item['result'] is True or item['result'] == 'approved':\n logger.info(\"%s approved\", item['user'])\n if item['user'] in self.declined_optional_list:\n self.declined_optional_list.remove(item['user'])\n self.approved_optional_list.append(item['user'])\n else:\n logger.info(\"%s declined\", item['user'])\n self.declined_optional_list.append(item['user'])\n if len(self.declined_optional_list) >= (len(self.optional_list) - self.number_optional):\n error_msg = \"Not be able to fulfill requirement that {} optional approvals, since {} declined request.\".format(\n self.number_optional, self.declined_optional_list)\n logger.error(error_msg)\n self.exit(rc=2, detail=error_msg)\n\n if len(self.approved_required_list) >= len(self.required_list) \\\n and len(self.approved_optional_list) >= self.number_optional:\n logger.info(\"Approval requirements are fully met. Exit gracefully.\")\n self.exit(0)","def is_action_applied(instance: Algorithm) -> bool:\n if len(get_results(instance)) == 0:\n return False\n return True","def _apply_item(self, item: Item) -> bool:\n if self.locked:\n self.__locked = item.item_type != self.__key\n return not self.locked","def Item(self) -> bool:","def other_threads_are_active():\n return len(fake_threads) >= 2","def overlap(component1, component2):\n if component1[0].start <= component2[0].stop and component2[0].start <= component1[0].stop:\n if component1[1].start <= component2[1].stop and component2[1].start <= component1[1].stop:\n return True\n return False","def check_tie(self, player1, player2):\n if self.check_win(player1) or self.check_win(player2):\n return False\n return self.check_grid_full()","def check_end_game(self):\n return False if (any(self.p1_pits()) and any(self.p2_pits())) else True","def ready(self):\n return len(self.player1.ships) == len(\n self.player2.ships) == len(self.SHIP_INFO)","def can_run(self):\n\t\treturn self._start is None","def _dispatching(self):\n return bool(self.generate_config or self.subapp or self.subcommand)","def is_ok_two_lines(line1, line2):\n card1 = line1[0]\n card2 = line1[1]\n card3 = line1[2]\n card4 = line2[0]\n card5 = line2[1]\n card6 = line2[2]\n idents1 = [card.ident for card in line1]\n idents2 = [card.ident for card in line2]\n intersection = list(set(idents1) & set(idents2))\n if intersection:\n return False\n if not is_coupled(card1.south, card4.north):\n return False\n if not is_coupled(card2.south, card5.north):\n return False\n if not is_coupled(card3.south, card6.north):\n return False\n return True","def __isJoint(self, taskA, taskB):\r\n if taskA.getDispatchedServer().getKey() == taskB.getDispatchedServer(). getKey():\r\n return True\r\n else:\r\n pathA = self._netGraph.getShortestPath(taskA.getAccessPoint(), taskA.getDispatchedServer())\r\n pathB = self._netGraph.getShortestPath(taskB.getAccessPoint(), taskB.getDispatchedServer())\r\n for la in pathA.getLinkList():\r\n for lb in pathB.getLinkList():\r\n if la.getKey() == lb.getKey():\r\n return True\r\n return False","def _is_item_allowed(resource, item, resourcesalloweddict, resourcesuseddict):\n\n if item in resourcesalloweddict[resource]:\n # this is semi nonsensical, but allows us to indicate which ports are used\n # through get_resource_information()\n resourcesuseddict[resource].add(item)\n return True\n\n else:\n return False","def _apply_item(self, item: Item) -> bool:\n return False","def validate_args(*args: Any) -> bool:\n\n return len(args) == 4 and Item.validate_price(args[2]) and Entity.validate_discount(args[3])","def check_for_group():\r\n if first_list[0][0] == second_list[0][0]:\r\n try:\r\n result = first_list[0][0], str(int(first_list[0][1]) + int(second_list[0][1]))\r\n except ValueError:\r\n result = first_list[0][0], str(float(first_list[0][1]) + float(second_list[0][1]))\r\n result_list.append(result)\r\n first_list.remove(first_list[0])\r\n second_list.remove(second_list[0])\r\n return True\r\n return False","def monkey_trouble(a_smile, b_smile):\n if (a_smile and b_smile) or (not(a_smile) and not(b_smile)):\n return True\n else:\n return False","def has_crossing_len2_ob(self) -> bool:\n fcell = self.first_cell\n scell = self.second_cell\n if self._fuse_row:\n possible_obs = [\n GriddedPerm((0, 1), (fcell, scell)),\n GriddedPerm((1, 0), (scell, fcell)),\n ]\n else:\n possible_obs = [\n GriddedPerm((0, 1), (fcell, scell)),\n GriddedPerm((1, 0), (fcell, scell)),\n ]\n return any(ob in possible_obs for ob in self._tiling.obstructions)","def check(self,item):\r\n raise AbstractError\r\n return False","def equals_items(self, item1, item2):\n if isinstance(item1, (text_type, binary_type)) is True:\n return self.equals_strings(item1, item2)\n\n if type(item1) is float or type(item2) is float:\n if round(item1, 4) != round(item2, 4):\n if self._verbose is True:\n logging.info(\"Float values rounded to \"\n \"4 digits are not equals: \"\n \"{:0.4f} != {:0.4f}\".format(item1, item2))\n return False\n return True\n\n if item1 != item2:\n if self._verbose is True:\n logging.info(\"Not equals: {0} {1}\".format(item1, item2))\n return False\n\n return True","def should_run(self, case: Tuple[Dict[str, Any], ...]) -> bool:\n return True","def is_valid_single_attempt(self, atoms_init, atoms_final):\n from scipy.spatial import cKDTree as KDTree\n from random import shuffle\n atoms1 = atoms_init.copy()\n atoms2 = atoms_final.copy()\n\n vol1 = atoms1.get_volume()\n vol2 = atoms2.get_volume()\n if vol2 > vol1:\n ratio = (vol2/vol1)**(1.0/3.0)\n cell1 = atoms1.get_cell()\n atoms1.set_cell(cell1*ratio, scale_atoms=True)\n else:\n ratio = (vol1/vol2)**(1.0/3.0)\n cell2 = atoms2.get_cell()\n atoms2.set_cell(cell2*ratio, scale_atoms=True)\n\n # Try construct the relation\n used_indices = []\n tree = KDTree(atoms2.get_positions())\n indices = list(range(0, len(atoms1)))\n shuffle(indices)\n for atom in atoms1:\n if atom.symbol in self.exclude:\n continue\n dist, closest = tree.query(atom.position, k=12)\n srt_indx = np.argsort(dist)\n dist = [dist[indx] for indx in srt_indx]\n closest = [closest[indx] for indx in srt_indx]\n\n if all(c in used_indices for c in closest):\n # More than one atom is closest to this\n # structure\n self.rejected_reason = \"More than one atom mapped onto the \"\n self.rejected_reason += \"same atoms in the initial structure\"\n return False\n\n # First, unused with mathing symbol\n closest_indx = None\n closest_dist = None\n for i, indx in enumerate(closest):\n if atoms2[indx].symbol == atom.symbol and indx not in used_indices:\n closest_indx = indx\n closest_dist = dist[i]\n break\n\n if closest_indx is None:\n self.rejected_reason = \"No unused atoms with macthing symbol!\"\n return False\n \n used_indices.append(closest_indx)\n if closest_dist > self.max_displacement:\n # The displacement is larger than the tolereance\n self.rejected_reason = \"Max displacement too large\"\n return False\n \n if atom.symbol != atoms2[closest_indx].symbol:\n self.rejected_reason = \"Mapped symbol does not match!\"\n return False\n return True","def _do_merge(ext, exts_other):\n for ext_other in exts_other:\n if not ext.is_duplicate(ext_other):\n return False\n return True","def connectable(iTypeA, iTypeB):\r\n return (iTypeA % 4) + (iTypeB % 4) == 3","def overlaps(self, other): # -> bool:\n ...","def is_queen_attacked(x1, y1, x2, y2):\n attacked_fields = queen_attack(x1, y1)\n second_queen_position = [x2, y2]\n if second_queen_position in attacked_fields:\n return True\n return False","def encompasses_broadcastable(b1, b2):\r\n if len(b1) < len(b2):\r\n return False\r\n b1 = b1[-len(b2):]\r\n return not any(v1 and not v2 for v1, v2 in zip(b1, b2))","def monkey_trouble(a_smile, b_smile):\r\n if a_smile and b_smile:\r\n return True\r\n if not a_smile and not b_smile:\r\n return True\r\n return False","def pareto_better(self, other: \"EvalItem\") -> bool:\n return self.size <= other.size and other.result <= self.result","def is_satisfied(self, item: Product) -> bool:\n return item.size == self.size","def can_run_experiment(self, info, device):\n nb_qubit_max = self.backends[device]['nq']\n nb_qubit_needed = info['nq']\n return nb_qubit_needed <= nb_qubit_max, nb_qubit_max, nb_qubit_needed","def valid_for_send(self, app):\n return (\n (self.to is not None) and\n (self.next_hop is not None) and\n (self.source is not None) and\n (self.command is not None) and\n (self.handler is not None) and\n (self.kind is not None) and\n (self.time_to_live is not None) and\n (self.time_to_live >= app.tick)\n )","def has_action2(self, feature):\n return feature in self._action2","def gameOver():\n if len(p1)==0 and len(p1winnings)==0:\n return True\n elif len(p2)==0 and len(p2winnings)==0:\n return True\n return False","def beats(self, one, two):\n return ((one == 'rock' and two == 'scissors') or\n (one == 'scissors' and two == 'paper') or\n (one == 'paper' and two == 'rock'))","def test_available_for_two_included(self):\n\n data = self._setup_two_included()\n self._do_test(\n data[\"run\"].id,\n self.available_param,\n [],\n )","async def test_multiple_same_state(hass):\n calls_1 = async_mock_service(hass, DOMAIN, SERVICE_TURN_ON)\n\n await async_reproduce_states(hass, [\n State(ENTITY_1, 'on'),\n State(ENTITY_2, 'on'),\n ])\n\n await hass.async_block_till_done()\n\n assert len(calls_1) == 2\n # order is not guaranteed\n assert any(call.data == {'entity_id': ENTITY_1} for call in calls_1)\n assert any(call.data == {'entity_id': ENTITY_2} for call in calls_1)","def verified_connection_ft3(self, id1, id2):\n if id2 not in self.users.keys() or id1 not in self.users.keys():\n return False\n\n f1 = self.users[id1]\n f2 = self.users[id2]\n fof1 = self.friends_of_friends(id1, f1)\n fof2 = self.friends_of_friends(id2, f2)\n return len((f1 | fof1) & (f2 | fof2)) != 0","def is_interfered(r, c, s1, s2):\n return r == 0 and c < s1 + s2 or r < s2 and c < s1","def is_bound(self, typ_one, thing_one, typ_two, thing_two):\n try:\n bound = self._is_bound(typ_one, thing_one, typ_two, thing_two)\n except BadNetScaler as error:\n # sigh, some combinations aren't done both ways\n if error.kwargs[\"errorcode\"] in (1088, 1232):\n bound = False\n else:\n raise\n\n if not bound:\n try:\n # Some combinations aren't the same both ways\n bound = self._is_bound(typ_two, thing_two, typ_one, thing_one)\n except BadNetScaler as error:\n if error.kwargs[\"errorcode\"] in (1088, 1232):\n bound = False\n else:\n raise\n\n return bound","def g2(a, b): \n if a and b:\n return False\n else:\n return True","def are_same(self, value1, value2):\n (group_1, val_1) = self.get_val_tuple(value1)\n (group_2, val_2) = self.get_val_tuple(value2)\n f_aresame = Or(*[ And(self.X[group_1, val_1, idx], self.X[group_2, val_2, idx])\n for idx in range(0, self.items_per) ])\n\n return f_aresame","def has_match(trajs_0, trajs_1):\n for i in range(len(trajs_0)):\n for j in range(len(trajs_1)):\n R = (trajs_0[i].get_slice()[:,:2] == trajs_1[j].get_slice()[:,:2])\n if isinstance(R, bool):\n if R:\n return True \n elif R.all():\n return True \n else:\n pass \n return False","def isMergeable(int1,int2):\n if set(int1.span)&set(int2.span) or int1.maxval+1==int2.minval:\n return True\n else:\n return False","def passes(self) -> bool:\n ...","def permissible(e1, e2):\n return e1[1] == e2[0] and \\\n total_edge_length(e1, e2) < maximum_distance and \\\n total_edge_angle(e1, e2) < maximum_angle_delta","def _and(cls, arg1, arg2):\n return arg1 and arg2","async def should_handle(self):\n local_controller = self.controller\n workers_total = len(local_controller.workers)\n geysers = local_controller.extractors\n drones_in_queue = local_controller.already_pending(DRONE)\n if (\n not local_controller.close_enemies_to_base\n and local_controller.can_train(DRONE)\n and not local_controller.counter_attack_vs_flying\n ):\n if workers_total == 12 and not drones_in_queue:\n return True\n if (\n workers_total in (13, 14, 15)\n and len(local_controller.overlords) + local_controller.already_pending(OVERLORD) > 1\n ):\n return True\n optimal_workers = min(\n sum(x.ideal_harvesters for x in local_controller.townhalls | geysers), 90 - len(geysers)\n )\n return (\n workers_total + drones_in_queue < optimal_workers\n and np.sum(\n np.array(\n [\n len(local_controller.zerglings),\n len(local_controller.hydras),\n len(local_controller.ultralisks),\n ]\n )\n * np.array([1, 2, 3])\n )\n > 15\n )\n return False","def is_valid_arg(self, muts, arg):\n for mut in muts:\n if arg in mut.args():\n return True\n\n return False","def can_overlap(self):\n return self.is_open","def can_overlap(self):\n return self.is_open","def check_other(seq_iter):\n\treturn any(filter(has_abba, seq_iter))","def number_of_images_valid():\r\n if number_of_images_a_valid() and number_of_images_b_valid():\r\n return True\r\n else:\r\n return False","def can_communicate_with(self, target):\n if self == target:\n return True\n msg = 'You try to connect topologies belonging to'\n msg += ' two different mpi tasks. Set taskids properly or use'\n msg += ' InterBridge.'\n assert self.task_id() == target.task_id(), msg\n\n # Parent communicator\n # Todo : define some proper conditions for compatibility\n # between topo_from, topo_to and parent:\n # - same size\n # - same domain\n # - common processus ...\n # At the time we check that both topo have\n # the same comm_origin.\n return self.is_consistent_with(target)","def check(self):\n\n if not self.target.ok():\n return False\n\n if not self.progid.ok():\n return False\n\n if not self.prinapp.ok():\n return False\n\n if not self.observers.ok():\n return False\n\n return True","def __contains__(self, item: Union[str, Socket]):\n return item in self.sequence","def true_false_both_filter(request, items, parameter):\n if parameter in request['args']:\n test = request['args'][parameter].lower()\n if test == 'true':\n items = [item for item in items if item[parameter]]\n elif test == 'false':\n items = [item for item in items if not item[parameter]]\n elif test == 'both':\n # Otherwise return both true and false values\n pass\n else:\n raise UserException(ERROR_TRUE_FALSE_BOTH_REQUIRED % parameter)\n\n return items","def cross(series1: Sequence, series2: Sequence) -> bool:\n return crossover(series1, series2) or crossover(series2, series1)","def test_select_same_element_multiple_times(self):\n\n sink = TObserver()\n obs = MergeSelectorObservable(\n left=self.left,\n right=self.right,\n # scheduler=self.scheduler,\n )\n obs.observe(init_observer_info(sink))\n ack_left = self.left.on_next_list([select_next, select_completed])\n\n ack_right = self.right.on_next_list([select_next, select_next, select_completed])\n\n self.assertIsInstance(self.measure_termination_state(obs), TerminationStates.InitState)\n self.assertIsInstance(self.measure_state(obs), ControlledZipStates.WaitOnLeftRight)\n self.assertEqual([select_next, select_next, select_completed], sink.received)\n self.assertIsInstance(ack_left.value, ContinueAck)\n self.assertIsInstance(ack_right, ContinueAck)","def win(player1, player2):\n if(player1 == 1 and player2 == 3) or (player1 == 2 and player2 == 1) \\\n or (player1 == 3 and player2 == 2):\n return True","def goal_test(self, state):\n \"*** YOUR CODE HERE ***\"\n if (state[0], state[1]) in self.goals: #Check to see if at goal state\n return True\n else:\n return False","def _overlap(x1, w1, x2, w2):\r\n if x1+w1 < x2-w2: return False\r\n if x1-w1 > x2+w2: return False\r\n\r\n return True","def handle_same_length(self, a, b):\n found = False\n for i, j in zip(a, b):\n if i == j:\n continue\n elif found:\n return False # this case is the second found edit, thus return false\n else:\n found = True\n return True"],"string":"[\n \"def got_both(self):\\r\\n if Item.A in self.items and Item.B in self.items:\\r\\n return True\",\n \"def valid_multiple_in_request(self):\\n return self._repeatable[0] is True\",\n \"def adaptable( item1, item2 ) :\\n\\n if( item2 is None ) : return( True )\\n return re.fullmatch(item2, item1) is not None\",\n \"def can_combine(self, first, second):\\n # Need to check out of order issues as\\n # blocks are sorted by where they start in a\\n mismatch_ab = (first.a_end <= second.a\\n and second.b_end <= first.b)\\n mismatch_ba = (second.a_end <= first.a\\n and first.b_end <= second.b)\\n out_of_order = mismatch_ab or mismatch_ba\\n return not out_of_order and self.jump_gap(second)\",\n \"def is_satisfied(self, item: Any) -> bool:\",\n \"def mutexActions(a1, a2, mutexProps):\\n if Pair(a1, a2) not in PlanGraphLevel.independentActions:\\n return True\\n\\n for x in [Pair(y, z) for y in a1.getPre() for z in a2.getPre()]:\\n if x in mutexProps:\\n return True\\n return False\",\n \"def valid_multiple_in_response(self):\\n return self._repeatable[1] is True\",\n \"def mutexPropositions(prop1, prop2, mutexActions):\\n for a1 in prop1.getProducers():\\n for a2 in prop2.getProducers():\\n if Pair(a1, a2) not in mutexActions:\\n return False\\n return True\",\n \"def is_same_set(self, item1, item2):\\n res = False\\n for s in self._data:\\n if item1 in s and item2 in s:\\n res = True\\n break\\n return res\",\n \"def can_split(self) -> bool:\\n if len(self.cards) == 2 and self.cards[0].value == self.cards[1].value:\\n return True\\n else:\\n return False\",\n \"def shouldMergeRequests(self, builder, req1, req2):\\n if self.mergeRequests is not None:\\n if callable(self.mergeRequests):\\n return self.mergeRequests(builder, req1, req2)\\n elif self.mergeRequests == False:\\n # To save typing, this allows c['mergeRequests'] = False\\n return False\\n return req1.canBeMergedWith(req2)\",\n \"def test_and_multichain(self) -> None:\\n assert Ok(2).and_(Ok(3)).and_(Ok(4)).and_(Ok(5)) == Ok(5)\",\n \"def activity_pair_matches(self, trace, activity1, activity2) -> bool:\\n raise NotImplementedError\",\n \"def take_item(self, item):\\r\\n if len(self.items) <= 2:\\r\\n self.items.append(item)\\r\\n if self.got_both():\\r\\n self.working = True\",\n \"def test_allow_multiples(self):\\r\\n o1 = self.b1.get(self.key)\\r\\n o2 = self.b2.get(self.key)\\r\\n\\r\\n o1.set_data(\\\"object-1\\\")\\r\\n o1.store()\\r\\n o2.set_data(\\\"object-2\\\")\\r\\n o2.store()\\r\\n\\r\\n conflicted = self.b1.get(self.key)\\r\\n siblings = filter(bool, (s.get_data() for s in conflicted.get_siblings()))\\r\\n self.assertEqual(len(siblings), 2)\",\n \"def is_multi_commands(args: list) -> bool:\\n for arg in args:\\n if not isinstance(arg, list):\\n return False\\n # all elements must be lists\\n return True\",\n \"def has_both(self) -> bool:\\n return self.has_required() and self.has_optional()\",\n \"def is_satisfied(self, item):\\n return all(map(\\n # we go through every single item in self.args and check if the specks are satisfied.\\n lambda spec: spec.is_satisfied(item), self.args\\n ))\",\n \"def verified_connection_ft2(self, id1, id2):\\n if id1 in self.users.keys():\\n return id2 in self.users.keys() and len(self.users[id1] & self.users[id2]) != 0\\n return False\",\n \"def activity_pair_matches(self, trace, activity1, activity2) -> bool:\\n return self.subtrace_count(trace, [activity1, activity2]) > 0\",\n \"def check_inputs(self, item_data):\\n if not item_data[0] in self.data['pizza']:\\n print('Error: ' + item_data[0] + ' pizza does not exist.')\\n return False\\n\\n if not item_data[1] in self.data['pizza'][item_data[0]]:\\n print('Error: ' + item_data[1] + ' size does not exist for '\\n + item_data[0] + ' pizza.')\\n return False\\n\\n for topping in item_data[2]:\\n if not topping in self.data['topping']:\\n print('Error: Pizza topping ' + topping + ' does not exist.')\\n return False\\n return True\",\n \"def OnCompareItems(self, item1, item2):\\r\\n\\r\\n # do the comparison here, and not delegate to self._main_win, in order\\r\\n # to let the user override it\\r\\n\\r\\n return self.GetItemText(item1) == self.GetItemText(item2)\",\n \"def done(poles):\\n if len(poles[0]) == 0 and len(poles[1]) == 0:\\n return True\\n else:\\n return False\",\n \"def is_allergic_to(self, item):\\n if item in self.list:\\n return True\\n else:\\n return False\",\n \"def can_overlap(self):\\n return False\",\n \"def can_act(self, **kwargs):\\n return True\",\n \"def compatible_sequences(self, seq1, seq2):\\n return (len(seq1) == len(seq1)\\n and all(self.compatible_elements(e1, e2) for e1, e2 in zip(seq1, seq2)))\",\n \"def both_events(self, Rover, name1, name2):\\n func1 = self.event.get(name1)\\n func2 = self.event.get(name2)\\n return func1(Rover) and func2(Rover)\",\n \"def _check_items(cls, sequence):\\n all([cls._check_item(x) for x in sequence])\",\n \"async def pair(self, *args, **kwargs) -> bool:\\n return await self._backend.pair(*args, **kwargs)\",\n \"def check(iters):\\n\\treturn check_hypernet(iters[0]) and check_other(iters[1])\",\n \"def __or__(p1, p2):\\n return p1.isparallel(p2)\",\n \"def hasConflicts(self):\\n partners = {}\\n for first, second in self:\\n #print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second\\n if first is None:\\n if second is None:\\n continue #no pairing info\\n else:\\n first, second = second, first #swap order so None is 2nd\\n if second is None: #check first isn't paired\\n if partners.get(first, None) is not None:\\n print >>sys.stderr, \\\"here1\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second\\n return True\\n else:\\n partners[first] = None\\n else: #first and second were both non-empty: check partners\\n if first in partners:\\n if partners[first] != second:\\n print >>sys.stderr, \\\"here2\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second, \\\"partners[first]\\\", partners[first]\\n print \\\"partners:\\\", partners\\n return True\\n if second in partners:\\n if partners[second] != first:\\n print >>sys.stderr, \\\"here3\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second, \\\"partners[second]:\\\", partners[second]\\n return True\\n #add current pair to the list of constraints\\n partners[first] = second\\n partners[second] = first\\n #can only get here if there weren't conflicts\\n return False\",\n \"def items_intersect(self):\\n for a, b in combinations(self.items, 2):\\n if a.intersects_with(b):\\n return True\\n\\n return False\",\n \"def batched(self) -> bool:\\n return False\",\n \"def checker(self, product):\\n for item in self.instock:\\n if item == product:\\n return True\\n return False\",\n \"def check_items(self, items):\\n for item in items:\\n if item['user'] in self.required_list and item['user'] not in self.approved_required_list:\\n if item['result'] is True or item['result'] == 'approved':\\n logger.info(\\\"%s approved\\\", item['user'])\\n self.approved_required_list.append(item['user'])\\n else:\\n logger.info(\\\"%s declined\\\", item['user'])\\n error_msg = \\\"Since {} is a required member for approval, this approval step fails. \\\".format(item['user'])\\n logger.error(error_msg)\\n self.exit(rc=2, detail=error_msg)\\n if item['user'] in self.optional_list and item['user'] not in self.approved_optional_list:\\n if item['result'] is True or item['result'] == 'approved':\\n logger.info(\\\"%s approved\\\", item['user'])\\n if item['user'] in self.declined_optional_list:\\n self.declined_optional_list.remove(item['user'])\\n self.approved_optional_list.append(item['user'])\\n else:\\n logger.info(\\\"%s declined\\\", item['user'])\\n self.declined_optional_list.append(item['user'])\\n if len(self.declined_optional_list) >= (len(self.optional_list) - self.number_optional):\\n error_msg = \\\"Not be able to fulfill requirement that {} optional approvals, since {} declined request.\\\".format(\\n self.number_optional, self.declined_optional_list)\\n logger.error(error_msg)\\n self.exit(rc=2, detail=error_msg)\\n\\n if len(self.approved_required_list) >= len(self.required_list) \\\\\\n and len(self.approved_optional_list) >= self.number_optional:\\n logger.info(\\\"Approval requirements are fully met. Exit gracefully.\\\")\\n self.exit(0)\",\n \"def is_action_applied(instance: Algorithm) -> bool:\\n if len(get_results(instance)) == 0:\\n return False\\n return True\",\n \"def _apply_item(self, item: Item) -> bool:\\n if self.locked:\\n self.__locked = item.item_type != self.__key\\n return not self.locked\",\n \"def Item(self) -> bool:\",\n \"def other_threads_are_active():\\n return len(fake_threads) >= 2\",\n \"def overlap(component1, component2):\\n if component1[0].start <= component2[0].stop and component2[0].start <= component1[0].stop:\\n if component1[1].start <= component2[1].stop and component2[1].start <= component1[1].stop:\\n return True\\n return False\",\n \"def check_tie(self, player1, player2):\\n if self.check_win(player1) or self.check_win(player2):\\n return False\\n return self.check_grid_full()\",\n \"def check_end_game(self):\\n return False if (any(self.p1_pits()) and any(self.p2_pits())) else True\",\n \"def ready(self):\\n return len(self.player1.ships) == len(\\n self.player2.ships) == len(self.SHIP_INFO)\",\n \"def can_run(self):\\n\\t\\treturn self._start is None\",\n \"def _dispatching(self):\\n return bool(self.generate_config or self.subapp or self.subcommand)\",\n \"def is_ok_two_lines(line1, line2):\\n card1 = line1[0]\\n card2 = line1[1]\\n card3 = line1[2]\\n card4 = line2[0]\\n card5 = line2[1]\\n card6 = line2[2]\\n idents1 = [card.ident for card in line1]\\n idents2 = [card.ident for card in line2]\\n intersection = list(set(idents1) & set(idents2))\\n if intersection:\\n return False\\n if not is_coupled(card1.south, card4.north):\\n return False\\n if not is_coupled(card2.south, card5.north):\\n return False\\n if not is_coupled(card3.south, card6.north):\\n return False\\n return True\",\n \"def __isJoint(self, taskA, taskB):\\r\\n if taskA.getDispatchedServer().getKey() == taskB.getDispatchedServer(). getKey():\\r\\n return True\\r\\n else:\\r\\n pathA = self._netGraph.getShortestPath(taskA.getAccessPoint(), taskA.getDispatchedServer())\\r\\n pathB = self._netGraph.getShortestPath(taskB.getAccessPoint(), taskB.getDispatchedServer())\\r\\n for la in pathA.getLinkList():\\r\\n for lb in pathB.getLinkList():\\r\\n if la.getKey() == lb.getKey():\\r\\n return True\\r\\n return False\",\n \"def _is_item_allowed(resource, item, resourcesalloweddict, resourcesuseddict):\\n\\n if item in resourcesalloweddict[resource]:\\n # this is semi nonsensical, but allows us to indicate which ports are used\\n # through get_resource_information()\\n resourcesuseddict[resource].add(item)\\n return True\\n\\n else:\\n return False\",\n \"def _apply_item(self, item: Item) -> bool:\\n return False\",\n \"def validate_args(*args: Any) -> bool:\\n\\n return len(args) == 4 and Item.validate_price(args[2]) and Entity.validate_discount(args[3])\",\n \"def check_for_group():\\r\\n if first_list[0][0] == second_list[0][0]:\\r\\n try:\\r\\n result = first_list[0][0], str(int(first_list[0][1]) + int(second_list[0][1]))\\r\\n except ValueError:\\r\\n result = first_list[0][0], str(float(first_list[0][1]) + float(second_list[0][1]))\\r\\n result_list.append(result)\\r\\n first_list.remove(first_list[0])\\r\\n second_list.remove(second_list[0])\\r\\n return True\\r\\n return False\",\n \"def monkey_trouble(a_smile, b_smile):\\n if (a_smile and b_smile) or (not(a_smile) and not(b_smile)):\\n return True\\n else:\\n return False\",\n \"def has_crossing_len2_ob(self) -> bool:\\n fcell = self.first_cell\\n scell = self.second_cell\\n if self._fuse_row:\\n possible_obs = [\\n GriddedPerm((0, 1), (fcell, scell)),\\n GriddedPerm((1, 0), (scell, fcell)),\\n ]\\n else:\\n possible_obs = [\\n GriddedPerm((0, 1), (fcell, scell)),\\n GriddedPerm((1, 0), (fcell, scell)),\\n ]\\n return any(ob in possible_obs for ob in self._tiling.obstructions)\",\n \"def check(self,item):\\r\\n raise AbstractError\\r\\n return False\",\n \"def equals_items(self, item1, item2):\\n if isinstance(item1, (text_type, binary_type)) is True:\\n return self.equals_strings(item1, item2)\\n\\n if type(item1) is float or type(item2) is float:\\n if round(item1, 4) != round(item2, 4):\\n if self._verbose is True:\\n logging.info(\\\"Float values rounded to \\\"\\n \\\"4 digits are not equals: \\\"\\n \\\"{:0.4f} != {:0.4f}\\\".format(item1, item2))\\n return False\\n return True\\n\\n if item1 != item2:\\n if self._verbose is True:\\n logging.info(\\\"Not equals: {0} {1}\\\".format(item1, item2))\\n return False\\n\\n return True\",\n \"def should_run(self, case: Tuple[Dict[str, Any], ...]) -> bool:\\n return True\",\n \"def is_valid_single_attempt(self, atoms_init, atoms_final):\\n from scipy.spatial import cKDTree as KDTree\\n from random import shuffle\\n atoms1 = atoms_init.copy()\\n atoms2 = atoms_final.copy()\\n\\n vol1 = atoms1.get_volume()\\n vol2 = atoms2.get_volume()\\n if vol2 > vol1:\\n ratio = (vol2/vol1)**(1.0/3.0)\\n cell1 = atoms1.get_cell()\\n atoms1.set_cell(cell1*ratio, scale_atoms=True)\\n else:\\n ratio = (vol1/vol2)**(1.0/3.0)\\n cell2 = atoms2.get_cell()\\n atoms2.set_cell(cell2*ratio, scale_atoms=True)\\n\\n # Try construct the relation\\n used_indices = []\\n tree = KDTree(atoms2.get_positions())\\n indices = list(range(0, len(atoms1)))\\n shuffle(indices)\\n for atom in atoms1:\\n if atom.symbol in self.exclude:\\n continue\\n dist, closest = tree.query(atom.position, k=12)\\n srt_indx = np.argsort(dist)\\n dist = [dist[indx] for indx in srt_indx]\\n closest = [closest[indx] for indx in srt_indx]\\n\\n if all(c in used_indices for c in closest):\\n # More than one atom is closest to this\\n # structure\\n self.rejected_reason = \\\"More than one atom mapped onto the \\\"\\n self.rejected_reason += \\\"same atoms in the initial structure\\\"\\n return False\\n\\n # First, unused with mathing symbol\\n closest_indx = None\\n closest_dist = None\\n for i, indx in enumerate(closest):\\n if atoms2[indx].symbol == atom.symbol and indx not in used_indices:\\n closest_indx = indx\\n closest_dist = dist[i]\\n break\\n\\n if closest_indx is None:\\n self.rejected_reason = \\\"No unused atoms with macthing symbol!\\\"\\n return False\\n \\n used_indices.append(closest_indx)\\n if closest_dist > self.max_displacement:\\n # The displacement is larger than the tolereance\\n self.rejected_reason = \\\"Max displacement too large\\\"\\n return False\\n \\n if atom.symbol != atoms2[closest_indx].symbol:\\n self.rejected_reason = \\\"Mapped symbol does not match!\\\"\\n return False\\n return True\",\n \"def _do_merge(ext, exts_other):\\n for ext_other in exts_other:\\n if not ext.is_duplicate(ext_other):\\n return False\\n return True\",\n \"def connectable(iTypeA, iTypeB):\\r\\n return (iTypeA % 4) + (iTypeB % 4) == 3\",\n \"def overlaps(self, other): # -> bool:\\n ...\",\n \"def is_queen_attacked(x1, y1, x2, y2):\\n attacked_fields = queen_attack(x1, y1)\\n second_queen_position = [x2, y2]\\n if second_queen_position in attacked_fields:\\n return True\\n return False\",\n \"def encompasses_broadcastable(b1, b2):\\r\\n if len(b1) < len(b2):\\r\\n return False\\r\\n b1 = b1[-len(b2):]\\r\\n return not any(v1 and not v2 for v1, v2 in zip(b1, b2))\",\n \"def monkey_trouble(a_smile, b_smile):\\r\\n if a_smile and b_smile:\\r\\n return True\\r\\n if not a_smile and not b_smile:\\r\\n return True\\r\\n return False\",\n \"def pareto_better(self, other: \\\"EvalItem\\\") -> bool:\\n return self.size <= other.size and other.result <= self.result\",\n \"def is_satisfied(self, item: Product) -> bool:\\n return item.size == self.size\",\n \"def can_run_experiment(self, info, device):\\n nb_qubit_max = self.backends[device]['nq']\\n nb_qubit_needed = info['nq']\\n return nb_qubit_needed <= nb_qubit_max, nb_qubit_max, nb_qubit_needed\",\n \"def valid_for_send(self, app):\\n return (\\n (self.to is not None) and\\n (self.next_hop is not None) and\\n (self.source is not None) and\\n (self.command is not None) and\\n (self.handler is not None) and\\n (self.kind is not None) and\\n (self.time_to_live is not None) and\\n (self.time_to_live >= app.tick)\\n )\",\n \"def has_action2(self, feature):\\n return feature in self._action2\",\n \"def gameOver():\\n if len(p1)==0 and len(p1winnings)==0:\\n return True\\n elif len(p2)==0 and len(p2winnings)==0:\\n return True\\n return False\",\n \"def beats(self, one, two):\\n return ((one == 'rock' and two == 'scissors') or\\n (one == 'scissors' and two == 'paper') or\\n (one == 'paper' and two == 'rock'))\",\n \"def test_available_for_two_included(self):\\n\\n data = self._setup_two_included()\\n self._do_test(\\n data[\\\"run\\\"].id,\\n self.available_param,\\n [],\\n )\",\n \"async def test_multiple_same_state(hass):\\n calls_1 = async_mock_service(hass, DOMAIN, SERVICE_TURN_ON)\\n\\n await async_reproduce_states(hass, [\\n State(ENTITY_1, 'on'),\\n State(ENTITY_2, 'on'),\\n ])\\n\\n await hass.async_block_till_done()\\n\\n assert len(calls_1) == 2\\n # order is not guaranteed\\n assert any(call.data == {'entity_id': ENTITY_1} for call in calls_1)\\n assert any(call.data == {'entity_id': ENTITY_2} for call in calls_1)\",\n \"def verified_connection_ft3(self, id1, id2):\\n if id2 not in self.users.keys() or id1 not in self.users.keys():\\n return False\\n\\n f1 = self.users[id1]\\n f2 = self.users[id2]\\n fof1 = self.friends_of_friends(id1, f1)\\n fof2 = self.friends_of_friends(id2, f2)\\n return len((f1 | fof1) & (f2 | fof2)) != 0\",\n \"def is_interfered(r, c, s1, s2):\\n return r == 0 and c < s1 + s2 or r < s2 and c < s1\",\n \"def is_bound(self, typ_one, thing_one, typ_two, thing_two):\\n try:\\n bound = self._is_bound(typ_one, thing_one, typ_two, thing_two)\\n except BadNetScaler as error:\\n # sigh, some combinations aren't done both ways\\n if error.kwargs[\\\"errorcode\\\"] in (1088, 1232):\\n bound = False\\n else:\\n raise\\n\\n if not bound:\\n try:\\n # Some combinations aren't the same both ways\\n bound = self._is_bound(typ_two, thing_two, typ_one, thing_one)\\n except BadNetScaler as error:\\n if error.kwargs[\\\"errorcode\\\"] in (1088, 1232):\\n bound = False\\n else:\\n raise\\n\\n return bound\",\n \"def g2(a, b): \\n if a and b:\\n return False\\n else:\\n return True\",\n \"def are_same(self, value1, value2):\\n (group_1, val_1) = self.get_val_tuple(value1)\\n (group_2, val_2) = self.get_val_tuple(value2)\\n f_aresame = Or(*[ And(self.X[group_1, val_1, idx], self.X[group_2, val_2, idx])\\n for idx in range(0, self.items_per) ])\\n\\n return f_aresame\",\n \"def has_match(trajs_0, trajs_1):\\n for i in range(len(trajs_0)):\\n for j in range(len(trajs_1)):\\n R = (trajs_0[i].get_slice()[:,:2] == trajs_1[j].get_slice()[:,:2])\\n if isinstance(R, bool):\\n if R:\\n return True \\n elif R.all():\\n return True \\n else:\\n pass \\n return False\",\n \"def isMergeable(int1,int2):\\n if set(int1.span)&set(int2.span) or int1.maxval+1==int2.minval:\\n return True\\n else:\\n return False\",\n \"def passes(self) -> bool:\\n ...\",\n \"def permissible(e1, e2):\\n return e1[1] == e2[0] and \\\\\\n total_edge_length(e1, e2) < maximum_distance and \\\\\\n total_edge_angle(e1, e2) < maximum_angle_delta\",\n \"def _and(cls, arg1, arg2):\\n return arg1 and arg2\",\n \"async def should_handle(self):\\n local_controller = self.controller\\n workers_total = len(local_controller.workers)\\n geysers = local_controller.extractors\\n drones_in_queue = local_controller.already_pending(DRONE)\\n if (\\n not local_controller.close_enemies_to_base\\n and local_controller.can_train(DRONE)\\n and not local_controller.counter_attack_vs_flying\\n ):\\n if workers_total == 12 and not drones_in_queue:\\n return True\\n if (\\n workers_total in (13, 14, 15)\\n and len(local_controller.overlords) + local_controller.already_pending(OVERLORD) > 1\\n ):\\n return True\\n optimal_workers = min(\\n sum(x.ideal_harvesters for x in local_controller.townhalls | geysers), 90 - len(geysers)\\n )\\n return (\\n workers_total + drones_in_queue < optimal_workers\\n and np.sum(\\n np.array(\\n [\\n len(local_controller.zerglings),\\n len(local_controller.hydras),\\n len(local_controller.ultralisks),\\n ]\\n )\\n * np.array([1, 2, 3])\\n )\\n > 15\\n )\\n return False\",\n \"def is_valid_arg(self, muts, arg):\\n for mut in muts:\\n if arg in mut.args():\\n return True\\n\\n return False\",\n \"def can_overlap(self):\\n return self.is_open\",\n \"def can_overlap(self):\\n return self.is_open\",\n \"def check_other(seq_iter):\\n\\treturn any(filter(has_abba, seq_iter))\",\n \"def number_of_images_valid():\\r\\n if number_of_images_a_valid() and number_of_images_b_valid():\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def can_communicate_with(self, target):\\n if self == target:\\n return True\\n msg = 'You try to connect topologies belonging to'\\n msg += ' two different mpi tasks. Set taskids properly or use'\\n msg += ' InterBridge.'\\n assert self.task_id() == target.task_id(), msg\\n\\n # Parent communicator\\n # Todo : define some proper conditions for compatibility\\n # between topo_from, topo_to and parent:\\n # - same size\\n # - same domain\\n # - common processus ...\\n # At the time we check that both topo have\\n # the same comm_origin.\\n return self.is_consistent_with(target)\",\n \"def check(self):\\n\\n if not self.target.ok():\\n return False\\n\\n if not self.progid.ok():\\n return False\\n\\n if not self.prinapp.ok():\\n return False\\n\\n if not self.observers.ok():\\n return False\\n\\n return True\",\n \"def __contains__(self, item: Union[str, Socket]):\\n return item in self.sequence\",\n \"def true_false_both_filter(request, items, parameter):\\n if parameter in request['args']:\\n test = request['args'][parameter].lower()\\n if test == 'true':\\n items = [item for item in items if item[parameter]]\\n elif test == 'false':\\n items = [item for item in items if not item[parameter]]\\n elif test == 'both':\\n # Otherwise return both true and false values\\n pass\\n else:\\n raise UserException(ERROR_TRUE_FALSE_BOTH_REQUIRED % parameter)\\n\\n return items\",\n \"def cross(series1: Sequence, series2: Sequence) -> bool:\\n return crossover(series1, series2) or crossover(series2, series1)\",\n \"def test_select_same_element_multiple_times(self):\\n\\n sink = TObserver()\\n obs = MergeSelectorObservable(\\n left=self.left,\\n right=self.right,\\n # scheduler=self.scheduler,\\n )\\n obs.observe(init_observer_info(sink))\\n ack_left = self.left.on_next_list([select_next, select_completed])\\n\\n ack_right = self.right.on_next_list([select_next, select_next, select_completed])\\n\\n self.assertIsInstance(self.measure_termination_state(obs), TerminationStates.InitState)\\n self.assertIsInstance(self.measure_state(obs), ControlledZipStates.WaitOnLeftRight)\\n self.assertEqual([select_next, select_next, select_completed], sink.received)\\n self.assertIsInstance(ack_left.value, ContinueAck)\\n self.assertIsInstance(ack_right, ContinueAck)\",\n \"def win(player1, player2):\\n if(player1 == 1 and player2 == 3) or (player1 == 2 and player2 == 1) \\\\\\n or (player1 == 3 and player2 == 2):\\n return True\",\n \"def goal_test(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if (state[0], state[1]) in self.goals: #Check to see if at goal state\\n return True\\n else:\\n return False\",\n \"def _overlap(x1, w1, x2, w2):\\r\\n if x1+w1 < x2-w2: return False\\r\\n if x1-w1 > x2+w2: return False\\r\\n\\r\\n return True\",\n \"def handle_same_length(self, a, b):\\n found = False\\n for i, j in zip(a, b):\\n if i == j:\\n continue\\n elif found:\\n return False # this case is the second found edit, thus return false\\n else:\\n found = True\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73054934","0.6250203","0.62348914","0.61885935","0.60863423","0.6018422","0.6008905","0.5933993","0.591542","0.5821401","0.58169997","0.5744042","0.57171375","0.57098925","0.5701733","0.570071","0.5699882","0.5689656","0.5678437","0.5675575","0.56661355","0.5656934","0.56426877","0.56329685","0.5628834","0.5600905","0.55985624","0.5593351","0.55898005","0.5584642","0.5551506","0.55425763","0.55239","0.5517491","0.55096024","0.5509374","0.5505439","0.5502006","0.5499983","0.5499845","0.5496484","0.5487205","0.5481365","0.54785085","0.54713875","0.546812","0.54618365","0.545201","0.5440355","0.5431939","0.5427502","0.54265976","0.54193395","0.54162186","0.5403553","0.5401576","0.539483","0.5392444","0.5391884","0.53834623","0.53797805","0.5366978","0.53608453","0.5360311","0.5357375","0.5355623","0.5348725","0.53397954","0.5339066","0.53290445","0.5327236","0.53266525","0.5325092","0.53236353","0.5322289","0.5316436","0.53154486","0.529878","0.529071","0.52900285","0.5289777","0.5287393","0.5287236","0.52856356","0.5282108","0.52815545","0.5274555","0.5274555","0.5270349","0.5270208","0.52696306","0.5266665","0.5265849","0.52630687","0.5249719","0.5248387","0.5247779","0.5245429","0.5244725","0.524397"],"string":"[\n \"0.73054934\",\n \"0.6250203\",\n \"0.62348914\",\n \"0.61885935\",\n \"0.60863423\",\n \"0.6018422\",\n \"0.6008905\",\n \"0.5933993\",\n \"0.591542\",\n \"0.5821401\",\n \"0.58169997\",\n \"0.5744042\",\n \"0.57171375\",\n \"0.57098925\",\n \"0.5701733\",\n \"0.570071\",\n \"0.5699882\",\n \"0.5689656\",\n \"0.5678437\",\n \"0.5675575\",\n \"0.56661355\",\n \"0.5656934\",\n \"0.56426877\",\n \"0.56329685\",\n \"0.5628834\",\n \"0.5600905\",\n \"0.55985624\",\n \"0.5593351\",\n \"0.55898005\",\n \"0.5584642\",\n \"0.5551506\",\n \"0.55425763\",\n \"0.55239\",\n \"0.5517491\",\n \"0.55096024\",\n \"0.5509374\",\n \"0.5505439\",\n \"0.5502006\",\n \"0.5499983\",\n \"0.5499845\",\n \"0.5496484\",\n \"0.5487205\",\n \"0.5481365\",\n \"0.54785085\",\n \"0.54713875\",\n \"0.546812\",\n \"0.54618365\",\n \"0.545201\",\n \"0.5440355\",\n \"0.5431939\",\n \"0.5427502\",\n \"0.54265976\",\n \"0.54193395\",\n \"0.54162186\",\n \"0.5403553\",\n \"0.5401576\",\n \"0.539483\",\n \"0.5392444\",\n \"0.5391884\",\n \"0.53834623\",\n \"0.53797805\",\n \"0.5366978\",\n \"0.53608453\",\n \"0.5360311\",\n \"0.5357375\",\n \"0.5355623\",\n \"0.5348725\",\n \"0.53397954\",\n \"0.5339066\",\n \"0.53290445\",\n \"0.5327236\",\n \"0.53266525\",\n \"0.5325092\",\n \"0.53236353\",\n \"0.5322289\",\n \"0.5316436\",\n \"0.53154486\",\n \"0.529878\",\n \"0.529071\",\n \"0.52900285\",\n \"0.5289777\",\n \"0.5287393\",\n \"0.5287236\",\n \"0.52856356\",\n \"0.5282108\",\n \"0.52815545\",\n \"0.5274555\",\n \"0.5274555\",\n \"0.5270349\",\n \"0.5270208\",\n \"0.52696306\",\n \"0.5266665\",\n \"0.5265849\",\n \"0.52630687\",\n \"0.5249719\",\n \"0.5248387\",\n \"0.5247779\",\n \"0.5245429\",\n \"0.5244725\",\n \"0.524397\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6191703"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":77693,"cells":{"query":{"kind":"string","value":"Allows doing manipulations or enriching with other data on test items (after grouping) Items have a test_group field."},"document":{"kind":"string","value":"def pytest_after_group_items(session, config, items):"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def pytest_before_group_items(session, config, items):","def test_add_group(self):\n pass","def test_grouping(self):\n s = self.create(ComponentItem, UML.Component)\n uc1 = self.create(UseCaseItem, UML.UseCase)\n uc2 = self.create(UseCaseItem, UML.UseCase)\n\n self.group(s, uc1)\n assert 1 == len(uc1.subject.subject)\n self.group(s, uc2)\n assert 1 == len(uc2.subject.subject)\n\n # Classifier.useCase is not navigable to UseCase\n # self.assertEqual(2, len(s.subject.useCase))","def add_test_group(self, test_group):\n self.test_groups[test_group.name] = test_group","def test_list_group(self):\n pass","def test_update_group(self):\n pass","def test_test_group_parameters(self):\n pass","def test_groups_post(self):\n pass","def test_read_group(self):\n pass","def test_get_group(self):\n pass","def test_get_groups(self):\n pass","def test_get_groups(self):\n pass","def test_group_of_one(self):\n self.testcases[0].group_id = 1\n self.testcases[0].put()\n self.testcases[1].key.delete()\n\n grouper.group_testcases()\n\n testcase = data_handler.get_testcase_by_id(self.testcases[0].key.id())\n self.assertEqual(testcase.group_id, 0)\n self.assertTrue(testcase.is_leader)","def test_patch_group(self):\n pass","def test_patch_group(self):\n pass","def test_groups_get(self):\n pass","def test_groups_get(self):\n pass","def test_000_add_group(self):\n # This case is always passed because it's tested in setup_module,\n # If setup module fails, this case will never run\n pass","def test_replace_groups(self):\n pass","def persist_test_group(self, obj: object, group: str) -> str:","def test_replace_group(self):\n pass","def test_reorder_in_group(self):\r\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty, self.group_b]},\r\n {self.group_a: [self.group_a_item_2, self.group_a_item_1]},\r\n {self.group_b: [self.group_b_item_1, self.group_b_item_2]},\r\n {self.group_empty: []}]\r\n self.drag_and_verify(self.group_a_item_2_handle, self.group_a_item_1_handle, expected_ordering)","def get_existing_test_group(self, obj: object) -> str:","def test_create_group(self):\n pass","def test_create_group(self):\n pass","def test_api_v1_groups_post(self):\n pass","def add_group(self):\n items = self.group_list.selectedItems()\n for item in items:\n self.parent.add_group_data(item.text())","def test_group(self):\n obs_group, obs_nogroup = group(self.seqstruct, 0.75)\n exp_group = {'cluster_337': ['cluster_343', 'cluster_345',\n 'cluster_339'],\n 'cluster_347': ['cluster_338'],\n 'cluster_344': ['cluster_340']}\n exp_nogroup = [self.seqstruct[6], self.seqstruct[8]]\n\n self.assertEqual(obs_group, exp_group)\n self.assertEqual(obs_nogroup, exp_nogroup)","def groupInputItem(name,items=[],**kargs):\n kargs['name'] = name\n kargs['items'] = items\n kargs['itemtype'] = 'group'\n return kargs","def item_group_type(self, item_group_type):\n\n self._item_group_type = item_group_type","def test_ungrouping(self):\n s = self.create(ComponentItem, UML.Component)\n uc1 = self.create(UseCaseItem, UML.UseCase)\n uc2 = self.create(UseCaseItem, UML.UseCase)\n\n self.group(s, uc1)\n self.group(s, uc2)\n\n self.ungroup(s, uc1)\n assert 0 == len(uc1.subject.subject)\n # Classifier.useCase is not navigable to UseCase\n # self.assertEqual(1, len(s.subject.useCase))\n\n self.ungroup(s, uc2)\n assert 0 == len(uc2.subject.subject)\n # Classifier.useCase is not navigable to UseCase\n # self.assertEqual(0, len(s.subject.useCase))","def test_grouping(self):\n n = self.create(NodeItem, UML.Node)\n a = self.create(ArtifactItem, UML.Artifact)\n\n self.group(n, a)\n\n assert 1 == len(n.subject.deployment)\n assert n.subject.deployment[0].deployedArtifact[0] is a.subject","def add_to_group(self,item):\n self.items.append(item)\n self.n += 1","def create_TestGroup(test_case, # type: AnyMagpieTestCaseType\n override_group_name=null, # type: Optional[Str]\n override_discoverable=null, # type: Optional[bool]\n override_data=null, # type: Optional[JSON]\n override_headers=null, # type: Optional[HeadersType]\n override_cookies=null, # type: Optional[CookiesType]\n ): # type: (...) -> JSON\n app_or_url = get_app_or_url(test_case)\n data = override_data\n if override_data is null:\n data = {\"group_name\": override_group_name if override_group_name is not null else test_case.test_group_name}\n # only add 'discoverable' if explicitly provided here to preserve original behaviour of 'no value provided'\n if override_discoverable is not null:\n data[\"discoverable\"] = override_discoverable\n grp_name = (data or {}).get(\"group_name\")\n if grp_name:\n test_case.extra_group_names.add(grp_name) # indicate potential removal at a later point\n resp = test_request(app_or_url, \"POST\", \"/groups\", json=data,\n headers=override_headers if override_headers is not null else test_case.json_headers,\n cookies=override_cookies if override_cookies is not null else test_case.cookies)\n return check_response_basic_info(resp, 201, expected_method=\"POST\")","def test_020_query_groups(self):\n\n testflow.step(\"Querying for groups\")\n assert self.query_cli.run(\n what='group'\n )[0], \"Failed to search for groups\"","def test_new_group(self, inventoryloader):\n inventoryloader.add_group(u'newgroup')\n assert 'newgroup' in inventoryloader.groups","def test_060_add_group_to_group(self):\n\n testflow.step(\"Adding group %s to group %s\", TEST_GROUP1, TEST_GROUP2)\n assert MANAGE_CLI.run(\n 'groupadd',\n TEST_GROUP1,\n group=TEST_GROUP2,\n )[0], \"Failed to add group to group '%s'\" % TEST_GROUP1","def pytest_collection_modifyitems(config, items):\n # check if studio tests myst be skipped\n run_study = config.getoption(\"--runstudy\")\n # 'all' will match all studies, '' will not match anything\n run_study = {'': '(?!x)x', 'all': '.*'}.get(run_study, run_study)\n # --runstudy given in cli: do not skip study tests and\n test_selected = list()\n test_skipped = list()\n groups = dict()\n incremental = pytest.mark.incremental()\n\n def add():\n \"helper for gathering test info\"\n marker = item.get_marker(mark)\n kwargs = parse_args(marker.args, marker.kwargs)\n group_name = kwargs['name']\n group = groups.setdefault(group_name, dict())\n group.setdefault(mark, list()).append((kwargs, item))\n item.add_marker(incremental)\n\n # place every test in regular, prerequisite and studies\n # group by name\n for item in items:\n for mark in set(item.keywords.keys()).intersection(MARKS):\n add()\n break\n else:\n test_selected.append(item)\n\n def sort(a, b):\n \"Sort two items by order priority\"\n return cmp(a[0]['order'], b[0]['order'])\n\n # use studies precedence to built the global sequence order\n mandatory = 'study' # mandatory mark for global sorting: study\n studies = list()\n for name, info in groups.items():\n studies.extend(info.get(mandatory, []))\n studies.sort(sort)\n\n def append(tests, where):\n \"helper to add the test item from info structure\"\n for test in tests:\n test = test[1]\n if test not in where:\n where.append(test)\n\n # select only the test that are going to be launched\n width = 0\n regexp = re.compile(run_study, re.I | re.DOTALL)\n for study in studies:\n group_name = study[0]['name']\n width = max(width, len(group_name))\n where = test_selected if regexp.search(group_name) else test_skipped\n for mark, seq in groups[group_name].items():\n if mark == mandatory:\n continue\n seq.sort(sort)\n append(seq, where)\n append([study], where)\n\n if config.getoption(\"--show_order\") or config.getoption(\"--debug\"):\n fmt = \"{0:>3d} [{1:>%s}] {2}\" % width\n for i, item in enumerate(test_selected + test_skipped):\n study = get_study_name(item)\n fqn = get_FQN(item)\n line = fmt.format(i, study, fqn)\n if item in test_selected:\n line = term.green('+' + line)\n else:\n line = term.yellow('-' + line)\n print(line)\n\n # we make the --runstudy check at the end to be able to show\n # test order with --show_order or --debig options\n # reorder tests by group name and replace items IN-PLACE\n if run_study:\n items[:] = test_selected\n return\n\n skip_test = pytest.mark.skip(reason=\"need --runstudy option to run\")\n for item in items:\n if set(item.keywords.keys()).intersection(MARKS):\n item.add_marker(skip_test)","def group_data_callback(self, action: EventType, group_id: str) -> None:\n self.process_item(group_id, {})","def test_update_device_group_by_id1(self):\n pass","def test_groups_state_post(self):\n pass","def IsGroup(self):\n return isinstance(self, TestGroup)","def onGroupDataset(self, event):\n\t\tselections = self.tree.GetSelections()\n\t\tif not selections and self.selectedItem:\n\t\t\tselections = [self.selectedItem]\n\t\tif not self.groupedDataUnit:\n\t\t\tpluginLoader = Modules.DynamicLoader.getPluginLoader()\n\t\t\ttaskMod = pluginLoader.getPluginModule(\"Task\", \"Process\")\n\t\t\tunitType = taskMod.getDataUnit()\n\t\t\tmoduleType = pluginLoader.getPluginClass(\"Task\",\"Process\")\n\t\t\tself.groupedDataUnit = unitType()\n\t\t\tmodule = moduleType()\n\t\t\tself.groupedDataUnit.setModule(module)\n\t\t\n\t\tfor item in selections:\n\t\t\tif item in self.groupedItems: continue\n\t\t\tself.groupedItems.append(item)\n\t\t\tself.markBlue([item], \"}\")\n\t\t\tobj = self.tree.GetPyData(item)\n\t\t\tprint \"Adding source dataunit\",obj\n\t\t\tself.groupedDataUnit.addSourceDataUnit(obj)\n\t\tsetting = self.groupedDataUnit.getSettings()\n\t\tsetting.set(\"FilterList\",[])\n\t\t\n\t\tprint \"Now=\",self.groupedDataUnit.getSourceDataUnits()","def tests_ti_document_get(self):\n super().group_get()","def test_drag_group_into_group(self):\r\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty]},\r\n {self.group_a: [self.group_b, self.group_a_item_1, self.group_a_item_2]},\r\n {self.group_b: [self.group_b_item_1, self.group_b_item_2]},\r\n {self.group_empty: []}]\r\n self.drag_and_verify(self.group_b_handle, self.group_a_item_1_handle, expected_ordering)","def group(self):\n raise NotImplementedError()","def test_grouping(self):\n n1 = self.create(NodeItem, UML.Node)\n n2 = self.create(NodeItem, UML.Node)\n\n self.group(n1, n2)\n\n assert n2.subject in n1.subject.nestedNode\n assert n1.subject not in n2.subject.nestedNode","def with_group(self, group):\n\t\tself.variables['group'] = group\n\t\treturn self","def test_get_groups_3(\n self, management_client, internal_client, inventory_attributes\n ):\n\n did = \"some-device-id\"\n internal_client.create_device(did, inventory_attributes)\n for i in range(10):\n group = management_client.group(group=\"group\" + str(i))\n management_client.addDeviceToGroup(group, did)\n\n assert len(management_client.getAllGroups()) == 1","def test_user_group_controller_update(self):\n pass","def test_update_device_group_by_id(self):\n pass","def test_users_groups_post(self):\n pass","def test_score_groups(test_input, expected):\n score = sp.score_groups(test_input)\n assert score == expected","def test_message_group():","def group(self, val):\n self.set_property(\"Group\", val)","def data_group():\n ...","def tests_ti_document_add_attribute(self, request: FixtureRequest):\n super().group_add_attribute(request)","def test_group_by_field(self):\r\n t = [\r\n ['#sample', 'loc', 'age'],\r\n ['a', 'US', '5'],\r\n ['b', 'US', '10'],\r\n ['c', 'Mal', '5'],\r\n ['d', 'Mal', '10'],\r\n ['e', 'Ven', '5'],\r\n ]\r\n self.assertEqual(group_by_field(t, 'loc'),\r\n {'US': ['a', 'b'], 'Mal': ['c', 'd'], 'Ven': ['e']})\r\n self.assertEqual(group_by_field(t, 'age'),\r\n {'5': ['a', 'c', 'e'], '10': ['b', 'd']})","def test_update_entry_groups(self):\r\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\r\n pass","def test_checkboxtextgroup(self):\r\n self.check_group('checkboxtextgroup', 'choice', 'checkbox')","def test_delete_group(self):\n pass","def test_delete_group(self):\n pass","def test_products_ref_groups_put(self):\n pass","def test_partially_update_device_group_by_id1(self):\n pass","def _process_group(self):\n if not isinstance(self.transform, GroupTransformModel):\n return\n\n self._process_name()\n\n if self.transformed_item['type'] == 'Campaign':\n self._process_metadata_datetime('firstSeen', self.transform.first_seen)\n\n if self.transformed_item['type'] == 'Document':\n self._process_metadata('fileName', self.transform.file_name)\n self._process_metadata('malware', self.transform.malware)\n self._process_metadata('password', self.transform.password)\n\n if self.transformed_item['type'] == 'Email':\n self._process_metadata('body', self.transform.body)\n self._process_metadata('from', self.transform.from_addr)\n self._process_metadata('header', self.transform.header)\n self._process_metadata('subject', self.transform.subject)\n self._process_metadata('to', self.transform.to_addr)\n\n if self.transformed_item['type'] in ('Event', 'Incident'):\n self._process_metadata_datetime('eventDate', self.transform.event_date)\n self._process_metadata('status', self.transform.status)\n\n if self.transformed_item['type'] == 'Report':\n self._process_metadata('fileName', self.transform.file_name)\n self._process_metadata_datetime('publishDate', self.transform.publish_date)\n\n # Handle sig specific fields here\n if self.transformed_item['type'] == 'Signature':\n self._process_metadata('fileName', self.transform.file_name)\n self._process_metadata('fileType', self.transform.file_type)\n self._process_metadata('fileText', self.transform.file_text)","def test_grouped(self):\n gfile = grades.writers.GradesFile(self.fname)\n gfile.table.compute_grouped_mean('Group')\n gfile.table_format = 'org'\n self.check_output(self.output_str2, gfile)","def test_api_v1_groups_get(self):\n pass","def test_groups(self):\n # Make a group and send to it\n channel_layer.group_add(\"tgroup\", \"tg_test\")\n channel_layer.group_add(\"tgroup\", \"tg_test2\")\n channel_layer.group_add(\"tgroup\", \"tg_test3\")\n channel_layer.group_discard(\"tgroup\", \"tg_test3\")\n channel_layer.send_group(\"tgroup\", {\"value\": \"orange\"})\n # Receive from the two channels in the group and ensure messages\n channel, message = channel_layer.receive_many([\"tg_test\"])\n self.assertEqual(channel, \"tg_test\")\n self.assertEqual(message, {\"value\": \"orange\"})\n channel, message = channel_layer.receive_many([\"tg_test2\"])\n self.assertEqual(channel, \"tg_test2\")\n self.assertEqual(message, {\"value\": \"orange\"})\n # Make sure another channel does not get a message\n channel, message = channel_layer.receive_many([\"tg_test3\"])\n self.assertIs(channel, None)\n self.assertIs(message, None)","def test_post_entry_groups(self):\r\n # This method utilises the POST request method and will make changes to the Canvas instance. This needs consideration.\r\n pass","def test_products_ref_groups_get(self):\n pass","def _itemAdded(self, item):\n group = self.item()\n if group is None:\n return\n\n row = group.getItems().index(item)\n self.addRow(nodeFromItem(item), row + self._CHILDREN_ROW_OFFSET)","def test_delete_groups(self):\n pass","def test_post_add_remove_group(self):\n # todo: think about what if owner doesn't want contributors to add groups\n # self.addgrouprequest = self.factory.post(reverse(\"add_album_groups\"))\n pass","def test_patchorganizations_item(self):\n pass","def test_partially_update_device_group_by_id(self):\n pass","def test_verify_that_you_can_create_a_new_group():","def group_by(self, key):\n ret = {}\n for test in self._testset():\n if hastag(test, key):\n ret.setdefault(gettag(test, key), []).append(test)\n continue\n ret.setdefault(\"others\", []).append(test)\n for k in ret:\n ret[k] = self.__class__(ret[k])\n return ret","def test_group(self):\n m = mapper(Order, orders, properties = {\n 'userident':deferred(orders.c.user_id, group='primary'),\n 'description':deferred(orders.c.description, group='primary'),\n 'opened':deferred(orders.c.isopen, group='primary')\n })\n sess = create_session()\n q = sess.query(m)\n def go():\n l = q.all()\n o2 = l[2]\n print o2.opened, o2.description, o2.userident\n assert o2.opened == 1\n assert o2.userident == 7\n assert o2.description == 'order 3'\n orderby = str(orders.default_order_by()[0].compile(testing.db))\n self.assert_sql(testing.db, go, [\n (\"SELECT orders.order_id AS orders_order_id FROM orders ORDER BY %s\" % orderby, {}),\n (\"SELECT orders.user_id AS orders_user_id, orders.description AS orders_description, orders.isopen AS orders_isopen FROM orders WHERE orders.order_id = :param_1\", {'param_1':3})\n ])\n\n o2 = q.all()[2]\n# assert o2.opened == 1\n assert o2.description == 'order 3'\n assert o2 not in sess.dirty\n o2.description = 'order 3'\n def go():\n sess.flush()\n self.assert_sql_count(testing.db, go, 0)","def test_properties_stats_group_by_group_by_and_sub_group_by_get(self):\n pass","def test_add(self):\n # add a new group\n self.assertTrue(self.run_function(\"group.add\", [self._group], gid=self._gid))\n group_info = self.run_function(\"group.info\", [self._group])\n self.assertEqual(group_info[\"gid\"], self._gid)\n self.assertEqual(group_info[\"name\"], self._group)\n # try adding the group again\n self.assertFalse(self.run_function(\"group.add\", [self._group], gid=self._gid))","def test_bulk_group(self):\n for fn, sep in [(self.filename_actg, '\\t'),\n (self.filename_actg_csv, ';')]:\n file_path_ag = os.path.join(os.path.dirname(__file__),\n self.testdata_folder,\n fn)\n data = {\n 'bulk_upload' : open(file_path_ag, 'rb'),\n }\n\n existing_ags = ActivityGroup.objects.filter(keyflow=self.kic)\n existing_codes = list(existing_ags.values_list('code', flat=True))\n\n encoding = 'utf8'\n df_file_ags = pd.read_csv(file_path_ag, sep=sep)\n df_file_ags = df_file_ags.rename(\n columns={c: c.lower() for c in df_file_ags.columns})\n file_codes = df_file_ags['code']\n new_codes = [c for c in file_codes if c not in existing_codes]\n\n res = self.client.post(self.ag_url, data)\n res_json = res.json()\n assert res.status_code == status.HTTP_201_CREATED\n assert res_json['count'] == len(file_codes)\n assert len(res_json['created']) == len(new_codes)\n\n # assert that the number of activities matches\n all_ag = ActivityGroup.objects.filter(keyflow_id=self.kic.id)\n assert len(all_ag) == len(existing_codes) + len(new_codes)\n\n # assert that the Name matches in all values\n for row in df_file_ags.itertuples(index=False):\n ag = ActivityGroup.objects.get(keyflow=self.keyflow,\n code=row.code)\n assert ag.name == row.name","def tests_ti_document_update(self, request: FixtureRequest):\n super().group_update(request)","def test_filter_device_group(self):\n pass","def test_mark_entry_as_read_groups(self):\r\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\r\n pass","def test_search_by_group_view(self):\n resp = self.client.get(reverse('minerals:group',\n kwargs={'group': self.mineral.group}))\n self.assertEqual(resp.status_code, 200)\n self.assertIn(self.mineral, resp.context['minerals'])\n self.assertNotIn(self.mineral2, resp.context['minerals'])\n self.assertTemplateUsed(resp, 'minerals/mineral_list.html')","def test_groups_group_id_get(self):\n pass","def test_radiotextgroup(self):\r\n self.check_group('radiotextgroup', 'choice', 'radio')","def test_trivial(self):\n group = Group()","def add_item(self):\n item = models.Item(item_name=self.test_item,\n list_id=1,\n description=self.test_item_desc)\n item.add()","def test_all_group_by_op_fields(self):\n for field in OCIGroupBySerializer._opfields:\n field = \"and:\" + field\n filter_param = {field: [\"1\", \"2\"]}\n serializer = OCIGroupBySerializer(data=filter_param)\n self.assertTrue(serializer.is_valid())\n for field in OCIGroupBySerializer._opfields:\n field = \"or:\" + field\n filter_param = {field: [\"1\", \"2\"]}\n serializer = OCIGroupBySerializer(data=filter_param)\n self.assertTrue(serializer.is_valid())","def test_umi_group(configuration_module, sample_id):\n config, _ = configuration_module\n tmp_dir = config[params.TMP_DIR]\n check_umi_groups(tmp_dir, sample_id, 5)","def test_str_group(self): \n expected_str = self.group.title\n self.assertEqual(expected_str, str(self.group))","def test_drag_into_different_group(self):\r\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty, self.group_b]},\r\n {self.group_a: [self.group_b_item_1, self.group_a_item_1, self.group_a_item_2]},\r\n {self.group_b: [self.group_b_item_2]},\r\n {self.group_empty: []}]\r\n self.drag_and_verify(self.group_b_item_1_handle, self.group_a_item_1_handle, expected_ordering)","def get_GroupInfo(test_case, # type: AnyMagpieTestCaseType\n override_body=None, # type: JSON\n override_group_name=null, # type: Optional[Str]\n override_version=null, # type: Optional[Str]\n override_headers=null, # type: Optional[HeadersType]\n override_cookies=null, # type: Optional[CookiesType]\n ): # type: (...) -> JSON\n version = override_version if override_version is not null else TestSetup.get_Version(test_case)\n grp_name = override_group_name if override_group_name is not null else test_case.test_group_name\n if TestVersion(version) < TestVersion(\"0.6.4\"): # route did not exist before that\n if override_body and \"group\" in override_body:\n return override_body[\"group\"]\n if override_body and \"group_name\" in override_body:\n return override_body\n return {\"group_name\": grp_name or {}}\n if override_body:\n if override_body and \"group\" in override_body:\n return override_body[\"group\"]\n if override_body and \"group_name\" in override_body:\n return override_body\n resp = test_request(test_case, \"GET\", \"/groups/{}\".format(grp_name),\n headers=override_headers if override_headers is not null else test_case.json_headers,\n cookies=override_cookies if override_cookies is not null else test_case.cookies)\n body = check_response_basic_info(resp)\n check_val_is_in(\"group\", body)\n return body[\"group\"] or {}","def test_fake_group(self):\n response = self.client.get(reverse('education:demographic_detail',args=(\"XYZ\",)))\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.context.get(\"json_rate_data\"), None)\n self.assertNotEqual(response.context.get(\"message\"), None)\n self.assertContains(response, \"Home\")\n self.assertContains(response, \"Error: No such group XYZ\")\n self.assertNotContains(response, '<svg id=\"popsvg\"')","def test_user_group_controller_list(self):\n pass","def test_getGroup(self):\n\t\turl = \"/groups/2/\"\n\t\tresponse = self.client.get(url, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(response.data[\"id\"], 2)\n\t\tself.assertEqual(response.data[\"name\"], \"testGroup2\")","def pytest_collection_modifyitems(items, config):\n from . import tagging\n\n remaining = []\n deselected = []\n for item in items:\n # Get all tags for this test (includes tags on class level if present)\n tags = item.get_marker(\"tags\")\n\n if config.option.collectonly:\n info = item.parent.name.split(\"/\")\n print({\"name\": item.name, \"folder\": info[3],\n \"module\": info[4][:-3], \"tags\": tags.args})\n\n # This line fills two purposes. Handle the cases where '--tags'\n # 1) was omitted, this will run all tests except 'not active' and\n # 'awaiting_fix' ones.\n # 2) has no arguments (a case that can occur when running in Docker).\n tags = tags.args + ('all',) if tags else ['all']\n\n # Create a list of the tags\n tags_list = tagging.TagsCollection.build_tags_list(tags)\n\n # Determine if test should be run depending on the parameter tags\n # See also: pytest_configure hook\n if config.parameter_tags.should_pick_up(tags_list):\n remaining.append(item)\n else:\n deselected.append(item)\n\n if deselected:\n config.hook.pytest_deselected(items=deselected)\n items[:] = remaining","def test_group_field(self):\n field = self.record.find('field[@name=\\'groups_id\\']')\n self.assertEqual(field.attrib['eval'],\n '[(4, ref(\\'nh_clinical.group_nhc_admin\\'))]',\n 'Incorrect eval on groups id')","def __getitem__(self, item):\n if isinstance(item, TestGroupReport):\n try:\n return self.data[(type(item), item.category)]\n except KeyError:\n pass\n return super(ReportRendererRegistry, self).__getitem__(item)"],"string":"[\n \"def pytest_before_group_items(session, config, items):\",\n \"def test_add_group(self):\\n pass\",\n \"def test_grouping(self):\\n s = self.create(ComponentItem, UML.Component)\\n uc1 = self.create(UseCaseItem, UML.UseCase)\\n uc2 = self.create(UseCaseItem, UML.UseCase)\\n\\n self.group(s, uc1)\\n assert 1 == len(uc1.subject.subject)\\n self.group(s, uc2)\\n assert 1 == len(uc2.subject.subject)\\n\\n # Classifier.useCase is not navigable to UseCase\\n # self.assertEqual(2, len(s.subject.useCase))\",\n \"def add_test_group(self, test_group):\\n self.test_groups[test_group.name] = test_group\",\n \"def test_list_group(self):\\n pass\",\n \"def test_update_group(self):\\n pass\",\n \"def test_test_group_parameters(self):\\n pass\",\n \"def test_groups_post(self):\\n pass\",\n \"def test_read_group(self):\\n pass\",\n \"def test_get_group(self):\\n pass\",\n \"def test_get_groups(self):\\n pass\",\n \"def test_get_groups(self):\\n pass\",\n \"def test_group_of_one(self):\\n self.testcases[0].group_id = 1\\n self.testcases[0].put()\\n self.testcases[1].key.delete()\\n\\n grouper.group_testcases()\\n\\n testcase = data_handler.get_testcase_by_id(self.testcases[0].key.id())\\n self.assertEqual(testcase.group_id, 0)\\n self.assertTrue(testcase.is_leader)\",\n \"def test_patch_group(self):\\n pass\",\n \"def test_patch_group(self):\\n pass\",\n \"def test_groups_get(self):\\n pass\",\n \"def test_groups_get(self):\\n pass\",\n \"def test_000_add_group(self):\\n # This case is always passed because it's tested in setup_module,\\n # If setup module fails, this case will never run\\n pass\",\n \"def test_replace_groups(self):\\n pass\",\n \"def persist_test_group(self, obj: object, group: str) -> str:\",\n \"def test_replace_group(self):\\n pass\",\n \"def test_reorder_in_group(self):\\r\\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty, self.group_b]},\\r\\n {self.group_a: [self.group_a_item_2, self.group_a_item_1]},\\r\\n {self.group_b: [self.group_b_item_1, self.group_b_item_2]},\\r\\n {self.group_empty: []}]\\r\\n self.drag_and_verify(self.group_a_item_2_handle, self.group_a_item_1_handle, expected_ordering)\",\n \"def get_existing_test_group(self, obj: object) -> str:\",\n \"def test_create_group(self):\\n pass\",\n \"def test_create_group(self):\\n pass\",\n \"def test_api_v1_groups_post(self):\\n pass\",\n \"def add_group(self):\\n items = self.group_list.selectedItems()\\n for item in items:\\n self.parent.add_group_data(item.text())\",\n \"def test_group(self):\\n obs_group, obs_nogroup = group(self.seqstruct, 0.75)\\n exp_group = {'cluster_337': ['cluster_343', 'cluster_345',\\n 'cluster_339'],\\n 'cluster_347': ['cluster_338'],\\n 'cluster_344': ['cluster_340']}\\n exp_nogroup = [self.seqstruct[6], self.seqstruct[8]]\\n\\n self.assertEqual(obs_group, exp_group)\\n self.assertEqual(obs_nogroup, exp_nogroup)\",\n \"def groupInputItem(name,items=[],**kargs):\\n kargs['name'] = name\\n kargs['items'] = items\\n kargs['itemtype'] = 'group'\\n return kargs\",\n \"def item_group_type(self, item_group_type):\\n\\n self._item_group_type = item_group_type\",\n \"def test_ungrouping(self):\\n s = self.create(ComponentItem, UML.Component)\\n uc1 = self.create(UseCaseItem, UML.UseCase)\\n uc2 = self.create(UseCaseItem, UML.UseCase)\\n\\n self.group(s, uc1)\\n self.group(s, uc2)\\n\\n self.ungroup(s, uc1)\\n assert 0 == len(uc1.subject.subject)\\n # Classifier.useCase is not navigable to UseCase\\n # self.assertEqual(1, len(s.subject.useCase))\\n\\n self.ungroup(s, uc2)\\n assert 0 == len(uc2.subject.subject)\\n # Classifier.useCase is not navigable to UseCase\\n # self.assertEqual(0, len(s.subject.useCase))\",\n \"def test_grouping(self):\\n n = self.create(NodeItem, UML.Node)\\n a = self.create(ArtifactItem, UML.Artifact)\\n\\n self.group(n, a)\\n\\n assert 1 == len(n.subject.deployment)\\n assert n.subject.deployment[0].deployedArtifact[0] is a.subject\",\n \"def add_to_group(self,item):\\n self.items.append(item)\\n self.n += 1\",\n \"def create_TestGroup(test_case, # type: AnyMagpieTestCaseType\\n override_group_name=null, # type: Optional[Str]\\n override_discoverable=null, # type: Optional[bool]\\n override_data=null, # type: Optional[JSON]\\n override_headers=null, # type: Optional[HeadersType]\\n override_cookies=null, # type: Optional[CookiesType]\\n ): # type: (...) -> JSON\\n app_or_url = get_app_or_url(test_case)\\n data = override_data\\n if override_data is null:\\n data = {\\\"group_name\\\": override_group_name if override_group_name is not null else test_case.test_group_name}\\n # only add 'discoverable' if explicitly provided here to preserve original behaviour of 'no value provided'\\n if override_discoverable is not null:\\n data[\\\"discoverable\\\"] = override_discoverable\\n grp_name = (data or {}).get(\\\"group_name\\\")\\n if grp_name:\\n test_case.extra_group_names.add(grp_name) # indicate potential removal at a later point\\n resp = test_request(app_or_url, \\\"POST\\\", \\\"/groups\\\", json=data,\\n headers=override_headers if override_headers is not null else test_case.json_headers,\\n cookies=override_cookies if override_cookies is not null else test_case.cookies)\\n return check_response_basic_info(resp, 201, expected_method=\\\"POST\\\")\",\n \"def test_020_query_groups(self):\\n\\n testflow.step(\\\"Querying for groups\\\")\\n assert self.query_cli.run(\\n what='group'\\n )[0], \\\"Failed to search for groups\\\"\",\n \"def test_new_group(self, inventoryloader):\\n inventoryloader.add_group(u'newgroup')\\n assert 'newgroup' in inventoryloader.groups\",\n \"def test_060_add_group_to_group(self):\\n\\n testflow.step(\\\"Adding group %s to group %s\\\", TEST_GROUP1, TEST_GROUP2)\\n assert MANAGE_CLI.run(\\n 'groupadd',\\n TEST_GROUP1,\\n group=TEST_GROUP2,\\n )[0], \\\"Failed to add group to group '%s'\\\" % TEST_GROUP1\",\n \"def pytest_collection_modifyitems(config, items):\\n # check if studio tests myst be skipped\\n run_study = config.getoption(\\\"--runstudy\\\")\\n # 'all' will match all studies, '' will not match anything\\n run_study = {'': '(?!x)x', 'all': '.*'}.get(run_study, run_study)\\n # --runstudy given in cli: do not skip study tests and\\n test_selected = list()\\n test_skipped = list()\\n groups = dict()\\n incremental = pytest.mark.incremental()\\n\\n def add():\\n \\\"helper for gathering test info\\\"\\n marker = item.get_marker(mark)\\n kwargs = parse_args(marker.args, marker.kwargs)\\n group_name = kwargs['name']\\n group = groups.setdefault(group_name, dict())\\n group.setdefault(mark, list()).append((kwargs, item))\\n item.add_marker(incremental)\\n\\n # place every test in regular, prerequisite and studies\\n # group by name\\n for item in items:\\n for mark in set(item.keywords.keys()).intersection(MARKS):\\n add()\\n break\\n else:\\n test_selected.append(item)\\n\\n def sort(a, b):\\n \\\"Sort two items by order priority\\\"\\n return cmp(a[0]['order'], b[0]['order'])\\n\\n # use studies precedence to built the global sequence order\\n mandatory = 'study' # mandatory mark for global sorting: study\\n studies = list()\\n for name, info in groups.items():\\n studies.extend(info.get(mandatory, []))\\n studies.sort(sort)\\n\\n def append(tests, where):\\n \\\"helper to add the test item from info structure\\\"\\n for test in tests:\\n test = test[1]\\n if test not in where:\\n where.append(test)\\n\\n # select only the test that are going to be launched\\n width = 0\\n regexp = re.compile(run_study, re.I | re.DOTALL)\\n for study in studies:\\n group_name = study[0]['name']\\n width = max(width, len(group_name))\\n where = test_selected if regexp.search(group_name) else test_skipped\\n for mark, seq in groups[group_name].items():\\n if mark == mandatory:\\n continue\\n seq.sort(sort)\\n append(seq, where)\\n append([study], where)\\n\\n if config.getoption(\\\"--show_order\\\") or config.getoption(\\\"--debug\\\"):\\n fmt = \\\"{0:>3d} [{1:>%s}] {2}\\\" % width\\n for i, item in enumerate(test_selected + test_skipped):\\n study = get_study_name(item)\\n fqn = get_FQN(item)\\n line = fmt.format(i, study, fqn)\\n if item in test_selected:\\n line = term.green('+' + line)\\n else:\\n line = term.yellow('-' + line)\\n print(line)\\n\\n # we make the --runstudy check at the end to be able to show\\n # test order with --show_order or --debig options\\n # reorder tests by group name and replace items IN-PLACE\\n if run_study:\\n items[:] = test_selected\\n return\\n\\n skip_test = pytest.mark.skip(reason=\\\"need --runstudy option to run\\\")\\n for item in items:\\n if set(item.keywords.keys()).intersection(MARKS):\\n item.add_marker(skip_test)\",\n \"def group_data_callback(self, action: EventType, group_id: str) -> None:\\n self.process_item(group_id, {})\",\n \"def test_update_device_group_by_id1(self):\\n pass\",\n \"def test_groups_state_post(self):\\n pass\",\n \"def IsGroup(self):\\n return isinstance(self, TestGroup)\",\n \"def onGroupDataset(self, event):\\n\\t\\tselections = self.tree.GetSelections()\\n\\t\\tif not selections and self.selectedItem:\\n\\t\\t\\tselections = [self.selectedItem]\\n\\t\\tif not self.groupedDataUnit:\\n\\t\\t\\tpluginLoader = Modules.DynamicLoader.getPluginLoader()\\n\\t\\t\\ttaskMod = pluginLoader.getPluginModule(\\\"Task\\\", \\\"Process\\\")\\n\\t\\t\\tunitType = taskMod.getDataUnit()\\n\\t\\t\\tmoduleType = pluginLoader.getPluginClass(\\\"Task\\\",\\\"Process\\\")\\n\\t\\t\\tself.groupedDataUnit = unitType()\\n\\t\\t\\tmodule = moduleType()\\n\\t\\t\\tself.groupedDataUnit.setModule(module)\\n\\t\\t\\n\\t\\tfor item in selections:\\n\\t\\t\\tif item in self.groupedItems: continue\\n\\t\\t\\tself.groupedItems.append(item)\\n\\t\\t\\tself.markBlue([item], \\\"}\\\")\\n\\t\\t\\tobj = self.tree.GetPyData(item)\\n\\t\\t\\tprint \\\"Adding source dataunit\\\",obj\\n\\t\\t\\tself.groupedDataUnit.addSourceDataUnit(obj)\\n\\t\\tsetting = self.groupedDataUnit.getSettings()\\n\\t\\tsetting.set(\\\"FilterList\\\",[])\\n\\t\\t\\n\\t\\tprint \\\"Now=\\\",self.groupedDataUnit.getSourceDataUnits()\",\n \"def tests_ti_document_get(self):\\n super().group_get()\",\n \"def test_drag_group_into_group(self):\\r\\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty]},\\r\\n {self.group_a: [self.group_b, self.group_a_item_1, self.group_a_item_2]},\\r\\n {self.group_b: [self.group_b_item_1, self.group_b_item_2]},\\r\\n {self.group_empty: []}]\\r\\n self.drag_and_verify(self.group_b_handle, self.group_a_item_1_handle, expected_ordering)\",\n \"def group(self):\\n raise NotImplementedError()\",\n \"def test_grouping(self):\\n n1 = self.create(NodeItem, UML.Node)\\n n2 = self.create(NodeItem, UML.Node)\\n\\n self.group(n1, n2)\\n\\n assert n2.subject in n1.subject.nestedNode\\n assert n1.subject not in n2.subject.nestedNode\",\n \"def with_group(self, group):\\n\\t\\tself.variables['group'] = group\\n\\t\\treturn self\",\n \"def test_get_groups_3(\\n self, management_client, internal_client, inventory_attributes\\n ):\\n\\n did = \\\"some-device-id\\\"\\n internal_client.create_device(did, inventory_attributes)\\n for i in range(10):\\n group = management_client.group(group=\\\"group\\\" + str(i))\\n management_client.addDeviceToGroup(group, did)\\n\\n assert len(management_client.getAllGroups()) == 1\",\n \"def test_user_group_controller_update(self):\\n pass\",\n \"def test_update_device_group_by_id(self):\\n pass\",\n \"def test_users_groups_post(self):\\n pass\",\n \"def test_score_groups(test_input, expected):\\n score = sp.score_groups(test_input)\\n assert score == expected\",\n \"def test_message_group():\",\n \"def group(self, val):\\n self.set_property(\\\"Group\\\", val)\",\n \"def data_group():\\n ...\",\n \"def tests_ti_document_add_attribute(self, request: FixtureRequest):\\n super().group_add_attribute(request)\",\n \"def test_group_by_field(self):\\r\\n t = [\\r\\n ['#sample', 'loc', 'age'],\\r\\n ['a', 'US', '5'],\\r\\n ['b', 'US', '10'],\\r\\n ['c', 'Mal', '5'],\\r\\n ['d', 'Mal', '10'],\\r\\n ['e', 'Ven', '5'],\\r\\n ]\\r\\n self.assertEqual(group_by_field(t, 'loc'),\\r\\n {'US': ['a', 'b'], 'Mal': ['c', 'd'], 'Ven': ['e']})\\r\\n self.assertEqual(group_by_field(t, 'age'),\\r\\n {'5': ['a', 'c', 'e'], '10': ['b', 'd']})\",\n \"def test_update_entry_groups(self):\\r\\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\\r\\n pass\",\n \"def test_checkboxtextgroup(self):\\r\\n self.check_group('checkboxtextgroup', 'choice', 'checkbox')\",\n \"def test_delete_group(self):\\n pass\",\n \"def test_delete_group(self):\\n pass\",\n \"def test_products_ref_groups_put(self):\\n pass\",\n \"def test_partially_update_device_group_by_id1(self):\\n pass\",\n \"def _process_group(self):\\n if not isinstance(self.transform, GroupTransformModel):\\n return\\n\\n self._process_name()\\n\\n if self.transformed_item['type'] == 'Campaign':\\n self._process_metadata_datetime('firstSeen', self.transform.first_seen)\\n\\n if self.transformed_item['type'] == 'Document':\\n self._process_metadata('fileName', self.transform.file_name)\\n self._process_metadata('malware', self.transform.malware)\\n self._process_metadata('password', self.transform.password)\\n\\n if self.transformed_item['type'] == 'Email':\\n self._process_metadata('body', self.transform.body)\\n self._process_metadata('from', self.transform.from_addr)\\n self._process_metadata('header', self.transform.header)\\n self._process_metadata('subject', self.transform.subject)\\n self._process_metadata('to', self.transform.to_addr)\\n\\n if self.transformed_item['type'] in ('Event', 'Incident'):\\n self._process_metadata_datetime('eventDate', self.transform.event_date)\\n self._process_metadata('status', self.transform.status)\\n\\n if self.transformed_item['type'] == 'Report':\\n self._process_metadata('fileName', self.transform.file_name)\\n self._process_metadata_datetime('publishDate', self.transform.publish_date)\\n\\n # Handle sig specific fields here\\n if self.transformed_item['type'] == 'Signature':\\n self._process_metadata('fileName', self.transform.file_name)\\n self._process_metadata('fileType', self.transform.file_type)\\n self._process_metadata('fileText', self.transform.file_text)\",\n \"def test_grouped(self):\\n gfile = grades.writers.GradesFile(self.fname)\\n gfile.table.compute_grouped_mean('Group')\\n gfile.table_format = 'org'\\n self.check_output(self.output_str2, gfile)\",\n \"def test_api_v1_groups_get(self):\\n pass\",\n \"def test_groups(self):\\n # Make a group and send to it\\n channel_layer.group_add(\\\"tgroup\\\", \\\"tg_test\\\")\\n channel_layer.group_add(\\\"tgroup\\\", \\\"tg_test2\\\")\\n channel_layer.group_add(\\\"tgroup\\\", \\\"tg_test3\\\")\\n channel_layer.group_discard(\\\"tgroup\\\", \\\"tg_test3\\\")\\n channel_layer.send_group(\\\"tgroup\\\", {\\\"value\\\": \\\"orange\\\"})\\n # Receive from the two channels in the group and ensure messages\\n channel, message = channel_layer.receive_many([\\\"tg_test\\\"])\\n self.assertEqual(channel, \\\"tg_test\\\")\\n self.assertEqual(message, {\\\"value\\\": \\\"orange\\\"})\\n channel, message = channel_layer.receive_many([\\\"tg_test2\\\"])\\n self.assertEqual(channel, \\\"tg_test2\\\")\\n self.assertEqual(message, {\\\"value\\\": \\\"orange\\\"})\\n # Make sure another channel does not get a message\\n channel, message = channel_layer.receive_many([\\\"tg_test3\\\"])\\n self.assertIs(channel, None)\\n self.assertIs(message, None)\",\n \"def test_post_entry_groups(self):\\r\\n # This method utilises the POST request method and will make changes to the Canvas instance. This needs consideration.\\r\\n pass\",\n \"def test_products_ref_groups_get(self):\\n pass\",\n \"def _itemAdded(self, item):\\n group = self.item()\\n if group is None:\\n return\\n\\n row = group.getItems().index(item)\\n self.addRow(nodeFromItem(item), row + self._CHILDREN_ROW_OFFSET)\",\n \"def test_delete_groups(self):\\n pass\",\n \"def test_post_add_remove_group(self):\\n # todo: think about what if owner doesn't want contributors to add groups\\n # self.addgrouprequest = self.factory.post(reverse(\\\"add_album_groups\\\"))\\n pass\",\n \"def test_patchorganizations_item(self):\\n pass\",\n \"def test_partially_update_device_group_by_id(self):\\n pass\",\n \"def test_verify_that_you_can_create_a_new_group():\",\n \"def group_by(self, key):\\n ret = {}\\n for test in self._testset():\\n if hastag(test, key):\\n ret.setdefault(gettag(test, key), []).append(test)\\n continue\\n ret.setdefault(\\\"others\\\", []).append(test)\\n for k in ret:\\n ret[k] = self.__class__(ret[k])\\n return ret\",\n \"def test_group(self):\\n m = mapper(Order, orders, properties = {\\n 'userident':deferred(orders.c.user_id, group='primary'),\\n 'description':deferred(orders.c.description, group='primary'),\\n 'opened':deferred(orders.c.isopen, group='primary')\\n })\\n sess = create_session()\\n q = sess.query(m)\\n def go():\\n l = q.all()\\n o2 = l[2]\\n print o2.opened, o2.description, o2.userident\\n assert o2.opened == 1\\n assert o2.userident == 7\\n assert o2.description == 'order 3'\\n orderby = str(orders.default_order_by()[0].compile(testing.db))\\n self.assert_sql(testing.db, go, [\\n (\\\"SELECT orders.order_id AS orders_order_id FROM orders ORDER BY %s\\\" % orderby, {}),\\n (\\\"SELECT orders.user_id AS orders_user_id, orders.description AS orders_description, orders.isopen AS orders_isopen FROM orders WHERE orders.order_id = :param_1\\\", {'param_1':3})\\n ])\\n\\n o2 = q.all()[2]\\n# assert o2.opened == 1\\n assert o2.description == 'order 3'\\n assert o2 not in sess.dirty\\n o2.description = 'order 3'\\n def go():\\n sess.flush()\\n self.assert_sql_count(testing.db, go, 0)\",\n \"def test_properties_stats_group_by_group_by_and_sub_group_by_get(self):\\n pass\",\n \"def test_add(self):\\n # add a new group\\n self.assertTrue(self.run_function(\\\"group.add\\\", [self._group], gid=self._gid))\\n group_info = self.run_function(\\\"group.info\\\", [self._group])\\n self.assertEqual(group_info[\\\"gid\\\"], self._gid)\\n self.assertEqual(group_info[\\\"name\\\"], self._group)\\n # try adding the group again\\n self.assertFalse(self.run_function(\\\"group.add\\\", [self._group], gid=self._gid))\",\n \"def test_bulk_group(self):\\n for fn, sep in [(self.filename_actg, '\\\\t'),\\n (self.filename_actg_csv, ';')]:\\n file_path_ag = os.path.join(os.path.dirname(__file__),\\n self.testdata_folder,\\n fn)\\n data = {\\n 'bulk_upload' : open(file_path_ag, 'rb'),\\n }\\n\\n existing_ags = ActivityGroup.objects.filter(keyflow=self.kic)\\n existing_codes = list(existing_ags.values_list('code', flat=True))\\n\\n encoding = 'utf8'\\n df_file_ags = pd.read_csv(file_path_ag, sep=sep)\\n df_file_ags = df_file_ags.rename(\\n columns={c: c.lower() for c in df_file_ags.columns})\\n file_codes = df_file_ags['code']\\n new_codes = [c for c in file_codes if c not in existing_codes]\\n\\n res = self.client.post(self.ag_url, data)\\n res_json = res.json()\\n assert res.status_code == status.HTTP_201_CREATED\\n assert res_json['count'] == len(file_codes)\\n assert len(res_json['created']) == len(new_codes)\\n\\n # assert that the number of activities matches\\n all_ag = ActivityGroup.objects.filter(keyflow_id=self.kic.id)\\n assert len(all_ag) == len(existing_codes) + len(new_codes)\\n\\n # assert that the Name matches in all values\\n for row in df_file_ags.itertuples(index=False):\\n ag = ActivityGroup.objects.get(keyflow=self.keyflow,\\n code=row.code)\\n assert ag.name == row.name\",\n \"def tests_ti_document_update(self, request: FixtureRequest):\\n super().group_update(request)\",\n \"def test_filter_device_group(self):\\n pass\",\n \"def test_mark_entry_as_read_groups(self):\\r\\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\\r\\n pass\",\n \"def test_search_by_group_view(self):\\n resp = self.client.get(reverse('minerals:group',\\n kwargs={'group': self.mineral.group}))\\n self.assertEqual(resp.status_code, 200)\\n self.assertIn(self.mineral, resp.context['minerals'])\\n self.assertNotIn(self.mineral2, resp.context['minerals'])\\n self.assertTemplateUsed(resp, 'minerals/mineral_list.html')\",\n \"def test_groups_group_id_get(self):\\n pass\",\n \"def test_radiotextgroup(self):\\r\\n self.check_group('radiotextgroup', 'choice', 'radio')\",\n \"def test_trivial(self):\\n group = Group()\",\n \"def add_item(self):\\n item = models.Item(item_name=self.test_item,\\n list_id=1,\\n description=self.test_item_desc)\\n item.add()\",\n \"def test_all_group_by_op_fields(self):\\n for field in OCIGroupBySerializer._opfields:\\n field = \\\"and:\\\" + field\\n filter_param = {field: [\\\"1\\\", \\\"2\\\"]}\\n serializer = OCIGroupBySerializer(data=filter_param)\\n self.assertTrue(serializer.is_valid())\\n for field in OCIGroupBySerializer._opfields:\\n field = \\\"or:\\\" + field\\n filter_param = {field: [\\\"1\\\", \\\"2\\\"]}\\n serializer = OCIGroupBySerializer(data=filter_param)\\n self.assertTrue(serializer.is_valid())\",\n \"def test_umi_group(configuration_module, sample_id):\\n config, _ = configuration_module\\n tmp_dir = config[params.TMP_DIR]\\n check_umi_groups(tmp_dir, sample_id, 5)\",\n \"def test_str_group(self): \\n expected_str = self.group.title\\n self.assertEqual(expected_str, str(self.group))\",\n \"def test_drag_into_different_group(self):\\r\\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty, self.group_b]},\\r\\n {self.group_a: [self.group_b_item_1, self.group_a_item_1, self.group_a_item_2]},\\r\\n {self.group_b: [self.group_b_item_2]},\\r\\n {self.group_empty: []}]\\r\\n self.drag_and_verify(self.group_b_item_1_handle, self.group_a_item_1_handle, expected_ordering)\",\n \"def get_GroupInfo(test_case, # type: AnyMagpieTestCaseType\\n override_body=None, # type: JSON\\n override_group_name=null, # type: Optional[Str]\\n override_version=null, # type: Optional[Str]\\n override_headers=null, # type: Optional[HeadersType]\\n override_cookies=null, # type: Optional[CookiesType]\\n ): # type: (...) -> JSON\\n version = override_version if override_version is not null else TestSetup.get_Version(test_case)\\n grp_name = override_group_name if override_group_name is not null else test_case.test_group_name\\n if TestVersion(version) < TestVersion(\\\"0.6.4\\\"): # route did not exist before that\\n if override_body and \\\"group\\\" in override_body:\\n return override_body[\\\"group\\\"]\\n if override_body and \\\"group_name\\\" in override_body:\\n return override_body\\n return {\\\"group_name\\\": grp_name or {}}\\n if override_body:\\n if override_body and \\\"group\\\" in override_body:\\n return override_body[\\\"group\\\"]\\n if override_body and \\\"group_name\\\" in override_body:\\n return override_body\\n resp = test_request(test_case, \\\"GET\\\", \\\"/groups/{}\\\".format(grp_name),\\n headers=override_headers if override_headers is not null else test_case.json_headers,\\n cookies=override_cookies if override_cookies is not null else test_case.cookies)\\n body = check_response_basic_info(resp)\\n check_val_is_in(\\\"group\\\", body)\\n return body[\\\"group\\\"] or {}\",\n \"def test_fake_group(self):\\n response = self.client.get(reverse('education:demographic_detail',args=(\\\"XYZ\\\",)))\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.context.get(\\\"json_rate_data\\\"), None)\\n self.assertNotEqual(response.context.get(\\\"message\\\"), None)\\n self.assertContains(response, \\\"Home\\\")\\n self.assertContains(response, \\\"Error: No such group XYZ\\\")\\n self.assertNotContains(response, '<svg id=\\\"popsvg\\\"')\",\n \"def test_user_group_controller_list(self):\\n pass\",\n \"def test_getGroup(self):\\n\\t\\turl = \\\"/groups/2/\\\"\\n\\t\\tresponse = self.client.get(url, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(response.data[\\\"id\\\"], 2)\\n\\t\\tself.assertEqual(response.data[\\\"name\\\"], \\\"testGroup2\\\")\",\n \"def pytest_collection_modifyitems(items, config):\\n from . import tagging\\n\\n remaining = []\\n deselected = []\\n for item in items:\\n # Get all tags for this test (includes tags on class level if present)\\n tags = item.get_marker(\\\"tags\\\")\\n\\n if config.option.collectonly:\\n info = item.parent.name.split(\\\"/\\\")\\n print({\\\"name\\\": item.name, \\\"folder\\\": info[3],\\n \\\"module\\\": info[4][:-3], \\\"tags\\\": tags.args})\\n\\n # This line fills two purposes. Handle the cases where '--tags'\\n # 1) was omitted, this will run all tests except 'not active' and\\n # 'awaiting_fix' ones.\\n # 2) has no arguments (a case that can occur when running in Docker).\\n tags = tags.args + ('all',) if tags else ['all']\\n\\n # Create a list of the tags\\n tags_list = tagging.TagsCollection.build_tags_list(tags)\\n\\n # Determine if test should be run depending on the parameter tags\\n # See also: pytest_configure hook\\n if config.parameter_tags.should_pick_up(tags_list):\\n remaining.append(item)\\n else:\\n deselected.append(item)\\n\\n if deselected:\\n config.hook.pytest_deselected(items=deselected)\\n items[:] = remaining\",\n \"def test_group_field(self):\\n field = self.record.find('field[@name=\\\\'groups_id\\\\']')\\n self.assertEqual(field.attrib['eval'],\\n '[(4, ref(\\\\'nh_clinical.group_nhc_admin\\\\'))]',\\n 'Incorrect eval on groups id')\",\n \"def __getitem__(self, item):\\n if isinstance(item, TestGroupReport):\\n try:\\n return self.data[(type(item), item.category)]\\n except KeyError:\\n pass\\n return super(ReportRendererRegistry, self).__getitem__(item)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.684022","0.66695523","0.6552354","0.6369141","0.63321984","0.63281184","0.62650174","0.6235142","0.61431545","0.61334264","0.61311626","0.61311626","0.6118693","0.60952663","0.60952663","0.6080429","0.6080429","0.6024302","0.60169107","0.5959551","0.5919496","0.5849684","0.5820592","0.5810374","0.5810374","0.57989275","0.5781627","0.57755375","0.57580984","0.5757381","0.57432395","0.57265246","0.57090056","0.5703924","0.56973964","0.56951624","0.56864375","0.5679311","0.56753576","0.56671435","0.5665608","0.56570417","0.5655406","0.5592135","0.5581487","0.55692273","0.55641866","0.5557758","0.5549842","0.55427957","0.5538947","0.55176157","0.55091345","0.55075306","0.5501269","0.5490158","0.54868054","0.5473262","0.5455002","0.54514927","0.5449676","0.5449676","0.54447305","0.544383","0.54397947","0.5431271","0.5425762","0.5422279","0.5410016","0.5409973","0.5398851","0.5387636","0.5383666","0.53834486","0.5379795","0.5368313","0.53673524","0.5366636","0.53665155","0.53569555","0.535404","0.53529614","0.53529423","0.5347981","0.53435034","0.5341459","0.53338504","0.5333571","0.5328123","0.53162104","0.53114855","0.5307467","0.53047425","0.5304337","0.53001225","0.5295164","0.52911097","0.5271779","0.527015","0.5250772"],"string":"[\n \"0.684022\",\n \"0.66695523\",\n \"0.6552354\",\n \"0.6369141\",\n \"0.63321984\",\n \"0.63281184\",\n \"0.62650174\",\n \"0.6235142\",\n \"0.61431545\",\n \"0.61334264\",\n \"0.61311626\",\n \"0.61311626\",\n \"0.6118693\",\n \"0.60952663\",\n \"0.60952663\",\n \"0.6080429\",\n \"0.6080429\",\n \"0.6024302\",\n \"0.60169107\",\n \"0.5959551\",\n \"0.5919496\",\n \"0.5849684\",\n \"0.5820592\",\n \"0.5810374\",\n \"0.5810374\",\n \"0.57989275\",\n \"0.5781627\",\n \"0.57755375\",\n \"0.57580984\",\n \"0.5757381\",\n \"0.57432395\",\n \"0.57265246\",\n \"0.57090056\",\n \"0.5703924\",\n \"0.56973964\",\n \"0.56951624\",\n \"0.56864375\",\n \"0.5679311\",\n \"0.56753576\",\n \"0.56671435\",\n \"0.5665608\",\n \"0.56570417\",\n \"0.5655406\",\n \"0.5592135\",\n \"0.5581487\",\n \"0.55692273\",\n \"0.55641866\",\n \"0.5557758\",\n \"0.5549842\",\n \"0.55427957\",\n \"0.5538947\",\n \"0.55176157\",\n \"0.55091345\",\n \"0.55075306\",\n \"0.5501269\",\n \"0.5490158\",\n \"0.54868054\",\n \"0.5473262\",\n \"0.5455002\",\n \"0.54514927\",\n \"0.5449676\",\n \"0.5449676\",\n \"0.54447305\",\n \"0.544383\",\n \"0.54397947\",\n \"0.5431271\",\n \"0.5425762\",\n \"0.5422279\",\n \"0.5410016\",\n \"0.5409973\",\n \"0.5398851\",\n \"0.5387636\",\n \"0.5383666\",\n \"0.53834486\",\n \"0.5379795\",\n \"0.5368313\",\n \"0.53673524\",\n \"0.5366636\",\n \"0.53665155\",\n \"0.53569555\",\n \"0.535404\",\n \"0.53529614\",\n \"0.53529423\",\n \"0.5347981\",\n \"0.53435034\",\n \"0.5341459\",\n \"0.53338504\",\n \"0.5333571\",\n \"0.5328123\",\n \"0.53162104\",\n \"0.53114855\",\n \"0.5307467\",\n \"0.53047425\",\n \"0.5304337\",\n \"0.53001225\",\n \"0.5295164\",\n \"0.52911097\",\n \"0.5271779\",\n \"0.527015\",\n \"0.5250772\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.660266"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":77694,"cells":{"query":{"kind":"string","value":"This is the place to provision if grouper is invoked"},"document":{"kind":"string","value":"def pytest_started_handling_group(session, worker):"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __on_group_created(self, logger, *args):","def test_create_group(self):\n pass","def test_create_group(self):\n pass","def pre_security_group_create(self, resource_dict):\n pass","def test_create_device_group(self):\n pass","def _make_group(self, _rk, _group_hint):\n\n if isinstance(_group_hint, dict):\n # _group_hint is a single key/value pair\n g = _group_hint[list(_group_hint)[0]]\n\n r_type = g.get(\"type\", \"none\")\n if r_type != \"OS::Nova::ServerGroup\":\n return \"support only ServerGroup resource\"\n\n properties = g.get(\"properties\", {})\n if len(properties) == 0:\n return \"no properties\"\n\n group_name = properties.get(\"name\", None)\n if group_name is None:\n return \"no group name\"\n group_name = group_name.strip()\n\n policies = properties.get(\"policies\", [])\n if len(policies) == 0:\n return \"no policy of the group\"\n\n if len(policies) > 1:\n return \"multiple policies\"\n\n # TODO: exclude soft-affinity and soft-anti-affinity?\n\n if group_name in self.groups.keys():\n group = self.groups[group_name]\n else:\n group = Group(group_name)\n\n policy = policies[0].strip()\n if policy == \"anti-affinity\":\n group_type = \"diversity\"\n else:\n group_type = policy\n\n group.group_type = group_type\n group.factory = \"server-group\"\n group.level = \"host\"\n\n self.groups[group_name] = group\n else:\n # group hint is uuid string.\n rg = self.resource.get_group_by_uuid(_group_hint)\n if rg is None:\n return \"unknown group found while making group\"\n\n # TODO: exclude soft-affinity and soft-anti-affinity?\n\n if rg.name in self.groups.keys():\n group = self.groups[rg.name]\n else:\n group = Group(rg.name)\n\n group.group_type = rg.group_type\n group.factory = rg.factory\n group.level = \"host\"\n\n self.groups[rg.name] = group\n\n if group is not None:\n group.server_list.append(self.app_name + \":\" + _rk)\n\n return \"ok\"","def test_create_resource_group(self):\n pass","def _provision_package(self):","def test_add_group(self):\n pass","def createMainGroup(self):\n\t\tmc.group( n = self.grp.name, em = True )","def test_get_group(self):\n pass","def capacitygroup_group():","def monitoring_group(ctx):\n pass","def test_user_group_controller_create(self):\n pass","def test_000_add_group(self):\n # This case is always passed because it's tested in setup_module,\n # If setup module fails, this case will never run\n pass","async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:\n if DOMAIN not in hass.data:\n hass.data[DOMAIN] = EntityComponent[Group](_LOGGER, DOMAIN, hass)\n\n await async_process_integration_platform_for_component(hass, DOMAIN)\n\n component: EntityComponent[Group] = hass.data[DOMAIN]\n\n hass.data[REG_KEY] = GroupIntegrationRegistry()\n\n await async_process_integration_platforms(hass, DOMAIN, _process_group_platform)\n\n await _async_process_config(hass, config)\n\n async def reload_service_handler(service: ServiceCall) -> None:\n \"\"\"Remove all user-defined groups and load new ones from config.\"\"\"\n auto = [e for e in component.entities if not e.user_defined]\n\n if (conf := await component.async_prepare_reload()) is None:\n return\n await _async_process_config(hass, conf)\n\n await component.async_add_entities(auto)\n\n await async_reload_integration_platforms(hass, DOMAIN, PLATFORMS)\n\n hass.services.async_register(\n DOMAIN, SERVICE_RELOAD, reload_service_handler, schema=vol.Schema({})\n )\n\n service_lock = asyncio.Lock()\n\n async def locked_service_handler(service: ServiceCall) -> None:\n \"\"\"Handle a service with an async lock.\"\"\"\n async with service_lock:\n await groups_service_handler(service)\n\n async def groups_service_handler(service: ServiceCall) -> None:\n \"\"\"Handle dynamic group service functions.\"\"\"\n object_id = service.data[ATTR_OBJECT_ID]\n entity_id = f\"{DOMAIN}.{object_id}\"\n group = component.get_entity(entity_id)\n\n # new group\n if service.service == SERVICE_SET and group is None:\n entity_ids = (\n service.data.get(ATTR_ENTITIES)\n or service.data.get(ATTR_ADD_ENTITIES)\n or None\n )\n\n extra_arg = {\n attr: service.data[attr]\n for attr in (ATTR_ICON,)\n if service.data.get(attr) is not None\n }\n\n await Group.async_create_group(\n hass,\n service.data.get(ATTR_NAME, object_id),\n object_id=object_id,\n entity_ids=entity_ids,\n user_defined=False,\n mode=service.data.get(ATTR_ALL),\n **extra_arg,\n )\n return\n\n if group is None:\n _LOGGER.warning(\"%s:Group '%s' doesn't exist!\", service.service, object_id)\n return\n\n # update group\n if service.service == SERVICE_SET:\n need_update = False\n\n if ATTR_ADD_ENTITIES in service.data:\n delta = service.data[ATTR_ADD_ENTITIES]\n entity_ids = set(group.tracking) | set(delta)\n await group.async_update_tracked_entity_ids(entity_ids)\n\n if ATTR_REMOVE_ENTITIES in service.data:\n delta = service.data[ATTR_REMOVE_ENTITIES]\n entity_ids = set(group.tracking) - set(delta)\n await group.async_update_tracked_entity_ids(entity_ids)\n\n if ATTR_ENTITIES in service.data:\n entity_ids = service.data[ATTR_ENTITIES]\n await group.async_update_tracked_entity_ids(entity_ids)\n\n if ATTR_NAME in service.data:\n group.name = service.data[ATTR_NAME]\n need_update = True\n\n if ATTR_ICON in service.data:\n group.icon = service.data[ATTR_ICON]\n need_update = True\n\n if ATTR_ALL in service.data:\n group.mode = all if service.data[ATTR_ALL] else any\n need_update = True\n\n if need_update:\n group.async_write_ha_state()\n\n return\n\n # remove group\n if service.service == SERVICE_REMOVE:\n await component.async_remove_entity(entity_id)\n\n hass.services.async_register(\n DOMAIN,\n SERVICE_SET,\n locked_service_handler,\n schema=vol.All(\n vol.Schema(\n {\n vol.Required(ATTR_OBJECT_ID): cv.slug,\n vol.Optional(ATTR_NAME): cv.string,\n vol.Optional(ATTR_ICON): cv.string,\n vol.Optional(ATTR_ALL): cv.boolean,\n vol.Exclusive(ATTR_ENTITIES, \"entities\"): cv.entity_ids,\n vol.Exclusive(ATTR_ADD_ENTITIES, \"entities\"): cv.entity_ids,\n vol.Exclusive(ATTR_REMOVE_ENTITIES, \"entities\"): cv.entity_ids,\n }\n )\n ),\n )\n\n hass.services.async_register(\n DOMAIN,\n SERVICE_REMOVE,\n groups_service_handler,\n schema=vol.Schema({vol.Required(ATTR_OBJECT_ID): cv.slug}),\n )\n\n return True","def create_seurity_group(self):\n return True","def __init__(self, group, **kwargs):\n #group can be robot stage floor or tool\n super(PhysicalPropertiesInterventionActorPolicy, self).__init__()\n self.task_intervention_space = None\n self.group = group","def group(self):\n raise NotImplementedError()","def test_create_device_group1(self):\n pass","def setUp(self):\n self.log = mock_log().bind(base_log=True)\n self.state = GroupState('tid', 'gid', 'g', {}, {}, None, {}, True,\n ScalingGroupStatus.ACTIVE)\n self.group = mock_group(self.state)","def main():\n snap_name = 'REST_Snap_' + strftime('%d%m%Y%H%M%S')\n ru.replication.create_storagegroup_snap(sg_id, snap_name)\n print('Check the Gui now or REST Client to see if snapshot '\n '{snap_name} was created for Storge Group {sg_id}'\n .format(snap_name=snap_name, sg_id=sg_id))","def test_patch_group(self):\n pass","def test_patch_group(self):\n pass","def test_get_groups(self):\n pass","def test_get_groups(self):\n pass","async def async_turn_on(self):\n if not self._raumfeld.group_is_valid(self._rooms):\n await self._raumfeld.async_create_group(self._rooms)\n await self.async_update_transport_state()\n else:\n log_debug(\n \"Method was called although speaker group '%s' is invalid\" % self._rooms\n )","def test_priority(self, inventoryloader):\n inventoryloader.set_group_priority('glance_api',-1)\n inventoryloader.add_group('glance_api',{'vars': {'management_bridge':'br_woot'}})\n assert 'br_woot' == inventoryloader.groups['glance_api'].vars.get('management_bridge')","def _create_child_group(self, name) -> \"GroupBase\":\n pass","def post_security_group_create(self, resource_dict):\n pass","def groupFormation(self):\n self.updatedPartnerNames()\n self.updatedPotentialPartnerNames()\n self.updatePartnerIdices()\n self.makeGraphDictionary()\n self.assignGroupIDs()","def __init__(__self__,\n resource_name: str,\n args: GroupArgs,\n opts: Optional[pulumi.ResourceOptions] = None):\n ...","def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None,\n auto_healing_policies: Optional[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerAutoHealingPoliciesArgs']]] = None,\n base_instance_name: Optional[pulumi.Input[str]] = None,\n description: Optional[pulumi.Input[str]] = None,\n distribution_policy_zones: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,\n name: Optional[pulumi.Input[str]] = None,\n named_ports: Optional[pulumi.Input[List[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerNamedPortArgs']]]]] = None,\n project: Optional[pulumi.Input[str]] = None,\n region: Optional[pulumi.Input[str]] = None,\n stateful_disks: Optional[pulumi.Input[List[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerStatefulDiskArgs']]]]] = None,\n target_pools: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,\n target_size: Optional[pulumi.Input[float]] = None,\n update_policy: Optional[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerUpdatePolicyArgs']]] = None,\n versions: Optional[pulumi.Input[List[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerVersionArgs']]]]] = None,\n wait_for_instances: Optional[pulumi.Input[bool]] = None,\n __props__=None,\n __name__=None,\n __opts__=None):\n if __name__ is not None:\n warnings.warn(\"explicit use of __name__ is deprecated\", DeprecationWarning)\n resource_name = __name__\n if __opts__ is not None:\n warnings.warn(\"explicit use of __opts__ is deprecated, use 'opts' instead\", DeprecationWarning)\n opts = __opts__\n if opts is None:\n opts = pulumi.ResourceOptions()\n if not isinstance(opts, pulumi.ResourceOptions):\n raise TypeError('Expected resource options to be a ResourceOptions instance')\n if opts.version is None:\n opts.version = _utilities.get_version()\n if opts.id is None:\n if __props__ is not None:\n raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')\n __props__ = dict()\n\n __props__['auto_healing_policies'] = auto_healing_policies\n if base_instance_name is None:\n raise TypeError(\"Missing required property 'base_instance_name'\")\n __props__['base_instance_name'] = base_instance_name\n __props__['description'] = description\n __props__['distribution_policy_zones'] = distribution_policy_zones\n __props__['name'] = name\n __props__['named_ports'] = named_ports\n __props__['project'] = project\n if region is None:\n raise TypeError(\"Missing required property 'region'\")\n __props__['region'] = region\n __props__['stateful_disks'] = stateful_disks\n __props__['target_pools'] = target_pools\n __props__['target_size'] = target_size\n __props__['update_policy'] = update_policy\n if versions is None:\n raise TypeError(\"Missing required property 'versions'\")\n __props__['versions'] = versions\n __props__['wait_for_instances'] = wait_for_instances\n __props__['fingerprint'] = None\n __props__['instance_group'] = None\n __props__['self_link'] = None\n super(RegionInstanceGroupManager, __self__).__init__(\n 'gcp:compute/regionInstanceGroupManager:RegionInstanceGroupManager',\n resource_name,\n __props__,\n opts)","async def _group(self, ctx):\r\n\t\tif ctx.invoked_subcommand is None:\r\n\t\t\tprint (\"Ryhmä komento annettiin ilman alakomentoa\")","def test_verify_that_you_can_create_a_new_group():","def test_5_group_required(self):\n user = User.objects.get(email=data_user['email'])\n self.factory = RequestFactory()\n\n @group_required('default')\n def test(request):\n return 200\n\n request = self.factory.get('/foo')\n request.user = user\n response = test(request)\n self.assertEqual(response.status_code, 302)\n\n group = Group.objects.create(\n name='default',\n )\n\n user.groups.add(group)\n request = self.factory.get('/foo')\n request.user = user\n response = test(request)\n self.assertEqual(response, 200)","def _initGroups(self):\n defaults = self._getGroupDefaults()\n ddict = self._getDefaultGroupDict(defaults)\n\n for group in self._config.sections():\n ddict[\"_name\"] = group\n container = self.getGroupContainer(**ddict)\n self._passConfig(container, group)\n self.groups.append(container)\n\n if not self.groups:\n self.groups.append(self.getGroupContainer(**defaults._dict_))","def user_post_save(sender, instance, created, **kwargs):\n if created:\n instance.groups.add(Group.objects.get(name=\"DefaultExportExtentGroup\"))","def test_groups_get(self):\n pass","def test_groups_get(self):\n pass","def setup_provider(self):\n pass","def test_read_group(self):\n pass","def test_patch_resource_group(self):\n pass","def __init__(self):\n self.groups_url = \"%s/groups\" % CONF.valet.HOST\n\n self.headers = {\"X-Auth-Token\": Auth.get_auth_token(),\n \"Content-Type\": \"application/json\"}","def test_groups_post(self):\n pass","def _check_required_if_provider(self):\n return","def test_get_device_groups(self):\n pass","def test_new_group(self, inventoryloader):\n inventoryloader.add_group(u'newgroup')\n assert 'newgroup' in inventoryloader.groups","def test_creator_group_enabled_nonempty(self):\r\n with mock.patch.dict('django.conf.settings.FEATURES', {\"ENABLE_CREATOR_GROUP\": True}):\r\n add_users(self.admin, CourseCreatorRole(), self.user)\r\n self.assertTrue(has_access(self.user, CourseCreatorRole()))\r\n\r\n # check that a user who has not been added to the group still returns false\r\n user_not_added = User.objects.create_user('testuser2', 'test+courses2@edx.org', 'foo2')\r\n self.assertFalse(has_access(user_not_added, CourseCreatorRole()))\r\n\r\n # remove first user from the group and verify that CourseCreatorRole().has_user now returns false\r\n remove_users(self.admin, CourseCreatorRole(), self.user)\r\n self.assertFalse(has_access(self.user, CourseCreatorRole()))","def test_update_group(self):\n pass","def setUpClass(cls):\n super().setUpClass()\n cls.group = Group.objects.create(\n title=TEST_GROUP_NAME,\n slug=TEST_GROUP_SLUG\n )","def deploy_group(group_name):\n group=get_entity_by_cond(Group,'group_name==\"%s\"'%group_name)\n nodes=session.query(Node).filter('group_name==\"%s\"'%group_name)\n\n machines_filename = os.path.join(\n spl.config.paths['headnode-config'],\n str(group.network_id),\n 'machines.txt',\n )\n\n machines_dirname = os.path.dirname(machines_filename)\n if not os.path.isdir(machines_dirname):\n os.mkdir(machines_dirname)\n\n with open(machines_filename, 'w') as f:\n for node in nodes:\n f.write((\"%s %s\\n\"%(node.mac_addr,node.manage_ip)))\n\n\n switches=[]\n ports='';\n for node in nodes:\n switches.append(node.port.switch_id)\n ports+=str(node.port.port_no)+','\n #Check all the nodes in the group are connected to the same switch\n switch_id=check_same_non_empty_list(switches)\n if switch_id==False:\n # TODO: raise an exception\n print \"error: ports not in same switch\"\n return\n\n switch=get_entity_by_cond(Switch,'switch_id==%d'%switch_id)\n\n import cisco_snmp\n switch_drivers = {'cisco_snmp.py':cisco_snmp}\n driver = switch_drivers[switch.script]\n\n\n\n\n print group.network_id\n driver.make_remove_vlans(str(group.network_id),True)\n print 'ports'+ports\n driver.edit_ports_on_vlan(ports,str(group.network_id),True)\n\n os.system(('../vm-vlan up %s %s' % (group.network_id,group.vm_name)))\n\n group.deployed = True","def test_autoscaling_group_valid(self) -> None:\n self.assertTrue(self.validate_autoscaling_group(is_prod=self.prod_env))","def __enter__(self):\n self._logger.debug(\"__enter__()\")\n self.install(\"PRE\")","def _check_groups_kvm():\n if not _user_belongs_to('libvirtd') and not _user_belongs_to('kvm'):\n _raise_group_error('kvm')","def setUpContainer(self):\n self.dev1 = Device(name='dev1')\n eg = ElectrodeGroup(name='elec1',\n description='a test ElectrodeGroup',\n location='a nonexistent place',\n device=self.dev1)\n return eg","def __init__(self, *args, **kwargs):\n print(\"Group Roses initialize.\")\n poems = []\n self.poems = poems\n\n # Each creator should have domain specified: title, poetry, music, image, etc.\n self.domain = 'poetry'","def test_user_group_controller_list(self):\n pass","def init_valet_groups(self):\n\n for rk, r in self.stack.items():\n properties = r.get(\"properties\", {})\n metadata = properties.get(\"metadata\", {})\n\n if len(metadata) > 0:\n valet_rules = metadata.get(\"valet_groups\", None)\n\n if valet_rules is not None and valet_rules != \"\":\n rule_list = []\n if isinstance(valet_rules, six.string_types):\n rules = valet_rules.split(\",\")\n for gr in rules:\n rule_list.append(gr.strip())\n else:\n self.status = \"incorrect valet group metadata format\"\n self.logger.error(self.status)\n return\n\n # Check rule validation of valet_groups.\n self.status = self.resource.check_valid_rules(self.tenant_id,\n rule_list,\n use_ex=self.use_dha)\n if self.status != \"ok\":\n self.logger.error(self.status)\n return\n\n self.status = self._make_valet_groups(properties.get(\"name\"),\n properties[\"availability_zone\"][0],\n rule_list)\n if self.status != \"ok\":\n self.logger.error(self.status)\n return\n\n # Check and create server groups if they do not exist.\n scheduler_hints = properties.get(\"scheduler_hints\", {})\n if len(scheduler_hints) > 0:\n for hint_key in scheduler_hints.keys():\n if hint_key == \"group\":\n hint = scheduler_hints[hint_key]\n self.status = self._make_group(properties.get(\"name\"), hint)\n if self.status != \"ok\":\n self.logger.error(self.status)\n return","def __enter__(self):\n self.key = self.make_new_key()\n self.sec_grp, self.group_id = self.make_new_group()\n\n printy(\"New key {} created\".format(self.key.name))\n printy(\"new security group {} created\".format(self.sec_grp.group_name))\n\n return self","def available_groups(cls):\n raise NotImplementedError","def _assert_create_group(self, personality, response=400):\n group_response = self.autoscale_behaviors.create_scaling_group_given(\n lc_personality=personality)\n self.assertEquals(group_response.status_code, response, msg='Create group '\n 'with invalid lc_personality returned {0} as against '\n '{1}'.format(group_response.status_code, response))\n if response is 200:\n group = group_response.entity\n self.resources.add(group, self.empty_scaling_group)\n return group","def _initialize(self):\n try:\n self._azure_client.get_resource_group(self.resource_group)\n\n except CloudError as cloud_error:\n if cloud_error.error.error == \"ResourceGroupNotFound\":\n resource_group_params = {'location': self.region_name}\n try:\n self._azure_client.\\\n create_resource_group(self.resource_group,\n resource_group_params)\n except CloudError as cloud_error2: # pragma: no cover\n if cloud_error2.error.error == \"AuthorizationFailed\":\n mess = 'The following error was returned by Azure:\\n' \\\n '%s\\n\\nThis is likely because the Role' \\\n 'associated with the given credentials does ' \\\n 'not allow for Resource Group creation.\\nA ' \\\n 'Resource Group is necessary to manage ' \\\n 'resources in Azure. You must either ' \\\n 'provide an existing Resource Group as part ' \\\n 'of the configuration, or elevate the ' \\\n 'associated role.\\nFor more information on ' \\\n 'roles, see: https://docs.microsoft.com/' \\\n 'en-us/azure/role-based-access-control/' \\\n 'overview\\n' % cloud_error2\n raise ProviderConnectionException(mess)\n else:\n raise cloud_error2\n\n else:\n raise cloud_error","def __init__(self, consumer_group):\n self.consumer_group = consumer_group","def setUp(self):\n # Create a private group\n self.group = mommy.make('groups.Group', private=True)\n self.user = mommy.make(\n 'accounts.User', is_active=True, invite_verified=True)\n self.thread = mommy.make(\n 'connectmessages.Thread', group=self.group)\n sender = mommy.make('accounts.User')\n sender.add_to_group(self.group.pk)\n mommy.make(\n 'connectmessages.Message', thread=self.thread, sender=sender)","def test_products_ref_groups_put(self):\n pass","def test_get_device_groups1(self):\n pass","def gen_inventory(self):\n if isinstance(self.resource, list):\n self.my_add_group(self.resource, 'default_group')\n elif isinstance(self.resource, dict):\n for groupname, hosts_and_vars in self.resource.iteritems():\n self.my_add_group(hosts_and_vars.get(\"hosts\"), groupname, hosts_and_vars.get(\"vars\"))","def execute(self, pool, vthunder):\n\n args = {'service_group': self.meta(pool, 'service_group', {})}\n try:\n conf_templates = self.readConf('SERVICE_GROUP','templates').strip('\"')\n service_group_temp = {}\n service_group_temp['template-server'] = conf_templates\n except:\n service_group_temp = None\n\n try:\n c = self.client_factory(vthunder)\n lb_method=openstack_mappings.service_group_lb_method(c,pool.lb_algorithm)\n out = c.slb.service_group.create(pool.id, pool.protocol, lb_method,\n service_group_temp, axapi_args=args)\n LOG.info(\"Pool created successfully.\")\n except Exception as e:\n print(str(e))\n LOG.info(\"Error occurred\")","def handle(self, *args, **options):\n new_group, created = Group.objects.get_or_create(name=options.get('group_name')) \n self.stdout.write(f\"Group {options.get('group_name')} created\")","def check_security_group(self):\n return True","def test_convert_to_newgroup(self, inventoryloader):\n inventoryloader.convert_group('glance_api', 'glance1')\n assert 'glance_api' not in inventoryloader.groups\n assert 'glance1' in inventoryloader.groups\n assert inventoryloader.groups['glance_all'].has_group('glance1')\n assert not inventoryloader.groups['glance_all'].has_group('glance_api')\n assert inventoryloader.groups['glance1'].has_host('localhost')\n assert \"management_bridge\" in inventoryloader.groups['glance1'].vars","def test_test_group_parameters(self):\n pass","def test_IGroupCapability(self):\n self.assertFalse(self.ldap.allowGroupAdd(\"uid0\", \"group0\"))\n self.assertFalse(self.ldap.allowGroupRemove(\"uid0\", \"group0\"))","def group_required(self, group):\n\n def decorator(view):\n @functools.wraps(view)\n def decorated(*args, **kwargs):\n log.info(\"Trying to get access to resource: %s protected by group: %s\", view.__name__, group)\n if request.method == 'POST':\n token = request.form['token']\n if self.development or self.group_authenticated(token, group):\n return view(*args, **kwargs)\n else:\n log.warning(\"User has not been authorized to get access to resource: %s\", view.__name__)\n else:\n log.error(\"Bad request type! Expected 'POST', actual '%s'\", request.method)\n\n return abort(403)\n\n return decorated\n return decorator","def do_push_group(dbsync, group):\n pass","def setUp(self):\n super(ScalingPoliciesNegativeFixture, self).setUp()\n self.create_group_response = \\\n self.autoscale_behaviors.create_scaling_group_given(\n gc_min_entities=2,\n gc_cooldown=0)\n self.group = self.create_group_response.entity\n self.policy_up_data = {'change': 2}\n self.policy_up = self.autoscale_behaviors.create_policy_webhook(\n group_id=self.group.id,\n policy_data=self.policy_up_data,\n execute_policy=False)\n self.policy_down_data = {'change': -2}\n self.policy_down = self.autoscale_behaviors.create_policy_webhook(\n group_id=self.group.id,\n policy_data=self.policy_down_data,\n execute_policy=False)\n self.resources.add(self.group, self.empty_scaling_group)","async def async_added_to_hass(self) -> None:\n self._group.set_callback(self.schedule_update_ha_state)\n self.hass.data[DOMAIN][self._entry_id].groups.append(self)","def __init__(__self__, *,\n fs_group: pulumi.Input['FSGroupStrategyOptionsArgs'],\n run_as_user: pulumi.Input['RunAsUserStrategyOptionsArgs'],\n se_linux: pulumi.Input['SELinuxStrategyOptionsArgs'],\n supplemental_groups: pulumi.Input['SupplementalGroupsStrategyOptionsArgs'],\n allow_privilege_escalation: Optional[pulumi.Input[bool]] = None,\n allowed_csi_drivers: Optional[pulumi.Input[Sequence[pulumi.Input['AllowedCSIDriverArgs']]]] = None,\n allowed_capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n allowed_flex_volumes: Optional[pulumi.Input[Sequence[pulumi.Input['AllowedFlexVolumeArgs']]]] = None,\n allowed_host_paths: Optional[pulumi.Input[Sequence[pulumi.Input['AllowedHostPathArgs']]]] = None,\n allowed_proc_mount_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n allowed_unsafe_sysctls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n default_add_capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n default_allow_privilege_escalation: Optional[pulumi.Input[bool]] = None,\n forbidden_sysctls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n host_ipc: Optional[pulumi.Input[bool]] = None,\n host_network: Optional[pulumi.Input[bool]] = None,\n host_pid: Optional[pulumi.Input[bool]] = None,\n host_ports: Optional[pulumi.Input[Sequence[pulumi.Input['HostPortRangeArgs']]]] = None,\n privileged: Optional[pulumi.Input[bool]] = None,\n read_only_root_filesystem: Optional[pulumi.Input[bool]] = None,\n required_drop_capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n run_as_group: Optional[pulumi.Input['RunAsGroupStrategyOptionsArgs']] = None,\n runtime_class: Optional[pulumi.Input['RuntimeClassStrategyOptionsArgs']] = None,\n volumes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):\n pulumi.set(__self__, \"fs_group\", fs_group)\n pulumi.set(__self__, \"run_as_user\", run_as_user)\n pulumi.set(__self__, \"se_linux\", se_linux)\n pulumi.set(__self__, \"supplemental_groups\", supplemental_groups)\n if allow_privilege_escalation is not None:\n pulumi.set(__self__, \"allow_privilege_escalation\", allow_privilege_escalation)\n if allowed_csi_drivers is not None:\n pulumi.set(__self__, \"allowed_csi_drivers\", allowed_csi_drivers)\n if allowed_capabilities is not None:\n pulumi.set(__self__, \"allowed_capabilities\", allowed_capabilities)\n if allowed_flex_volumes is not None:\n pulumi.set(__self__, \"allowed_flex_volumes\", allowed_flex_volumes)\n if allowed_host_paths is not None:\n pulumi.set(__self__, \"allowed_host_paths\", allowed_host_paths)\n if allowed_proc_mount_types is not None:\n pulumi.set(__self__, \"allowed_proc_mount_types\", allowed_proc_mount_types)\n if allowed_unsafe_sysctls is not None:\n pulumi.set(__self__, \"allowed_unsafe_sysctls\", allowed_unsafe_sysctls)\n if default_add_capabilities is not None:\n pulumi.set(__self__, \"default_add_capabilities\", default_add_capabilities)\n if default_allow_privilege_escalation is not None:\n pulumi.set(__self__, \"default_allow_privilege_escalation\", default_allow_privilege_escalation)\n if forbidden_sysctls is not None:\n pulumi.set(__self__, \"forbidden_sysctls\", forbidden_sysctls)\n if host_ipc is not None:\n pulumi.set(__self__, \"host_ipc\", host_ipc)\n if host_network is not None:\n pulumi.set(__self__, \"host_network\", host_network)\n if host_pid is not None:\n pulumi.set(__self__, \"host_pid\", host_pid)\n if host_ports is not None:\n pulumi.set(__self__, \"host_ports\", host_ports)\n if privileged is not None:\n pulumi.set(__self__, \"privileged\", privileged)\n if read_only_root_filesystem is not None:\n pulumi.set(__self__, \"read_only_root_filesystem\", read_only_root_filesystem)\n if required_drop_capabilities is not None:\n pulumi.set(__self__, \"required_drop_capabilities\", required_drop_capabilities)\n if run_as_group is not None:\n pulumi.set(__self__, \"run_as_group\", run_as_group)\n if runtime_class is not None:\n pulumi.set(__self__, \"runtime_class\", runtime_class)\n if volumes is not None:\n pulumi.set(__self__, \"volumes\", volumes)","def test_update_resource_group(self):\n pass","def cli_run_group(log_level, endpoint, email, password, org_name, grp_name):\n logging.basicConfig(\n level=log_level,\n format='%(levelname)s: %(message)s',\n )\n knex = Knex(endpoint)\n User(knex, email, password).login()\n org = Organization(knex, org_name).get()\n logger.info(f'Loaded {org}')\n grp = org.sample_group(grp_name).get()\n logger.info(f'Loaded {grp}')\n auto_metadata(list(grp.get_samples()), grp)\n logger.info(f'Processed Metadata')\n run_group(grp, lambda x: click.echo(x, err=True))","def test_get_resource_group_by_moid(self):\n pass","def test_api_v1_groups_post(self):\n pass","def add_to_group(self, group):\n\n if not self.in_group(group):\n self.secondary_groups.append(group)\n return self","def pre_security_group_read(self, resource_id):\n pass","def _service_task(self):\n pass","def group(self, group):\n self._group = group","def setUp(self):\n super().setUp()\n self.devices = _DEVICE_STRATEGY()\n command_line = [\"pool\", \"create\", self._POOLNAME] + self.devices\n RUNNER(command_line)","def save(self, *args, **kwargs):\n grupo_vendedor = Group.objects.get_or_create(name=\"vendedor\")[0]\n self.user.groups.add(grupo_vendedor)\n return super(Vendedor, self).save(*args, **kwargs)","def groupManager(request):\n \n return render_to_response('centers.html',context_instance=RequestContext(request))","def test_convert_to_existing_group(self, inventoryloader):\n inventoryloader.convert_group('glance_api', 'glance_registry')\n assert 'glance_api' not in inventoryloader.groups\n assert not inventoryloader.groups['glance_all'].has_group('glance_api')\n assert inventoryloader.groups['glance_registry'].has_host('localhost')\n assert inventoryloader.groups['glance_registry'].has_host('localhost2')\n assert \"management_bridge\" in inventoryloader.groups['glance_registry'].vars","def __create_group(self):\n\n group = time.strftime(_GROUP_NAME_FORMAT, time.localtime())\n LOG.info(\"Creating backup group '%s'.\", group)\n\n group_path = self.group_path(group)\n\n try:\n os.mkdir(group_path)\n except EnvironmentError as e:\n if e.errno != errno.EEXIST:\n raise Error(\"Unable to create a new backup group '{}': {}.\",\n group_path, psys.e(e))\n\n self.__on_group_created(group)\n\n return group","def add_to_group(self, org, contact, group):\n pass","def notebooks_group():\n pass","def test_creator_group_enabled_but_empty(self):\r\n with mock.patch.dict('django.conf.settings.FEATURES', {\"ENABLE_CREATOR_GROUP\": True}):\r\n self.assertFalse(has_access(self.user, CourseCreatorRole()))\r\n\r\n # Make user staff. This will cause CourseCreatorRole().has_user to return True.\r\n self.user.is_staff = True\r\n self.assertTrue(has_access(self.user, CourseCreatorRole()))","def create_new_scaling_group(self, request, data):\n group_cfg = data['groupConfiguration']\n\n group_cfg.setdefault('maxEntities', MAX_ENTITIES)\n group_cfg.setdefault('metadata', {})\n\n if group_cfg['minEntities'] > group_cfg['maxEntities']:\n raise InvalidMinEntities(\n \"minEntities must be less than or equal to maxEntities\")\n\n if data['launchConfiguration']['type'] == 'launch_server':\n validate_launch_config_servicenet(data['launchConfiguration'])\n\n deferred = get_supervisor().validate_launch_config(\n self.log, self.tenant_id, data['launchConfiguration'])\n\n deferred.addCallback(\n lambda _: self.store.create_scaling_group(\n self.log, self.tenant_id,\n group_cfg,\n normalize_launch_config(data['launchConfiguration']),\n data.get('scalingPolicies', None)))\n\n def _do_obey_config_change(result):\n group_id = result['id']\n config = result['groupConfiguration']\n launch = result['launchConfiguration']\n group = self.store.get_scaling_group(\n self.log, self.tenant_id, group_id)\n log = self.log.bind(scaling_group_id=group_id)\n d = controller.modify_and_trigger(\n self.dispatcher,\n group,\n bound_log_kwargs(log),\n partial(\n controller.obey_config_change, log,\n transaction_id(request), config, launch_config=launch),\n modify_state_reason='create_new_scaling_group')\n return d.addCallback(lambda _: result)\n\n deferred.addCallback(_do_obey_config_change)\n\n def _add_to_bobby(result, client):\n d = client.create_group(self.tenant_id, result['id'])\n return d.addCallback(lambda _: result)\n\n bobby = get_bobby()\n if bobby is not None:\n deferred.addCallback(_add_to_bobby, bobby)\n\n def _format_output(result):\n uuid = result['id']\n result[\"state\"] = format_state_dict(result[\"state\"])\n request.setHeader(\n \"Location\",\n get_autoscale_links(self.tenant_id, uuid, format=None))\n result[\"links\"] = get_autoscale_links(self.tenant_id, uuid)\n linkify_policy_list(\n result['scalingPolicies'], self.tenant_id, uuid)\n result['scalingPolicies_links'] = get_policies_links(\n result['scalingPolicies'],\n self.tenant_id, uuid, rel='policies')\n return {\"group\": result}\n\n deferred.addCallback(_format_output)\n deferred.addCallback(json.dumps)\n return deferred","def __check_new_groups(self) -> None:\n for group in main_app_groups:\n try:\n group_old = Group.objects.get(name=group)\n self.__upgrade_group(group_old, group)\n except ObjectDoesNotExist: # need to create new group\n self.__create_new_group(group)\n\n self.stdout.write(f'Added new group {group} with {main_app_groups[group]} permissions')","def reserve_group(self, name, sco):\n\t\tif self.client is None:\n\t\t\traise UsageError(\"Not connected!\")\n\t\treturn self.client.reserve_group(name, sco)","def setup(self):\n base = automap_base()\n engine = create_engine(\"mysql+pymysql://\" + csconfig.config.db_user + \":\" +\n csconfig.config.db_password + \"@\" +\n csconfig.config.db_host + \":\" +\n str(csconfig.config.db_port) +\n \"/\" + csconfig.config.db_name)\n base.prepare(engine, reflect=True)\n session = Session(engine)\n cloud_yaml = base.classes.csv2_group_resource_yaml\n\n for cloud in self.group_resources:\n cloud_yamls = session.query(cloud_yaml).\\\n filter(cloud_yaml.group_name == self.name,\n cloud_yaml.cloud_name == cloud.cloud_name)\n cloud_yaml_list = []\n for yam in cloud_yamls:\n cloud_yaml_list.append([yam.yaml_name, yam.yaml, yam.mime_type])\n if cloud.cloud_type == 'localhost':\n newcloud = cloudscheduler.localhostcloud.LocalHostCloud(extrayaml=cloud_yaml_list, resource=cloud)\n else:\n newcloud = cloudscheduler.openstackcloud.\\\n OpenStackCloud(extrayaml=cloud_yaml_list, resource=cloud)\n self.clouds[newcloud.name] = newcloud\n self.log.debug(\"Added all clouds for group: %s\", self.name)","def test_aws_service_api_vm_security_group_put(self):\n pass"],"string":"[\n \"def __on_group_created(self, logger, *args):\",\n \"def test_create_group(self):\\n pass\",\n \"def test_create_group(self):\\n pass\",\n \"def pre_security_group_create(self, resource_dict):\\n pass\",\n \"def test_create_device_group(self):\\n pass\",\n \"def _make_group(self, _rk, _group_hint):\\n\\n if isinstance(_group_hint, dict):\\n # _group_hint is a single key/value pair\\n g = _group_hint[list(_group_hint)[0]]\\n\\n r_type = g.get(\\\"type\\\", \\\"none\\\")\\n if r_type != \\\"OS::Nova::ServerGroup\\\":\\n return \\\"support only ServerGroup resource\\\"\\n\\n properties = g.get(\\\"properties\\\", {})\\n if len(properties) == 0:\\n return \\\"no properties\\\"\\n\\n group_name = properties.get(\\\"name\\\", None)\\n if group_name is None:\\n return \\\"no group name\\\"\\n group_name = group_name.strip()\\n\\n policies = properties.get(\\\"policies\\\", [])\\n if len(policies) == 0:\\n return \\\"no policy of the group\\\"\\n\\n if len(policies) > 1:\\n return \\\"multiple policies\\\"\\n\\n # TODO: exclude soft-affinity and soft-anti-affinity?\\n\\n if group_name in self.groups.keys():\\n group = self.groups[group_name]\\n else:\\n group = Group(group_name)\\n\\n policy = policies[0].strip()\\n if policy == \\\"anti-affinity\\\":\\n group_type = \\\"diversity\\\"\\n else:\\n group_type = policy\\n\\n group.group_type = group_type\\n group.factory = \\\"server-group\\\"\\n group.level = \\\"host\\\"\\n\\n self.groups[group_name] = group\\n else:\\n # group hint is uuid string.\\n rg = self.resource.get_group_by_uuid(_group_hint)\\n if rg is None:\\n return \\\"unknown group found while making group\\\"\\n\\n # TODO: exclude soft-affinity and soft-anti-affinity?\\n\\n if rg.name in self.groups.keys():\\n group = self.groups[rg.name]\\n else:\\n group = Group(rg.name)\\n\\n group.group_type = rg.group_type\\n group.factory = rg.factory\\n group.level = \\\"host\\\"\\n\\n self.groups[rg.name] = group\\n\\n if group is not None:\\n group.server_list.append(self.app_name + \\\":\\\" + _rk)\\n\\n return \\\"ok\\\"\",\n \"def test_create_resource_group(self):\\n pass\",\n \"def _provision_package(self):\",\n \"def test_add_group(self):\\n pass\",\n \"def createMainGroup(self):\\n\\t\\tmc.group( n = self.grp.name, em = True )\",\n \"def test_get_group(self):\\n pass\",\n \"def capacitygroup_group():\",\n \"def monitoring_group(ctx):\\n pass\",\n \"def test_user_group_controller_create(self):\\n pass\",\n \"def test_000_add_group(self):\\n # This case is always passed because it's tested in setup_module,\\n # If setup module fails, this case will never run\\n pass\",\n \"async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:\\n if DOMAIN not in hass.data:\\n hass.data[DOMAIN] = EntityComponent[Group](_LOGGER, DOMAIN, hass)\\n\\n await async_process_integration_platform_for_component(hass, DOMAIN)\\n\\n component: EntityComponent[Group] = hass.data[DOMAIN]\\n\\n hass.data[REG_KEY] = GroupIntegrationRegistry()\\n\\n await async_process_integration_platforms(hass, DOMAIN, _process_group_platform)\\n\\n await _async_process_config(hass, config)\\n\\n async def reload_service_handler(service: ServiceCall) -> None:\\n \\\"\\\"\\\"Remove all user-defined groups and load new ones from config.\\\"\\\"\\\"\\n auto = [e for e in component.entities if not e.user_defined]\\n\\n if (conf := await component.async_prepare_reload()) is None:\\n return\\n await _async_process_config(hass, conf)\\n\\n await component.async_add_entities(auto)\\n\\n await async_reload_integration_platforms(hass, DOMAIN, PLATFORMS)\\n\\n hass.services.async_register(\\n DOMAIN, SERVICE_RELOAD, reload_service_handler, schema=vol.Schema({})\\n )\\n\\n service_lock = asyncio.Lock()\\n\\n async def locked_service_handler(service: ServiceCall) -> None:\\n \\\"\\\"\\\"Handle a service with an async lock.\\\"\\\"\\\"\\n async with service_lock:\\n await groups_service_handler(service)\\n\\n async def groups_service_handler(service: ServiceCall) -> None:\\n \\\"\\\"\\\"Handle dynamic group service functions.\\\"\\\"\\\"\\n object_id = service.data[ATTR_OBJECT_ID]\\n entity_id = f\\\"{DOMAIN}.{object_id}\\\"\\n group = component.get_entity(entity_id)\\n\\n # new group\\n if service.service == SERVICE_SET and group is None:\\n entity_ids = (\\n service.data.get(ATTR_ENTITIES)\\n or service.data.get(ATTR_ADD_ENTITIES)\\n or None\\n )\\n\\n extra_arg = {\\n attr: service.data[attr]\\n for attr in (ATTR_ICON,)\\n if service.data.get(attr) is not None\\n }\\n\\n await Group.async_create_group(\\n hass,\\n service.data.get(ATTR_NAME, object_id),\\n object_id=object_id,\\n entity_ids=entity_ids,\\n user_defined=False,\\n mode=service.data.get(ATTR_ALL),\\n **extra_arg,\\n )\\n return\\n\\n if group is None:\\n _LOGGER.warning(\\\"%s:Group '%s' doesn't exist!\\\", service.service, object_id)\\n return\\n\\n # update group\\n if service.service == SERVICE_SET:\\n need_update = False\\n\\n if ATTR_ADD_ENTITIES in service.data:\\n delta = service.data[ATTR_ADD_ENTITIES]\\n entity_ids = set(group.tracking) | set(delta)\\n await group.async_update_tracked_entity_ids(entity_ids)\\n\\n if ATTR_REMOVE_ENTITIES in service.data:\\n delta = service.data[ATTR_REMOVE_ENTITIES]\\n entity_ids = set(group.tracking) - set(delta)\\n await group.async_update_tracked_entity_ids(entity_ids)\\n\\n if ATTR_ENTITIES in service.data:\\n entity_ids = service.data[ATTR_ENTITIES]\\n await group.async_update_tracked_entity_ids(entity_ids)\\n\\n if ATTR_NAME in service.data:\\n group.name = service.data[ATTR_NAME]\\n need_update = True\\n\\n if ATTR_ICON in service.data:\\n group.icon = service.data[ATTR_ICON]\\n need_update = True\\n\\n if ATTR_ALL in service.data:\\n group.mode = all if service.data[ATTR_ALL] else any\\n need_update = True\\n\\n if need_update:\\n group.async_write_ha_state()\\n\\n return\\n\\n # remove group\\n if service.service == SERVICE_REMOVE:\\n await component.async_remove_entity(entity_id)\\n\\n hass.services.async_register(\\n DOMAIN,\\n SERVICE_SET,\\n locked_service_handler,\\n schema=vol.All(\\n vol.Schema(\\n {\\n vol.Required(ATTR_OBJECT_ID): cv.slug,\\n vol.Optional(ATTR_NAME): cv.string,\\n vol.Optional(ATTR_ICON): cv.string,\\n vol.Optional(ATTR_ALL): cv.boolean,\\n vol.Exclusive(ATTR_ENTITIES, \\\"entities\\\"): cv.entity_ids,\\n vol.Exclusive(ATTR_ADD_ENTITIES, \\\"entities\\\"): cv.entity_ids,\\n vol.Exclusive(ATTR_REMOVE_ENTITIES, \\\"entities\\\"): cv.entity_ids,\\n }\\n )\\n ),\\n )\\n\\n hass.services.async_register(\\n DOMAIN,\\n SERVICE_REMOVE,\\n groups_service_handler,\\n schema=vol.Schema({vol.Required(ATTR_OBJECT_ID): cv.slug}),\\n )\\n\\n return True\",\n \"def create_seurity_group(self):\\n return True\",\n \"def __init__(self, group, **kwargs):\\n #group can be robot stage floor or tool\\n super(PhysicalPropertiesInterventionActorPolicy, self).__init__()\\n self.task_intervention_space = None\\n self.group = group\",\n \"def group(self):\\n raise NotImplementedError()\",\n \"def test_create_device_group1(self):\\n pass\",\n \"def setUp(self):\\n self.log = mock_log().bind(base_log=True)\\n self.state = GroupState('tid', 'gid', 'g', {}, {}, None, {}, True,\\n ScalingGroupStatus.ACTIVE)\\n self.group = mock_group(self.state)\",\n \"def main():\\n snap_name = 'REST_Snap_' + strftime('%d%m%Y%H%M%S')\\n ru.replication.create_storagegroup_snap(sg_id, snap_name)\\n print('Check the Gui now or REST Client to see if snapshot '\\n '{snap_name} was created for Storge Group {sg_id}'\\n .format(snap_name=snap_name, sg_id=sg_id))\",\n \"def test_patch_group(self):\\n pass\",\n \"def test_patch_group(self):\\n pass\",\n \"def test_get_groups(self):\\n pass\",\n \"def test_get_groups(self):\\n pass\",\n \"async def async_turn_on(self):\\n if not self._raumfeld.group_is_valid(self._rooms):\\n await self._raumfeld.async_create_group(self._rooms)\\n await self.async_update_transport_state()\\n else:\\n log_debug(\\n \\\"Method was called although speaker group '%s' is invalid\\\" % self._rooms\\n )\",\n \"def test_priority(self, inventoryloader):\\n inventoryloader.set_group_priority('glance_api',-1)\\n inventoryloader.add_group('glance_api',{'vars': {'management_bridge':'br_woot'}})\\n assert 'br_woot' == inventoryloader.groups['glance_api'].vars.get('management_bridge')\",\n \"def _create_child_group(self, name) -> \\\"GroupBase\\\":\\n pass\",\n \"def post_security_group_create(self, resource_dict):\\n pass\",\n \"def groupFormation(self):\\n self.updatedPartnerNames()\\n self.updatedPotentialPartnerNames()\\n self.updatePartnerIdices()\\n self.makeGraphDictionary()\\n self.assignGroupIDs()\",\n \"def __init__(__self__,\\n resource_name: str,\\n args: GroupArgs,\\n opts: Optional[pulumi.ResourceOptions] = None):\\n ...\",\n \"def __init__(__self__,\\n resource_name: str,\\n opts: Optional[pulumi.ResourceOptions] = None,\\n auto_healing_policies: Optional[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerAutoHealingPoliciesArgs']]] = None,\\n base_instance_name: Optional[pulumi.Input[str]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n distribution_policy_zones: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n named_ports: Optional[pulumi.Input[List[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerNamedPortArgs']]]]] = None,\\n project: Optional[pulumi.Input[str]] = None,\\n region: Optional[pulumi.Input[str]] = None,\\n stateful_disks: Optional[pulumi.Input[List[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerStatefulDiskArgs']]]]] = None,\\n target_pools: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,\\n target_size: Optional[pulumi.Input[float]] = None,\\n update_policy: Optional[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerUpdatePolicyArgs']]] = None,\\n versions: Optional[pulumi.Input[List[pulumi.Input[pulumi.InputType['RegionInstanceGroupManagerVersionArgs']]]]] = None,\\n wait_for_instances: Optional[pulumi.Input[bool]] = None,\\n __props__=None,\\n __name__=None,\\n __opts__=None):\\n if __name__ is not None:\\n warnings.warn(\\\"explicit use of __name__ is deprecated\\\", DeprecationWarning)\\n resource_name = __name__\\n if __opts__ is not None:\\n warnings.warn(\\\"explicit use of __opts__ is deprecated, use 'opts' instead\\\", DeprecationWarning)\\n opts = __opts__\\n if opts is None:\\n opts = pulumi.ResourceOptions()\\n if not isinstance(opts, pulumi.ResourceOptions):\\n raise TypeError('Expected resource options to be a ResourceOptions instance')\\n if opts.version is None:\\n opts.version = _utilities.get_version()\\n if opts.id is None:\\n if __props__ is not None:\\n raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')\\n __props__ = dict()\\n\\n __props__['auto_healing_policies'] = auto_healing_policies\\n if base_instance_name is None:\\n raise TypeError(\\\"Missing required property 'base_instance_name'\\\")\\n __props__['base_instance_name'] = base_instance_name\\n __props__['description'] = description\\n __props__['distribution_policy_zones'] = distribution_policy_zones\\n __props__['name'] = name\\n __props__['named_ports'] = named_ports\\n __props__['project'] = project\\n if region is None:\\n raise TypeError(\\\"Missing required property 'region'\\\")\\n __props__['region'] = region\\n __props__['stateful_disks'] = stateful_disks\\n __props__['target_pools'] = target_pools\\n __props__['target_size'] = target_size\\n __props__['update_policy'] = update_policy\\n if versions is None:\\n raise TypeError(\\\"Missing required property 'versions'\\\")\\n __props__['versions'] = versions\\n __props__['wait_for_instances'] = wait_for_instances\\n __props__['fingerprint'] = None\\n __props__['instance_group'] = None\\n __props__['self_link'] = None\\n super(RegionInstanceGroupManager, __self__).__init__(\\n 'gcp:compute/regionInstanceGroupManager:RegionInstanceGroupManager',\\n resource_name,\\n __props__,\\n opts)\",\n \"async def _group(self, ctx):\\r\\n\\t\\tif ctx.invoked_subcommand is None:\\r\\n\\t\\t\\tprint (\\\"Ryhmä komento annettiin ilman alakomentoa\\\")\",\n \"def test_verify_that_you_can_create_a_new_group():\",\n \"def test_5_group_required(self):\\n user = User.objects.get(email=data_user['email'])\\n self.factory = RequestFactory()\\n\\n @group_required('default')\\n def test(request):\\n return 200\\n\\n request = self.factory.get('/foo')\\n request.user = user\\n response = test(request)\\n self.assertEqual(response.status_code, 302)\\n\\n group = Group.objects.create(\\n name='default',\\n )\\n\\n user.groups.add(group)\\n request = self.factory.get('/foo')\\n request.user = user\\n response = test(request)\\n self.assertEqual(response, 200)\",\n \"def _initGroups(self):\\n defaults = self._getGroupDefaults()\\n ddict = self._getDefaultGroupDict(defaults)\\n\\n for group in self._config.sections():\\n ddict[\\\"_name\\\"] = group\\n container = self.getGroupContainer(**ddict)\\n self._passConfig(container, group)\\n self.groups.append(container)\\n\\n if not self.groups:\\n self.groups.append(self.getGroupContainer(**defaults._dict_))\",\n \"def user_post_save(sender, instance, created, **kwargs):\\n if created:\\n instance.groups.add(Group.objects.get(name=\\\"DefaultExportExtentGroup\\\"))\",\n \"def test_groups_get(self):\\n pass\",\n \"def test_groups_get(self):\\n pass\",\n \"def setup_provider(self):\\n pass\",\n \"def test_read_group(self):\\n pass\",\n \"def test_patch_resource_group(self):\\n pass\",\n \"def __init__(self):\\n self.groups_url = \\\"%s/groups\\\" % CONF.valet.HOST\\n\\n self.headers = {\\\"X-Auth-Token\\\": Auth.get_auth_token(),\\n \\\"Content-Type\\\": \\\"application/json\\\"}\",\n \"def test_groups_post(self):\\n pass\",\n \"def _check_required_if_provider(self):\\n return\",\n \"def test_get_device_groups(self):\\n pass\",\n \"def test_new_group(self, inventoryloader):\\n inventoryloader.add_group(u'newgroup')\\n assert 'newgroup' in inventoryloader.groups\",\n \"def test_creator_group_enabled_nonempty(self):\\r\\n with mock.patch.dict('django.conf.settings.FEATURES', {\\\"ENABLE_CREATOR_GROUP\\\": True}):\\r\\n add_users(self.admin, CourseCreatorRole(), self.user)\\r\\n self.assertTrue(has_access(self.user, CourseCreatorRole()))\\r\\n\\r\\n # check that a user who has not been added to the group still returns false\\r\\n user_not_added = User.objects.create_user('testuser2', 'test+courses2@edx.org', 'foo2')\\r\\n self.assertFalse(has_access(user_not_added, CourseCreatorRole()))\\r\\n\\r\\n # remove first user from the group and verify that CourseCreatorRole().has_user now returns false\\r\\n remove_users(self.admin, CourseCreatorRole(), self.user)\\r\\n self.assertFalse(has_access(self.user, CourseCreatorRole()))\",\n \"def test_update_group(self):\\n pass\",\n \"def setUpClass(cls):\\n super().setUpClass()\\n cls.group = Group.objects.create(\\n title=TEST_GROUP_NAME,\\n slug=TEST_GROUP_SLUG\\n )\",\n \"def deploy_group(group_name):\\n group=get_entity_by_cond(Group,'group_name==\\\"%s\\\"'%group_name)\\n nodes=session.query(Node).filter('group_name==\\\"%s\\\"'%group_name)\\n\\n machines_filename = os.path.join(\\n spl.config.paths['headnode-config'],\\n str(group.network_id),\\n 'machines.txt',\\n )\\n\\n machines_dirname = os.path.dirname(machines_filename)\\n if not os.path.isdir(machines_dirname):\\n os.mkdir(machines_dirname)\\n\\n with open(machines_filename, 'w') as f:\\n for node in nodes:\\n f.write((\\\"%s %s\\\\n\\\"%(node.mac_addr,node.manage_ip)))\\n\\n\\n switches=[]\\n ports='';\\n for node in nodes:\\n switches.append(node.port.switch_id)\\n ports+=str(node.port.port_no)+','\\n #Check all the nodes in the group are connected to the same switch\\n switch_id=check_same_non_empty_list(switches)\\n if switch_id==False:\\n # TODO: raise an exception\\n print \\\"error: ports not in same switch\\\"\\n return\\n\\n switch=get_entity_by_cond(Switch,'switch_id==%d'%switch_id)\\n\\n import cisco_snmp\\n switch_drivers = {'cisco_snmp.py':cisco_snmp}\\n driver = switch_drivers[switch.script]\\n\\n\\n\\n\\n print group.network_id\\n driver.make_remove_vlans(str(group.network_id),True)\\n print 'ports'+ports\\n driver.edit_ports_on_vlan(ports,str(group.network_id),True)\\n\\n os.system(('../vm-vlan up %s %s' % (group.network_id,group.vm_name)))\\n\\n group.deployed = True\",\n \"def test_autoscaling_group_valid(self) -> None:\\n self.assertTrue(self.validate_autoscaling_group(is_prod=self.prod_env))\",\n \"def __enter__(self):\\n self._logger.debug(\\\"__enter__()\\\")\\n self.install(\\\"PRE\\\")\",\n \"def _check_groups_kvm():\\n if not _user_belongs_to('libvirtd') and not _user_belongs_to('kvm'):\\n _raise_group_error('kvm')\",\n \"def setUpContainer(self):\\n self.dev1 = Device(name='dev1')\\n eg = ElectrodeGroup(name='elec1',\\n description='a test ElectrodeGroup',\\n location='a nonexistent place',\\n device=self.dev1)\\n return eg\",\n \"def __init__(self, *args, **kwargs):\\n print(\\\"Group Roses initialize.\\\")\\n poems = []\\n self.poems = poems\\n\\n # Each creator should have domain specified: title, poetry, music, image, etc.\\n self.domain = 'poetry'\",\n \"def test_user_group_controller_list(self):\\n pass\",\n \"def init_valet_groups(self):\\n\\n for rk, r in self.stack.items():\\n properties = r.get(\\\"properties\\\", {})\\n metadata = properties.get(\\\"metadata\\\", {})\\n\\n if len(metadata) > 0:\\n valet_rules = metadata.get(\\\"valet_groups\\\", None)\\n\\n if valet_rules is not None and valet_rules != \\\"\\\":\\n rule_list = []\\n if isinstance(valet_rules, six.string_types):\\n rules = valet_rules.split(\\\",\\\")\\n for gr in rules:\\n rule_list.append(gr.strip())\\n else:\\n self.status = \\\"incorrect valet group metadata format\\\"\\n self.logger.error(self.status)\\n return\\n\\n # Check rule validation of valet_groups.\\n self.status = self.resource.check_valid_rules(self.tenant_id,\\n rule_list,\\n use_ex=self.use_dha)\\n if self.status != \\\"ok\\\":\\n self.logger.error(self.status)\\n return\\n\\n self.status = self._make_valet_groups(properties.get(\\\"name\\\"),\\n properties[\\\"availability_zone\\\"][0],\\n rule_list)\\n if self.status != \\\"ok\\\":\\n self.logger.error(self.status)\\n return\\n\\n # Check and create server groups if they do not exist.\\n scheduler_hints = properties.get(\\\"scheduler_hints\\\", {})\\n if len(scheduler_hints) > 0:\\n for hint_key in scheduler_hints.keys():\\n if hint_key == \\\"group\\\":\\n hint = scheduler_hints[hint_key]\\n self.status = self._make_group(properties.get(\\\"name\\\"), hint)\\n if self.status != \\\"ok\\\":\\n self.logger.error(self.status)\\n return\",\n \"def __enter__(self):\\n self.key = self.make_new_key()\\n self.sec_grp, self.group_id = self.make_new_group()\\n\\n printy(\\\"New key {} created\\\".format(self.key.name))\\n printy(\\\"new security group {} created\\\".format(self.sec_grp.group_name))\\n\\n return self\",\n \"def available_groups(cls):\\n raise NotImplementedError\",\n \"def _assert_create_group(self, personality, response=400):\\n group_response = self.autoscale_behaviors.create_scaling_group_given(\\n lc_personality=personality)\\n self.assertEquals(group_response.status_code, response, msg='Create group '\\n 'with invalid lc_personality returned {0} as against '\\n '{1}'.format(group_response.status_code, response))\\n if response is 200:\\n group = group_response.entity\\n self.resources.add(group, self.empty_scaling_group)\\n return group\",\n \"def _initialize(self):\\n try:\\n self._azure_client.get_resource_group(self.resource_group)\\n\\n except CloudError as cloud_error:\\n if cloud_error.error.error == \\\"ResourceGroupNotFound\\\":\\n resource_group_params = {'location': self.region_name}\\n try:\\n self._azure_client.\\\\\\n create_resource_group(self.resource_group,\\n resource_group_params)\\n except CloudError as cloud_error2: # pragma: no cover\\n if cloud_error2.error.error == \\\"AuthorizationFailed\\\":\\n mess = 'The following error was returned by Azure:\\\\n' \\\\\\n '%s\\\\n\\\\nThis is likely because the Role' \\\\\\n 'associated with the given credentials does ' \\\\\\n 'not allow for Resource Group creation.\\\\nA ' \\\\\\n 'Resource Group is necessary to manage ' \\\\\\n 'resources in Azure. You must either ' \\\\\\n 'provide an existing Resource Group as part ' \\\\\\n 'of the configuration, or elevate the ' \\\\\\n 'associated role.\\\\nFor more information on ' \\\\\\n 'roles, see: https://docs.microsoft.com/' \\\\\\n 'en-us/azure/role-based-access-control/' \\\\\\n 'overview\\\\n' % cloud_error2\\n raise ProviderConnectionException(mess)\\n else:\\n raise cloud_error2\\n\\n else:\\n raise cloud_error\",\n \"def __init__(self, consumer_group):\\n self.consumer_group = consumer_group\",\n \"def setUp(self):\\n # Create a private group\\n self.group = mommy.make('groups.Group', private=True)\\n self.user = mommy.make(\\n 'accounts.User', is_active=True, invite_verified=True)\\n self.thread = mommy.make(\\n 'connectmessages.Thread', group=self.group)\\n sender = mommy.make('accounts.User')\\n sender.add_to_group(self.group.pk)\\n mommy.make(\\n 'connectmessages.Message', thread=self.thread, sender=sender)\",\n \"def test_products_ref_groups_put(self):\\n pass\",\n \"def test_get_device_groups1(self):\\n pass\",\n \"def gen_inventory(self):\\n if isinstance(self.resource, list):\\n self.my_add_group(self.resource, 'default_group')\\n elif isinstance(self.resource, dict):\\n for groupname, hosts_and_vars in self.resource.iteritems():\\n self.my_add_group(hosts_and_vars.get(\\\"hosts\\\"), groupname, hosts_and_vars.get(\\\"vars\\\"))\",\n \"def execute(self, pool, vthunder):\\n\\n args = {'service_group': self.meta(pool, 'service_group', {})}\\n try:\\n conf_templates = self.readConf('SERVICE_GROUP','templates').strip('\\\"')\\n service_group_temp = {}\\n service_group_temp['template-server'] = conf_templates\\n except:\\n service_group_temp = None\\n\\n try:\\n c = self.client_factory(vthunder)\\n lb_method=openstack_mappings.service_group_lb_method(c,pool.lb_algorithm)\\n out = c.slb.service_group.create(pool.id, pool.protocol, lb_method,\\n service_group_temp, axapi_args=args)\\n LOG.info(\\\"Pool created successfully.\\\")\\n except Exception as e:\\n print(str(e))\\n LOG.info(\\\"Error occurred\\\")\",\n \"def handle(self, *args, **options):\\n new_group, created = Group.objects.get_or_create(name=options.get('group_name')) \\n self.stdout.write(f\\\"Group {options.get('group_name')} created\\\")\",\n \"def check_security_group(self):\\n return True\",\n \"def test_convert_to_newgroup(self, inventoryloader):\\n inventoryloader.convert_group('glance_api', 'glance1')\\n assert 'glance_api' not in inventoryloader.groups\\n assert 'glance1' in inventoryloader.groups\\n assert inventoryloader.groups['glance_all'].has_group('glance1')\\n assert not inventoryloader.groups['glance_all'].has_group('glance_api')\\n assert inventoryloader.groups['glance1'].has_host('localhost')\\n assert \\\"management_bridge\\\" in inventoryloader.groups['glance1'].vars\",\n \"def test_test_group_parameters(self):\\n pass\",\n \"def test_IGroupCapability(self):\\n self.assertFalse(self.ldap.allowGroupAdd(\\\"uid0\\\", \\\"group0\\\"))\\n self.assertFalse(self.ldap.allowGroupRemove(\\\"uid0\\\", \\\"group0\\\"))\",\n \"def group_required(self, group):\\n\\n def decorator(view):\\n @functools.wraps(view)\\n def decorated(*args, **kwargs):\\n log.info(\\\"Trying to get access to resource: %s protected by group: %s\\\", view.__name__, group)\\n if request.method == 'POST':\\n token = request.form['token']\\n if self.development or self.group_authenticated(token, group):\\n return view(*args, **kwargs)\\n else:\\n log.warning(\\\"User has not been authorized to get access to resource: %s\\\", view.__name__)\\n else:\\n log.error(\\\"Bad request type! Expected 'POST', actual '%s'\\\", request.method)\\n\\n return abort(403)\\n\\n return decorated\\n return decorator\",\n \"def do_push_group(dbsync, group):\\n pass\",\n \"def setUp(self):\\n super(ScalingPoliciesNegativeFixture, self).setUp()\\n self.create_group_response = \\\\\\n self.autoscale_behaviors.create_scaling_group_given(\\n gc_min_entities=2,\\n gc_cooldown=0)\\n self.group = self.create_group_response.entity\\n self.policy_up_data = {'change': 2}\\n self.policy_up = self.autoscale_behaviors.create_policy_webhook(\\n group_id=self.group.id,\\n policy_data=self.policy_up_data,\\n execute_policy=False)\\n self.policy_down_data = {'change': -2}\\n self.policy_down = self.autoscale_behaviors.create_policy_webhook(\\n group_id=self.group.id,\\n policy_data=self.policy_down_data,\\n execute_policy=False)\\n self.resources.add(self.group, self.empty_scaling_group)\",\n \"async def async_added_to_hass(self) -> None:\\n self._group.set_callback(self.schedule_update_ha_state)\\n self.hass.data[DOMAIN][self._entry_id].groups.append(self)\",\n \"def __init__(__self__, *,\\n fs_group: pulumi.Input['FSGroupStrategyOptionsArgs'],\\n run_as_user: pulumi.Input['RunAsUserStrategyOptionsArgs'],\\n se_linux: pulumi.Input['SELinuxStrategyOptionsArgs'],\\n supplemental_groups: pulumi.Input['SupplementalGroupsStrategyOptionsArgs'],\\n allow_privilege_escalation: Optional[pulumi.Input[bool]] = None,\\n allowed_csi_drivers: Optional[pulumi.Input[Sequence[pulumi.Input['AllowedCSIDriverArgs']]]] = None,\\n allowed_capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n allowed_flex_volumes: Optional[pulumi.Input[Sequence[pulumi.Input['AllowedFlexVolumeArgs']]]] = None,\\n allowed_host_paths: Optional[pulumi.Input[Sequence[pulumi.Input['AllowedHostPathArgs']]]] = None,\\n allowed_proc_mount_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n allowed_unsafe_sysctls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n default_add_capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n default_allow_privilege_escalation: Optional[pulumi.Input[bool]] = None,\\n forbidden_sysctls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n host_ipc: Optional[pulumi.Input[bool]] = None,\\n host_network: Optional[pulumi.Input[bool]] = None,\\n host_pid: Optional[pulumi.Input[bool]] = None,\\n host_ports: Optional[pulumi.Input[Sequence[pulumi.Input['HostPortRangeArgs']]]] = None,\\n privileged: Optional[pulumi.Input[bool]] = None,\\n read_only_root_filesystem: Optional[pulumi.Input[bool]] = None,\\n required_drop_capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n run_as_group: Optional[pulumi.Input['RunAsGroupStrategyOptionsArgs']] = None,\\n runtime_class: Optional[pulumi.Input['RuntimeClassStrategyOptionsArgs']] = None,\\n volumes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):\\n pulumi.set(__self__, \\\"fs_group\\\", fs_group)\\n pulumi.set(__self__, \\\"run_as_user\\\", run_as_user)\\n pulumi.set(__self__, \\\"se_linux\\\", se_linux)\\n pulumi.set(__self__, \\\"supplemental_groups\\\", supplemental_groups)\\n if allow_privilege_escalation is not None:\\n pulumi.set(__self__, \\\"allow_privilege_escalation\\\", allow_privilege_escalation)\\n if allowed_csi_drivers is not None:\\n pulumi.set(__self__, \\\"allowed_csi_drivers\\\", allowed_csi_drivers)\\n if allowed_capabilities is not None:\\n pulumi.set(__self__, \\\"allowed_capabilities\\\", allowed_capabilities)\\n if allowed_flex_volumes is not None:\\n pulumi.set(__self__, \\\"allowed_flex_volumes\\\", allowed_flex_volumes)\\n if allowed_host_paths is not None:\\n pulumi.set(__self__, \\\"allowed_host_paths\\\", allowed_host_paths)\\n if allowed_proc_mount_types is not None:\\n pulumi.set(__self__, \\\"allowed_proc_mount_types\\\", allowed_proc_mount_types)\\n if allowed_unsafe_sysctls is not None:\\n pulumi.set(__self__, \\\"allowed_unsafe_sysctls\\\", allowed_unsafe_sysctls)\\n if default_add_capabilities is not None:\\n pulumi.set(__self__, \\\"default_add_capabilities\\\", default_add_capabilities)\\n if default_allow_privilege_escalation is not None:\\n pulumi.set(__self__, \\\"default_allow_privilege_escalation\\\", default_allow_privilege_escalation)\\n if forbidden_sysctls is not None:\\n pulumi.set(__self__, \\\"forbidden_sysctls\\\", forbidden_sysctls)\\n if host_ipc is not None:\\n pulumi.set(__self__, \\\"host_ipc\\\", host_ipc)\\n if host_network is not None:\\n pulumi.set(__self__, \\\"host_network\\\", host_network)\\n if host_pid is not None:\\n pulumi.set(__self__, \\\"host_pid\\\", host_pid)\\n if host_ports is not None:\\n pulumi.set(__self__, \\\"host_ports\\\", host_ports)\\n if privileged is not None:\\n pulumi.set(__self__, \\\"privileged\\\", privileged)\\n if read_only_root_filesystem is not None:\\n pulumi.set(__self__, \\\"read_only_root_filesystem\\\", read_only_root_filesystem)\\n if required_drop_capabilities is not None:\\n pulumi.set(__self__, \\\"required_drop_capabilities\\\", required_drop_capabilities)\\n if run_as_group is not None:\\n pulumi.set(__self__, \\\"run_as_group\\\", run_as_group)\\n if runtime_class is not None:\\n pulumi.set(__self__, \\\"runtime_class\\\", runtime_class)\\n if volumes is not None:\\n pulumi.set(__self__, \\\"volumes\\\", volumes)\",\n \"def test_update_resource_group(self):\\n pass\",\n \"def cli_run_group(log_level, endpoint, email, password, org_name, grp_name):\\n logging.basicConfig(\\n level=log_level,\\n format='%(levelname)s: %(message)s',\\n )\\n knex = Knex(endpoint)\\n User(knex, email, password).login()\\n org = Organization(knex, org_name).get()\\n logger.info(f'Loaded {org}')\\n grp = org.sample_group(grp_name).get()\\n logger.info(f'Loaded {grp}')\\n auto_metadata(list(grp.get_samples()), grp)\\n logger.info(f'Processed Metadata')\\n run_group(grp, lambda x: click.echo(x, err=True))\",\n \"def test_get_resource_group_by_moid(self):\\n pass\",\n \"def test_api_v1_groups_post(self):\\n pass\",\n \"def add_to_group(self, group):\\n\\n if not self.in_group(group):\\n self.secondary_groups.append(group)\\n return self\",\n \"def pre_security_group_read(self, resource_id):\\n pass\",\n \"def _service_task(self):\\n pass\",\n \"def group(self, group):\\n self._group = group\",\n \"def setUp(self):\\n super().setUp()\\n self.devices = _DEVICE_STRATEGY()\\n command_line = [\\\"pool\\\", \\\"create\\\", self._POOLNAME] + self.devices\\n RUNNER(command_line)\",\n \"def save(self, *args, **kwargs):\\n grupo_vendedor = Group.objects.get_or_create(name=\\\"vendedor\\\")[0]\\n self.user.groups.add(grupo_vendedor)\\n return super(Vendedor, self).save(*args, **kwargs)\",\n \"def groupManager(request):\\n \\n return render_to_response('centers.html',context_instance=RequestContext(request))\",\n \"def test_convert_to_existing_group(self, inventoryloader):\\n inventoryloader.convert_group('glance_api', 'glance_registry')\\n assert 'glance_api' not in inventoryloader.groups\\n assert not inventoryloader.groups['glance_all'].has_group('glance_api')\\n assert inventoryloader.groups['glance_registry'].has_host('localhost')\\n assert inventoryloader.groups['glance_registry'].has_host('localhost2')\\n assert \\\"management_bridge\\\" in inventoryloader.groups['glance_registry'].vars\",\n \"def __create_group(self):\\n\\n group = time.strftime(_GROUP_NAME_FORMAT, time.localtime())\\n LOG.info(\\\"Creating backup group '%s'.\\\", group)\\n\\n group_path = self.group_path(group)\\n\\n try:\\n os.mkdir(group_path)\\n except EnvironmentError as e:\\n if e.errno != errno.EEXIST:\\n raise Error(\\\"Unable to create a new backup group '{}': {}.\\\",\\n group_path, psys.e(e))\\n\\n self.__on_group_created(group)\\n\\n return group\",\n \"def add_to_group(self, org, contact, group):\\n pass\",\n \"def notebooks_group():\\n pass\",\n \"def test_creator_group_enabled_but_empty(self):\\r\\n with mock.patch.dict('django.conf.settings.FEATURES', {\\\"ENABLE_CREATOR_GROUP\\\": True}):\\r\\n self.assertFalse(has_access(self.user, CourseCreatorRole()))\\r\\n\\r\\n # Make user staff. This will cause CourseCreatorRole().has_user to return True.\\r\\n self.user.is_staff = True\\r\\n self.assertTrue(has_access(self.user, CourseCreatorRole()))\",\n \"def create_new_scaling_group(self, request, data):\\n group_cfg = data['groupConfiguration']\\n\\n group_cfg.setdefault('maxEntities', MAX_ENTITIES)\\n group_cfg.setdefault('metadata', {})\\n\\n if group_cfg['minEntities'] > group_cfg['maxEntities']:\\n raise InvalidMinEntities(\\n \\\"minEntities must be less than or equal to maxEntities\\\")\\n\\n if data['launchConfiguration']['type'] == 'launch_server':\\n validate_launch_config_servicenet(data['launchConfiguration'])\\n\\n deferred = get_supervisor().validate_launch_config(\\n self.log, self.tenant_id, data['launchConfiguration'])\\n\\n deferred.addCallback(\\n lambda _: self.store.create_scaling_group(\\n self.log, self.tenant_id,\\n group_cfg,\\n normalize_launch_config(data['launchConfiguration']),\\n data.get('scalingPolicies', None)))\\n\\n def _do_obey_config_change(result):\\n group_id = result['id']\\n config = result['groupConfiguration']\\n launch = result['launchConfiguration']\\n group = self.store.get_scaling_group(\\n self.log, self.tenant_id, group_id)\\n log = self.log.bind(scaling_group_id=group_id)\\n d = controller.modify_and_trigger(\\n self.dispatcher,\\n group,\\n bound_log_kwargs(log),\\n partial(\\n controller.obey_config_change, log,\\n transaction_id(request), config, launch_config=launch),\\n modify_state_reason='create_new_scaling_group')\\n return d.addCallback(lambda _: result)\\n\\n deferred.addCallback(_do_obey_config_change)\\n\\n def _add_to_bobby(result, client):\\n d = client.create_group(self.tenant_id, result['id'])\\n return d.addCallback(lambda _: result)\\n\\n bobby = get_bobby()\\n if bobby is not None:\\n deferred.addCallback(_add_to_bobby, bobby)\\n\\n def _format_output(result):\\n uuid = result['id']\\n result[\\\"state\\\"] = format_state_dict(result[\\\"state\\\"])\\n request.setHeader(\\n \\\"Location\\\",\\n get_autoscale_links(self.tenant_id, uuid, format=None))\\n result[\\\"links\\\"] = get_autoscale_links(self.tenant_id, uuid)\\n linkify_policy_list(\\n result['scalingPolicies'], self.tenant_id, uuid)\\n result['scalingPolicies_links'] = get_policies_links(\\n result['scalingPolicies'],\\n self.tenant_id, uuid, rel='policies')\\n return {\\\"group\\\": result}\\n\\n deferred.addCallback(_format_output)\\n deferred.addCallback(json.dumps)\\n return deferred\",\n \"def __check_new_groups(self) -> None:\\n for group in main_app_groups:\\n try:\\n group_old = Group.objects.get(name=group)\\n self.__upgrade_group(group_old, group)\\n except ObjectDoesNotExist: # need to create new group\\n self.__create_new_group(group)\\n\\n self.stdout.write(f'Added new group {group} with {main_app_groups[group]} permissions')\",\n \"def reserve_group(self, name, sco):\\n\\t\\tif self.client is None:\\n\\t\\t\\traise UsageError(\\\"Not connected!\\\")\\n\\t\\treturn self.client.reserve_group(name, sco)\",\n \"def setup(self):\\n base = automap_base()\\n engine = create_engine(\\\"mysql+pymysql://\\\" + csconfig.config.db_user + \\\":\\\" +\\n csconfig.config.db_password + \\\"@\\\" +\\n csconfig.config.db_host + \\\":\\\" +\\n str(csconfig.config.db_port) +\\n \\\"/\\\" + csconfig.config.db_name)\\n base.prepare(engine, reflect=True)\\n session = Session(engine)\\n cloud_yaml = base.classes.csv2_group_resource_yaml\\n\\n for cloud in self.group_resources:\\n cloud_yamls = session.query(cloud_yaml).\\\\\\n filter(cloud_yaml.group_name == self.name,\\n cloud_yaml.cloud_name == cloud.cloud_name)\\n cloud_yaml_list = []\\n for yam in cloud_yamls:\\n cloud_yaml_list.append([yam.yaml_name, yam.yaml, yam.mime_type])\\n if cloud.cloud_type == 'localhost':\\n newcloud = cloudscheduler.localhostcloud.LocalHostCloud(extrayaml=cloud_yaml_list, resource=cloud)\\n else:\\n newcloud = cloudscheduler.openstackcloud.\\\\\\n OpenStackCloud(extrayaml=cloud_yaml_list, resource=cloud)\\n self.clouds[newcloud.name] = newcloud\\n self.log.debug(\\\"Added all clouds for group: %s\\\", self.name)\",\n \"def test_aws_service_api_vm_security_group_put(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6569253","0.62589484","0.62589484","0.6143284","0.6102148","0.6084975","0.5941392","0.59400153","0.58592314","0.585574","0.58110565","0.5778987","0.5748649","0.5700932","0.5689231","0.56728923","0.5657217","0.5652605","0.560312","0.5590086","0.5553873","0.5495813","0.54792327","0.54792327","0.54658365","0.54658365","0.5462874","0.54622006","0.5460493","0.54497725","0.54389936","0.54291826","0.54261076","0.5422644","0.54218084","0.54177874","0.541184","0.5368996","0.53674257","0.53674257","0.5354993","0.5343998","0.53143364","0.53141713","0.5313181","0.52997696","0.5286462","0.526394","0.52349687","0.5214627","0.51983285","0.5182038","0.5168711","0.51625663","0.51616395","0.5159592","0.51536965","0.51493615","0.51492107","0.51488924","0.51371974","0.51334214","0.5133157","0.5131988","0.5128881","0.51213944","0.51126903","0.5108607","0.5105844","0.5100544","0.509728","0.5096565","0.50930744","0.5092978","0.5092851","0.5090549","0.5088946","0.50875306","0.5075989","0.50752974","0.5072522","0.5068563","0.5057462","0.505656","0.50563633","0.50556505","0.50556314","0.5054037","0.5052667","0.50493073","0.5047398","0.50457036","0.5042771","0.50402796","0.5040102","0.50362533","0.5033369","0.50284684","0.5023447","0.5018118"],"string":"[\n \"0.6569253\",\n \"0.62589484\",\n \"0.62589484\",\n \"0.6143284\",\n \"0.6102148\",\n \"0.6084975\",\n \"0.5941392\",\n \"0.59400153\",\n \"0.58592314\",\n \"0.585574\",\n \"0.58110565\",\n \"0.5778987\",\n \"0.5748649\",\n \"0.5700932\",\n \"0.5689231\",\n \"0.56728923\",\n \"0.5657217\",\n \"0.5652605\",\n \"0.560312\",\n \"0.5590086\",\n \"0.5553873\",\n \"0.5495813\",\n \"0.54792327\",\n \"0.54792327\",\n \"0.54658365\",\n \"0.54658365\",\n \"0.5462874\",\n \"0.54622006\",\n \"0.5460493\",\n \"0.54497725\",\n \"0.54389936\",\n \"0.54291826\",\n \"0.54261076\",\n \"0.5422644\",\n \"0.54218084\",\n \"0.54177874\",\n \"0.541184\",\n \"0.5368996\",\n \"0.53674257\",\n \"0.53674257\",\n \"0.5354993\",\n \"0.5343998\",\n \"0.53143364\",\n \"0.53141713\",\n \"0.5313181\",\n \"0.52997696\",\n \"0.5286462\",\n \"0.526394\",\n \"0.52349687\",\n \"0.5214627\",\n \"0.51983285\",\n \"0.5182038\",\n \"0.5168711\",\n \"0.51625663\",\n \"0.51616395\",\n \"0.5159592\",\n \"0.51536965\",\n \"0.51493615\",\n \"0.51492107\",\n \"0.51488924\",\n \"0.51371974\",\n \"0.51334214\",\n \"0.5133157\",\n \"0.5131988\",\n \"0.5128881\",\n \"0.51213944\",\n \"0.51126903\",\n \"0.5108607\",\n \"0.5105844\",\n \"0.5100544\",\n \"0.509728\",\n \"0.5096565\",\n \"0.50930744\",\n \"0.5092978\",\n \"0.5092851\",\n \"0.5090549\",\n \"0.5088946\",\n \"0.50875306\",\n \"0.5075989\",\n \"0.50752974\",\n \"0.5072522\",\n \"0.5068563\",\n \"0.5057462\",\n \"0.505656\",\n \"0.50563633\",\n \"0.50556505\",\n \"0.50556314\",\n \"0.5054037\",\n \"0.5052667\",\n \"0.50493073\",\n \"0.5047398\",\n \"0.50457036\",\n \"0.5042771\",\n \"0.50402796\",\n \"0.5040102\",\n \"0.50362533\",\n \"0.5033369\",\n \"0.50284684\",\n \"0.5023447\",\n \"0.5018118\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5379457"},"document_rank":{"kind":"string","value":"37"}}},{"rowIdx":77695,"cells":{"query":{"kind":"string","value":"This is the place to release if grouper is invoked (ie if hardware still exists on this hook call)"},"document":{"kind":"string","value":"def pytest_finished_handling_group(session, worker):"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __exit__(self, *_):\r\n\t\tself.ueye.is_FreeImageMem(self.hCam, self.pcImageMemory, self.MemID)\r\n\r\n\t\t# Disables the hCam camera handle and releases the data structures and memory areas taken up by the uEye camera\r\n\t\tself.ueye.is_ExitCamera(self.hCam)","def __del__(self):\n self.p.sleep()\n GPIO.cleanup()","def release(self):\r\n pass","def __del__(self):\n\t\tself._pc.gid_clear()","def __del__(self):\n if hasattr(self, 'dev'):\n kernel32.CloseHandle(self.dev)","def cleanup(self):\n self.GP.cleanup()","def __del__(self):\n if self.is_locked:\n self.release()","def _cleanup(self):\n # If module object not yet created, return\n if getattr(self, \"this\", None) is None:\n return\n\n deallocate = getattr(self, \"deallocate\", None)\n if callable(deallocate):\n deallocate()","def release(self):\n ckresult(_dll.FMOD_System_Release(self._ptr))","def cleanup(self):\r\n # XXX should be fixed properly!!!\r\n try:\r\n self.unlock()\r\n except:\r\n pass","def cleanup():\n dist.destroy_process_group()","def release(self):","def __exit__(self, type, value, traceback):\r\n if self.is_locked:\r\n self.release()","def __del__(self):\n GPIO.cleanup()","def cleanup_processor(self):\n pass","def __exit__(self, type_, value, traceback):\n if self.is_locked:\n self.release()","def __del__(self):\n GPIO.cleanup()\n logging.info('GPIO Cleanup Complete')","def _group_hook_memory_cleanup(\n self,\n accumulation,\n group,\n keep_gram_mat,\n keep_gram_evals,\n keep_gram_evecs,\n keep_gammas,\n keep_lambdas,\n keep_batch_size,\n ):\n buffers = []\n\n if not keep_gram_mat:\n buffers.append(\"_gram_mat\")\n if not keep_gram_evals:\n buffers.append(\"_gram_evals\")\n if not keep_gram_evecs:\n buffers.append(\"_gram_evecs\")\n if not keep_gammas and self._compute_gammas:\n buffers.append(\"_gammas\")\n if not keep_lambdas and self._compute_lambdas:\n buffers.append(\"_lambdas\")\n if not keep_batch_size:\n buffers.append(\"_batch_size\")\n\n group_id = id(group)\n for b in buffers:\n\n if self._verbose:\n print(f\"Group {group_id}: Delete '{b}'\")\n\n getattr(self, b).pop(group_id)","def unregisterProducer():","def __del__(self):\r\n self.release()","def Release(self):\n if self.on_release:\n self.on_release()","def clean_up(self):\n dist.destroy_process_group()","def release(self):\n self.acquired = False","def _kill_kernel(self):","def __del__(self):\n\n if self._needs_release:\n send_message(self, \"release\", restype=objc_id, argtypes=[])","def __del__(self):\n self.release()","def __del__(self):\n self.release()","def __del__(self):\n self.release()","def __del__(self):\n self.release()","def __del__(self):\n self.release()","def __del__(self):\n self.release()","def __exit__(self, *_exc):\r\n self.release()","def release_control(self):\n pass","def __exit__(self, exc_type, exc_val, exc_tb):\n printy(\"Cleaning after myself...\")\n self.key.delete()\n if self.instance:\n self.instance.terminate()\n # wait for the machine to terminate\n self.wait_for_status(48)\n\n self.sec_grp.delete()\n os.remove(self.key.name + \".pem\")\n printy(\"Builder teardown complete\")","def destroy(self):\r\n if self._group:\r\n if self._machine:\r\n self._group.unregisterContainer(self)\r\n self._machine.unregisterContainer(self)\r\n self._machine = None\r\n\r\n self._group = None\r\n\r\n super(Container, self).destroy()\r\n else:\r\n print('container.Container destroy() called multiple times...')","def cleanup(self):\r\n logging.info(\"entered the cleanup\")","def __del__(self):\n self.motorStop()\n GPIO.cleanup()","def __del__(self):\n self._proc.kill()","def release(self):\n # type: () -> None\n for k in self.kernels:\n k.release()","def __del__(self):\n self.shutdown()","def cleanup(self):\r\n pass","def __del__(self):\r\n if self.coreInst:\r\n for mod in self.coreInst.keys():\r\n self.coreInst[mod][plug_key].stop()","def __exit__(self, type, value, traceback):\n self.release()","def __exit__(self, type, value, traceback):\n self.release()","def __exit__(self, type, value, traceback):\r\n self.release()","def __del__(self):\r\n self.cleanup()","def __exit__(self, eType, eValue, eTrace):\n log.info(\"Destroying \"+str(self))\n self.set([0, 0, 0])\n sleep(PWM_PRD/1e6) # wait a period to ensure set() has been actioned\n PWM.clear_channel(PWM_DMA)\n PWM.clear_channel(PWM_DMA1)\n PWM.cleanup()\n return False","def __exit__(self, exc_type=None, exc_value=None, traceback=None):\n if self.cap:\n self.cap.release()\n self.cap = None","def __del__(self):\n self.DcMotor.run(Adafruit_MotorHAT.RELEASE) # changed rightMotor to DcMotor , RFMH_2019_02_28\n del self.motorhat","def cleanup():","def cleanup(self):\r\n pass","def cleanup(self):\r\n pass","def free(self):\n pass","def free(self):\n pass","def __del__(self):\n if self.plasma_client.alive:\n libplasma.release(self.plasma_client.conn, self.plasma_id)","def cleanUp(self):\n self.isConnected=False\n self.spawnProc=None","def _cleanup():\n for itr_ref in ITERATORS_LIST:\n if context:\n device_type = context.get_context(\"device_target\")\n if device_type == \"GPU\":\n itr_ref.release()\n else:\n itr = itr_ref()\n if itr is not None:\n itr.release()\n else:\n itr = itr_ref()\n if itr is not None:\n itr.release()","def cleanup(self):\r\n print(\"Cleanup not implemented\")","def cleanup (self):\n pass","def cleanup(self):","def cleanup(self):","def cleanup(self):","def __del__(self):\n if self.child_pid:\n self.host.Kill(self.child_pid, IperfClient.KILL_STRING)","def cleanup(self):\n GPIO.cleanup(self.chanlist)","def __exit__(self, exc_type, exc_val, exc_tb):\n self.release()","def cleanup(self, source=None, frame=None):\n print(\"Cleaning up the ProggerStateManager\")\n # stop tests\n self.killTests()\n\n # stop main loop\n self.running = False\n\n # stop threads\n self.ledController.stop()\n self.buttonWatcher.stop()\n\n # cleanup used gpio\n self.buttonWatcher.cleanup()\n self.ledController.cleanup()\n\n time.sleep(1)\n\n quit()","def release():\n return releaseFunc(Camera())","def __del__(self):\n self._cleanup()","def on_cleanup(self):\n raise NotImplementedError","def __del__(self):\n self.exit()","async def release(self) -> None:\n ...","async def release(self) -> None:\n ...","async def release(self) -> None:\n ...","def cleanup(self):\n log(\"[%s] Cleaning up\" % (self.__class__.__name__))\n self.manager.close()\n self.capture.release()\n self.barrier.abort()","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n self.sensor.cleanup()","def cleanUp(self):\r\n for group in self._groups.values():\r\n group.destroy()\r\n\r\n assert len(self._groups) == 0\r\n\r\n for machine in self._machines.copy():\r\n self.destroyMachine(machine)\r\n\r\n assert len(self._machines) == 0\r\n\r\n self.unregisterIAASHook()","def cleanup_resources(self, kernel_id, restart=False):","def gpio_cleanup(self):\n self.motor.gpio_cleanup()","def __exit__(self, type, value, tb):\n self._with_count -= 1\n if self._with_count > 0:\n return\n\n logging.info('Cleaning up Amber root: ' + self._amber_root)\n shutil.rmtree(self._amber_root)\n self._amber_root = None\n\n self._UnregisterAmberRepository()\n self._pm_serve_task.kill()\n self._pm_serve_task = None","def release_substitute(voter, group):","def dist_cleanup():\n dist.destroy_process_group()","def cleanup(self):\n print('GPIO cleanup...')\n GPIO.cleanup()","def free(self, gpu=None):\n if self.gpus:\n self.gpu_running_procs[gpu] -= 1\n self.running_procs -= 1","def cleanup(self):\n raise NotImplementedError","def release(local):\n local.__release__()","def purge() -> None:\r\n _purge_func(False)","def device_gc():\n safe_call(backend.get().af_device_gc())","def Release(self):\n print(\"Release : stopping event loop\", self.loop)\n self.loop.quit()\n pass","def _release(self):\n\t\tassert ltrace(TRACE_BASE, '| Enumeration._release(FAKE!!)')\n\t\tpass","def cog_unload(self):\n self.bot.lavalink_event_hooks.clear()"],"string":"[\n \"def __exit__(self, *_):\\r\\n\\t\\tself.ueye.is_FreeImageMem(self.hCam, self.pcImageMemory, self.MemID)\\r\\n\\r\\n\\t\\t# Disables the hCam camera handle and releases the data structures and memory areas taken up by the uEye camera\\r\\n\\t\\tself.ueye.is_ExitCamera(self.hCam)\",\n \"def __del__(self):\\n self.p.sleep()\\n GPIO.cleanup()\",\n \"def release(self):\\r\\n pass\",\n \"def __del__(self):\\n\\t\\tself._pc.gid_clear()\",\n \"def __del__(self):\\n if hasattr(self, 'dev'):\\n kernel32.CloseHandle(self.dev)\",\n \"def cleanup(self):\\n self.GP.cleanup()\",\n \"def __del__(self):\\n if self.is_locked:\\n self.release()\",\n \"def _cleanup(self):\\n # If module object not yet created, return\\n if getattr(self, \\\"this\\\", None) is None:\\n return\\n\\n deallocate = getattr(self, \\\"deallocate\\\", None)\\n if callable(deallocate):\\n deallocate()\",\n \"def release(self):\\n ckresult(_dll.FMOD_System_Release(self._ptr))\",\n \"def cleanup(self):\\r\\n # XXX should be fixed properly!!!\\r\\n try:\\r\\n self.unlock()\\r\\n except:\\r\\n pass\",\n \"def cleanup():\\n dist.destroy_process_group()\",\n \"def release(self):\",\n \"def __exit__(self, type, value, traceback):\\r\\n if self.is_locked:\\r\\n self.release()\",\n \"def __del__(self):\\n GPIO.cleanup()\",\n \"def cleanup_processor(self):\\n pass\",\n \"def __exit__(self, type_, value, traceback):\\n if self.is_locked:\\n self.release()\",\n \"def __del__(self):\\n GPIO.cleanup()\\n logging.info('GPIO Cleanup Complete')\",\n \"def _group_hook_memory_cleanup(\\n self,\\n accumulation,\\n group,\\n keep_gram_mat,\\n keep_gram_evals,\\n keep_gram_evecs,\\n keep_gammas,\\n keep_lambdas,\\n keep_batch_size,\\n ):\\n buffers = []\\n\\n if not keep_gram_mat:\\n buffers.append(\\\"_gram_mat\\\")\\n if not keep_gram_evals:\\n buffers.append(\\\"_gram_evals\\\")\\n if not keep_gram_evecs:\\n buffers.append(\\\"_gram_evecs\\\")\\n if not keep_gammas and self._compute_gammas:\\n buffers.append(\\\"_gammas\\\")\\n if not keep_lambdas and self._compute_lambdas:\\n buffers.append(\\\"_lambdas\\\")\\n if not keep_batch_size:\\n buffers.append(\\\"_batch_size\\\")\\n\\n group_id = id(group)\\n for b in buffers:\\n\\n if self._verbose:\\n print(f\\\"Group {group_id}: Delete '{b}'\\\")\\n\\n getattr(self, b).pop(group_id)\",\n \"def unregisterProducer():\",\n \"def __del__(self):\\r\\n self.release()\",\n \"def Release(self):\\n if self.on_release:\\n self.on_release()\",\n \"def clean_up(self):\\n dist.destroy_process_group()\",\n \"def release(self):\\n self.acquired = False\",\n \"def _kill_kernel(self):\",\n \"def __del__(self):\\n\\n if self._needs_release:\\n send_message(self, \\\"release\\\", restype=objc_id, argtypes=[])\",\n \"def __del__(self):\\n self.release()\",\n \"def __del__(self):\\n self.release()\",\n \"def __del__(self):\\n self.release()\",\n \"def __del__(self):\\n self.release()\",\n \"def __del__(self):\\n self.release()\",\n \"def __del__(self):\\n self.release()\",\n \"def __exit__(self, *_exc):\\r\\n self.release()\",\n \"def release_control(self):\\n pass\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n printy(\\\"Cleaning after myself...\\\")\\n self.key.delete()\\n if self.instance:\\n self.instance.terminate()\\n # wait for the machine to terminate\\n self.wait_for_status(48)\\n\\n self.sec_grp.delete()\\n os.remove(self.key.name + \\\".pem\\\")\\n printy(\\\"Builder teardown complete\\\")\",\n \"def destroy(self):\\r\\n if self._group:\\r\\n if self._machine:\\r\\n self._group.unregisterContainer(self)\\r\\n self._machine.unregisterContainer(self)\\r\\n self._machine = None\\r\\n\\r\\n self._group = None\\r\\n\\r\\n super(Container, self).destroy()\\r\\n else:\\r\\n print('container.Container destroy() called multiple times...')\",\n \"def cleanup(self):\\r\\n logging.info(\\\"entered the cleanup\\\")\",\n \"def __del__(self):\\n self.motorStop()\\n GPIO.cleanup()\",\n \"def __del__(self):\\n self._proc.kill()\",\n \"def release(self):\\n # type: () -> None\\n for k in self.kernels:\\n k.release()\",\n \"def __del__(self):\\n self.shutdown()\",\n \"def cleanup(self):\\r\\n pass\",\n \"def __del__(self):\\r\\n if self.coreInst:\\r\\n for mod in self.coreInst.keys():\\r\\n self.coreInst[mod][plug_key].stop()\",\n \"def __exit__(self, type, value, traceback):\\n self.release()\",\n \"def __exit__(self, type, value, traceback):\\n self.release()\",\n \"def __exit__(self, type, value, traceback):\\r\\n self.release()\",\n \"def __del__(self):\\r\\n self.cleanup()\",\n \"def __exit__(self, eType, eValue, eTrace):\\n log.info(\\\"Destroying \\\"+str(self))\\n self.set([0, 0, 0])\\n sleep(PWM_PRD/1e6) # wait a period to ensure set() has been actioned\\n PWM.clear_channel(PWM_DMA)\\n PWM.clear_channel(PWM_DMA1)\\n PWM.cleanup()\\n return False\",\n \"def __exit__(self, exc_type=None, exc_value=None, traceback=None):\\n if self.cap:\\n self.cap.release()\\n self.cap = None\",\n \"def __del__(self):\\n self.DcMotor.run(Adafruit_MotorHAT.RELEASE) # changed rightMotor to DcMotor , RFMH_2019_02_28\\n del self.motorhat\",\n \"def cleanup():\",\n \"def cleanup(self):\\r\\n pass\",\n \"def cleanup(self):\\r\\n pass\",\n \"def free(self):\\n pass\",\n \"def free(self):\\n pass\",\n \"def __del__(self):\\n if self.plasma_client.alive:\\n libplasma.release(self.plasma_client.conn, self.plasma_id)\",\n \"def cleanUp(self):\\n self.isConnected=False\\n self.spawnProc=None\",\n \"def _cleanup():\\n for itr_ref in ITERATORS_LIST:\\n if context:\\n device_type = context.get_context(\\\"device_target\\\")\\n if device_type == \\\"GPU\\\":\\n itr_ref.release()\\n else:\\n itr = itr_ref()\\n if itr is not None:\\n itr.release()\\n else:\\n itr = itr_ref()\\n if itr is not None:\\n itr.release()\",\n \"def cleanup(self):\\r\\n print(\\\"Cleanup not implemented\\\")\",\n \"def cleanup (self):\\n pass\",\n \"def cleanup(self):\",\n \"def cleanup(self):\",\n \"def cleanup(self):\",\n \"def __del__(self):\\n if self.child_pid:\\n self.host.Kill(self.child_pid, IperfClient.KILL_STRING)\",\n \"def cleanup(self):\\n GPIO.cleanup(self.chanlist)\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n self.release()\",\n \"def cleanup(self, source=None, frame=None):\\n print(\\\"Cleaning up the ProggerStateManager\\\")\\n # stop tests\\n self.killTests()\\n\\n # stop main loop\\n self.running = False\\n\\n # stop threads\\n self.ledController.stop()\\n self.buttonWatcher.stop()\\n\\n # cleanup used gpio\\n self.buttonWatcher.cleanup()\\n self.ledController.cleanup()\\n\\n time.sleep(1)\\n\\n quit()\",\n \"def release():\\n return releaseFunc(Camera())\",\n \"def __del__(self):\\n self._cleanup()\",\n \"def on_cleanup(self):\\n raise NotImplementedError\",\n \"def __del__(self):\\n self.exit()\",\n \"async def release(self) -> None:\\n ...\",\n \"async def release(self) -> None:\\n ...\",\n \"async def release(self) -> None:\\n ...\",\n \"def cleanup(self):\\n log(\\\"[%s] Cleaning up\\\" % (self.__class__.__name__))\\n self.manager.close()\\n self.capture.release()\\n self.barrier.abort()\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n self.sensor.cleanup()\",\n \"def cleanUp(self):\\r\\n for group in self._groups.values():\\r\\n group.destroy()\\r\\n\\r\\n assert len(self._groups) == 0\\r\\n\\r\\n for machine in self._machines.copy():\\r\\n self.destroyMachine(machine)\\r\\n\\r\\n assert len(self._machines) == 0\\r\\n\\r\\n self.unregisterIAASHook()\",\n \"def cleanup_resources(self, kernel_id, restart=False):\",\n \"def gpio_cleanup(self):\\n self.motor.gpio_cleanup()\",\n \"def __exit__(self, type, value, tb):\\n self._with_count -= 1\\n if self._with_count > 0:\\n return\\n\\n logging.info('Cleaning up Amber root: ' + self._amber_root)\\n shutil.rmtree(self._amber_root)\\n self._amber_root = None\\n\\n self._UnregisterAmberRepository()\\n self._pm_serve_task.kill()\\n self._pm_serve_task = None\",\n \"def release_substitute(voter, group):\",\n \"def dist_cleanup():\\n dist.destroy_process_group()\",\n \"def cleanup(self):\\n print('GPIO cleanup...')\\n GPIO.cleanup()\",\n \"def free(self, gpu=None):\\n if self.gpus:\\n self.gpu_running_procs[gpu] -= 1\\n self.running_procs -= 1\",\n \"def cleanup(self):\\n raise NotImplementedError\",\n \"def release(local):\\n local.__release__()\",\n \"def purge() -> None:\\r\\n _purge_func(False)\",\n \"def device_gc():\\n safe_call(backend.get().af_device_gc())\",\n \"def Release(self):\\n print(\\\"Release : stopping event loop\\\", self.loop)\\n self.loop.quit()\\n pass\",\n \"def _release(self):\\n\\t\\tassert ltrace(TRACE_BASE, '| Enumeration._release(FAKE!!)')\\n\\t\\tpass\",\n \"def cog_unload(self):\\n self.bot.lavalink_event_hooks.clear()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64408547","0.63653266","0.6343562","0.6335266","0.63285846","0.62338746","0.61478007","0.6144899","0.6130134","0.61175394","0.6112023","0.6108773","0.61039203","0.60399","0.60207015","0.5983089","0.5948264","0.59431905","0.5941086","0.5926044","0.59239423","0.59219116","0.591669","0.5905587","0.5894843","0.5892324","0.5892324","0.5892324","0.5892324","0.5892324","0.5892324","0.58826625","0.5864688","0.5825025","0.582375","0.58199495","0.5802122","0.57988083","0.5762224","0.57482165","0.5747767","0.57395697","0.5733857","0.5733857","0.57265955","0.57253367","0.5725037","0.57220465","0.57098293","0.5698598","0.56902736","0.56902736","0.56867737","0.56867737","0.56705","0.5664995","0.56631887","0.566214","0.5656539","0.56513697","0.56513697","0.56513697","0.56447804","0.5643224","0.5638408","0.56102103","0.56059474","0.5599078","0.5597202","0.55961734","0.5595063","0.5595063","0.5595063","0.5590838","0.5589996","0.5589996","0.5589996","0.5589996","0.5589996","0.5589996","0.5589996","0.5589996","0.5589996","0.5589996","0.5589996","0.5566299","0.5559188","0.55530053","0.5545108","0.5542309","0.55410564","0.55408776","0.55376494","0.55329543","0.5525241","0.5521793","0.5513184","0.5511869","0.5507482","0.55023944","0.5500867"],"string":"[\n \"0.64408547\",\n \"0.63653266\",\n \"0.6343562\",\n \"0.6335266\",\n \"0.63285846\",\n \"0.62338746\",\n \"0.61478007\",\n \"0.6144899\",\n \"0.6130134\",\n \"0.61175394\",\n \"0.6112023\",\n \"0.6108773\",\n \"0.61039203\",\n \"0.60399\",\n \"0.60207015\",\n \"0.5983089\",\n \"0.5948264\",\n \"0.59431905\",\n \"0.5941086\",\n \"0.5926044\",\n \"0.59239423\",\n \"0.59219116\",\n \"0.591669\",\n \"0.5905587\",\n \"0.5894843\",\n \"0.5892324\",\n \"0.5892324\",\n \"0.5892324\",\n \"0.5892324\",\n \"0.5892324\",\n \"0.5892324\",\n \"0.58826625\",\n \"0.5864688\",\n \"0.5825025\",\n \"0.582375\",\n \"0.58199495\",\n \"0.5802122\",\n \"0.57988083\",\n \"0.5762224\",\n \"0.57482165\",\n \"0.5747767\",\n \"0.57395697\",\n \"0.5733857\",\n \"0.5733857\",\n \"0.57265955\",\n \"0.57253367\",\n \"0.5725037\",\n \"0.57220465\",\n \"0.57098293\",\n \"0.5698598\",\n \"0.56902736\",\n \"0.56902736\",\n \"0.56867737\",\n \"0.56867737\",\n \"0.56705\",\n \"0.5664995\",\n \"0.56631887\",\n \"0.566214\",\n \"0.5656539\",\n \"0.56513697\",\n \"0.56513697\",\n \"0.56513697\",\n \"0.56447804\",\n \"0.5643224\",\n \"0.5638408\",\n \"0.56102103\",\n \"0.56059474\",\n \"0.5599078\",\n \"0.5597202\",\n \"0.55961734\",\n \"0.5595063\",\n \"0.5595063\",\n \"0.5595063\",\n \"0.5590838\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5589996\",\n \"0.5566299\",\n \"0.5559188\",\n \"0.55530053\",\n \"0.5545108\",\n \"0.5542309\",\n \"0.55410564\",\n \"0.55408776\",\n \"0.55376494\",\n \"0.55329543\",\n \"0.5525241\",\n \"0.5521793\",\n \"0.5513184\",\n \"0.5511869\",\n \"0.5507482\",\n \"0.55023944\",\n \"0.5500867\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":77696,"cells":{"query":{"kind":"string","value":"Define the toolbox (the name of the toolbox is the name of the .pyt file)."},"document":{"kind":"string","value":"def __init__(self):\n self.label = \"PFRR Tools\"\n self.alias = \"PFRR Tools\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Ending_Point, Range_Distance, PFRR]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def setup_toolbox(self, engine_name, task_name, toolbox_name):\n pass","def __init__(self):\n self.label = \"Python ToolBox\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Tool]","def __init__(self):\n self.label = \"Create\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n if core.get_pass():\n self.tools = [Fbound, Roads, Diekdikisi]\n else:\n self.tools = []","def __init__(self):\n self.label = \"Toolbox\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [FilesWithin, UpdateAiracInfo, CalculatePolygonRotationUTM33, CalculatePolygonRotationLCC10E, SetLayoutsNorAirac, SetLayoutsSweAirac, SetLayoutsFinDnkAirac, Export330charts]","def __init__(self):\r\n\t\tself.label = \"Toolbox\"\r\n\t\tself.alias = \"\"\r\n\r\n\t\t# List of tool classes associated with this toolbox\r\n\t\tself.tools = [LinkedDataSpatialQuery, LinkedDataPropertyEnrich, MergeBatchNoFunctionalProperty, MergeSingleNoFunctionalProperty, LocationPropertyPath, RelFinder]","def main():\n tbx = Toolbox()\n tool = FieldName()\n tool.execute(tool.getParameterInfo(), None)","def __init__(self):\n self.label = \"Toolbox\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Offset]","def __init__(self):\n self.label = \"Check\"\n self.alias = \"Check Shapefiles\"\n\n # List of tool classes associated with this toolbox\n if core.get_pass():\n self.tools = [Dbound, Overlaps, Numbering, Geometry, Roads, Bld]\n else:\n self.tools = []","def __init__(self):\r\n self.label = \"Toolbox\"\r\n self.alias = \"Geodesic Densification using arcpy\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [GeodesicDensification_arcpy]","def __init__(self):\n self.label = \"CDA Tools\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [SecondaryCraterRemovalTool]","def __init__(self):\n self.label = \"Service Downloader\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Edown]","def __init__(self):\n self.label = \"Data Assistant\"\n self.alias = \"dla\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Append, Stage, NewFile, Preview, Replace]","def __init__(self):\n self.label = \"Surface Generation\"\n self.alias = \"far77\"\n\n # List of tool classes associated with this toolbox\n self.tools = [LineToFar77]","def __init__(self):\r\n self.label = \"OVL Tools\"\r\n self.alias = \"\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [OVLtoFeature, BatchOVLtoFeature]","def __init__(self):\r\n self.label = \"Python Toolbox: Floodwater Depth Analysis\"\r\n self.alias = \"\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [FEMAClip, FEMA_BFE, Depth]","def __init__(self):\n self.label = \"Change Field Name\"\n self.alias = \"Field name\"\n\n # List of tool classes associated with this toolbox\n self.tools = [FieldName]","def setToolTo(*args, **kwargs)->None:\n pass","def __init__(self):\n self.label = \"RAPID Tools\"\n self.alias = \"RAPIDTools\"\n\n # List of tool classes associated with this toolbox\n self.tools = [AddSPTFields,\n AutomaticRAPIDfileGenerator, \n CopyDataToServer,\n CreateNetworkConnectivityFile,\n CreateNetworkConnectivityFileNHDPlus,\n CreateMuskingumParameterFiles,\n CreateMuskingumKFile,\n CreateMuskingumKfacFile,\n CreateMuskingumXField, \n CreateMuskingumXFile, \n CreateRivIDGageFile, \n CreateSubsetFile,\n CreateWeightTableFromWRFGeogrid,\n CreateInflowFileFromWRFHydroRunoff,\n CreateWeightTableFromECMWFRunoff,\n CreateInflowFileFromECMWFRunoff,\n CreateWeightTableFromLDASRunoff,\n CreateWeightTableFrom2DLatLonRunoff,\n CreateDischargeTable,\n CreateDischargeMap,\n FlowlineToPoint,\n DEMtoStreamNetwork,\n PublishDischargeMap,\n StreamNetworktoRAPID,\n StreamNetworktoSPT,\n UpdateWeightTable,\n UpdateDischargeMap,\n ]","def __init__(self):\r\n self.label = \"ProcessAirQuality\"\r\n self.alias = \"ProcessAirQuality\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [AirQuality]","def installTools(self, out):\r\n # Check that the tool has not been added using its id\r\n if not hasattr(self, 'selenium_ft_tool'):\r\n addTool = self.manage_addProduct['Selenium'].manage_addTool\r\n # Add the tool by its meta_type\r\n addTool('Selenium Functional Test Tool')\r\n out.write('Successfully added Selenium Functional Test Tool.\\n')","def __init__(self):\r\n self.label = \"GEOGRID_STANDALONE\"\r\n self.alias = \"\"\r\n self.description = \"This is a standalone processing tool for WRF-HYDRO.\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [ProcessGeogridFile, ExportGrid, ExamineOutputs, ExportPRJ, GenerateLatLon, DomainShapefile]","def __init__(self):\n \n self.label = \"ArcSDM Tools\"\n self.alias = \"ArcSDM\" \n\n # List of tool classes associated with this toolbox\n self.tools = [PartitionNNInputFiles, CombineNNOutputFiles, NeuralNetworkOutputFiles, NeuralNetworkInputFiles, \n CalculateWeightsTool,SiteReductionTool,CategoricalMembershipToool,\n CategoricalAndReclassTool, TOCFuzzificationTool, CalculateResponse, LogisticRegressionTool, Symbolize, \n ROCTool, AgterbergChengCITest, AreaFrequencyTable, GetSDMValues, GrandWofe]","def tb_add_tool(tb, id, name, img, description):\n tb.AddTool(id, name, wx.ArtProvider.GetBitmap(img), description)","def SetupToolBar( self ):\n tb = self.CreateToolBar( self.TBFLAGS )\n tsize = (24,24)\n tb.ToolBitmapSize = tsize\n open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize)\n tb.AddLabelTool(ID_OPEN, \"Open\", open_bmp, shortHelp=\"Open\", longHelp=\"Open a (c)Profile trace file\")\n tb.AddSeparator()\n# self.Bind(wx.EVT_TOOL, self.OnOpenFile, id=ID_OPEN)\n self.rootViewTool = tb.AddLabelTool(\n ID_ROOT_VIEW, _(\"Root View\"),\n wx.ArtProvider.GetBitmap(wx.ART_GO_HOME, wx.ART_TOOLBAR, tsize),\n shortHelp=_(\"Display the root of the current view tree (home view)\")\n )\n self.rootViewTool = tb.AddLabelTool(\n ID_BACK_VIEW, _(\"Back\"), \n wx.ArtProvider.GetBitmap(wx.ART_GO_BACK, wx.ART_TOOLBAR, tsize),\n shortHelp=_(\"Back to the previously activated node in the call tree\")\n )\n self.upViewTool = tb.AddLabelTool(\n ID_UP_VIEW, _(\"Up\"),\n wx.ArtProvider.GetBitmap(wx.ART_GO_UP, wx.ART_TOOLBAR, tsize),\n shortHelp=_(\"Go one level up the call tree (highest-percentage parent)\")\n )\n tb.AddSeparator()\n # TODO: figure out why the control is sizing the label incorrectly on Linux\n self.percentageViewTool = wx.CheckBox( tb, -1, _(\"Percent \") )\n self.percentageViewTool.SetToolTip( wx.ToolTip(_(\"Toggle display of percentages in list views\")) )\n tb.AddControl( self.percentageViewTool )\n wx.EVT_CHECKBOX( self.percentageViewTool, self.percentageViewTool.GetId(), self.OnPercentageView )\n \n self.packageViewTool = wx.CheckBox( tb, -1, _(\"File View \") )\n self.packageViewTool.SetToolTip( wx.ToolTip(_(\"Switch between call-hierarchy and package/module/function hierarchy\")) )\n tb.AddControl( self.packageViewTool )\n wx.EVT_CHECKBOX( self.packageViewTool, self.packageViewTool.GetId(), self.OnPackageView )\n tb.Realize()","def __init__(self):\r\n\t\tself.label = \"smart_move\"\r\n\t\tself.alias = \"Smart Move Operations\"\r\n\r\n\t\t# List of tool classes associated with this toolbox\r\n\t\tself.tools = [SmartMoveFeatures]","def _on_modeling_language_changed(self, event: ModelingLanguageChanged) -> None:\n toolbox = self.create_toolbox(self.modeling_language.toolbox_definition)\n if self._toolbox_container:\n if Gtk.get_major_version() == 3:\n self._toolbox_container.remove(self._toolbox_container.get_child())\n self._toolbox_container.add(toolbox)\n else:\n self._toolbox_container.set_child(toolbox)\n self._toolbox = toolbox","def __init__(self):\n self.label = \"AlternateUnitBounds_Processing\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [FindMissingBounds, FindUpdatedIMDParks]","def register_other_tools(self):\n self.add_tool(SaveAsTool)\n self.add_tool(CopyToClipboardTool)\n self.add_tool(PrintTool)\n self.add_tool(HelpTool)","def __init__(self, toolName):\n\t\tself.toolName = toolName","def register_standard_tools(self):\n t = self.add_tool(SelectTool)\n self.set_default_tool(t)\n self.add_tool(RectZoomTool)\n self.add_tool(BasePlotMenuTool, \"item\")\n self.add_tool(ExportItemDataTool)\n try:\n import spyderlib.widgets.objecteditor # analysis:ignore\n self.add_tool(EditItemDataTool)\n except ImportError:\n pass\n self.add_tool(ItemCenterTool)\n self.add_tool(DeleteItemTool)\n self.add_separator_tool()\n self.add_tool(BasePlotMenuTool, \"grid\")\n self.add_tool(BasePlotMenuTool, \"axes\")\n self.add_tool(DisplayCoordsTool)\n if self.get_itemlist_panel():\n self.add_tool(ItemListPanelTool)","def initialize(context):\n\n content_types, constructors, ftis = atapi.process_types(\n atapi.listTypes(config.PROJECTNAME),\n config.PROJECTNAME)\n\n for atype, constructor in zip(content_types, constructors):\n utils.ContentInit('%s: %s' % (config.PROJECTNAME, atype.portal_type),\n content_types=(atype, ),\n permission=config.ADD_PERMISSIONS[atype.portal_type],\n extra_constructors=(constructor,),\n ).initialize(context)\n \n \n # Import tool\n ToolInit(\n '%s Tool' % PROJECTNAME,\n tools=(PloneAnnuaireTool,),\n icon='tool.gif').initialize(context)","def about ():\n easygui.textbox(title='About olebrowse', text=__doc__)","def get_tools(cls):\n pass","def __init__(self):\r\n self.label = \"Bulk Layout Text Replace\"\r\n self.alias = \" Jake's Toolbox Alias Property True\"\r\n self.description = \"\"\r\n self.canRunInBackground = False","def test_install(self):\n\n\n adminuser,adminpass = self.testdata.find_account_for('toolmanager')\n\n self.utils.account.login_as(adminuser,adminpass)\n\n self.contribtool.install(TOOLNAME,adminuser,adminpass)","def menu_python_library(self, event=None):\n self.parentPanel.python_help('lib')","def createToolBar(self):\n pass","def cli(ctx, **kwds):\n invalid = _validate_kwds(kwds)\n if invalid:\n ctx.exit(invalid)\n tool_description = tool_builder.build(**kwds)\n tool_builder.write_tool_description(ctx, tool_description, **kwds)","def test_create(self):\n\n adminuser,adminpass = self.testdata.find_account_for('toolmanager')\n\n self.utils.account.login_as(adminuser,adminpass)\n\n self.contribtool.create(TOOLNAME)","def setup(bot):\n bot.add_cog(Help(bot))","def setup(bot: Bot) -> None:\n bot.add_cog(Help(bot))","def __init__(self, windows):\n super().__init__(self, windows) # this inherits the init from the previous building class\n self.windows = windows\n self.workbench = True\n self.tools = []","def _its_tool_ ( self , typename , name = None , interface = None , createIf = True , parent = None ) :\n if not name :\n t,s,n = typename.rpartition('/')\n if t and s and n :\n typename = t\n name = n\n else : name = typename\n \n p1 = typename.find ( ':PUBLIC' )\n if 0 < p1 and p1 + 6 == len(typename) :\n typename = typename [:p1]\n \n itool = GaudiPython.Bindings.Helper.tool ( self._its , typename , name , parent , createIf ) \n if itool and interface :\n iif = GaudiPython.Bindings.InterfaceCast(interface)( itool )\n if not iif : logger.warning(\"Can't retrieve proepr interface %s for %s\" % ( interface , itool ) )\n return GaudiPython.Bindings.iAlgTool ( itool.name() , iif )\n elif not itool : logger.warning(\"Can't retrieve the tool %s'%s\" % ( typename , name ) )\n \n return GaudiPython.Bindings.iAlgTool ( name , itool )","def create_analysis_tools(self):\r\n raise NotImplementedError()","def setUpClass(cls):\n stu._extract_tk('testtkpy')","def setUpClass(cls):\n stu._extract_tk('testtkpy')","def setUpClass(cls):\n stu._extract_tk('testtkpy')","def setUpClass(cls):\n stu._extract_tk('testtkpy')","def main():\n\n parser = argparse.ArgumentParser(description=\"generateTestStubs\")\n\n parser.add_argument(\"taskFile\",\n help=\"Path for assignment file.\")\n\n args = parser.parse_args()\n\n if not os.path.exists(args.taskFile):\n print(\"Task file does not exist.\")\n sys.exit(1)\n\n taskMgr = EEWebLPProject()\n taskMgr.initLP()\n\n #taskMgr.listProjects()\n #taskMgr.loadTree([\"project_id=8008922\"])\n tasks = taskMgr.getTasks([\"project_id=6890048\"],parent_id=8008922)\n\n fileByAssignee = taskMgr.getTaskOwners(args.taskFile)\n taskMgr.updateTaskOwners(fileByAssignee,tasks)","def create_tool_bar(self):\n tb = self.CreateToolBar(wx.TB_DEFAULT_STYLE, wx.ID_ANY, \"Main\")\n\n tb_add_tool(tb, wx.ID_NEW, \"New\", wx.ART_NEW, \"Create a new braille document\")\n tb_add_tool(tb, wx.ID_OPEN, \"Import\", wx.ART_FILE_OPEN, \"Import and convert a print document\")\n tb.AddSeparator()\n tb_add_tool(tb, wx.ID_SAVE, \"Save\", wx.ART_FILE_SAVE, \"Save the current braille document\")\n tb_add_tool(tb, wx.ID_SAVEAS, \"Save As\", wx.ART_FILE_SAVE_AS, \"Save the current braille document under a new name\")\n tb.AddSeparator()\n\n tb_add_tool(tb, wx.ID_UNDO, \"Undo\", wx.ART_UNDO, \"Undo the last operation\")\n tb_add_tool(tb, wx.ID_REDO, \"Redo\", wx.ART_REDO, \"Redo the last operation\")\n tb.AddSeparator()\n tb_add_tool(tb, wx.ID_CUT, \"Cut\", wx.ART_CUT, \"Move text to the clipboard\")\n tb_add_tool(tb, wx.ID_COPY, \"Copy\", wx.ART_COPY, \"Copy text to the clipboard\")\n tb_add_tool(tb, wx.ID_PASTE, \"Copy\", wx.ART_PASTE, \"Insert text from the clipboard\")\n\n tb.Realize() # Allow WX to position and size all widgets on the toolbar\n return tb","def create_launcher():\n data = textwrap.dedent('''\\\n #!/usr/bin/env python3\n\n \"\"\"QasteTray launcher.\"\"\"\n\n\n from qastetray.__main__ import main\n\n if __name__ == '__main__':\n main()\n ''')\n with open('build/usr/bin/qastetray', 'w') as f:\n f.write(data)","def __tool_name__(cls):","def __init__(self, args):\n # etree.write(stdout, xml_declaration=True, encoding='UTF-8')\n JsonShell.__init__(self, args)\n self.args = args\n tool = etree.Element('tool', id='gatk4_auto_' + self.shell_dict['id'], name=self.shell_dict['name'],\n version=\"@WRAPPER_VERSION@0\", profile=self.profile)\n description = etree.SubElement(tool, 'description')\n description.text = '- ' + self.shell_dict['description']\n macros = etree.SubElement(tool, 'macros')\n macros_imp = etree.SubElement(macros, 'import')\n macros_imp.text = 'macros.xml'\n exp_reqs = etree.SubElement(tool, 'expand', macro='requirements')\n exp_vers = etree.SubElement(tool, 'expand', macro='version_cmd')\n command = etree.SubElement(tool, 'command', detect_errors='exit_code')\n command.text = etree.CDATA(self.command_create())\n\n # INPUT section\n self.inputs = etree.SubElement(tool, 'inputs')\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['pre_params']:\n etree.SubElement(self.inputs, 'expand', macro=entry)\n self.build_inputs(self.tool_xml, self.inputs, 'param')\n if self.xml_opt or self.my_xml.tool_data[self.shell_dict['short_name']]['opt_params']:\n self.opt_sect = etree.SubElement(self.inputs, 'section', name='optional', title='Optional Parameters', expanded='False')\n self.build_inputs(self.xml_opt, self.opt_sect, 'param')\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['opt_params']:\n etree.SubElement(self.opt_sect, 'expand', macro=entry)\n# self.build_inputs(self.xml_opt, self.opt_sect, 'param')\n\n if self.xml_adv or self.my_xml.tool_data[self.shell_dict['short_name']]['adv_params']:\n# self.adv_sect, self.when_yes = self._section_write('advanced', 'Advanced Parameters', 'advanced_sel')\n self.adv_sect = etree.SubElement(self.inputs, 'section', name='advanced', title='Advanced Parameters', expanded='False')\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['adv_params']:\n etree.SubElement(self.adv_sect, 'expand', macro=entry)\n# if not self.args.old_galaxy:\n self.build_inputs(self.xml_adv, self.adv_sect, 'param')\n # else:\n # self.build_inputs(self.xml_adv, self.when_yes, 'param')\n\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['post_params']:\n etree.SubElement(self.inputs, 'expand', macro=entry)\n\n # Temporary common section to work on macros.\n if self.xml_comm:\n# self.comm_sect, self.when_yes = self._section_write('common', 'Common Parameters', 'common_sel')\n self.comm_sect = etree.SubElement(self.inputs, 'section', name='common', title='Common Parameters', expanded='False')\n self.build_inputs(self.xml_comm, self.comm_sect, 'param')\n\n # OUTPUT section\n if self.xml_out:\n# self.output_sect, self.when_yes = self._section_write('output_opt', 'Additional Output Parameters', 'output_opt_sel')\n if not self.args.old_galaxy:\n self.output_sect = etree.SubElement(self.inputs, 'section', name='output_opt',\n title='Additional Output Parameters',\n expanded='False')\n self.build_inputs_out_sel(self.xml_out, self.output_sect)\n else:\n self.build_inputs_out_sel(self.xml_out, self.inputs)\n\n self.outputs = etree.SubElement(tool, 'outputs')\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['output_params']:\n etree.SubElement(self.outputs, 'expand', macro=entry)\n self.build_inputs(self.xml_req_out, self.outputs, 'data')\n self.build_inputs(self.xml_out, self.outputs, 'data', True)\n\n tests = etree.SubElement(tool, 'tests')\n help = etree.SubElement(tool, 'help')\n help.text = etree.CDATA(self.shell_dict['summary'])\n citations = etree.SubElement(tool, 'citations')\n exp_cit = etree.SubElement(citations, 'expand', macro='citations')\n\n self.to_write = etree.tostring(tool, pretty_print=True, encoding=\"unicode\")","def setup_dev():\n setup_general()","def setup_make_tool_plugin():\n arg_parser = argparse.ArgumentParser()\n arg_parser.add_argument(\"--show-tool-output\", dest=\"show_tool_output\",\n action=\"store_false\", help=\"Show tool output\")\n arg_parser.add_argument('--mapping-file-suffix', dest=\"mapping_file_suffix\",\n type=str)\n\n resources = Resources([os.path.join(os.path.dirname(statick_tool.__file__),\n 'plugins')])\n config = Config(resources.get_file(\"config.yaml\"))\n plugin_context = PluginContext(arg_parser.parse_args([]), resources, config)\n plugin_context.args.output_directory = os.path.dirname(__file__)\n mtp = MakeToolPlugin()\n mtp.set_plugin_context(plugin_context)\n return mtp","def tool_config(request):\n if request.is_secure():\n host = 'https://' + request.get_host()\n else:\n host = 'http://' + request.get_host()\n\n url = host + reverse('edx2canvas:lti_launch')\n\n lti_tool_config = ToolConfig(\n title='Add edX Content',\n launch_url=url,\n secure_launch_url=url,\n )\n account_nav_params = {\n 'enabled': 'true',\n 'text': 'Add edX Content',\n 'visibility': 'admins',\n }\n lti_tool_config.set_ext_param('canvas.instructure.com', 'privacy_level', 'public')\n lti_tool_config.set_ext_param('canvas.instructure.com', 'course_navigation', account_nav_params)\n lti_tool_config.description = 'Import content from edX to Canvas'\n\n return http.HttpResponse(\n lti_tool_config.to_xml(), content_type='text/xml', status=200\n )","def tool_name(self) -> str:\n return \"BlackbirdOptional\"","def imports():\r\n out_str = \"\"\"\r\ntry:\r\n import tkinter as tk \r\nexcept ImportError:\r\n import Tkinter as tk\r\nfrom os.path import join\r\nimport tempfile\r\n\r\nimport zipfile\r\nimport math\r\nfrom pymol import cmd, finish_launching, plugins\r\nfrom pymol.cgo import *\r\n\r\nwd = None\r\nfinish_launching()\r\n\"\"\"\r\n return out_str","def runDefine(self):\n\n # Select the layers open in the legendInterface and add them to an array\n layers = self.iface.legendInterface().layers()\n layer_list = []\n # Append only Vector (type == 0) to the layer_list\n for layer in layers:\n if layer.type() == 0:\n layer_list.append(layer.name())\n else:\n pass\n # Add layer_list array to listWidget, clear layer if removed to layer in tools\n self.dlgtool1.listWidget.clear()\n self.dlgtool1.listWidget.addItems(layer_list)\n\n # show the dialog\n self.dlgtool1.show()\n # Run the dialog event loop\n result = self.dlgtool1.exec_()\n\n if result:\n # Do something useful here - delete the line containing pass and\n # substitute with your code.\n pass\n\n htd = self.dlgtool1.comboBox.currentText()\n for f in layers:\n if f.type() != 0:\n return False\n temp = self.getCustom(htd, f)\n if htd != \"System\":\n f.setCrs(temp)","def on_pre_enter(self):\r\n self.ids.alabel.text = \"\"\"[b][size=20]CEToolBox kivy v\"\"\"+ __version__ +\"\"\"[/size][/b]\\n\"\"\"","def lticonfig(tool):\n if tool not in CONFIG:\n return False\n else:\n tconfig = CONFIG[tool]\n\n if 'title' not in tconfig:\n return False\n else:\n text = tconfig['title']\n\n if 'launch_relative' in tconfig:\n launch = CONFIG['app']['SERVER_NAME'] + tconfig['launch_relative']\n elif 'launch_uri' in tconfig:\n launch = tconfig['launch_url']\n else:\n return False\n\n if 'icon_relative' in tconfig:\n icon = CONFIG['app']['SERVER_NAME'] + tconfig['icon_relative']\n elif 'icon_uri' in tconfig:\n icon = tconfig['icon_url']\n else:\n icon = ''\n\n if 'tool_suffix' in CONFIG['app']:\n text += ' ' + CONFIG['app']['tool_suffix']\n\n outconfig = ToolConfig(\n launch_url=launch,\n secure_launch_url=launch,\n title=tconfig['title'],\n extensions={\n 'canvas.instructure.com': {\n 'tool_id':'cu_' + tool,\n 'privacy_level':'public',\n 'course_navigation': {\n 'url': launch,\n 'text': text,\n 'visibility': tconfig['visibility'],\n 'enabled': 'true',\n 'default': 'enabled'\n }\n }\n },\n icon=icon,\n description=tconfig['description'],\n cartridge_bundle='BLTI001_Bundle',\n cartridge_icon='BLTI001_icon'\n )\n outxml = outconfig.to_xml().decode(\"utf-8\")\n if len(outxml) < 40:\n outxml = outxml + '<error>Error creating XML</error>'\n return outxml","def startup():\n menuhook.register(\n \"quickpreview\",\n \"howtos\",\n quickpreview,\n menu=[\"&Scripting\", \"Python3 Development\", \"How To\"],\n text=\"Create a quick preview\",\n tooltip=\"Create a quick preview\")","def create_control():\n os.makedirs('build/DEBIAN', exist_ok=True)\n\n # The description needs to be formatted in a special way.\n description = ''\n for line in textwrap.wrap(qastetray.LONG_DESC, 71):\n description += ' '\n if line:\n description += line\n else:\n description += '.'\n description += '\\n'\n\n data = textwrap.dedent('''\\\n Package: qastetray\n Priority: extra\n Section: net\n Installed-Size: {size}\n Maintainer: {maintainer}\n Architecture: all\n Version: {version}\n Depends: {depends}\n Description: {short_desc}\n {long_desc}\n ''')\n data = data.format(\n size=math.ceil(_get_dir_size('build') / 1024),\n maintainer=qastetray.MAINTAINER,\n version=qastetray.VERSION,\n depends=', '.join(qastetray.DEBIAN_DEPENDS),\n short_desc=qastetray.SHORT_DESC.rstrip('.'),\n long_desc=description,\n )\n with open('build/DEBIAN/control', 'w') as f:\n f.write(data)","def main(verbose, debug, names):\n initialize(debug)\n\n echome(names)\n # click.echo(\"hello\")\n # see\n # https://www.brianthicks.com/post/2014/11/03/build-modular-command-line-tools-with-click/","def toolName(self):\n return QCoreApplication.translate(\"VDLTools\", \"Multiselect\")","def augment_cli(parser):\n\n parser.add_argument(\n \"--with-tox\",\n dest=\"extensions\",\n action=\"append_const\",\n const=extend_project,\n help=\"generate Tox configuration file\")","def __init__(self):\n BuildSystemBase.__init__(self, \"makefile\")","def setup(self):\n ...","def main_menu_toolbar():\n\n pass","def install(self,toolname,adminuser,adminpass):\n\n self.logger.info(\"installing the tool '%s'\" % (toolname))\n\n self.push_admin_install_button(toolname)\n\n self.compile_code(toolname,adminuser,adminpass)\n\n self.flip_tool_status('ToolsStatusUploadedAdminPage',toolname,'Installed')","def setup(self):\n pass","def setup(self):\n pass","def _setup(self):","def _setup(self):","def setup(self):\n\t\tpass","def CreateTool(tool_name, adb):\n if not tool_name:\n return BaseTool()\n\n ctor = TOOL_REGISTRY.get(tool_name)\n if ctor:\n return ctor(adb)\n else:\n print 'Unknown tool %s, available tools: %s' % (\n tool_name, ', '.join(sorted(TOOL_REGISTRY.keys())))\n sys.exit(1)","def setup(self):","def setup(self):","def setup(self):","def setup(self):","def get_setup_text(project_name):\r\n \r\n return \"\"\"\r\ntry:\r\n from setuptools import setup\r\nexcept ImportError:\r\n from distutils.core import setup\r\n\r\nconfig = {\r\n 'description': 'My Project',\r\n 'author': 'My Name',\r\n 'url': 'URL to get it at.',\r\n 'download_url': 'Where to download it.',\r\n 'author_email': 'My email.',\r\n 'version': '0.1',\r\n 'install_requires': ['nose'],\r\n 'packages': ['%s'],\r\n 'scripts': [],\r\n 'name': 'projectname'\r\n}\r\n\r\nsetup(**config)\r\n\"\"\" % project_name","def create_toolbox_button(\n self, action_name: str, icon_name: str, label: str, shortcut: Optional[str]\n ) -> Gtk.Button:\n button = Gtk.ToggleButton.new()\n if Gtk.get_major_version() == 3:\n icon = Gtk.Image.new_from_icon_name(icon_name, Gtk.IconSize.BUTTON)\n button.add(icon)\n else:\n icon = Gtk.Image.new_from_icon_name(icon_name)\n button.set_child(icon)\n button.set_action_name(\"toolbox.select-tool\")\n button.set_action_target_value(GLib.Variant.new_string(action_name))\n button.get_style_context().add_class(\"flat\")\n if label:\n if shortcut:\n if Gtk.get_major_version() == 3:\n a, m = Gtk.accelerator_parse(shortcut)\n else:\n _, a, m = Gtk.accelerator_parse(shortcut)\n button.set_tooltip_text(f\"{label} ({Gtk.accelerator_get_label(a, m)})\")\n else:\n button.set_tooltip_text(f\"{label}\")\n\n # Enable Drag and Drop\n if action_name != \"toolbox-pointer\" and Gtk.get_major_version() == 3:\n button.drag_source_set(\n Gdk.ModifierType.BUTTON1_MASK | Gdk.ModifierType.BUTTON3_MASK,\n self.DND_TARGETS,\n Gdk.DragAction.COPY | Gdk.DragAction.LINK,\n )\n button.drag_source_set_icon_name(icon_name)\n button.connect(\"drag-data-get\", _button_drag_data_get, action_name)\n return button","def _create_setup_py(self, package_name, version, summary, author,\n author_email, class_name):\n return \"\"\"\n #!/usr/bin/env python\n\n from reviewboard.extensions.packaging import setup\n from setuptools import find_packages\n\n\n setup(\n name='%(package_name)s',\n version='%(version)s',\n description=%(description)s,\n author=%(author)s,\n author_email=%(author_email)s,\n packages=find_packages(),\n install_requires=[\n # Your package dependencies go here.\n # Don't include \"ReviewBoard\" in this list.\n ],\n entry_points={\n 'reviewboard.extensions': [\n '%(package_name)s = %(ext_class_path)s',\n ],\n },\n classifiers=[\n # For a full list of package classifiers, see\n # %(classifiers_url)s\n\n 'Development Status :: 3 - Alpha',\n 'Environment :: Web Framework',\n 'Framework :: Review Board',\n 'Operating System :: OS Independent',\n 'Programming Language :: Python',\n ],\n )\n \"\"\" % {\n 'author': self._sanitize_string_for_python(author or\n '<REPLACE ME>'),\n 'author_email': self._sanitize_string_for_python(author_email or\n '<REPLACE ME>'),\n 'classifiers_url':\n 'https://pypi.python.org/pypi?%3Aaction=list_classifiers',\n 'description': self._sanitize_string_for_python(summary or\n '<REPLACE ME>'),\n 'ext_class_path': '%s.extension:%s' % (package_name, class_name),\n 'package_name': package_name,\n 'version': version,\n }","def AddSimpleTool(self, tool_id, label, bitmap, short_help_string=\"\", kind=ITEM_NORMAL):\r\n \r\n return self.AddTool(tool_id, label, bitmap, wx.NullBitmap, kind, short_help_string, \"\", None)","def createCasaTool(mytool):\n if (type(casac.Quantity) != type): # casa 4.x\n myt = mytool()\n else: # casa 3.x\n myt = mytool.create()\n return(myt)","def __init__(self):\n self.ext_folder = ckan_config.get('ckanext.needupdate.ext_folder', '/usr/lib/ckan/default/src')\n self.ext_prefix = ckan_config.get('ckanext.needupdate.ext_folder', 'ckanext-')\n self.ext_sufix = ckan_config.get('ckanext.needupdate.ext_folder', '')","def register_curve_tools(self):\n self.add_tool(SignalStatsTool)\n self.add_tool(AntiAliasingTool)\n self.add_tool(AxisScaleTool)","def configTVassocTool(name,\n tvSGkey,\n tpcSGkey,\n vcSGkey, ):\n\n from JetRecTools.JetRecToolsConf import TrackVertexAssociationTool \n\n toolProperties = dict(\n TrackParticleContainer = tpcSGkey,\n TrackVertexAssociation = tvSGkey,\n VertexContainer = vcSGkey,\n TrackVertexAssoTool = jtm.jetLooseTVAtool,\n )\n\n # Build the tool :\n return TrackVertexAssociationTool(name, **toolProperties)","def quick_test():\n do_command('Help: Command=Help')\n do_command('Help: Command=\"GetInfo\"')\n #do_command('SetPreference: Name=GUI/Theme Value=classic Reload=1')","def init():\n # pylint: disable=too-many-statements\n\n @click.group()\n def top():\n \"\"\"Manage Kerberos tickets.\n \"\"\"\n\n @top.command(name='locker')\n @click.option('--tkt-spool-dir',\n help='Ticket spool directory.')\n @click.option('--trusted', type=(str, str, str),\n help=\"Trusted app (princ, app, tkt1[,tkt2,...])\",\n multiple=True)\n @click.option('--no-register', is_flag=True, default=False,\n help='Do no register in Zookeeper.')\n def locker_cmd(tkt_spool_dir, trusted, no_register):\n \"\"\"Run ticket locker daemon.\"\"\"\n trusted_apps = {}\n for hostname, app, tkts in trusted:\n tkts = list(set(tkts.split(',')))\n _LOGGER.info('Trusted: %s/%s : %r', hostname, app, tkts)\n trusted_apps[(hostname, app)] = tkts\n\n tkt_locker = locker.TicketLocker(\n context.GLOBAL.zk.conn,\n tkt_spool_dir,\n trusted=trusted_apps\n )\n locker.run_server(tkt_locker, register=(not no_register))\n\n @top.command(name='accept')\n @click.option('--tkt-spool-dir',\n help='Ticket spool directory.')\n @click.option('--approot', type=click.Path(exists=True),\n envvar='TREADMILL_APPROOT', required=True)\n @click.option('--port', help='Receiver port.', default=0)\n @click.option('--appname', help='Pseudo app name to use for discovery',\n required=True)\n @click.option('--endpoint', help='Pseudo endpoint to use for discovery',\n default='tickets')\n @click.option('--keytab', help='List of keytabs to merge.',\n multiple=True,\n required=False)\n @click.option('--use-tktrecv', help='Run ticketreceiver protocol.',\n is_flag=True, default=False)\n def accept_cmd(tkt_spool_dir, approot, port, appname, endpoint, keytab,\n use_tktrecv):\n \"\"\"Run ticket locker receiver.\"\"\"\n if keytab:\n _construct_keytab(keytab)\n\n if port == 0:\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n sock.bind(('0.0.0.0', 0))\n port = sock.getsockname()[1]\n sock.close()\n\n hostname = sysinfo.hostname()\n hostport = '%s:%s' % (hostname, port)\n\n endpoint_proid_path = z.path.endpoint_proid(appname)\n acl = context.GLOBAL.zk.conn.make_servers_acl()\n _LOGGER.info(\n 'Ensuring %s exists with ACL %r',\n endpoint_proid_path,\n acl\n )\n zkutils.ensure_exists(\n context.GLOBAL.zk.conn,\n endpoint_proid_path,\n acl=[acl]\n )\n\n endpoint_path = z.path.endpoint(appname, 'tcp', endpoint)\n _LOGGER.info('Registering %s %s', endpoint_path, hostport)\n\n # Need to delete/create endpoints for the disovery to pick it up in\n # case of master restart.\n #\n # Unlike typical endpoint, we cannot make the node ephemeral as we\n # exec into tkt-recv.\n zkutils.ensure_deleted(context.GLOBAL.zk.conn, endpoint_path)\n time.sleep(5)\n zkutils.put(context.GLOBAL.zk.conn, endpoint_path, hostport)\n\n context.GLOBAL.zk.conn.stop()\n\n # TODO: this will publish information about the endpoint state\n # under /discovery. Once discovery is refactored (if it will be)\n # we can remove the \"manual\" zookeeper manipulation.\n tm_env = appenv.AppEnvironment(approot)\n endpoints_mgr = endpoints.EndpointsMgr(tm_env.endpoints_dir)\n endpoints_mgr.unlink_all(\n appname=appname,\n endpoint=endpoint,\n proto='tcp'\n )\n endpoints_mgr.create_spec(\n appname=appname,\n endpoint=endpoint,\n proto='tcp',\n real_port=port,\n pid=os.getpid(),\n port=port,\n owner='/proc/{}'.format(os.getpid()),\n )\n\n if not use_tktrecv:\n subproc.safe_exec(['tkt_recv_v2',\n '-p{}'.format(port),\n '-d{}'.format(tkt_spool_dir)])\n else:\n _LOGGER.info('Running ticket receiver.')\n receiver.run_server(port, tkt_spool_dir)\n\n @top.command(name='monitor')\n @click.option('--tkt-spool-dir', help='Ticket spool directory.',\n required=True)\n @click.option('--scandir', help='Supervisor scan directory.',\n required=True)\n @click.option('--location', help='Location pattern to filter cells.',\n required=False, envvar='TREADMILL_TKTFWD_CELLLOC')\n def monitor_cmd(tkt_spool_dir, scandir, location):\n \"\"\"Configure ticket locker for each cell.\"\"\"\n if location:\n _LOGGER.info('Using location filter: %s', location)\n else:\n _LOGGER.info('No location filter, configuring all cells.')\n\n admin_cell = context.GLOBAL.admin.cell()\n while True:\n for cell in admin_cell.list({}):\n celluser = cell['username']\n cellname = cell['_id']\n celllocation = cell.get('location', '')\n if location and not fnmatch.fnmatch(celllocation, location):\n _LOGGER.info(\n 'Skip cell by location: %s %s', cellname, celllocation\n )\n continue\n\n _configure_locker(tkt_spool_dir, scandir, cellname, celluser)\n\n # TODO: need to stop/remove extra services. For now, extra\n # services are removed on group restart.\n\n supervisor.control_svscan(scandir, (\n supervisor.SvscanControlAction.alarm,\n supervisor.SvscanControlAction.nuke\n ))\n time.sleep(60)\n\n @top.command(name='info')\n @click.option('--tkt-spool-dir', help='Ticket spool directory.',\n required=True)\n @click.option('--tkt-info-dir', help='Ticket info directory.',\n required=True)\n @click.option('--tkt-realms', help='List of supported kerberos realms.',\n required=False, type=cli.LIST)\n def info_cmd(tkt_spool_dir, tkt_info_dir, tkt_realms):\n \"\"\"Monitor tickets and dump ticket info as json file.\"\"\"\n\n realms = krb5.get_host_realm(sysinfo.hostname())\n if tkt_realms:\n realms.extend(tkt_realms)\n\n def _is_valid(princ):\n if princ.startswith('.'):\n return False\n\n for realm in realms:\n if princ.endswith(realm):\n return True\n\n return False\n\n def handle_tkt_event(tkt_file):\n \"\"\"Handle ticket created event.\n \"\"\"\n princ = os.path.basename(tkt_file)\n if not _is_valid(princ):\n return\n\n infofile = os.path.join(tkt_info_dir, princ)\n _LOGGER.info('Processing: %s', princ)\n try:\n os.environ['KRB5CCNAME'] = os.path.join(tkt_spool_dir, princ)\n creds = gssapi.creds.Credentials(usage='initiate')\n with open(infofile, 'wb') as f:\n f.write(json.dumps({\n 'expires_at': int(time.time()) + creds.lifetime\n }).encode())\n except gssapi.raw.GSSError as gss_err:\n fs.rm_safe(infofile)\n finally:\n del os.environ['KRB5CCNAME']\n\n def handle_tkt_delete(tkt_file):\n \"\"\"Delete ticket info.\n \"\"\"\n princ = os.path.basename(tkt_file)\n if not _is_valid(princ):\n return\n\n infofile = os.path.join(tkt_info_dir, princ)\n _LOGGER.info('Deleting: %s', princ)\n fs.rm_safe(infofile)\n\n watch = dirwatch.DirWatcher(tkt_spool_dir)\n watch.on_created = handle_tkt_event\n watch.on_deleted = handle_tkt_delete\n\n for tkt_file in os.listdir(tkt_spool_dir):\n handle_tkt_event(tkt_file)\n\n while True:\n if watch.wait_for_events(timeout=60):\n watch.process_events(max_events=100)\n\n del accept_cmd\n del monitor_cmd\n del locker_cmd\n del info_cmd\n\n return top","def setup(self, optparser):\n\t\tpass","def setup( self ):","def create(self):\n fileserver = servers.get_file_server()\n self.AddLabelTool(\r\n filecmds.ID_New, \r\n \"new\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/new.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL,\n \"New File\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n filecmds.ID_Open, \r\n \"open\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/open.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL,\n \"Open File\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n filecmds.ID_Save, \r\n \"save\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/save.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL,\n \"Save File\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n levelcmds.ID_Save, \r\n \"save level\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/save_level.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL,\n \"Save Level\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n filecmds.ID_SaveAll, \r\n \"saveall\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/saveall.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL,\n \"Save All Files\", \r\n \"\"\r\n )\n self.AddSeparator()\n self.AddLabelTool(\r\n editcmds.ID_Undo, \r\n \"undo\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/undo.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL, \r\n \"Undo\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n editcmds.ID_Redo, \r\n \"redo\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/redo.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ),\r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL, \r\n \"Redo\", \r\n \"\"\r\n )\n self.AddSeparator()\n self.AddLabelTool(\r\n toolscmds.ID_NullTool, \r\n \"null tool\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/null.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Do Nothing Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_SelectObjTool, \r\n \"select object\",\n wx.Bitmap(\r\n fileserver.manglepath(\"outgui:images/tools/select.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Select Object Tool\", \r\n \"\"\r\n )\r\n self.AddLabelTool(\r\n toolscmds.ID_TranslateObjTool, \r\n \"translate object\",\n wx.Bitmap(\r\n fileserver.manglepath(\"outgui:images/tools/translate.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Translate Object Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_RotateObjTool, \r\n \"rotate object\",\n wx.Bitmap(\r\n fileserver.manglepath(\"outgui:images/tools/rotate.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Rotate Object Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_ScaleObjTool, \r\n \"scale object\",\n wx.Bitmap(\r\n fileserver.manglepath(\"outgui:images/tools/scale.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Scale Object Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_PlaceObjTool, \r\n \"place object\",\n wx.Bitmap(\r\n fileserver.manglepath(\"outgui:images/tools/place.bmp\"),\n wx.BITMAP_TYPE_ANY), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Place Object Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_MultiplaceObjTool, \r\n \"multiplace object\",\n wx.Bitmap(\r\n fileserver.manglepath(\"outgui:images/tools/multiplace.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Multiplace Object Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_TrnEditTool, \r\n \"terrain edit\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/terrain_edit.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Terrain Edit Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_WaypointsTool, \r\n \"create waypoints\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/waypoints.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Waypoints Creation Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_CircleTriggerTool, \r\n \"circle triggers\", \r\n wx.Bitmap(\n fileserver.manglepath(\"outgui:images/tools/circle_trigger.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Circle Trigger Creation Tool\", \r\n \"\"\r\n )\n self.AddLabelTool(\r\n toolscmds.ID_PolygonTriggerTool, \r\n \"polygon triggers\", \r\n wx.Bitmap(\n fileserver.manglepath(\r\n \"outgui:images/tools/polygon_trigger.bmp\"\r\n ),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\n \"Polygon Trigger Creation Tool\", \r\n \"\"\r\n )\r\n self.AddLabelTool(\r\n toolscmds.ID_CircleSoundSourceTool, \r\n \"circle sound sources\", \r\n wx.Bitmap(\r\n fileserver.manglepath(\r\n \"outgui:images/tools/circle_sound_source.bmp\"\r\n ),\r\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\r\n \"Circle Sound Source Creation Tool\",\r\n \"\"\r\n )\r\n self.AddLabelTool(\r\n toolscmds.ID_PolygonSoundSourceTool, \r\n \"polygon sound sources\", \r\n wx.Bitmap(\r\n fileserver.manglepath(\r\n \"outgui:images/tools/polygon_sound_source.bmp\"\r\n ),\r\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_RADIO,\r\n \"Polygon Sound Source Creation Tool\",\r\n \"\"\r\n )\r\n self.AddLabelTool(\r\n toolscmds.ID_MeasureTool, \r\n \"measure\", \r\n wx.Bitmap(\n fileserver.manglepath(\r\n \"outgui:images/tools/measure.bmp\"\r\n ),\n wx.BITMAP_TYPE_ANY), \r\n wx.NullBitmap, wx.ITEM_RADIO,\n \"Terrain Distance Measure Tool\", \r\n \"\"\r\n )\r\n self.AddSeparator()\n self.AddLabelTool(\r\n viewcmds.ID_LocalTransform, \r\n \"local/world transform\",\n wx.Bitmap(\r\n fileserver.manglepath(\n \"outgui:images/tools/world_axis.bmp\"\r\n ), \r\n wx.BITMAP_TYPE_ANY\r\n ),\n wx.Bitmap(\r\n fileserver.manglepath(\n \"outgui:images/tools/local_axis.bmp\"\r\n ), \r\n wx.BITMAP_TYPE_ANY\r\n ),\n wx.ITEM_CHECK,\r\n \"Switch between local and world transform\",\r\n \"\"\r\n )\n self.choice_move_mode = wx.Choice(\r\n self, \r\n -1, \r\n choices = [\r\n 'No terrain collision', \r\n 'Terrain collision', \r\n 'Snap to terrain'\r\n ]\r\n )\n self.AddControl( self.choice_move_mode )\n self.choice_selection_mode = wx.Choice(\r\n self, \r\n -1, \r\n choices = [\r\n 'Objects', \r\n 'Subentities', \r\n 'Terrain cells'\r\n ]\r\n )\n self.AddControl( self.choice_selection_mode )\n self.AddLabelTool(\r\n viewcmds.ID_LockSelection, \r\n \"lock selection\",\n wx.Bitmap(\r\n fileserver.manglepath(\r\n \"outgui:images/tools/lock2.bmp\"\r\n ),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_CHECK,\n \"Lock/Unlock current selection\",\r\n \"\"\r\n )\n self.AddSeparator()\n self.AddLabelTool(\r\n debugcmds.ID_ToggleAI, \r\n \"toggle AI\", \r\n wx.Bitmap(\n fileserver.manglepath(\r\n \"outgui:images/tools/ai.bmp\"\r\n ),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_CHECK,\n \"Turn on/off triggers and agents\",\r\n \"\"\r\n )\n self.AddLabelTool(\r\n debugcmds.ID_ToggleSound,\r\n \"toggle sound\",\n wx.Bitmap(\r\n fileserver.manglepath(\r\n \"outgui:images/tools/sound.bmp\"\r\n ),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_CHECK,\n \"Turn on/off the sound sources\",\r\n \"\"\r\n )\n self.AddSeparator()\n self.AddLabelTool(\r\n viewcmds.ID_ObjBrowser, \r\n \"object browser\",\n wx.Bitmap(\r\n fileserver.manglepath(\"outgui:images/tools/browser.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL,\n \"Open an Object Browser\", \r\n \"\"\r\n )\n self.AddSeparator()\n self.AddLabelTool(\r\n toolscmds.ID_WaypointsPathTool, \r\n \"create waypoint paths\", \r\n wx.Bitmap(\r\n fileserver.manglepath(\"outgui:images/tools/waypoints.bmp\"),\n wx.BITMAP_TYPE_ANY\r\n ), \r\n wx.NullBitmap, \r\n wx.ITEM_NORMAL,\n \"Waypoint Paths Creation Tool\", \r\n \"\"\r\n )\n\n # initial state\n self.toggle_axis_transform(True)\n self.choice_move_mode.SetSelection(0)\n self.choice_selection_mode.SetSelection(0)\n\n # bindings\n self.Bind(\r\n wx.EVT_CHOICE, \r\n self.__on_move_mode, \r\n self.choice_move_mode\r\n )\n self.Bind(\r\n wx.EVT_CHOICE, \r\n self.__on_selection_mode, \r\n self.choice_selection_mode\r\n )","def pytest_runtest_setup(item):\n global _widget\n module, line, method = item.location\n module = module.replace('.py', '.')\n title = module + method\n widgets = QApplication.instance().topLevelWidgets()\n for w in widgets:\n w.setWindowTitle(title)\n logging.info(\"------------------- %s -------------------\", title)","def call_toolTips(self):\n self.choose_fold_button.setToolTip(\"Select folder containing the specific test TCReader log files\")\n self.get_test_presets.setToolTip(\"Select the test set points (temperatures that you want statistics for)\")\n self.selectdata_label.setToolTip(\"In this section select the folder with the .csv log files and name the \"\n \"units and TCs you want to analyze.\\n \"\n \"The tool will concatenate all files with the same unit names, so make sure \"\n \"to place only files that you require to analyze.\")\n self.date_sort_checkbox.setToolTip(\"Sort csv log files in respect to time\")\n self.temp_range.setToolTip(\"Temperature range around the set points to be analyzed\")\n self.mean_stdev.setToolTip(\"Add mean and standard deviation of each set point to output\")\n self.max_min.setToolTip(\"Add max and minimum of each set point to output\")\n self.analyze_button.setToolTip(\"Perform analysis and output it to test folder \")","def SetToolPacking(self, packing):\r\n\r\n self._tool_packing = packing","def name(self):\r\n return 'lockdownliveabilitytool'","def setup(self):\n pass","def tool(self):\n tool_type = self.__class__.__module__.split('.')[-1]\n return g.config.tools[tool_type]","def load_hidden_tool( self, config_file, **kwds ):\n tool = self.load_tool( config_file, **kwds )\n self.register_tool( tool )\n return tool"],"string":"[\n \"def setup_toolbox(self, engine_name, task_name, toolbox_name):\\n pass\",\n \"def __init__(self):\\n self.label = \\\"Python ToolBox\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Tool]\",\n \"def __init__(self):\\n self.label = \\\"Create\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n if core.get_pass():\\n self.tools = [Fbound, Roads, Diekdikisi]\\n else:\\n self.tools = []\",\n \"def __init__(self):\\n self.label = \\\"Toolbox\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [FilesWithin, UpdateAiracInfo, CalculatePolygonRotationUTM33, CalculatePolygonRotationLCC10E, SetLayoutsNorAirac, SetLayoutsSweAirac, SetLayoutsFinDnkAirac, Export330charts]\",\n \"def __init__(self):\\r\\n\\t\\tself.label = \\\"Toolbox\\\"\\r\\n\\t\\tself.alias = \\\"\\\"\\r\\n\\r\\n\\t\\t# List of tool classes associated with this toolbox\\r\\n\\t\\tself.tools = [LinkedDataSpatialQuery, LinkedDataPropertyEnrich, MergeBatchNoFunctionalProperty, MergeSingleNoFunctionalProperty, LocationPropertyPath, RelFinder]\",\n \"def main():\\n tbx = Toolbox()\\n tool = FieldName()\\n tool.execute(tool.getParameterInfo(), None)\",\n \"def __init__(self):\\n self.label = \\\"Toolbox\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Offset]\",\n \"def __init__(self):\\n self.label = \\\"Check\\\"\\n self.alias = \\\"Check Shapefiles\\\"\\n\\n # List of tool classes associated with this toolbox\\n if core.get_pass():\\n self.tools = [Dbound, Overlaps, Numbering, Geometry, Roads, Bld]\\n else:\\n self.tools = []\",\n \"def __init__(self):\\r\\n self.label = \\\"Toolbox\\\"\\r\\n self.alias = \\\"Geodesic Densification using arcpy\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [GeodesicDensification_arcpy]\",\n \"def __init__(self):\\n self.label = \\\"CDA Tools\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [SecondaryCraterRemovalTool]\",\n \"def __init__(self):\\n self.label = \\\"Service Downloader\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Edown]\",\n \"def __init__(self):\\n self.label = \\\"Data Assistant\\\"\\n self.alias = \\\"dla\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Append, Stage, NewFile, Preview, Replace]\",\n \"def __init__(self):\\n self.label = \\\"Surface Generation\\\"\\n self.alias = \\\"far77\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [LineToFar77]\",\n \"def __init__(self):\\r\\n self.label = \\\"OVL Tools\\\"\\r\\n self.alias = \\\"\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [OVLtoFeature, BatchOVLtoFeature]\",\n \"def __init__(self):\\r\\n self.label = \\\"Python Toolbox: Floodwater Depth Analysis\\\"\\r\\n self.alias = \\\"\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [FEMAClip, FEMA_BFE, Depth]\",\n \"def __init__(self):\\n self.label = \\\"Change Field Name\\\"\\n self.alias = \\\"Field name\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [FieldName]\",\n \"def setToolTo(*args, **kwargs)->None:\\n pass\",\n \"def __init__(self):\\n self.label = \\\"RAPID Tools\\\"\\n self.alias = \\\"RAPIDTools\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [AddSPTFields,\\n AutomaticRAPIDfileGenerator, \\n CopyDataToServer,\\n CreateNetworkConnectivityFile,\\n CreateNetworkConnectivityFileNHDPlus,\\n CreateMuskingumParameterFiles,\\n CreateMuskingumKFile,\\n CreateMuskingumKfacFile,\\n CreateMuskingumXField, \\n CreateMuskingumXFile, \\n CreateRivIDGageFile, \\n CreateSubsetFile,\\n CreateWeightTableFromWRFGeogrid,\\n CreateInflowFileFromWRFHydroRunoff,\\n CreateWeightTableFromECMWFRunoff,\\n CreateInflowFileFromECMWFRunoff,\\n CreateWeightTableFromLDASRunoff,\\n CreateWeightTableFrom2DLatLonRunoff,\\n CreateDischargeTable,\\n CreateDischargeMap,\\n FlowlineToPoint,\\n DEMtoStreamNetwork,\\n PublishDischargeMap,\\n StreamNetworktoRAPID,\\n StreamNetworktoSPT,\\n UpdateWeightTable,\\n UpdateDischargeMap,\\n ]\",\n \"def __init__(self):\\r\\n self.label = \\\"ProcessAirQuality\\\"\\r\\n self.alias = \\\"ProcessAirQuality\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [AirQuality]\",\n \"def installTools(self, out):\\r\\n # Check that the tool has not been added using its id\\r\\n if not hasattr(self, 'selenium_ft_tool'):\\r\\n addTool = self.manage_addProduct['Selenium'].manage_addTool\\r\\n # Add the tool by its meta_type\\r\\n addTool('Selenium Functional Test Tool')\\r\\n out.write('Successfully added Selenium Functional Test Tool.\\\\n')\",\n \"def __init__(self):\\r\\n self.label = \\\"GEOGRID_STANDALONE\\\"\\r\\n self.alias = \\\"\\\"\\r\\n self.description = \\\"This is a standalone processing tool for WRF-HYDRO.\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [ProcessGeogridFile, ExportGrid, ExamineOutputs, ExportPRJ, GenerateLatLon, DomainShapefile]\",\n \"def __init__(self):\\n \\n self.label = \\\"ArcSDM Tools\\\"\\n self.alias = \\\"ArcSDM\\\" \\n\\n # List of tool classes associated with this toolbox\\n self.tools = [PartitionNNInputFiles, CombineNNOutputFiles, NeuralNetworkOutputFiles, NeuralNetworkInputFiles, \\n CalculateWeightsTool,SiteReductionTool,CategoricalMembershipToool,\\n CategoricalAndReclassTool, TOCFuzzificationTool, CalculateResponse, LogisticRegressionTool, Symbolize, \\n ROCTool, AgterbergChengCITest, AreaFrequencyTable, GetSDMValues, GrandWofe]\",\n \"def tb_add_tool(tb, id, name, img, description):\\n tb.AddTool(id, name, wx.ArtProvider.GetBitmap(img), description)\",\n \"def SetupToolBar( self ):\\n tb = self.CreateToolBar( self.TBFLAGS )\\n tsize = (24,24)\\n tb.ToolBitmapSize = tsize\\n open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize)\\n tb.AddLabelTool(ID_OPEN, \\\"Open\\\", open_bmp, shortHelp=\\\"Open\\\", longHelp=\\\"Open a (c)Profile trace file\\\")\\n tb.AddSeparator()\\n# self.Bind(wx.EVT_TOOL, self.OnOpenFile, id=ID_OPEN)\\n self.rootViewTool = tb.AddLabelTool(\\n ID_ROOT_VIEW, _(\\\"Root View\\\"),\\n wx.ArtProvider.GetBitmap(wx.ART_GO_HOME, wx.ART_TOOLBAR, tsize),\\n shortHelp=_(\\\"Display the root of the current view tree (home view)\\\")\\n )\\n self.rootViewTool = tb.AddLabelTool(\\n ID_BACK_VIEW, _(\\\"Back\\\"), \\n wx.ArtProvider.GetBitmap(wx.ART_GO_BACK, wx.ART_TOOLBAR, tsize),\\n shortHelp=_(\\\"Back to the previously activated node in the call tree\\\")\\n )\\n self.upViewTool = tb.AddLabelTool(\\n ID_UP_VIEW, _(\\\"Up\\\"),\\n wx.ArtProvider.GetBitmap(wx.ART_GO_UP, wx.ART_TOOLBAR, tsize),\\n shortHelp=_(\\\"Go one level up the call tree (highest-percentage parent)\\\")\\n )\\n tb.AddSeparator()\\n # TODO: figure out why the control is sizing the label incorrectly on Linux\\n self.percentageViewTool = wx.CheckBox( tb, -1, _(\\\"Percent \\\") )\\n self.percentageViewTool.SetToolTip( wx.ToolTip(_(\\\"Toggle display of percentages in list views\\\")) )\\n tb.AddControl( self.percentageViewTool )\\n wx.EVT_CHECKBOX( self.percentageViewTool, self.percentageViewTool.GetId(), self.OnPercentageView )\\n \\n self.packageViewTool = wx.CheckBox( tb, -1, _(\\\"File View \\\") )\\n self.packageViewTool.SetToolTip( wx.ToolTip(_(\\\"Switch between call-hierarchy and package/module/function hierarchy\\\")) )\\n tb.AddControl( self.packageViewTool )\\n wx.EVT_CHECKBOX( self.packageViewTool, self.packageViewTool.GetId(), self.OnPackageView )\\n tb.Realize()\",\n \"def __init__(self):\\r\\n\\t\\tself.label = \\\"smart_move\\\"\\r\\n\\t\\tself.alias = \\\"Smart Move Operations\\\"\\r\\n\\r\\n\\t\\t# List of tool classes associated with this toolbox\\r\\n\\t\\tself.tools = [SmartMoveFeatures]\",\n \"def _on_modeling_language_changed(self, event: ModelingLanguageChanged) -> None:\\n toolbox = self.create_toolbox(self.modeling_language.toolbox_definition)\\n if self._toolbox_container:\\n if Gtk.get_major_version() == 3:\\n self._toolbox_container.remove(self._toolbox_container.get_child())\\n self._toolbox_container.add(toolbox)\\n else:\\n self._toolbox_container.set_child(toolbox)\\n self._toolbox = toolbox\",\n \"def __init__(self):\\n self.label = \\\"AlternateUnitBounds_Processing\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [FindMissingBounds, FindUpdatedIMDParks]\",\n \"def register_other_tools(self):\\n self.add_tool(SaveAsTool)\\n self.add_tool(CopyToClipboardTool)\\n self.add_tool(PrintTool)\\n self.add_tool(HelpTool)\",\n \"def __init__(self, toolName):\\n\\t\\tself.toolName = toolName\",\n \"def register_standard_tools(self):\\n t = self.add_tool(SelectTool)\\n self.set_default_tool(t)\\n self.add_tool(RectZoomTool)\\n self.add_tool(BasePlotMenuTool, \\\"item\\\")\\n self.add_tool(ExportItemDataTool)\\n try:\\n import spyderlib.widgets.objecteditor # analysis:ignore\\n self.add_tool(EditItemDataTool)\\n except ImportError:\\n pass\\n self.add_tool(ItemCenterTool)\\n self.add_tool(DeleteItemTool)\\n self.add_separator_tool()\\n self.add_tool(BasePlotMenuTool, \\\"grid\\\")\\n self.add_tool(BasePlotMenuTool, \\\"axes\\\")\\n self.add_tool(DisplayCoordsTool)\\n if self.get_itemlist_panel():\\n self.add_tool(ItemListPanelTool)\",\n \"def initialize(context):\\n\\n content_types, constructors, ftis = atapi.process_types(\\n atapi.listTypes(config.PROJECTNAME),\\n config.PROJECTNAME)\\n\\n for atype, constructor in zip(content_types, constructors):\\n utils.ContentInit('%s: %s' % (config.PROJECTNAME, atype.portal_type),\\n content_types=(atype, ),\\n permission=config.ADD_PERMISSIONS[atype.portal_type],\\n extra_constructors=(constructor,),\\n ).initialize(context)\\n \\n \\n # Import tool\\n ToolInit(\\n '%s Tool' % PROJECTNAME,\\n tools=(PloneAnnuaireTool,),\\n icon='tool.gif').initialize(context)\",\n \"def about ():\\n easygui.textbox(title='About olebrowse', text=__doc__)\",\n \"def get_tools(cls):\\n pass\",\n \"def __init__(self):\\r\\n self.label = \\\"Bulk Layout Text Replace\\\"\\r\\n self.alias = \\\" Jake's Toolbox Alias Property True\\\"\\r\\n self.description = \\\"\\\"\\r\\n self.canRunInBackground = False\",\n \"def test_install(self):\\n\\n\\n adminuser,adminpass = self.testdata.find_account_for('toolmanager')\\n\\n self.utils.account.login_as(adminuser,adminpass)\\n\\n self.contribtool.install(TOOLNAME,adminuser,adminpass)\",\n \"def menu_python_library(self, event=None):\\n self.parentPanel.python_help('lib')\",\n \"def createToolBar(self):\\n pass\",\n \"def cli(ctx, **kwds):\\n invalid = _validate_kwds(kwds)\\n if invalid:\\n ctx.exit(invalid)\\n tool_description = tool_builder.build(**kwds)\\n tool_builder.write_tool_description(ctx, tool_description, **kwds)\",\n \"def test_create(self):\\n\\n adminuser,adminpass = self.testdata.find_account_for('toolmanager')\\n\\n self.utils.account.login_as(adminuser,adminpass)\\n\\n self.contribtool.create(TOOLNAME)\",\n \"def setup(bot):\\n bot.add_cog(Help(bot))\",\n \"def setup(bot: Bot) -> None:\\n bot.add_cog(Help(bot))\",\n \"def __init__(self, windows):\\n super().__init__(self, windows) # this inherits the init from the previous building class\\n self.windows = windows\\n self.workbench = True\\n self.tools = []\",\n \"def _its_tool_ ( self , typename , name = None , interface = None , createIf = True , parent = None ) :\\n if not name :\\n t,s,n = typename.rpartition('/')\\n if t and s and n :\\n typename = t\\n name = n\\n else : name = typename\\n \\n p1 = typename.find ( ':PUBLIC' )\\n if 0 < p1 and p1 + 6 == len(typename) :\\n typename = typename [:p1]\\n \\n itool = GaudiPython.Bindings.Helper.tool ( self._its , typename , name , parent , createIf ) \\n if itool and interface :\\n iif = GaudiPython.Bindings.InterfaceCast(interface)( itool )\\n if not iif : logger.warning(\\\"Can't retrieve proepr interface %s for %s\\\" % ( interface , itool ) )\\n return GaudiPython.Bindings.iAlgTool ( itool.name() , iif )\\n elif not itool : logger.warning(\\\"Can't retrieve the tool %s'%s\\\" % ( typename , name ) )\\n \\n return GaudiPython.Bindings.iAlgTool ( name , itool )\",\n \"def create_analysis_tools(self):\\r\\n raise NotImplementedError()\",\n \"def setUpClass(cls):\\n stu._extract_tk('testtkpy')\",\n \"def setUpClass(cls):\\n stu._extract_tk('testtkpy')\",\n \"def setUpClass(cls):\\n stu._extract_tk('testtkpy')\",\n \"def setUpClass(cls):\\n stu._extract_tk('testtkpy')\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(description=\\\"generateTestStubs\\\")\\n\\n parser.add_argument(\\\"taskFile\\\",\\n help=\\\"Path for assignment file.\\\")\\n\\n args = parser.parse_args()\\n\\n if not os.path.exists(args.taskFile):\\n print(\\\"Task file does not exist.\\\")\\n sys.exit(1)\\n\\n taskMgr = EEWebLPProject()\\n taskMgr.initLP()\\n\\n #taskMgr.listProjects()\\n #taskMgr.loadTree([\\\"project_id=8008922\\\"])\\n tasks = taskMgr.getTasks([\\\"project_id=6890048\\\"],parent_id=8008922)\\n\\n fileByAssignee = taskMgr.getTaskOwners(args.taskFile)\\n taskMgr.updateTaskOwners(fileByAssignee,tasks)\",\n \"def create_tool_bar(self):\\n tb = self.CreateToolBar(wx.TB_DEFAULT_STYLE, wx.ID_ANY, \\\"Main\\\")\\n\\n tb_add_tool(tb, wx.ID_NEW, \\\"New\\\", wx.ART_NEW, \\\"Create a new braille document\\\")\\n tb_add_tool(tb, wx.ID_OPEN, \\\"Import\\\", wx.ART_FILE_OPEN, \\\"Import and convert a print document\\\")\\n tb.AddSeparator()\\n tb_add_tool(tb, wx.ID_SAVE, \\\"Save\\\", wx.ART_FILE_SAVE, \\\"Save the current braille document\\\")\\n tb_add_tool(tb, wx.ID_SAVEAS, \\\"Save As\\\", wx.ART_FILE_SAVE_AS, \\\"Save the current braille document under a new name\\\")\\n tb.AddSeparator()\\n\\n tb_add_tool(tb, wx.ID_UNDO, \\\"Undo\\\", wx.ART_UNDO, \\\"Undo the last operation\\\")\\n tb_add_tool(tb, wx.ID_REDO, \\\"Redo\\\", wx.ART_REDO, \\\"Redo the last operation\\\")\\n tb.AddSeparator()\\n tb_add_tool(tb, wx.ID_CUT, \\\"Cut\\\", wx.ART_CUT, \\\"Move text to the clipboard\\\")\\n tb_add_tool(tb, wx.ID_COPY, \\\"Copy\\\", wx.ART_COPY, \\\"Copy text to the clipboard\\\")\\n tb_add_tool(tb, wx.ID_PASTE, \\\"Copy\\\", wx.ART_PASTE, \\\"Insert text from the clipboard\\\")\\n\\n tb.Realize() # Allow WX to position and size all widgets on the toolbar\\n return tb\",\n \"def create_launcher():\\n data = textwrap.dedent('''\\\\\\n #!/usr/bin/env python3\\n\\n \\\"\\\"\\\"QasteTray launcher.\\\"\\\"\\\"\\n\\n\\n from qastetray.__main__ import main\\n\\n if __name__ == '__main__':\\n main()\\n ''')\\n with open('build/usr/bin/qastetray', 'w') as f:\\n f.write(data)\",\n \"def __tool_name__(cls):\",\n \"def __init__(self, args):\\n # etree.write(stdout, xml_declaration=True, encoding='UTF-8')\\n JsonShell.__init__(self, args)\\n self.args = args\\n tool = etree.Element('tool', id='gatk4_auto_' + self.shell_dict['id'], name=self.shell_dict['name'],\\n version=\\\"@WRAPPER_VERSION@0\\\", profile=self.profile)\\n description = etree.SubElement(tool, 'description')\\n description.text = '- ' + self.shell_dict['description']\\n macros = etree.SubElement(tool, 'macros')\\n macros_imp = etree.SubElement(macros, 'import')\\n macros_imp.text = 'macros.xml'\\n exp_reqs = etree.SubElement(tool, 'expand', macro='requirements')\\n exp_vers = etree.SubElement(tool, 'expand', macro='version_cmd')\\n command = etree.SubElement(tool, 'command', detect_errors='exit_code')\\n command.text = etree.CDATA(self.command_create())\\n\\n # INPUT section\\n self.inputs = etree.SubElement(tool, 'inputs')\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['pre_params']:\\n etree.SubElement(self.inputs, 'expand', macro=entry)\\n self.build_inputs(self.tool_xml, self.inputs, 'param')\\n if self.xml_opt or self.my_xml.tool_data[self.shell_dict['short_name']]['opt_params']:\\n self.opt_sect = etree.SubElement(self.inputs, 'section', name='optional', title='Optional Parameters', expanded='False')\\n self.build_inputs(self.xml_opt, self.opt_sect, 'param')\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['opt_params']:\\n etree.SubElement(self.opt_sect, 'expand', macro=entry)\\n# self.build_inputs(self.xml_opt, self.opt_sect, 'param')\\n\\n if self.xml_adv or self.my_xml.tool_data[self.shell_dict['short_name']]['adv_params']:\\n# self.adv_sect, self.when_yes = self._section_write('advanced', 'Advanced Parameters', 'advanced_sel')\\n self.adv_sect = etree.SubElement(self.inputs, 'section', name='advanced', title='Advanced Parameters', expanded='False')\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['adv_params']:\\n etree.SubElement(self.adv_sect, 'expand', macro=entry)\\n# if not self.args.old_galaxy:\\n self.build_inputs(self.xml_adv, self.adv_sect, 'param')\\n # else:\\n # self.build_inputs(self.xml_adv, self.when_yes, 'param')\\n\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['post_params']:\\n etree.SubElement(self.inputs, 'expand', macro=entry)\\n\\n # Temporary common section to work on macros.\\n if self.xml_comm:\\n# self.comm_sect, self.when_yes = self._section_write('common', 'Common Parameters', 'common_sel')\\n self.comm_sect = etree.SubElement(self.inputs, 'section', name='common', title='Common Parameters', expanded='False')\\n self.build_inputs(self.xml_comm, self.comm_sect, 'param')\\n\\n # OUTPUT section\\n if self.xml_out:\\n# self.output_sect, self.when_yes = self._section_write('output_opt', 'Additional Output Parameters', 'output_opt_sel')\\n if not self.args.old_galaxy:\\n self.output_sect = etree.SubElement(self.inputs, 'section', name='output_opt',\\n title='Additional Output Parameters',\\n expanded='False')\\n self.build_inputs_out_sel(self.xml_out, self.output_sect)\\n else:\\n self.build_inputs_out_sel(self.xml_out, self.inputs)\\n\\n self.outputs = etree.SubElement(tool, 'outputs')\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['output_params']:\\n etree.SubElement(self.outputs, 'expand', macro=entry)\\n self.build_inputs(self.xml_req_out, self.outputs, 'data')\\n self.build_inputs(self.xml_out, self.outputs, 'data', True)\\n\\n tests = etree.SubElement(tool, 'tests')\\n help = etree.SubElement(tool, 'help')\\n help.text = etree.CDATA(self.shell_dict['summary'])\\n citations = etree.SubElement(tool, 'citations')\\n exp_cit = etree.SubElement(citations, 'expand', macro='citations')\\n\\n self.to_write = etree.tostring(tool, pretty_print=True, encoding=\\\"unicode\\\")\",\n \"def setup_dev():\\n setup_general()\",\n \"def setup_make_tool_plugin():\\n arg_parser = argparse.ArgumentParser()\\n arg_parser.add_argument(\\\"--show-tool-output\\\", dest=\\\"show_tool_output\\\",\\n action=\\\"store_false\\\", help=\\\"Show tool output\\\")\\n arg_parser.add_argument('--mapping-file-suffix', dest=\\\"mapping_file_suffix\\\",\\n type=str)\\n\\n resources = Resources([os.path.join(os.path.dirname(statick_tool.__file__),\\n 'plugins')])\\n config = Config(resources.get_file(\\\"config.yaml\\\"))\\n plugin_context = PluginContext(arg_parser.parse_args([]), resources, config)\\n plugin_context.args.output_directory = os.path.dirname(__file__)\\n mtp = MakeToolPlugin()\\n mtp.set_plugin_context(plugin_context)\\n return mtp\",\n \"def tool_config(request):\\n if request.is_secure():\\n host = 'https://' + request.get_host()\\n else:\\n host = 'http://' + request.get_host()\\n\\n url = host + reverse('edx2canvas:lti_launch')\\n\\n lti_tool_config = ToolConfig(\\n title='Add edX Content',\\n launch_url=url,\\n secure_launch_url=url,\\n )\\n account_nav_params = {\\n 'enabled': 'true',\\n 'text': 'Add edX Content',\\n 'visibility': 'admins',\\n }\\n lti_tool_config.set_ext_param('canvas.instructure.com', 'privacy_level', 'public')\\n lti_tool_config.set_ext_param('canvas.instructure.com', 'course_navigation', account_nav_params)\\n lti_tool_config.description = 'Import content from edX to Canvas'\\n\\n return http.HttpResponse(\\n lti_tool_config.to_xml(), content_type='text/xml', status=200\\n )\",\n \"def tool_name(self) -> str:\\n return \\\"BlackbirdOptional\\\"\",\n \"def imports():\\r\\n out_str = \\\"\\\"\\\"\\r\\ntry:\\r\\n import tkinter as tk \\r\\nexcept ImportError:\\r\\n import Tkinter as tk\\r\\nfrom os.path import join\\r\\nimport tempfile\\r\\n\\r\\nimport zipfile\\r\\nimport math\\r\\nfrom pymol import cmd, finish_launching, plugins\\r\\nfrom pymol.cgo import *\\r\\n\\r\\nwd = None\\r\\nfinish_launching()\\r\\n\\\"\\\"\\\"\\r\\n return out_str\",\n \"def runDefine(self):\\n\\n # Select the layers open in the legendInterface and add them to an array\\n layers = self.iface.legendInterface().layers()\\n layer_list = []\\n # Append only Vector (type == 0) to the layer_list\\n for layer in layers:\\n if layer.type() == 0:\\n layer_list.append(layer.name())\\n else:\\n pass\\n # Add layer_list array to listWidget, clear layer if removed to layer in tools\\n self.dlgtool1.listWidget.clear()\\n self.dlgtool1.listWidget.addItems(layer_list)\\n\\n # show the dialog\\n self.dlgtool1.show()\\n # Run the dialog event loop\\n result = self.dlgtool1.exec_()\\n\\n if result:\\n # Do something useful here - delete the line containing pass and\\n # substitute with your code.\\n pass\\n\\n htd = self.dlgtool1.comboBox.currentText()\\n for f in layers:\\n if f.type() != 0:\\n return False\\n temp = self.getCustom(htd, f)\\n if htd != \\\"System\\\":\\n f.setCrs(temp)\",\n \"def on_pre_enter(self):\\r\\n self.ids.alabel.text = \\\"\\\"\\\"[b][size=20]CEToolBox kivy v\\\"\\\"\\\"+ __version__ +\\\"\\\"\\\"[/size][/b]\\\\n\\\"\\\"\\\"\",\n \"def lticonfig(tool):\\n if tool not in CONFIG:\\n return False\\n else:\\n tconfig = CONFIG[tool]\\n\\n if 'title' not in tconfig:\\n return False\\n else:\\n text = tconfig['title']\\n\\n if 'launch_relative' in tconfig:\\n launch = CONFIG['app']['SERVER_NAME'] + tconfig['launch_relative']\\n elif 'launch_uri' in tconfig:\\n launch = tconfig['launch_url']\\n else:\\n return False\\n\\n if 'icon_relative' in tconfig:\\n icon = CONFIG['app']['SERVER_NAME'] + tconfig['icon_relative']\\n elif 'icon_uri' in tconfig:\\n icon = tconfig['icon_url']\\n else:\\n icon = ''\\n\\n if 'tool_suffix' in CONFIG['app']:\\n text += ' ' + CONFIG['app']['tool_suffix']\\n\\n outconfig = ToolConfig(\\n launch_url=launch,\\n secure_launch_url=launch,\\n title=tconfig['title'],\\n extensions={\\n 'canvas.instructure.com': {\\n 'tool_id':'cu_' + tool,\\n 'privacy_level':'public',\\n 'course_navigation': {\\n 'url': launch,\\n 'text': text,\\n 'visibility': tconfig['visibility'],\\n 'enabled': 'true',\\n 'default': 'enabled'\\n }\\n }\\n },\\n icon=icon,\\n description=tconfig['description'],\\n cartridge_bundle='BLTI001_Bundle',\\n cartridge_icon='BLTI001_icon'\\n )\\n outxml = outconfig.to_xml().decode(\\\"utf-8\\\")\\n if len(outxml) < 40:\\n outxml = outxml + '<error>Error creating XML</error>'\\n return outxml\",\n \"def startup():\\n menuhook.register(\\n \\\"quickpreview\\\",\\n \\\"howtos\\\",\\n quickpreview,\\n menu=[\\\"&Scripting\\\", \\\"Python3 Development\\\", \\\"How To\\\"],\\n text=\\\"Create a quick preview\\\",\\n tooltip=\\\"Create a quick preview\\\")\",\n \"def create_control():\\n os.makedirs('build/DEBIAN', exist_ok=True)\\n\\n # The description needs to be formatted in a special way.\\n description = ''\\n for line in textwrap.wrap(qastetray.LONG_DESC, 71):\\n description += ' '\\n if line:\\n description += line\\n else:\\n description += '.'\\n description += '\\\\n'\\n\\n data = textwrap.dedent('''\\\\\\n Package: qastetray\\n Priority: extra\\n Section: net\\n Installed-Size: {size}\\n Maintainer: {maintainer}\\n Architecture: all\\n Version: {version}\\n Depends: {depends}\\n Description: {short_desc}\\n {long_desc}\\n ''')\\n data = data.format(\\n size=math.ceil(_get_dir_size('build') / 1024),\\n maintainer=qastetray.MAINTAINER,\\n version=qastetray.VERSION,\\n depends=', '.join(qastetray.DEBIAN_DEPENDS),\\n short_desc=qastetray.SHORT_DESC.rstrip('.'),\\n long_desc=description,\\n )\\n with open('build/DEBIAN/control', 'w') as f:\\n f.write(data)\",\n \"def main(verbose, debug, names):\\n initialize(debug)\\n\\n echome(names)\\n # click.echo(\\\"hello\\\")\\n # see\\n # https://www.brianthicks.com/post/2014/11/03/build-modular-command-line-tools-with-click/\",\n \"def toolName(self):\\n return QCoreApplication.translate(\\\"VDLTools\\\", \\\"Multiselect\\\")\",\n \"def augment_cli(parser):\\n\\n parser.add_argument(\\n \\\"--with-tox\\\",\\n dest=\\\"extensions\\\",\\n action=\\\"append_const\\\",\\n const=extend_project,\\n help=\\\"generate Tox configuration file\\\")\",\n \"def __init__(self):\\n BuildSystemBase.__init__(self, \\\"makefile\\\")\",\n \"def setup(self):\\n ...\",\n \"def main_menu_toolbar():\\n\\n pass\",\n \"def install(self,toolname,adminuser,adminpass):\\n\\n self.logger.info(\\\"installing the tool '%s'\\\" % (toolname))\\n\\n self.push_admin_install_button(toolname)\\n\\n self.compile_code(toolname,adminuser,adminpass)\\n\\n self.flip_tool_status('ToolsStatusUploadedAdminPage',toolname,'Installed')\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def _setup(self):\",\n \"def _setup(self):\",\n \"def setup(self):\\n\\t\\tpass\",\n \"def CreateTool(tool_name, adb):\\n if not tool_name:\\n return BaseTool()\\n\\n ctor = TOOL_REGISTRY.get(tool_name)\\n if ctor:\\n return ctor(adb)\\n else:\\n print 'Unknown tool %s, available tools: %s' % (\\n tool_name, ', '.join(sorted(TOOL_REGISTRY.keys())))\\n sys.exit(1)\",\n \"def setup(self):\",\n \"def setup(self):\",\n \"def setup(self):\",\n \"def setup(self):\",\n \"def get_setup_text(project_name):\\r\\n \\r\\n return \\\"\\\"\\\"\\r\\ntry:\\r\\n from setuptools import setup\\r\\nexcept ImportError:\\r\\n from distutils.core import setup\\r\\n\\r\\nconfig = {\\r\\n 'description': 'My Project',\\r\\n 'author': 'My Name',\\r\\n 'url': 'URL to get it at.',\\r\\n 'download_url': 'Where to download it.',\\r\\n 'author_email': 'My email.',\\r\\n 'version': '0.1',\\r\\n 'install_requires': ['nose'],\\r\\n 'packages': ['%s'],\\r\\n 'scripts': [],\\r\\n 'name': 'projectname'\\r\\n}\\r\\n\\r\\nsetup(**config)\\r\\n\\\"\\\"\\\" % project_name\",\n \"def create_toolbox_button(\\n self, action_name: str, icon_name: str, label: str, shortcut: Optional[str]\\n ) -> Gtk.Button:\\n button = Gtk.ToggleButton.new()\\n if Gtk.get_major_version() == 3:\\n icon = Gtk.Image.new_from_icon_name(icon_name, Gtk.IconSize.BUTTON)\\n button.add(icon)\\n else:\\n icon = Gtk.Image.new_from_icon_name(icon_name)\\n button.set_child(icon)\\n button.set_action_name(\\\"toolbox.select-tool\\\")\\n button.set_action_target_value(GLib.Variant.new_string(action_name))\\n button.get_style_context().add_class(\\\"flat\\\")\\n if label:\\n if shortcut:\\n if Gtk.get_major_version() == 3:\\n a, m = Gtk.accelerator_parse(shortcut)\\n else:\\n _, a, m = Gtk.accelerator_parse(shortcut)\\n button.set_tooltip_text(f\\\"{label} ({Gtk.accelerator_get_label(a, m)})\\\")\\n else:\\n button.set_tooltip_text(f\\\"{label}\\\")\\n\\n # Enable Drag and Drop\\n if action_name != \\\"toolbox-pointer\\\" and Gtk.get_major_version() == 3:\\n button.drag_source_set(\\n Gdk.ModifierType.BUTTON1_MASK | Gdk.ModifierType.BUTTON3_MASK,\\n self.DND_TARGETS,\\n Gdk.DragAction.COPY | Gdk.DragAction.LINK,\\n )\\n button.drag_source_set_icon_name(icon_name)\\n button.connect(\\\"drag-data-get\\\", _button_drag_data_get, action_name)\\n return button\",\n \"def _create_setup_py(self, package_name, version, summary, author,\\n author_email, class_name):\\n return \\\"\\\"\\\"\\n #!/usr/bin/env python\\n\\n from reviewboard.extensions.packaging import setup\\n from setuptools import find_packages\\n\\n\\n setup(\\n name='%(package_name)s',\\n version='%(version)s',\\n description=%(description)s,\\n author=%(author)s,\\n author_email=%(author_email)s,\\n packages=find_packages(),\\n install_requires=[\\n # Your package dependencies go here.\\n # Don't include \\\"ReviewBoard\\\" in this list.\\n ],\\n entry_points={\\n 'reviewboard.extensions': [\\n '%(package_name)s = %(ext_class_path)s',\\n ],\\n },\\n classifiers=[\\n # For a full list of package classifiers, see\\n # %(classifiers_url)s\\n\\n 'Development Status :: 3 - Alpha',\\n 'Environment :: Web Framework',\\n 'Framework :: Review Board',\\n 'Operating System :: OS Independent',\\n 'Programming Language :: Python',\\n ],\\n )\\n \\\"\\\"\\\" % {\\n 'author': self._sanitize_string_for_python(author or\\n '<REPLACE ME>'),\\n 'author_email': self._sanitize_string_for_python(author_email or\\n '<REPLACE ME>'),\\n 'classifiers_url':\\n 'https://pypi.python.org/pypi?%3Aaction=list_classifiers',\\n 'description': self._sanitize_string_for_python(summary or\\n '<REPLACE ME>'),\\n 'ext_class_path': '%s.extension:%s' % (package_name, class_name),\\n 'package_name': package_name,\\n 'version': version,\\n }\",\n \"def AddSimpleTool(self, tool_id, label, bitmap, short_help_string=\\\"\\\", kind=ITEM_NORMAL):\\r\\n \\r\\n return self.AddTool(tool_id, label, bitmap, wx.NullBitmap, kind, short_help_string, \\\"\\\", None)\",\n \"def createCasaTool(mytool):\\n if (type(casac.Quantity) != type): # casa 4.x\\n myt = mytool()\\n else: # casa 3.x\\n myt = mytool.create()\\n return(myt)\",\n \"def __init__(self):\\n self.ext_folder = ckan_config.get('ckanext.needupdate.ext_folder', '/usr/lib/ckan/default/src')\\n self.ext_prefix = ckan_config.get('ckanext.needupdate.ext_folder', 'ckanext-')\\n self.ext_sufix = ckan_config.get('ckanext.needupdate.ext_folder', '')\",\n \"def register_curve_tools(self):\\n self.add_tool(SignalStatsTool)\\n self.add_tool(AntiAliasingTool)\\n self.add_tool(AxisScaleTool)\",\n \"def configTVassocTool(name,\\n tvSGkey,\\n tpcSGkey,\\n vcSGkey, ):\\n\\n from JetRecTools.JetRecToolsConf import TrackVertexAssociationTool \\n\\n toolProperties = dict(\\n TrackParticleContainer = tpcSGkey,\\n TrackVertexAssociation = tvSGkey,\\n VertexContainer = vcSGkey,\\n TrackVertexAssoTool = jtm.jetLooseTVAtool,\\n )\\n\\n # Build the tool :\\n return TrackVertexAssociationTool(name, **toolProperties)\",\n \"def quick_test():\\n do_command('Help: Command=Help')\\n do_command('Help: Command=\\\"GetInfo\\\"')\\n #do_command('SetPreference: Name=GUI/Theme Value=classic Reload=1')\",\n \"def init():\\n # pylint: disable=too-many-statements\\n\\n @click.group()\\n def top():\\n \\\"\\\"\\\"Manage Kerberos tickets.\\n \\\"\\\"\\\"\\n\\n @top.command(name='locker')\\n @click.option('--tkt-spool-dir',\\n help='Ticket spool directory.')\\n @click.option('--trusted', type=(str, str, str),\\n help=\\\"Trusted app (princ, app, tkt1[,tkt2,...])\\\",\\n multiple=True)\\n @click.option('--no-register', is_flag=True, default=False,\\n help='Do no register in Zookeeper.')\\n def locker_cmd(tkt_spool_dir, trusted, no_register):\\n \\\"\\\"\\\"Run ticket locker daemon.\\\"\\\"\\\"\\n trusted_apps = {}\\n for hostname, app, tkts in trusted:\\n tkts = list(set(tkts.split(',')))\\n _LOGGER.info('Trusted: %s/%s : %r', hostname, app, tkts)\\n trusted_apps[(hostname, app)] = tkts\\n\\n tkt_locker = locker.TicketLocker(\\n context.GLOBAL.zk.conn,\\n tkt_spool_dir,\\n trusted=trusted_apps\\n )\\n locker.run_server(tkt_locker, register=(not no_register))\\n\\n @top.command(name='accept')\\n @click.option('--tkt-spool-dir',\\n help='Ticket spool directory.')\\n @click.option('--approot', type=click.Path(exists=True),\\n envvar='TREADMILL_APPROOT', required=True)\\n @click.option('--port', help='Receiver port.', default=0)\\n @click.option('--appname', help='Pseudo app name to use for discovery',\\n required=True)\\n @click.option('--endpoint', help='Pseudo endpoint to use for discovery',\\n default='tickets')\\n @click.option('--keytab', help='List of keytabs to merge.',\\n multiple=True,\\n required=False)\\n @click.option('--use-tktrecv', help='Run ticketreceiver protocol.',\\n is_flag=True, default=False)\\n def accept_cmd(tkt_spool_dir, approot, port, appname, endpoint, keytab,\\n use_tktrecv):\\n \\\"\\\"\\\"Run ticket locker receiver.\\\"\\\"\\\"\\n if keytab:\\n _construct_keytab(keytab)\\n\\n if port == 0:\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n sock.bind(('0.0.0.0', 0))\\n port = sock.getsockname()[1]\\n sock.close()\\n\\n hostname = sysinfo.hostname()\\n hostport = '%s:%s' % (hostname, port)\\n\\n endpoint_proid_path = z.path.endpoint_proid(appname)\\n acl = context.GLOBAL.zk.conn.make_servers_acl()\\n _LOGGER.info(\\n 'Ensuring %s exists with ACL %r',\\n endpoint_proid_path,\\n acl\\n )\\n zkutils.ensure_exists(\\n context.GLOBAL.zk.conn,\\n endpoint_proid_path,\\n acl=[acl]\\n )\\n\\n endpoint_path = z.path.endpoint(appname, 'tcp', endpoint)\\n _LOGGER.info('Registering %s %s', endpoint_path, hostport)\\n\\n # Need to delete/create endpoints for the disovery to pick it up in\\n # case of master restart.\\n #\\n # Unlike typical endpoint, we cannot make the node ephemeral as we\\n # exec into tkt-recv.\\n zkutils.ensure_deleted(context.GLOBAL.zk.conn, endpoint_path)\\n time.sleep(5)\\n zkutils.put(context.GLOBAL.zk.conn, endpoint_path, hostport)\\n\\n context.GLOBAL.zk.conn.stop()\\n\\n # TODO: this will publish information about the endpoint state\\n # under /discovery. Once discovery is refactored (if it will be)\\n # we can remove the \\\"manual\\\" zookeeper manipulation.\\n tm_env = appenv.AppEnvironment(approot)\\n endpoints_mgr = endpoints.EndpointsMgr(tm_env.endpoints_dir)\\n endpoints_mgr.unlink_all(\\n appname=appname,\\n endpoint=endpoint,\\n proto='tcp'\\n )\\n endpoints_mgr.create_spec(\\n appname=appname,\\n endpoint=endpoint,\\n proto='tcp',\\n real_port=port,\\n pid=os.getpid(),\\n port=port,\\n owner='/proc/{}'.format(os.getpid()),\\n )\\n\\n if not use_tktrecv:\\n subproc.safe_exec(['tkt_recv_v2',\\n '-p{}'.format(port),\\n '-d{}'.format(tkt_spool_dir)])\\n else:\\n _LOGGER.info('Running ticket receiver.')\\n receiver.run_server(port, tkt_spool_dir)\\n\\n @top.command(name='monitor')\\n @click.option('--tkt-spool-dir', help='Ticket spool directory.',\\n required=True)\\n @click.option('--scandir', help='Supervisor scan directory.',\\n required=True)\\n @click.option('--location', help='Location pattern to filter cells.',\\n required=False, envvar='TREADMILL_TKTFWD_CELLLOC')\\n def monitor_cmd(tkt_spool_dir, scandir, location):\\n \\\"\\\"\\\"Configure ticket locker for each cell.\\\"\\\"\\\"\\n if location:\\n _LOGGER.info('Using location filter: %s', location)\\n else:\\n _LOGGER.info('No location filter, configuring all cells.')\\n\\n admin_cell = context.GLOBAL.admin.cell()\\n while True:\\n for cell in admin_cell.list({}):\\n celluser = cell['username']\\n cellname = cell['_id']\\n celllocation = cell.get('location', '')\\n if location and not fnmatch.fnmatch(celllocation, location):\\n _LOGGER.info(\\n 'Skip cell by location: %s %s', cellname, celllocation\\n )\\n continue\\n\\n _configure_locker(tkt_spool_dir, scandir, cellname, celluser)\\n\\n # TODO: need to stop/remove extra services. For now, extra\\n # services are removed on group restart.\\n\\n supervisor.control_svscan(scandir, (\\n supervisor.SvscanControlAction.alarm,\\n supervisor.SvscanControlAction.nuke\\n ))\\n time.sleep(60)\\n\\n @top.command(name='info')\\n @click.option('--tkt-spool-dir', help='Ticket spool directory.',\\n required=True)\\n @click.option('--tkt-info-dir', help='Ticket info directory.',\\n required=True)\\n @click.option('--tkt-realms', help='List of supported kerberos realms.',\\n required=False, type=cli.LIST)\\n def info_cmd(tkt_spool_dir, tkt_info_dir, tkt_realms):\\n \\\"\\\"\\\"Monitor tickets and dump ticket info as json file.\\\"\\\"\\\"\\n\\n realms = krb5.get_host_realm(sysinfo.hostname())\\n if tkt_realms:\\n realms.extend(tkt_realms)\\n\\n def _is_valid(princ):\\n if princ.startswith('.'):\\n return False\\n\\n for realm in realms:\\n if princ.endswith(realm):\\n return True\\n\\n return False\\n\\n def handle_tkt_event(tkt_file):\\n \\\"\\\"\\\"Handle ticket created event.\\n \\\"\\\"\\\"\\n princ = os.path.basename(tkt_file)\\n if not _is_valid(princ):\\n return\\n\\n infofile = os.path.join(tkt_info_dir, princ)\\n _LOGGER.info('Processing: %s', princ)\\n try:\\n os.environ['KRB5CCNAME'] = os.path.join(tkt_spool_dir, princ)\\n creds = gssapi.creds.Credentials(usage='initiate')\\n with open(infofile, 'wb') as f:\\n f.write(json.dumps({\\n 'expires_at': int(time.time()) + creds.lifetime\\n }).encode())\\n except gssapi.raw.GSSError as gss_err:\\n fs.rm_safe(infofile)\\n finally:\\n del os.environ['KRB5CCNAME']\\n\\n def handle_tkt_delete(tkt_file):\\n \\\"\\\"\\\"Delete ticket info.\\n \\\"\\\"\\\"\\n princ = os.path.basename(tkt_file)\\n if not _is_valid(princ):\\n return\\n\\n infofile = os.path.join(tkt_info_dir, princ)\\n _LOGGER.info('Deleting: %s', princ)\\n fs.rm_safe(infofile)\\n\\n watch = dirwatch.DirWatcher(tkt_spool_dir)\\n watch.on_created = handle_tkt_event\\n watch.on_deleted = handle_tkt_delete\\n\\n for tkt_file in os.listdir(tkt_spool_dir):\\n handle_tkt_event(tkt_file)\\n\\n while True:\\n if watch.wait_for_events(timeout=60):\\n watch.process_events(max_events=100)\\n\\n del accept_cmd\\n del monitor_cmd\\n del locker_cmd\\n del info_cmd\\n\\n return top\",\n \"def setup(self, optparser):\\n\\t\\tpass\",\n \"def setup( self ):\",\n \"def create(self):\\n fileserver = servers.get_file_server()\\n self.AddLabelTool(\\r\\n filecmds.ID_New, \\r\\n \\\"new\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/new.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL,\\n \\\"New File\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n filecmds.ID_Open, \\r\\n \\\"open\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/open.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL,\\n \\\"Open File\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n filecmds.ID_Save, \\r\\n \\\"save\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/save.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL,\\n \\\"Save File\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n levelcmds.ID_Save, \\r\\n \\\"save level\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/save_level.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL,\\n \\\"Save Level\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n filecmds.ID_SaveAll, \\r\\n \\\"saveall\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/saveall.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL,\\n \\\"Save All Files\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddSeparator()\\n self.AddLabelTool(\\r\\n editcmds.ID_Undo, \\r\\n \\\"undo\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/undo.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL, \\r\\n \\\"Undo\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n editcmds.ID_Redo, \\r\\n \\\"redo\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/redo.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ),\\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL, \\r\\n \\\"Redo\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddSeparator()\\n self.AddLabelTool(\\r\\n toolscmds.ID_NullTool, \\r\\n \\\"null tool\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/null.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Do Nothing Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_SelectObjTool, \\r\\n \\\"select object\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\\"outgui:images/tools/select.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Select Object Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\r\\n self.AddLabelTool(\\r\\n toolscmds.ID_TranslateObjTool, \\r\\n \\\"translate object\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\\"outgui:images/tools/translate.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Translate Object Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_RotateObjTool, \\r\\n \\\"rotate object\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\\"outgui:images/tools/rotate.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Rotate Object Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_ScaleObjTool, \\r\\n \\\"scale object\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\\"outgui:images/tools/scale.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Scale Object Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_PlaceObjTool, \\r\\n \\\"place object\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\\"outgui:images/tools/place.bmp\\\"),\\n wx.BITMAP_TYPE_ANY), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Place Object Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_MultiplaceObjTool, \\r\\n \\\"multiplace object\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\\"outgui:images/tools/multiplace.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Multiplace Object Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_TrnEditTool, \\r\\n \\\"terrain edit\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/terrain_edit.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Terrain Edit Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_WaypointsTool, \\r\\n \\\"create waypoints\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/waypoints.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Waypoints Creation Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_CircleTriggerTool, \\r\\n \\\"circle triggers\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\\"outgui:images/tools/circle_trigger.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Circle Trigger Creation Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n toolscmds.ID_PolygonTriggerTool, \\r\\n \\\"polygon triggers\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\r\\n \\\"outgui:images/tools/polygon_trigger.bmp\\\"\\r\\n ),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\n \\\"Polygon Trigger Creation Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\r\\n self.AddLabelTool(\\r\\n toolscmds.ID_CircleSoundSourceTool, \\r\\n \\\"circle sound sources\\\", \\r\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\r\\n \\\"outgui:images/tools/circle_sound_source.bmp\\\"\\r\\n ),\\r\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\r\\n \\\"Circle Sound Source Creation Tool\\\",\\r\\n \\\"\\\"\\r\\n )\\r\\n self.AddLabelTool(\\r\\n toolscmds.ID_PolygonSoundSourceTool, \\r\\n \\\"polygon sound sources\\\", \\r\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\r\\n \\\"outgui:images/tools/polygon_sound_source.bmp\\\"\\r\\n ),\\r\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_RADIO,\\r\\n \\\"Polygon Sound Source Creation Tool\\\",\\r\\n \\\"\\\"\\r\\n )\\r\\n self.AddLabelTool(\\r\\n toolscmds.ID_MeasureTool, \\r\\n \\\"measure\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\r\\n \\\"outgui:images/tools/measure.bmp\\\"\\r\\n ),\\n wx.BITMAP_TYPE_ANY), \\r\\n wx.NullBitmap, wx.ITEM_RADIO,\\n \\\"Terrain Distance Measure Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\r\\n self.AddSeparator()\\n self.AddLabelTool(\\r\\n viewcmds.ID_LocalTransform, \\r\\n \\\"local/world transform\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\n \\\"outgui:images/tools/world_axis.bmp\\\"\\r\\n ), \\r\\n wx.BITMAP_TYPE_ANY\\r\\n ),\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\n \\\"outgui:images/tools/local_axis.bmp\\\"\\r\\n ), \\r\\n wx.BITMAP_TYPE_ANY\\r\\n ),\\n wx.ITEM_CHECK,\\r\\n \\\"Switch between local and world transform\\\",\\r\\n \\\"\\\"\\r\\n )\\n self.choice_move_mode = wx.Choice(\\r\\n self, \\r\\n -1, \\r\\n choices = [\\r\\n 'No terrain collision', \\r\\n 'Terrain collision', \\r\\n 'Snap to terrain'\\r\\n ]\\r\\n )\\n self.AddControl( self.choice_move_mode )\\n self.choice_selection_mode = wx.Choice(\\r\\n self, \\r\\n -1, \\r\\n choices = [\\r\\n 'Objects', \\r\\n 'Subentities', \\r\\n 'Terrain cells'\\r\\n ]\\r\\n )\\n self.AddControl( self.choice_selection_mode )\\n self.AddLabelTool(\\r\\n viewcmds.ID_LockSelection, \\r\\n \\\"lock selection\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\r\\n \\\"outgui:images/tools/lock2.bmp\\\"\\r\\n ),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_CHECK,\\n \\\"Lock/Unlock current selection\\\",\\r\\n \\\"\\\"\\r\\n )\\n self.AddSeparator()\\n self.AddLabelTool(\\r\\n debugcmds.ID_ToggleAI, \\r\\n \\\"toggle AI\\\", \\r\\n wx.Bitmap(\\n fileserver.manglepath(\\r\\n \\\"outgui:images/tools/ai.bmp\\\"\\r\\n ),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_CHECK,\\n \\\"Turn on/off triggers and agents\\\",\\r\\n \\\"\\\"\\r\\n )\\n self.AddLabelTool(\\r\\n debugcmds.ID_ToggleSound,\\r\\n \\\"toggle sound\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\r\\n \\\"outgui:images/tools/sound.bmp\\\"\\r\\n ),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_CHECK,\\n \\\"Turn on/off the sound sources\\\",\\r\\n \\\"\\\"\\r\\n )\\n self.AddSeparator()\\n self.AddLabelTool(\\r\\n viewcmds.ID_ObjBrowser, \\r\\n \\\"object browser\\\",\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\\"outgui:images/tools/browser.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL,\\n \\\"Open an Object Browser\\\", \\r\\n \\\"\\\"\\r\\n )\\n self.AddSeparator()\\n self.AddLabelTool(\\r\\n toolscmds.ID_WaypointsPathTool, \\r\\n \\\"create waypoint paths\\\", \\r\\n wx.Bitmap(\\r\\n fileserver.manglepath(\\\"outgui:images/tools/waypoints.bmp\\\"),\\n wx.BITMAP_TYPE_ANY\\r\\n ), \\r\\n wx.NullBitmap, \\r\\n wx.ITEM_NORMAL,\\n \\\"Waypoint Paths Creation Tool\\\", \\r\\n \\\"\\\"\\r\\n )\\n\\n # initial state\\n self.toggle_axis_transform(True)\\n self.choice_move_mode.SetSelection(0)\\n self.choice_selection_mode.SetSelection(0)\\n\\n # bindings\\n self.Bind(\\r\\n wx.EVT_CHOICE, \\r\\n self.__on_move_mode, \\r\\n self.choice_move_mode\\r\\n )\\n self.Bind(\\r\\n wx.EVT_CHOICE, \\r\\n self.__on_selection_mode, \\r\\n self.choice_selection_mode\\r\\n )\",\n \"def pytest_runtest_setup(item):\\n global _widget\\n module, line, method = item.location\\n module = module.replace('.py', '.')\\n title = module + method\\n widgets = QApplication.instance().topLevelWidgets()\\n for w in widgets:\\n w.setWindowTitle(title)\\n logging.info(\\\"------------------- %s -------------------\\\", title)\",\n \"def call_toolTips(self):\\n self.choose_fold_button.setToolTip(\\\"Select folder containing the specific test TCReader log files\\\")\\n self.get_test_presets.setToolTip(\\\"Select the test set points (temperatures that you want statistics for)\\\")\\n self.selectdata_label.setToolTip(\\\"In this section select the folder with the .csv log files and name the \\\"\\n \\\"units and TCs you want to analyze.\\\\n \\\"\\n \\\"The tool will concatenate all files with the same unit names, so make sure \\\"\\n \\\"to place only files that you require to analyze.\\\")\\n self.date_sort_checkbox.setToolTip(\\\"Sort csv log files in respect to time\\\")\\n self.temp_range.setToolTip(\\\"Temperature range around the set points to be analyzed\\\")\\n self.mean_stdev.setToolTip(\\\"Add mean and standard deviation of each set point to output\\\")\\n self.max_min.setToolTip(\\\"Add max and minimum of each set point to output\\\")\\n self.analyze_button.setToolTip(\\\"Perform analysis and output it to test folder \\\")\",\n \"def SetToolPacking(self, packing):\\r\\n\\r\\n self._tool_packing = packing\",\n \"def name(self):\\r\\n return 'lockdownliveabilitytool'\",\n \"def setup(self):\\n pass\",\n \"def tool(self):\\n tool_type = self.__class__.__module__.split('.')[-1]\\n return g.config.tools[tool_type]\",\n \"def load_hidden_tool( self, config_file, **kwds ):\\n tool = self.load_tool( config_file, **kwds )\\n self.register_tool( tool )\\n return tool\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8001657","0.76821536","0.7338371","0.7278725","0.7259962","0.7148503","0.7061571","0.67234725","0.66628635","0.6649481","0.6587418","0.6583463","0.65043044","0.64949065","0.6422432","0.6311597","0.62550175","0.62525314","0.62455046","0.6217126","0.6120763","0.61155814","0.6031775","0.6025028","0.60111755","0.59465736","0.59463745","0.5938488","0.586648","0.5795218","0.57449067","0.5744322","0.57164335","0.5697251","0.56130004","0.5553672","0.5498054","0.5486646","0.5450893","0.54423684","0.5440952","0.54195726","0.54149884","0.54053515","0.5390809","0.5390809","0.5390809","0.5390809","0.5381744","0.53687423","0.53595984","0.5352485","0.5347902","0.53339714","0.5325162","0.5318457","0.5315499","0.5299451","0.5287579","0.52633196","0.5257381","0.5227109","0.52242136","0.52226293","0.52220297","0.5211222","0.5208111","0.5203312","0.51988","0.51981676","0.5192859","0.5192859","0.5183327","0.5183327","0.51825476","0.5180386","0.5173992","0.5173992","0.5173992","0.5173992","0.51710045","0.5166073","0.5154436","0.51413995","0.51324457","0.51282763","0.51277566","0.51276803","0.512699","0.5117973","0.51127756","0.5112158","0.5111727","0.51107734","0.5105335","0.5102189","0.5097545","0.5093802","0.5093356","0.50860614"],"string":"[\n \"0.8001657\",\n \"0.76821536\",\n \"0.7338371\",\n \"0.7278725\",\n \"0.7259962\",\n \"0.7148503\",\n \"0.7061571\",\n \"0.67234725\",\n \"0.66628635\",\n \"0.6649481\",\n \"0.6587418\",\n \"0.6583463\",\n \"0.65043044\",\n \"0.64949065\",\n \"0.6422432\",\n \"0.6311597\",\n \"0.62550175\",\n \"0.62525314\",\n \"0.62455046\",\n \"0.6217126\",\n \"0.6120763\",\n \"0.61155814\",\n \"0.6031775\",\n \"0.6025028\",\n \"0.60111755\",\n \"0.59465736\",\n \"0.59463745\",\n \"0.5938488\",\n \"0.586648\",\n \"0.5795218\",\n \"0.57449067\",\n \"0.5744322\",\n \"0.57164335\",\n \"0.5697251\",\n \"0.56130004\",\n \"0.5553672\",\n \"0.5498054\",\n \"0.5486646\",\n \"0.5450893\",\n \"0.54423684\",\n \"0.5440952\",\n \"0.54195726\",\n \"0.54149884\",\n \"0.54053515\",\n \"0.5390809\",\n \"0.5390809\",\n \"0.5390809\",\n \"0.5390809\",\n \"0.5381744\",\n \"0.53687423\",\n \"0.53595984\",\n \"0.5352485\",\n \"0.5347902\",\n \"0.53339714\",\n \"0.5325162\",\n \"0.5318457\",\n \"0.5315499\",\n \"0.5299451\",\n \"0.5287579\",\n \"0.52633196\",\n \"0.5257381\",\n \"0.5227109\",\n \"0.52242136\",\n \"0.52226293\",\n \"0.52220297\",\n \"0.5211222\",\n \"0.5208111\",\n \"0.5203312\",\n \"0.51988\",\n \"0.51981676\",\n \"0.5192859\",\n \"0.5192859\",\n \"0.5183327\",\n \"0.5183327\",\n \"0.51825476\",\n \"0.5180386\",\n \"0.5173992\",\n \"0.5173992\",\n \"0.5173992\",\n \"0.5173992\",\n \"0.51710045\",\n \"0.5166073\",\n \"0.5154436\",\n \"0.51413995\",\n \"0.51324457\",\n \"0.51282763\",\n \"0.51277566\",\n \"0.51276803\",\n \"0.512699\",\n \"0.5117973\",\n \"0.51127756\",\n \"0.5112158\",\n \"0.5111727\",\n \"0.51107734\",\n \"0.5105335\",\n \"0.5102189\",\n \"0.5097545\",\n \"0.5093802\",\n \"0.5093356\",\n \"0.50860614\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64769334"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":77697,"cells":{"query":{"kind":"string","value":"Define the tool (tool name is the name of the class)."},"document":{"kind":"string","value":"def __init__(self):\n self.label = \"Ending Point\"\n self.description = \"This tool calculates the final point given\" + \\\n \"the initial point, range and bearing.\"\n self.canRunInBackground = False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, toolName):\n\t\tself.toolName = toolName","def __init__(self):\n self.label = \"Create\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n if core.get_pass():\n self.tools = [Fbound, Roads, Diekdikisi]\n else:\n self.tools = []","def __tool_name__(cls):","def __init__(self):\n self.label = \"Python ToolBox\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Tool]","def CreateTool(tool_name, adb):\n if not tool_name:\n return BaseTool()\n\n ctor = TOOL_REGISTRY.get(tool_name)\n if ctor:\n return ctor(adb)\n else:\n print 'Unknown tool %s, available tools: %s' % (\n tool_name, ', '.join(sorted(TOOL_REGISTRY.keys())))\n sys.exit(1)","def tool(self, tool_cls, *args, options={}, **kwargs):\n tool_options = self.OPTIONS.copy()\n tool_options.update(options)\n\n tool_instance = tool_cls(\n *args,\n flags=self.FLAGS,\n bin_dir=self.BIN_DIR,\n HHLIB=self.HHLIB,\n options=tool_options,\n **kwargs)\n tool_instance.tool = unittest.mock.MagicMock()\n return tool_instance","def __init__(self):\n self.label = \"Toolbox\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Offset]","def __init__(self):\n self.label = \"Surface Generation\"\n self.alias = \"far77\"\n\n # List of tool classes associated with this toolbox\n self.tools = [LineToFar77]","def __init__(self):\n self.label = \"CDA Tools\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [SecondaryCraterRemovalTool]","def __init__(self):\n self.label = \"Check\"\n self.alias = \"Check Shapefiles\"\n\n # List of tool classes associated with this toolbox\n if core.get_pass():\n self.tools = [Dbound, Overlaps, Numbering, Geometry, Roads, Bld]\n else:\n self.tools = []","def setToolTo(*args, **kwargs)->None:\n pass","def __init__(self):\n self.label = \"Data Assistant\"\n self.alias = \"dla\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Append, Stage, NewFile, Preview, Replace]","def __init__(self):\n self.label = \"Toolbox\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [FilesWithin, UpdateAiracInfo, CalculatePolygonRotationUTM33, CalculatePolygonRotationLCC10E, SetLayoutsNorAirac, SetLayoutsSweAirac, SetLayoutsFinDnkAirac, Export330charts]","def __init__(self):\r\n\t\tself.label = \"Toolbox\"\r\n\t\tself.alias = \"\"\r\n\r\n\t\t# List of tool classes associated with this toolbox\r\n\t\tself.tools = [LinkedDataSpatialQuery, LinkedDataPropertyEnrich, MergeBatchNoFunctionalProperty, MergeSingleNoFunctionalProperty, LocationPropertyPath, RelFinder]","def __init__(self):\r\n self.label = \"Python Toolbox: Floodwater Depth Analysis\"\r\n self.alias = \"\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [FEMAClip, FEMA_BFE, Depth]","def add_tool(self, ToolKlass, *args, **kwargs):\n if self._first_tool_flag:\n # This is the very first tool to be added to this manager\n self._first_tool_flag = False\n self.configure_panels()\n tool = ToolKlass(self, *args, **kwargs)\n self.tools.append(tool)\n for plot in list(self.plots.values()):\n tool.register_plot(plot)\n if len(self.tools) == 1:\n self.default_tool = tool\n return tool","def __init__(self):\n self.label = \"PFRR Tools\"\n self.alias = \"PFRR Tools\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Ending_Point, Range_Distance, PFRR]","def __init__(self):\r\n self.label = \"Toolbox\"\r\n self.alias = \"Geodesic Densification using arcpy\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [GeodesicDensification_arcpy]","def __init__(self):\n self.label = \"Service Downloader\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Edown]","def __init__(self):\n \n self.label = \"ArcSDM Tools\"\n self.alias = \"ArcSDM\" \n\n # List of tool classes associated with this toolbox\n self.tools = [PartitionNNInputFiles, CombineNNOutputFiles, NeuralNetworkOutputFiles, NeuralNetworkInputFiles, \n CalculateWeightsTool,SiteReductionTool,CategoricalMembershipToool,\n CategoricalAndReclassTool, TOCFuzzificationTool, CalculateResponse, LogisticRegressionTool, Symbolize, \n ROCTool, AgterbergChengCITest, AreaFrequencyTable, GetSDMValues, GrandWofe]","def __init__(self):\r\n self.label = \"ProcessAirQuality\"\r\n self.alias = \"ProcessAirQuality\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [AirQuality]","def __init__(self):\r\n self.label = \"OVL Tools\"\r\n self.alias = \"\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [OVLtoFeature, BatchOVLtoFeature]","def calrissian_make_tool(spec, loadingContext):\n if \"class\" in spec and spec[\"class\"] == \"CommandLineTool\":\n return CalrissianCommandLineTool(spec, loadingContext)\n else:\n return default_make_tool(spec, loadingContext)","def tool(self):\n tool_type = self.__class__.__module__.split('.')[-1]\n return g.config.tools[tool_type]","def get_tools(cls):\n pass","def register_tool(cls, tool_name: str, reset_function):\n if tool_name in cls.TOOLS:\n raise PedalToolAlreadyRegistered(tool_name)\n cls.TOOLS[tool_name] = ToolRegistration(tool_name, reset_function)","def __init__(self):\n self.label = \"RAPID Tools\"\n self.alias = \"RAPIDTools\"\n\n # List of tool classes associated with this toolbox\n self.tools = [AddSPTFields,\n AutomaticRAPIDfileGenerator, \n CopyDataToServer,\n CreateNetworkConnectivityFile,\n CreateNetworkConnectivityFileNHDPlus,\n CreateMuskingumParameterFiles,\n CreateMuskingumKFile,\n CreateMuskingumKfacFile,\n CreateMuskingumXField, \n CreateMuskingumXFile, \n CreateRivIDGageFile, \n CreateSubsetFile,\n CreateWeightTableFromWRFGeogrid,\n CreateInflowFileFromWRFHydroRunoff,\n CreateWeightTableFromECMWFRunoff,\n CreateInflowFileFromECMWFRunoff,\n CreateWeightTableFromLDASRunoff,\n CreateWeightTableFrom2DLatLonRunoff,\n CreateDischargeTable,\n CreateDischargeMap,\n FlowlineToPoint,\n DEMtoStreamNetwork,\n PublishDischargeMap,\n StreamNetworktoRAPID,\n StreamNetworktoSPT,\n UpdateWeightTable,\n UpdateDischargeMap,\n ]","def tool(self):\n if self._tool is None:\n return SE3()\n else:\n return self._tool","def build_tool(self, doc, entity):\n match = self.tool_re.match(entity)\n if match and validations.validate_tool_name(match.group(self.TOOL_NAME_GROUP)):\n name = match.group(self.TOOL_NAME_GROUP)\n return creationinfo.Tool(name)\n else:\n raise SPDXValueError('Failed to extract tool name')","def register_other_tools(self):\n self.add_tool(SaveAsTool)\n self.add_tool(CopyToClipboardTool)\n self.add_tool(PrintTool)\n self.add_tool(HelpTool)","def setup_toolbox(self, engine_name, task_name, toolbox_name):\n pass","def __init__(self):\r\n\t\tself.label = \"smart_move\"\r\n\t\tself.alias = \"Smart Move Operations\"\r\n\r\n\t\t# List of tool classes associated with this toolbox\r\n\t\tself.tools = [SmartMoveFeatures]","def tool(self):\n return self._tool","def __init__(self):\n self.label = \"Change Field Name\"\n self.alias = \"Field name\"\n\n # List of tool classes associated with this toolbox\n self.tools = [FieldName]","def get_tool(self, name, parameters, version=None):\n # TODO: use the version\n if version is not None:\n logging.warn(\"Tool versions not yet supported\")\n\n tool_class = self.get_tool_class(name)\n\n # Check that the number of arguments is correct for this tool\n arg_spec = inspect.getargspec(tool_class.__init__)\n max_expected = len(arg_spec[0])\n if arg_spec.defaults:\n min_expected = max_expected - len(arg_spec.defaults)\n else:\n min_expected = max_expected\n num_parameters = len(parameters) if parameters is not None else 0\n if not (min_expected <= num_parameters + 1 <= max_expected):\n message = \"Tool {} takes between {} and {} arguments ({} given)\".format(\n tool_class.__name__, min_expected, max_expected, num_parameters + 1)\n raise ToolInitialisationError(message)\n\n # Instantiate tool\n try:\n tool = tool_class(**parameters) if parameters is not None else tool_class()\n except TypeError:\n raise ToolInitialisationError(name, parameters)\n\n if not tool:\n raise ToolNotFoundError(name, parameters)\n\n tool.name = name\n\n return tool","def register_standard_tools(self):\n t = self.add_tool(SelectTool)\n self.set_default_tool(t)\n self.add_tool(RectZoomTool)\n self.add_tool(BasePlotMenuTool, \"item\")\n self.add_tool(ExportItemDataTool)\n try:\n import spyderlib.widgets.objecteditor # analysis:ignore\n self.add_tool(EditItemDataTool)\n except ImportError:\n pass\n self.add_tool(ItemCenterTool)\n self.add_tool(DeleteItemTool)\n self.add_separator_tool()\n self.add_tool(BasePlotMenuTool, \"grid\")\n self.add_tool(BasePlotMenuTool, \"axes\")\n self.add_tool(DisplayCoordsTool)\n if self.get_itemlist_panel():\n self.add_tool(ItemListPanelTool)","def cli(ctx, **kwds):\n invalid = _validate_kwds(kwds)\n if invalid:\n ctx.exit(invalid)\n tool_description = tool_builder.build(**kwds)\n tool_builder.write_tool_description(ctx, tool_description, **kwds)","def get_tool(cls, tool_name):\n if cls.tool_dict is None:\n # Init the module_dict once.\n cls.tool_dict = {tool.name: tool for tool in cls.get_pb().tools}\n return cls.tool_dict.get(tool_name)","def __init__(self):\r\n self.label = \"GEOGRID_STANDALONE\"\r\n self.alias = \"\"\r\n self.description = \"This is a standalone processing tool for WRF-HYDRO.\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [ProcessGeogridFile, ExportGrid, ExamineOutputs, ExportPRJ, GenerateLatLon, DomainShapefile]","def _its_tool_ ( self , typename , name = None , interface = None , createIf = True , parent = None ) :\n if not name :\n t,s,n = typename.rpartition('/')\n if t and s and n :\n typename = t\n name = n\n else : name = typename\n \n p1 = typename.find ( ':PUBLIC' )\n if 0 < p1 and p1 + 6 == len(typename) :\n typename = typename [:p1]\n \n itool = GaudiPython.Bindings.Helper.tool ( self._its , typename , name , parent , createIf ) \n if itool and interface :\n iif = GaudiPython.Bindings.InterfaceCast(interface)( itool )\n if not iif : logger.warning(\"Can't retrieve proepr interface %s for %s\" % ( interface , itool ) )\n return GaudiPython.Bindings.iAlgTool ( itool.name() , iif )\n elif not itool : logger.warning(\"Can't retrieve the tool %s'%s\" % ( typename , name ) )\n \n return GaudiPython.Bindings.iAlgTool ( name , itool )","def set_active_tool(self, tool=None):\n self.active_tool = tool","def __init__(self):\n self.label = \"AlternateUnitBounds_Processing\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [FindMissingBounds, FindUpdatedIMDParks]","def installTools(self, out):\r\n # Check that the tool has not been added using its id\r\n if not hasattr(self, 'selenium_ft_tool'):\r\n addTool = self.manage_addProduct['Selenium'].manage_addTool\r\n # Add the tool by its meta_type\r\n addTool('Selenium Functional Test Tool')\r\n out.write('Successfully added Selenium Functional Test Tool.\\n')","def main():\n tbx = Toolbox()\n tool = FieldName()\n tool.execute(tool.getParameterInfo(), None)","def on_tool(self):\n if self.tmFile is not None:\n self.log.info(\"Launch tool %s\" % self.pItem.itemName)\n toolMngrCmds.launchTools(self.pItem.itemName, self.tmFile, self.log.level)","def tb_add_tool(tb, id, name, img, description):\n tb.AddTool(id, name, wx.ArtProvider.GetBitmap(img), description)","def get_tool(self, ToolKlass):\n for tool in self.tools:\n if isinstance(tool, ToolKlass):\n return tool","def __setitem__(self, tool_name, value):\n self._tool_data[tool_name] = value","def __init__( self, config_filenames, tool_root_dir, app, tool_conf_watcher=None ):\n # The _dynamic_tool_confs list contains dictionaries storing\n # information about the tools defined in each shed-related\n # shed_tool_conf.xml file.\n self._dynamic_tool_confs = []\n self._tools_by_id = {}\n self._integrated_section_by_tool = {}\n # Tool lineages can contain chains of related tools with different ids\n # so each will be present once in the above dictionary. The following\n # dictionary can instead hold multiple tools with different versions.\n self._tool_versions_by_id = {}\n self._workflows_by_id = {}\n # In-memory dictionary that defines the layout of the tool panel.\n self._tool_panel = ToolPanelElements()\n self._index = 0\n self.data_manager_tools = odict()\n self._lineage_map = LineageMap( app )\n # Sets self._integrated_tool_panel and self._integrated_tool_panel_config_has_contents\n self._init_integrated_tool_panel( app.config )\n # The following refers to the tool_path config setting for backward compatibility. The shed-related\n # (e.g., shed_tool_conf.xml) files include the tool_path attribute within the <toolbox> tag.\n self._tool_root_dir = tool_root_dir\n self.app = app\n self._tool_watcher = get_tool_watcher( self, app.config )\n if tool_conf_watcher:\n self._tool_conf_watcher = tool_conf_watcher # Avoids (re-)starting threads in uwsgi\n else:\n self._tool_conf_watcher = get_tool_conf_watcher(lambda: self.handle_reload_toolbox())\n self._filter_factory = FilterFactory( self )\n self._tool_tag_manager = tool_tag_manager( app )\n self._init_tools_from_configs( config_filenames )\n if self.app.name == 'galaxy' and self._integrated_tool_panel_config_has_contents:\n # Load self._tool_panel based on the order in self._integrated_tool_panel.\n self._load_tool_panel()\n self._save_integrated_tool_panel()","def createCasaTool(mytool):\n if (type(casac.Quantity) != type): # casa 4.x\n myt = mytool()\n else: # casa 3.x\n myt = mytool.create()\n return(myt)","def _add_comment_tool(self, tool):\r\n \r\n existing = self.tools.get(tool.number)\r\n if existing and existing.plated == None:\r\n existing.plated = tool.plated\r\n \r\n self.comment_tools[tool.number] = tool","def create_analysis_tools(self):\r\n raise NotImplementedError()","def SetToolId(self, id):\r\n\r\n self.tool_id = id","def load_hidden_tool( self, config_file, **kwds ):\n tool = self.load_tool( config_file, **kwds )\n self.register_tool( tool )\n return tool","def main():\n\n parser = get_populated_argparser()\n cli_dict = generate_cli_dictionary()\n\n # Parse arguments.\n if len(sys.argv) > 1:\n args = parser.parse_args(sys.argv[1:])\n\n # Validate arguments.\n args = cli_dict[args.tool].validate_args(args)\n\n # Run the tool.\n cli_dict[args.tool].run(args)\n\n else:\n\n parser.print_help()","def AddSimpleTool(self, tool_id, label, bitmap, short_help_string=\"\", kind=ITEM_NORMAL):\r\n \r\n return self.AddTool(tool_id, label, bitmap, wx.NullBitmap, kind, short_help_string, \"\", None)","def tool(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"tool\")","def get_tool(tool_name: str, project_dir: Union[str, os.PathLike]):\n valid_tools = {\n Judy.name: Judy(project_dir),\n Jumble.name: Jumble(project_dir),\n Major.name: Major(project_dir),\n Pit.name: Pit(project_dir),\n }\n if tool_name not in valid_tools.keys():\n msg = f\"Invalid tool provided: {tool_name}. Valid tools are {list(valid_tools.keys())}\"\n logger.error(msg)\n raise ValueError(msg)\n\n return valid_tools[tool_name]","def mgmt_tool(self, mgmt_tool: MgmtClient):\n self._mgmt_tool = mgmt_tool","def main(args):\n\n tools = []\n for tool in args.tools: # Parse tools, their subs and args\n logging.info(\"Parsing tool: %r\", tool)\n\n tsig = parse_tool_sig(tool)\n if not tsig or not tsig.get(\"snames\", None):\n logging.error(\"failed parsing snames from tool: '%s'\", tool)\n continue\n\n tools.append(tsig)\n\n return args.gen(args, tools)","def setTool(self):\n self.canvas().setMapTool(self)","def register_curve_tools(self):\n self.add_tool(SignalStatsTool)\n self.add_tool(AntiAliasingTool)\n self.add_tool(AxisScaleTool)","def create_refactoring_tool(self, fixer_names):\n return refactor.RefactoringTool(fixer_names)","def name(self):\r\n return 'lockdownliveabilitytool'","def add_tool(self, sut, tool, timeout):\n\n if tool.install_type == 'basic_install':\n self._tests.append(BasicInstaller(tool, sut, timeout))\n elif tool.install_type == 'msi_install':\n self._tests.append(MSIInstaller(tool, sut, timeout))\n elif tool.install_type == 'no_install':\n pass\n else:\n raise CoreError('The install_type \"{0}\" for tool \"{1}\" '\n 'is unsupported!'.format(tool.install_type, tool.name))","def __init__(self, name=\"Tester\"): \n # Call base constructor to set up app state, registry and add default params.\n super(Tester, self).__init__(name)\n\n # Add arguments are related to the basic ``Tester``.\n self.parser.add_argument('--visualize',\n action='store_true',\n dest='visualize',\n help='Activate dynamic visualization')","def default_cmdclass():\n return {'build_script': SetupCommandBuildScript,\n 'build_sphinx': SetupCommandSphinx,\n 'clean_space': SetupCommandCleanSpace,\n 'display': SetupCommandDisplay,\n 'history': SetupCommandHistory,\n 'lab': SetupCommandLab,\n 'local_jenkins': SetupCommandLocalJenkins,\n 'notebook': SetupCommandNotebook,\n 'unittests': SetupCommandUnitTests,\n 'unittests_GUI': SetupCommandUnitTestGUI,\n 'unittests_LONG': SetupCommandUnitTestLONG,\n 'unittests_SKIP': SetupCommandUnitTestSKIP,\n 'validate_urls': SetupCommandValidateUrls,\n 'write_version': SetupCommandVersion}","def tool_factory_function(source, **parameters):\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n return dict(\n workflow=self.current_workflow,\n tool=tool_func(**parameters),\n source=source)","def makeTestProcessingTool(test_processing_tool_path, test_processing_factory_path):\r\n\r\n className = splitext(basename(test_processing_tool_path))[0]\r\n factory_name = splitext(basename(test_processing_factory_path))[0]\r\n\r\n with open(test_processing_tool_path, 'w') as f:\r\n f.write(\"\"\"\\\r\n'''\r\nTest processing tool class - should be deleted upon completion of test\r\n'''\r\n\r\n'''___Built-In Modules___'''\r\nimport sys\r\nfrom os.path import dirname\r\n\r\n'''___Third-Party Modules___'''\r\n\r\n'''___NPL Modules___'''\r\ndataProcessing_directory = dirname(dirname(dirname(dirname(__file__))))\r\nsys.path.append(dataProcessing_directory)\r\nfrom AbstractProcessingTool import AbstractProcessingTool\r\n\r\nsys.path.append(dirname(__file__))\r\nfrom %s import %s\r\n\r\n\r\nclass %s(AbstractProcessingTool):\r\n\r\n def setProcessingFactory(self, product_string):\r\n processingFactory = %s\r\n return processingFactory\r\n\r\n\r\nif __name__ == \"__main__\":\r\n pass\r\n\"\"\" % (factory_name, factory_name, className, factory_name))\r\n\r\n return 0","def setup_make_tool_plugin():\n arg_parser = argparse.ArgumentParser()\n arg_parser.add_argument(\"--show-tool-output\", dest=\"show_tool_output\",\n action=\"store_false\", help=\"Show tool output\")\n arg_parser.add_argument('--mapping-file-suffix', dest=\"mapping_file_suffix\",\n type=str)\n\n resources = Resources([os.path.join(os.path.dirname(statick_tool.__file__),\n 'plugins')])\n config = Config(resources.get_file(\"config.yaml\"))\n plugin_context = PluginContext(arg_parser.parse_args([]), resources, config)\n plugin_context.args.output_directory = os.path.dirname(__file__)\n mtp = MakeToolPlugin()\n mtp.set_plugin_context(plugin_context)\n return mtp","def create_factory_function(tool_func):\n base = tool_function.__bases__[0]\n if base == Tool:\n def tool_factory_function(sources, alignment_node=None, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param sources: source nodes\n :param alignment_node: alignment node\n :return: the created factor\n :type sources: list[Node] | tuple[Node] | None\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.sources == sources\n and m.alignment_node == alignment_node\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(**parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n sources=sources,\n alignment_node=alignment_node)\n\n return tool_factory_function\n elif base == MultiOutputTool:\n def tool_factory_function(source, splitting_node=None, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param source: source node\n :param splitting_node: splitting node\n :return: the created factor\n :type source: Node\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if\n f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.source == source\n and m.splitting_node == splitting_node\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(**parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n source=source,\n splitting_node=splitting_node)\n\n return tool_factory_function\n\n elif base == AggregateTool:\n def tool_factory_function(sources, alignment_node, aggregation_meta_data, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param aggregation_meta_data: the meta data to aggregate over\n :param sources: source nodes\n :param alignment_node: alignment node\n :return: the created factor\n :type sources: list[Node] | tuple[Node] | None\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if\n f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.sources == sources\n and m.alignment_node == alignment_node\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(aggregation_meta_data=aggregation_meta_data, **parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n sources=sources,\n alignment_node=alignment_node)\n\n return tool_factory_function\n elif base == SelectorTool:\n def tool_factory_function(sources, selector_meta_data, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param selector_meta_data: the meta data to select over\n :param sources: source nodes\n :return: the created factor\n :type sources: list[Node] | tuple[Node] | None\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if\n f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.sources == sources\n and m.selector_meta_data == selector_meta_data\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(selector_meta_data=selector_meta_data, **parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n sources=sources)\n\n return tool_factory_function\n elif base == PlateCreationTool:\n def tool_factory_function(source, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param source: source node\n :return: the created factor\n :type source: Node\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n return dict(\n workflow=self.current_workflow,\n tool=tool_func(**parameters),\n source=source)\n\n return tool_factory_function\n else:\n raise NotImplementedError","def __init__(self, windows):\n super().__init__(self, windows) # this inherits the init from the previous building class\n self.windows = windows\n self.workbench = True\n self.tools = []","def test_create(self):\n\n adminuser,adminpass = self.testdata.find_account_for('toolmanager')\n\n self.utils.account.login_as(adminuser,adminpass)\n\n self.contribtool.create(TOOLNAME)","def useBookTool(tool, arguments=[None]):\n\tif tool is None:\n\t\treturn 3\n\tif tool in BOOK_UNITS.keys():\n\t\tBOOK_UNITS[tool].main(arguments)\n\t\treturn 0\n\telse:\n\t\treturn 3","def install(self,toolname,adminuser,adminpass):\n\n self.logger.info(\"installing the tool '%s'\" % (toolname))\n\n self.push_admin_install_button(toolname)\n\n self.compile_code(toolname,adminuser,adminpass)\n\n self.flip_tool_status('ToolsStatusUploadedAdminPage',toolname,'Installed')","def __init__(self, argv):\n tool_path = str(self.__find_tool_path().resolve())\n\n try:\n result = subprocess.run(\n [tool_path],\n stdout=subprocess.PIPE,\n universal_newlines=True\n )\n\n if result.returncode != 0:\n sys.exit(result.returncode)\n\n if (\n len(argv) == 0 or\n (len(argv) == 1 and argv[0] == '-h') or\n (len(argv) == 1 and argv[0] == '--help')\n ):\n print(self.__edit_tool_help(result.stdout))\n else:\n # Call the tool\n result = subprocess.run([tool_path] + argv)\n if result.returncode != 0:\n sys.exit(result.returncode)\n\n except KeyboardInterrupt:\n # it lets the subprocess to handle the exception\n pass\n\n except BaseException as e:\n self.__help_message += str(e)\n self.__help_message += '\\n fast-discovery-server tool not found!'\n print(self.__help_message)\n sys.exit(1)","def __init__(self, args):\n # etree.write(stdout, xml_declaration=True, encoding='UTF-8')\n JsonShell.__init__(self, args)\n self.args = args\n tool = etree.Element('tool', id='gatk4_auto_' + self.shell_dict['id'], name=self.shell_dict['name'],\n version=\"@WRAPPER_VERSION@0\", profile=self.profile)\n description = etree.SubElement(tool, 'description')\n description.text = '- ' + self.shell_dict['description']\n macros = etree.SubElement(tool, 'macros')\n macros_imp = etree.SubElement(macros, 'import')\n macros_imp.text = 'macros.xml'\n exp_reqs = etree.SubElement(tool, 'expand', macro='requirements')\n exp_vers = etree.SubElement(tool, 'expand', macro='version_cmd')\n command = etree.SubElement(tool, 'command', detect_errors='exit_code')\n command.text = etree.CDATA(self.command_create())\n\n # INPUT section\n self.inputs = etree.SubElement(tool, 'inputs')\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['pre_params']:\n etree.SubElement(self.inputs, 'expand', macro=entry)\n self.build_inputs(self.tool_xml, self.inputs, 'param')\n if self.xml_opt or self.my_xml.tool_data[self.shell_dict['short_name']]['opt_params']:\n self.opt_sect = etree.SubElement(self.inputs, 'section', name='optional', title='Optional Parameters', expanded='False')\n self.build_inputs(self.xml_opt, self.opt_sect, 'param')\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['opt_params']:\n etree.SubElement(self.opt_sect, 'expand', macro=entry)\n# self.build_inputs(self.xml_opt, self.opt_sect, 'param')\n\n if self.xml_adv or self.my_xml.tool_data[self.shell_dict['short_name']]['adv_params']:\n# self.adv_sect, self.when_yes = self._section_write('advanced', 'Advanced Parameters', 'advanced_sel')\n self.adv_sect = etree.SubElement(self.inputs, 'section', name='advanced', title='Advanced Parameters', expanded='False')\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['adv_params']:\n etree.SubElement(self.adv_sect, 'expand', macro=entry)\n# if not self.args.old_galaxy:\n self.build_inputs(self.xml_adv, self.adv_sect, 'param')\n # else:\n # self.build_inputs(self.xml_adv, self.when_yes, 'param')\n\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['post_params']:\n etree.SubElement(self.inputs, 'expand', macro=entry)\n\n # Temporary common section to work on macros.\n if self.xml_comm:\n# self.comm_sect, self.when_yes = self._section_write('common', 'Common Parameters', 'common_sel')\n self.comm_sect = etree.SubElement(self.inputs, 'section', name='common', title='Common Parameters', expanded='False')\n self.build_inputs(self.xml_comm, self.comm_sect, 'param')\n\n # OUTPUT section\n if self.xml_out:\n# self.output_sect, self.when_yes = self._section_write('output_opt', 'Additional Output Parameters', 'output_opt_sel')\n if not self.args.old_galaxy:\n self.output_sect = etree.SubElement(self.inputs, 'section', name='output_opt',\n title='Additional Output Parameters',\n expanded='False')\n self.build_inputs_out_sel(self.xml_out, self.output_sect)\n else:\n self.build_inputs_out_sel(self.xml_out, self.inputs)\n\n self.outputs = etree.SubElement(tool, 'outputs')\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['output_params']:\n etree.SubElement(self.outputs, 'expand', macro=entry)\n self.build_inputs(self.xml_req_out, self.outputs, 'data')\n self.build_inputs(self.xml_out, self.outputs, 'data', True)\n\n tests = etree.SubElement(tool, 'tests')\n help = etree.SubElement(tool, 'help')\n help.text = etree.CDATA(self.shell_dict['summary'])\n citations = etree.SubElement(tool, 'citations')\n exp_cit = etree.SubElement(citations, 'expand', macro='citations')\n\n self.to_write = etree.tostring(tool, pretty_print=True, encoding=\"unicode\")","def get_name(self):\n return \"make\"","def setup(self, tool_id=None, tool_version=None, preserve_galaxy_python_environment=None):\n setup_args = {\"job_id\": self.job_id}\n if tool_id:\n setup_args[\"tool_id\"] = tool_id\n if tool_version:\n setup_args[\"tool_version\"] = tool_version\n if preserve_galaxy_python_environment:\n setup_args[\"preserve_galaxy_python_environment\"] = preserve_galaxy_python_environment\n return self.setup_handler.setup(**setup_args)","def __init__(self, tool_dir, host_name):\n self.tool_dir = tool_dir\n if (not os.path.exists(self._get_rsg_path())):\n raise RsgError(\"Can't find rsg tool. Path is invalid:%s\" \\\n % self._get_rsg_path())\n self.host_name = host_name","def tool_name(self) -> str:\n return \"BlackbirdOptional\"","def test2SetToolProperties( self ):\n\n from AthExHelloWorld.AthExHelloWorldConf import HelloAlg\n from AthExHelloWorld.AthExHelloWorldConf import HelloTool\n\n HelloWorld = HelloAlg( 'HelloWorld' )\n\n msg1 = \"A Private Message!\"\n\n HelloWorld.MyPrivateHelloTool = HelloTool( \"HelloTool\" )\n HelloWorld.MyPrivateHelloTool.MyMessage = msg1\n\n HelloWorld.setup()\n\n global ToolSvc\n\n msg2 = \"A Public Message!\"\n\n ToolSvc += HelloTool( \"PublicHello\" )\n ToolSvc.PublicHello.MyMessage = msg2\n\n ToolSvc.setup()\n\n self.assertEqual( HelloWorld.MyPrivateHelloTool.MyMessage, msg1 )\n client = HelloWorld.getName() + '.' + HelloWorld.MyPrivateHelloTool.getName()\n self.assertTrue( JobOptionsSvc.verify( client, 'MyMessage', msg1 ) )\n\n self.assertEqual( ToolSvc.PublicHello.MyMessage, msg2 )\n self.assertTrue( JobOptionsSvc.verify( 'ToolSvc.PublicHello', 'MyMessage', msg2 ) )","def AddCheckTool(self, tool_id, label, bitmap, disabled_bitmap, short_help_string=\"\", long_help_string=\"\", client_data=None):\r\n\r\n return self.AddTool(tool_id, label, bitmap, disabled_bitmap, ITEM_CHECK, short_help_string, long_help_string, client_data)","def toolName(self):\n return QCoreApplication.translate(\"VDLTools\", \"Multiselect\")","def _check_toolplus(x):\n Tool = collections.namedtuple(\"Tool\", [\"name\", \"fname\"])\n if \"=\" in x and len(x.split(\"=\")) == 2:\n name, fname = x.split(\"=\")\n fname = os.path.normpath(os.path.realpath(fname))\n if not os.path.exists(fname):\n raise argparse.ArgumentTypeError(\"Unexpected --toolplus argument for %s. File does not exist: %s\"\n % (name, fname))\n return Tool(name, fname)\n else:\n raise argparse.ArgumentTypeError(\"Unexpected --toolplus argument. Expect toolname=filename.\")","def SetToolLabel(self, tool_id, label):\r\n \r\n tool = self.FindTool(tool_id)\r\n if tool: \r\n tool.label = label","def parse_tool_path(self):","def __init__(self, name, description, cli_opts):\n self.name = name\n self.description = description\n self.cli_opts = cli_opts","def package_tool( self, trans, tool_id ):\n # Make sure the tool is actually loaded.\n if tool_id not in self._tools_by_id:\n raise ObjectNotFound(\"No tool found with id '%s'.\" % escape( tool_id ))\n else:\n tool = self._tools_by_id[ tool_id ]\n return tool.to_archive()","def run(self):\n self.iface.mapCanvas().setMapTool(self.tool)","def tool_factory_function(source, splitting_node=None, **parameters):\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if\n f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.source == source\n and m.splitting_node == splitting_node\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(**parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n source=source,\n splitting_node=splitting_node)","def setup_tool(shell,tool_name,tool_revision,invoke_script,\n test_program_name,test_program_script):\n\n # check that the user is in the apps group\n groups,es = shell.execute(\"echo ${USER} | groups\")\n if \"apps\" not in groups.split():\n # user not in the apps group, bail\n username,es = shell.execute(\"echo ${USER}\")\n# raise RuntimeError(\"user %s not in apps group: %s\" % (username,groups))\n raise GroupMembershipError(\"user %s not in apps group: %s\" % (username,groups))\n\n # become the apps user\n shell.send('sudo su - apps')\n shell.start_bash_shell()\n\n tool_revision_string = \"r%s\" % (tool_revision)\n tool_path = \"/apps/%s/%s\" % (tool_name, tool_revision_string)\n dev_path = \"/apps/%s/dev\" % (tool_name)\n\n # setup the new tool's invoke script\n # mv %(tool_path)s %(tmp_tool_path)s;\n # tmp_tool_path = tool_path + \".old\"\n # \"\"\" % {'tool_path' : tool_path, 'tmp_tool_path' : tmp_tool_path}\n script = \"\"\"\n rm -rf %(tool_path)s;\n mkdir %(tool_path)s;\n rm -f %(dev_path)s;\n ln -s %(tool_path)s %(dev_path)s;\n cd %(tool_path)s;\n mkdir middleware bin;\n \"\"\" % {'tool_path' : tool_path,\n 'dev_path' : dev_path}\n\n commands = script.strip().split('\\n')\n shell.execute(commands)\n\n # write the invoke script to disk\n shell.write_file('middleware/invoke', invoke_script)\n shell.execute('chmod 755 middleware/invoke')\n\n # write the test program to disk\n shell.write_file(\"bin/%s\" % (test_program_name), test_program_script)\n shell.execute(\"chmod 755 bin/%s\" % (test_program_name))\n\n # exit from apps user\n shell.stop_bash_shell()\n shell.send('exit')","def runmain(args):\n\n #case: no extra args, so return help\n if len(args) == 0:\n print USAGE\n return\n\n toolname = args[1]\n if toolname == 'help':\n print USAGE\n return\n\n elif toolname == 'splitdata':\n splitdata(args)\n return\n \n elif toolname == 'aboutdata':\n aboutdata(args)\n return\n\n elif toolname == 'test':\n testffx(args)\n return\n \n else:\n print \"There is no toolname of '%s'.\" % toolname\n print USAGE\n return","def SetupToolBar( self ):\n tb = self.CreateToolBar( self.TBFLAGS )\n tsize = (24,24)\n tb.ToolBitmapSize = tsize\n open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize)\n tb.AddLabelTool(ID_OPEN, \"Open\", open_bmp, shortHelp=\"Open\", longHelp=\"Open a (c)Profile trace file\")\n tb.AddSeparator()\n# self.Bind(wx.EVT_TOOL, self.OnOpenFile, id=ID_OPEN)\n self.rootViewTool = tb.AddLabelTool(\n ID_ROOT_VIEW, _(\"Root View\"),\n wx.ArtProvider.GetBitmap(wx.ART_GO_HOME, wx.ART_TOOLBAR, tsize),\n shortHelp=_(\"Display the root of the current view tree (home view)\")\n )\n self.rootViewTool = tb.AddLabelTool(\n ID_BACK_VIEW, _(\"Back\"), \n wx.ArtProvider.GetBitmap(wx.ART_GO_BACK, wx.ART_TOOLBAR, tsize),\n shortHelp=_(\"Back to the previously activated node in the call tree\")\n )\n self.upViewTool = tb.AddLabelTool(\n ID_UP_VIEW, _(\"Up\"),\n wx.ArtProvider.GetBitmap(wx.ART_GO_UP, wx.ART_TOOLBAR, tsize),\n shortHelp=_(\"Go one level up the call tree (highest-percentage parent)\")\n )\n tb.AddSeparator()\n # TODO: figure out why the control is sizing the label incorrectly on Linux\n self.percentageViewTool = wx.CheckBox( tb, -1, _(\"Percent \") )\n self.percentageViewTool.SetToolTip( wx.ToolTip(_(\"Toggle display of percentages in list views\")) )\n tb.AddControl( self.percentageViewTool )\n wx.EVT_CHECKBOX( self.percentageViewTool, self.percentageViewTool.GetId(), self.OnPercentageView )\n \n self.packageViewTool = wx.CheckBox( tb, -1, _(\"File View \") )\n self.packageViewTool.SetToolTip( wx.ToolTip(_(\"Switch between call-hierarchy and package/module/function hierarchy\")) )\n tb.AddControl( self.packageViewTool )\n wx.EVT_CHECKBOX( self.packageViewTool, self.packageViewTool.GetId(), self.OnPackageView )\n tb.Realize()","def setup(self, optparser):\n\t\tpass","def find_and_register(cls, name, vers):\n # locate the given tool using its name as an executable,\n # and adjust the version to match the detected version (major.minor)\n\n tc = CLang(name, vers)\n\n if tc.version is None:\n debug(\"looking for {}\".format(tc.name))\n err = tc.detect_version_on_path_or_env('CC', tc.name, needs_version=False,\n allow_unversioned=(vers is None))\n if err is not None:\n return\n\n try:\n comp = subprocess.run([tc.name, '--version'],\n stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n\n # ignore stray intl chars\n comp.stdout = str(comp.stdout, encoding='ascii', errors='ignore')\n comp.stderr = str(comp.stderr, encoding='ascii', errors='ignore')\n except OSError as e:\n # e.g. PermissionError, from trying to run Cygwin softlink\n debug(\"failed to invoke '{}', error '{}'\".format(tc.name, e))\n return\n\n if comp.returncode == 0:\n # e.g. clang version 3.8.0-2ubuntu3~trusty5 (tags/RELEASE_380/final)\n # e.g. clang version 3.8.1 (branches/release_38)\n # e.g. clang version 5.0.1-svn319952-1~exp1 (branches/release_50)\n # and the outliers:\n # e.g. Apple LLVM version 8.0.0 (clang-800.0.42.1)\n # e.g. Apple LLVM version 10.0.0 (clang-1000.11.45.2)\n # the version does not correspond to any actual upstream LLVM version :-p\n stdout = comp.stdout\n m = re.match(r'.*?\\s+version\\s+(\\d+\\.\\d+)(\\.\\d+)?.*', stdout, re.M)\n if m:\n version = m.group(1)\n debug(\"matched {}\".format(version))\n\n # then rename this tool to be more specific\n tc.name = 'clang-' + version\n tc.version = version\n else:\n debug(\"did not find version information in output: {}\".format(\n comp.stdout + comp.stderr))\n else:\n debug(\"failed to run '{} --version': {}\".format(tc.name, comp.stderr))\n\n if tc.version:\n if version_compare(tc.version, cls.VERSION_CLANG_LATEST) > 0:\n cls.VERSION_CLANG_LATEST = tc.version\n\n Toolchain.register(tc, force=True)","def __init__(self, name=\"ProRobot\"):\n super().__init__(name)","def __init__(self, name, progname, progtype):\n self.progargs = \"\"\n self.name = name\n if progtype in self.INTERPRETED:\n #sys.chmod(progname, stat.S_IXUS)\n self.progname = self.INTERPRETED[progtype]\n self.progargs = progname\n elif progtype in self.COMPILED:\n self.progname = self.build(progname, progtype)\n else:\n raise AssertionError","def get_tool_by_id(self, tool_id, package_name=None, dev=False, *args, **kwargs):\n\n if not package_name:\n package_name = tool_id.replace('.', '-').split('-')[0]\n\n if package_name not in self._plugins:\n LOGGER.warning('Impossible to load tool by id: package \"{}\" is not registered!'.format(package_name))\n return None\n\n if tool_id in self._plugins[package_name]:\n tool_inst = self._plugins[package_name][tool_id].get('tool_instance', None)\n if tool_inst:\n return tool_inst\n\n tool_to_run = None\n\n for plugin_id in self._plugins[package_name].keys():\n tool_path = self._plugins[package_name][plugin_id]['plugin_package']\n sec_path = tool_path.replace('.', '-')\n if sec_path == tool_path or sec_path == tool_id:\n tool_to_run = tool_id\n break\n else:\n tool_name = tool_path.split('.')[-1]\n if tool_name == tool_path:\n tool_to_run = tool_id\n break\n\n if not tool_to_run or tool_to_run not in self._plugins[package_name]:\n LOGGER.warning('Tool \"{}\" is not registered!'.format(tool_id))\n return None\n\n tool_loader = self._plugins[package_name][tool_to_run]['loader']\n pkg_loader = self._plugins[package_name][tool_to_run]['loader']\n tool_config = self._plugins[package_name][tool_to_run]['config']\n tool_fullname = tool_loader.fullname if python.is_python2() else tool_loader.loader.name\n tool_version = self._plugins[package_name][tool_to_run]['version']\n\n pkg_name = pkg_loader.filename if python.is_python2() else os.path.dirname(pkg_loader.loader.path)\n pkg_path = pkg_loader.fullname if python.is_python2() else pkg_loader.loader.name\n\n tool_found = None\n for sub_module in pkgutil.walk_packages([self._plugins[package_name][tool_to_run]['plugin_package_path']]):\n tool_importer, sub_module_name, _ = sub_module\n mod = tool_importer.find_module(sub_module_name).load_module(sub_module_name)\n for cname, obj in inspect.getmembers(mod, inspect.isclass):\n if issubclass(obj, tool.DccTool):\n obj.FILE_NAME = pkg_name\n obj.FULL_NAME = pkg_path\n tool_found = obj\n break\n if tool_found:\n break\n\n if not tool_found:\n LOGGER.error(\"Error while launching tool: {}\".format(tool_fullname))\n return None\n\n # if dcc_loader:\n # tool_config = dcc_config\n\n tool_settings = self.get_tool_settings_file(tool_id)\n if not tool_settings.has_setting('theme'):\n tool_settings.set('theme', 'default')\n tool_settings.setFallbacksEnabled(False)\n\n tool_inst = tool_found(self, config=tool_config, settings=tool_settings, dev=dev, *args, **kwargs)\n tool_inst.ID = tool_id\n tool_inst.VERSION = tool_version\n tool_inst.AUTHOR = tool_inst.config_dict().get('creator', None)\n tool_inst.PACKAGE = package_name\n\n self._plugins[package_name][tool_id]['tool_instance'] = tool_inst\n # self._plugins[package_name][plugin_id]['tool_instance'] = tool_inst\n\n return tool_inst","def createToolBar(self):\n pass","def __init__(self,name:str,int,str,dex):\r\n super(Warrior, self).__init__(name,int,str,dex)\r\n self._class = 'Warrior'"],"string":"[\n \"def __init__(self, toolName):\\n\\t\\tself.toolName = toolName\",\n \"def __init__(self):\\n self.label = \\\"Create\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n if core.get_pass():\\n self.tools = [Fbound, Roads, Diekdikisi]\\n else:\\n self.tools = []\",\n \"def __tool_name__(cls):\",\n \"def __init__(self):\\n self.label = \\\"Python ToolBox\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Tool]\",\n \"def CreateTool(tool_name, adb):\\n if not tool_name:\\n return BaseTool()\\n\\n ctor = TOOL_REGISTRY.get(tool_name)\\n if ctor:\\n return ctor(adb)\\n else:\\n print 'Unknown tool %s, available tools: %s' % (\\n tool_name, ', '.join(sorted(TOOL_REGISTRY.keys())))\\n sys.exit(1)\",\n \"def tool(self, tool_cls, *args, options={}, **kwargs):\\n tool_options = self.OPTIONS.copy()\\n tool_options.update(options)\\n\\n tool_instance = tool_cls(\\n *args,\\n flags=self.FLAGS,\\n bin_dir=self.BIN_DIR,\\n HHLIB=self.HHLIB,\\n options=tool_options,\\n **kwargs)\\n tool_instance.tool = unittest.mock.MagicMock()\\n return tool_instance\",\n \"def __init__(self):\\n self.label = \\\"Toolbox\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Offset]\",\n \"def __init__(self):\\n self.label = \\\"Surface Generation\\\"\\n self.alias = \\\"far77\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [LineToFar77]\",\n \"def __init__(self):\\n self.label = \\\"CDA Tools\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [SecondaryCraterRemovalTool]\",\n \"def __init__(self):\\n self.label = \\\"Check\\\"\\n self.alias = \\\"Check Shapefiles\\\"\\n\\n # List of tool classes associated with this toolbox\\n if core.get_pass():\\n self.tools = [Dbound, Overlaps, Numbering, Geometry, Roads, Bld]\\n else:\\n self.tools = []\",\n \"def setToolTo(*args, **kwargs)->None:\\n pass\",\n \"def __init__(self):\\n self.label = \\\"Data Assistant\\\"\\n self.alias = \\\"dla\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Append, Stage, NewFile, Preview, Replace]\",\n \"def __init__(self):\\n self.label = \\\"Toolbox\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [FilesWithin, UpdateAiracInfo, CalculatePolygonRotationUTM33, CalculatePolygonRotationLCC10E, SetLayoutsNorAirac, SetLayoutsSweAirac, SetLayoutsFinDnkAirac, Export330charts]\",\n \"def __init__(self):\\r\\n\\t\\tself.label = \\\"Toolbox\\\"\\r\\n\\t\\tself.alias = \\\"\\\"\\r\\n\\r\\n\\t\\t# List of tool classes associated with this toolbox\\r\\n\\t\\tself.tools = [LinkedDataSpatialQuery, LinkedDataPropertyEnrich, MergeBatchNoFunctionalProperty, MergeSingleNoFunctionalProperty, LocationPropertyPath, RelFinder]\",\n \"def __init__(self):\\r\\n self.label = \\\"Python Toolbox: Floodwater Depth Analysis\\\"\\r\\n self.alias = \\\"\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [FEMAClip, FEMA_BFE, Depth]\",\n \"def add_tool(self, ToolKlass, *args, **kwargs):\\n if self._first_tool_flag:\\n # This is the very first tool to be added to this manager\\n self._first_tool_flag = False\\n self.configure_panels()\\n tool = ToolKlass(self, *args, **kwargs)\\n self.tools.append(tool)\\n for plot in list(self.plots.values()):\\n tool.register_plot(plot)\\n if len(self.tools) == 1:\\n self.default_tool = tool\\n return tool\",\n \"def __init__(self):\\n self.label = \\\"PFRR Tools\\\"\\n self.alias = \\\"PFRR Tools\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Ending_Point, Range_Distance, PFRR]\",\n \"def __init__(self):\\r\\n self.label = \\\"Toolbox\\\"\\r\\n self.alias = \\\"Geodesic Densification using arcpy\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [GeodesicDensification_arcpy]\",\n \"def __init__(self):\\n self.label = \\\"Service Downloader\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Edown]\",\n \"def __init__(self):\\n \\n self.label = \\\"ArcSDM Tools\\\"\\n self.alias = \\\"ArcSDM\\\" \\n\\n # List of tool classes associated with this toolbox\\n self.tools = [PartitionNNInputFiles, CombineNNOutputFiles, NeuralNetworkOutputFiles, NeuralNetworkInputFiles, \\n CalculateWeightsTool,SiteReductionTool,CategoricalMembershipToool,\\n CategoricalAndReclassTool, TOCFuzzificationTool, CalculateResponse, LogisticRegressionTool, Symbolize, \\n ROCTool, AgterbergChengCITest, AreaFrequencyTable, GetSDMValues, GrandWofe]\",\n \"def __init__(self):\\r\\n self.label = \\\"ProcessAirQuality\\\"\\r\\n self.alias = \\\"ProcessAirQuality\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [AirQuality]\",\n \"def __init__(self):\\r\\n self.label = \\\"OVL Tools\\\"\\r\\n self.alias = \\\"\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [OVLtoFeature, BatchOVLtoFeature]\",\n \"def calrissian_make_tool(spec, loadingContext):\\n if \\\"class\\\" in spec and spec[\\\"class\\\"] == \\\"CommandLineTool\\\":\\n return CalrissianCommandLineTool(spec, loadingContext)\\n else:\\n return default_make_tool(spec, loadingContext)\",\n \"def tool(self):\\n tool_type = self.__class__.__module__.split('.')[-1]\\n return g.config.tools[tool_type]\",\n \"def get_tools(cls):\\n pass\",\n \"def register_tool(cls, tool_name: str, reset_function):\\n if tool_name in cls.TOOLS:\\n raise PedalToolAlreadyRegistered(tool_name)\\n cls.TOOLS[tool_name] = ToolRegistration(tool_name, reset_function)\",\n \"def __init__(self):\\n self.label = \\\"RAPID Tools\\\"\\n self.alias = \\\"RAPIDTools\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [AddSPTFields,\\n AutomaticRAPIDfileGenerator, \\n CopyDataToServer,\\n CreateNetworkConnectivityFile,\\n CreateNetworkConnectivityFileNHDPlus,\\n CreateMuskingumParameterFiles,\\n CreateMuskingumKFile,\\n CreateMuskingumKfacFile,\\n CreateMuskingumXField, \\n CreateMuskingumXFile, \\n CreateRivIDGageFile, \\n CreateSubsetFile,\\n CreateWeightTableFromWRFGeogrid,\\n CreateInflowFileFromWRFHydroRunoff,\\n CreateWeightTableFromECMWFRunoff,\\n CreateInflowFileFromECMWFRunoff,\\n CreateWeightTableFromLDASRunoff,\\n CreateWeightTableFrom2DLatLonRunoff,\\n CreateDischargeTable,\\n CreateDischargeMap,\\n FlowlineToPoint,\\n DEMtoStreamNetwork,\\n PublishDischargeMap,\\n StreamNetworktoRAPID,\\n StreamNetworktoSPT,\\n UpdateWeightTable,\\n UpdateDischargeMap,\\n ]\",\n \"def tool(self):\\n if self._tool is None:\\n return SE3()\\n else:\\n return self._tool\",\n \"def build_tool(self, doc, entity):\\n match = self.tool_re.match(entity)\\n if match and validations.validate_tool_name(match.group(self.TOOL_NAME_GROUP)):\\n name = match.group(self.TOOL_NAME_GROUP)\\n return creationinfo.Tool(name)\\n else:\\n raise SPDXValueError('Failed to extract tool name')\",\n \"def register_other_tools(self):\\n self.add_tool(SaveAsTool)\\n self.add_tool(CopyToClipboardTool)\\n self.add_tool(PrintTool)\\n self.add_tool(HelpTool)\",\n \"def setup_toolbox(self, engine_name, task_name, toolbox_name):\\n pass\",\n \"def __init__(self):\\r\\n\\t\\tself.label = \\\"smart_move\\\"\\r\\n\\t\\tself.alias = \\\"Smart Move Operations\\\"\\r\\n\\r\\n\\t\\t# List of tool classes associated with this toolbox\\r\\n\\t\\tself.tools = [SmartMoveFeatures]\",\n \"def tool(self):\\n return self._tool\",\n \"def __init__(self):\\n self.label = \\\"Change Field Name\\\"\\n self.alias = \\\"Field name\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [FieldName]\",\n \"def get_tool(self, name, parameters, version=None):\\n # TODO: use the version\\n if version is not None:\\n logging.warn(\\\"Tool versions not yet supported\\\")\\n\\n tool_class = self.get_tool_class(name)\\n\\n # Check that the number of arguments is correct for this tool\\n arg_spec = inspect.getargspec(tool_class.__init__)\\n max_expected = len(arg_spec[0])\\n if arg_spec.defaults:\\n min_expected = max_expected - len(arg_spec.defaults)\\n else:\\n min_expected = max_expected\\n num_parameters = len(parameters) if parameters is not None else 0\\n if not (min_expected <= num_parameters + 1 <= max_expected):\\n message = \\\"Tool {} takes between {} and {} arguments ({} given)\\\".format(\\n tool_class.__name__, min_expected, max_expected, num_parameters + 1)\\n raise ToolInitialisationError(message)\\n\\n # Instantiate tool\\n try:\\n tool = tool_class(**parameters) if parameters is not None else tool_class()\\n except TypeError:\\n raise ToolInitialisationError(name, parameters)\\n\\n if not tool:\\n raise ToolNotFoundError(name, parameters)\\n\\n tool.name = name\\n\\n return tool\",\n \"def register_standard_tools(self):\\n t = self.add_tool(SelectTool)\\n self.set_default_tool(t)\\n self.add_tool(RectZoomTool)\\n self.add_tool(BasePlotMenuTool, \\\"item\\\")\\n self.add_tool(ExportItemDataTool)\\n try:\\n import spyderlib.widgets.objecteditor # analysis:ignore\\n self.add_tool(EditItemDataTool)\\n except ImportError:\\n pass\\n self.add_tool(ItemCenterTool)\\n self.add_tool(DeleteItemTool)\\n self.add_separator_tool()\\n self.add_tool(BasePlotMenuTool, \\\"grid\\\")\\n self.add_tool(BasePlotMenuTool, \\\"axes\\\")\\n self.add_tool(DisplayCoordsTool)\\n if self.get_itemlist_panel():\\n self.add_tool(ItemListPanelTool)\",\n \"def cli(ctx, **kwds):\\n invalid = _validate_kwds(kwds)\\n if invalid:\\n ctx.exit(invalid)\\n tool_description = tool_builder.build(**kwds)\\n tool_builder.write_tool_description(ctx, tool_description, **kwds)\",\n \"def get_tool(cls, tool_name):\\n if cls.tool_dict is None:\\n # Init the module_dict once.\\n cls.tool_dict = {tool.name: tool for tool in cls.get_pb().tools}\\n return cls.tool_dict.get(tool_name)\",\n \"def __init__(self):\\r\\n self.label = \\\"GEOGRID_STANDALONE\\\"\\r\\n self.alias = \\\"\\\"\\r\\n self.description = \\\"This is a standalone processing tool for WRF-HYDRO.\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [ProcessGeogridFile, ExportGrid, ExamineOutputs, ExportPRJ, GenerateLatLon, DomainShapefile]\",\n \"def _its_tool_ ( self , typename , name = None , interface = None , createIf = True , parent = None ) :\\n if not name :\\n t,s,n = typename.rpartition('/')\\n if t and s and n :\\n typename = t\\n name = n\\n else : name = typename\\n \\n p1 = typename.find ( ':PUBLIC' )\\n if 0 < p1 and p1 + 6 == len(typename) :\\n typename = typename [:p1]\\n \\n itool = GaudiPython.Bindings.Helper.tool ( self._its , typename , name , parent , createIf ) \\n if itool and interface :\\n iif = GaudiPython.Bindings.InterfaceCast(interface)( itool )\\n if not iif : logger.warning(\\\"Can't retrieve proepr interface %s for %s\\\" % ( interface , itool ) )\\n return GaudiPython.Bindings.iAlgTool ( itool.name() , iif )\\n elif not itool : logger.warning(\\\"Can't retrieve the tool %s'%s\\\" % ( typename , name ) )\\n \\n return GaudiPython.Bindings.iAlgTool ( name , itool )\",\n \"def set_active_tool(self, tool=None):\\n self.active_tool = tool\",\n \"def __init__(self):\\n self.label = \\\"AlternateUnitBounds_Processing\\\"\\n self.alias = \\\"\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [FindMissingBounds, FindUpdatedIMDParks]\",\n \"def installTools(self, out):\\r\\n # Check that the tool has not been added using its id\\r\\n if not hasattr(self, 'selenium_ft_tool'):\\r\\n addTool = self.manage_addProduct['Selenium'].manage_addTool\\r\\n # Add the tool by its meta_type\\r\\n addTool('Selenium Functional Test Tool')\\r\\n out.write('Successfully added Selenium Functional Test Tool.\\\\n')\",\n \"def main():\\n tbx = Toolbox()\\n tool = FieldName()\\n tool.execute(tool.getParameterInfo(), None)\",\n \"def on_tool(self):\\n if self.tmFile is not None:\\n self.log.info(\\\"Launch tool %s\\\" % self.pItem.itemName)\\n toolMngrCmds.launchTools(self.pItem.itemName, self.tmFile, self.log.level)\",\n \"def tb_add_tool(tb, id, name, img, description):\\n tb.AddTool(id, name, wx.ArtProvider.GetBitmap(img), description)\",\n \"def get_tool(self, ToolKlass):\\n for tool in self.tools:\\n if isinstance(tool, ToolKlass):\\n return tool\",\n \"def __setitem__(self, tool_name, value):\\n self._tool_data[tool_name] = value\",\n \"def __init__( self, config_filenames, tool_root_dir, app, tool_conf_watcher=None ):\\n # The _dynamic_tool_confs list contains dictionaries storing\\n # information about the tools defined in each shed-related\\n # shed_tool_conf.xml file.\\n self._dynamic_tool_confs = []\\n self._tools_by_id = {}\\n self._integrated_section_by_tool = {}\\n # Tool lineages can contain chains of related tools with different ids\\n # so each will be present once in the above dictionary. The following\\n # dictionary can instead hold multiple tools with different versions.\\n self._tool_versions_by_id = {}\\n self._workflows_by_id = {}\\n # In-memory dictionary that defines the layout of the tool panel.\\n self._tool_panel = ToolPanelElements()\\n self._index = 0\\n self.data_manager_tools = odict()\\n self._lineage_map = LineageMap( app )\\n # Sets self._integrated_tool_panel and self._integrated_tool_panel_config_has_contents\\n self._init_integrated_tool_panel( app.config )\\n # The following refers to the tool_path config setting for backward compatibility. The shed-related\\n # (e.g., shed_tool_conf.xml) files include the tool_path attribute within the <toolbox> tag.\\n self._tool_root_dir = tool_root_dir\\n self.app = app\\n self._tool_watcher = get_tool_watcher( self, app.config )\\n if tool_conf_watcher:\\n self._tool_conf_watcher = tool_conf_watcher # Avoids (re-)starting threads in uwsgi\\n else:\\n self._tool_conf_watcher = get_tool_conf_watcher(lambda: self.handle_reload_toolbox())\\n self._filter_factory = FilterFactory( self )\\n self._tool_tag_manager = tool_tag_manager( app )\\n self._init_tools_from_configs( config_filenames )\\n if self.app.name == 'galaxy' and self._integrated_tool_panel_config_has_contents:\\n # Load self._tool_panel based on the order in self._integrated_tool_panel.\\n self._load_tool_panel()\\n self._save_integrated_tool_panel()\",\n \"def createCasaTool(mytool):\\n if (type(casac.Quantity) != type): # casa 4.x\\n myt = mytool()\\n else: # casa 3.x\\n myt = mytool.create()\\n return(myt)\",\n \"def _add_comment_tool(self, tool):\\r\\n \\r\\n existing = self.tools.get(tool.number)\\r\\n if existing and existing.plated == None:\\r\\n existing.plated = tool.plated\\r\\n \\r\\n self.comment_tools[tool.number] = tool\",\n \"def create_analysis_tools(self):\\r\\n raise NotImplementedError()\",\n \"def SetToolId(self, id):\\r\\n\\r\\n self.tool_id = id\",\n \"def load_hidden_tool( self, config_file, **kwds ):\\n tool = self.load_tool( config_file, **kwds )\\n self.register_tool( tool )\\n return tool\",\n \"def main():\\n\\n parser = get_populated_argparser()\\n cli_dict = generate_cli_dictionary()\\n\\n # Parse arguments.\\n if len(sys.argv) > 1:\\n args = parser.parse_args(sys.argv[1:])\\n\\n # Validate arguments.\\n args = cli_dict[args.tool].validate_args(args)\\n\\n # Run the tool.\\n cli_dict[args.tool].run(args)\\n\\n else:\\n\\n parser.print_help()\",\n \"def AddSimpleTool(self, tool_id, label, bitmap, short_help_string=\\\"\\\", kind=ITEM_NORMAL):\\r\\n \\r\\n return self.AddTool(tool_id, label, bitmap, wx.NullBitmap, kind, short_help_string, \\\"\\\", None)\",\n \"def tool(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"tool\\\")\",\n \"def get_tool(tool_name: str, project_dir: Union[str, os.PathLike]):\\n valid_tools = {\\n Judy.name: Judy(project_dir),\\n Jumble.name: Jumble(project_dir),\\n Major.name: Major(project_dir),\\n Pit.name: Pit(project_dir),\\n }\\n if tool_name not in valid_tools.keys():\\n msg = f\\\"Invalid tool provided: {tool_name}. Valid tools are {list(valid_tools.keys())}\\\"\\n logger.error(msg)\\n raise ValueError(msg)\\n\\n return valid_tools[tool_name]\",\n \"def mgmt_tool(self, mgmt_tool: MgmtClient):\\n self._mgmt_tool = mgmt_tool\",\n \"def main(args):\\n\\n tools = []\\n for tool in args.tools: # Parse tools, their subs and args\\n logging.info(\\\"Parsing tool: %r\\\", tool)\\n\\n tsig = parse_tool_sig(tool)\\n if not tsig or not tsig.get(\\\"snames\\\", None):\\n logging.error(\\\"failed parsing snames from tool: '%s'\\\", tool)\\n continue\\n\\n tools.append(tsig)\\n\\n return args.gen(args, tools)\",\n \"def setTool(self):\\n self.canvas().setMapTool(self)\",\n \"def register_curve_tools(self):\\n self.add_tool(SignalStatsTool)\\n self.add_tool(AntiAliasingTool)\\n self.add_tool(AxisScaleTool)\",\n \"def create_refactoring_tool(self, fixer_names):\\n return refactor.RefactoringTool(fixer_names)\",\n \"def name(self):\\r\\n return 'lockdownliveabilitytool'\",\n \"def add_tool(self, sut, tool, timeout):\\n\\n if tool.install_type == 'basic_install':\\n self._tests.append(BasicInstaller(tool, sut, timeout))\\n elif tool.install_type == 'msi_install':\\n self._tests.append(MSIInstaller(tool, sut, timeout))\\n elif tool.install_type == 'no_install':\\n pass\\n else:\\n raise CoreError('The install_type \\\"{0}\\\" for tool \\\"{1}\\\" '\\n 'is unsupported!'.format(tool.install_type, tool.name))\",\n \"def __init__(self, name=\\\"Tester\\\"): \\n # Call base constructor to set up app state, registry and add default params.\\n super(Tester, self).__init__(name)\\n\\n # Add arguments are related to the basic ``Tester``.\\n self.parser.add_argument('--visualize',\\n action='store_true',\\n dest='visualize',\\n help='Activate dynamic visualization')\",\n \"def default_cmdclass():\\n return {'build_script': SetupCommandBuildScript,\\n 'build_sphinx': SetupCommandSphinx,\\n 'clean_space': SetupCommandCleanSpace,\\n 'display': SetupCommandDisplay,\\n 'history': SetupCommandHistory,\\n 'lab': SetupCommandLab,\\n 'local_jenkins': SetupCommandLocalJenkins,\\n 'notebook': SetupCommandNotebook,\\n 'unittests': SetupCommandUnitTests,\\n 'unittests_GUI': SetupCommandUnitTestGUI,\\n 'unittests_LONG': SetupCommandUnitTestLONG,\\n 'unittests_SKIP': SetupCommandUnitTestSKIP,\\n 'validate_urls': SetupCommandValidateUrls,\\n 'write_version': SetupCommandVersion}\",\n \"def tool_factory_function(source, **parameters):\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool_func(**parameters),\\n source=source)\",\n \"def makeTestProcessingTool(test_processing_tool_path, test_processing_factory_path):\\r\\n\\r\\n className = splitext(basename(test_processing_tool_path))[0]\\r\\n factory_name = splitext(basename(test_processing_factory_path))[0]\\r\\n\\r\\n with open(test_processing_tool_path, 'w') as f:\\r\\n f.write(\\\"\\\"\\\"\\\\\\r\\n'''\\r\\nTest processing tool class - should be deleted upon completion of test\\r\\n'''\\r\\n\\r\\n'''___Built-In Modules___'''\\r\\nimport sys\\r\\nfrom os.path import dirname\\r\\n\\r\\n'''___Third-Party Modules___'''\\r\\n\\r\\n'''___NPL Modules___'''\\r\\ndataProcessing_directory = dirname(dirname(dirname(dirname(__file__))))\\r\\nsys.path.append(dataProcessing_directory)\\r\\nfrom AbstractProcessingTool import AbstractProcessingTool\\r\\n\\r\\nsys.path.append(dirname(__file__))\\r\\nfrom %s import %s\\r\\n\\r\\n\\r\\nclass %s(AbstractProcessingTool):\\r\\n\\r\\n def setProcessingFactory(self, product_string):\\r\\n processingFactory = %s\\r\\n return processingFactory\\r\\n\\r\\n\\r\\nif __name__ == \\\"__main__\\\":\\r\\n pass\\r\\n\\\"\\\"\\\" % (factory_name, factory_name, className, factory_name))\\r\\n\\r\\n return 0\",\n \"def setup_make_tool_plugin():\\n arg_parser = argparse.ArgumentParser()\\n arg_parser.add_argument(\\\"--show-tool-output\\\", dest=\\\"show_tool_output\\\",\\n action=\\\"store_false\\\", help=\\\"Show tool output\\\")\\n arg_parser.add_argument('--mapping-file-suffix', dest=\\\"mapping_file_suffix\\\",\\n type=str)\\n\\n resources = Resources([os.path.join(os.path.dirname(statick_tool.__file__),\\n 'plugins')])\\n config = Config(resources.get_file(\\\"config.yaml\\\"))\\n plugin_context = PluginContext(arg_parser.parse_args([]), resources, config)\\n plugin_context.args.output_directory = os.path.dirname(__file__)\\n mtp = MakeToolPlugin()\\n mtp.set_plugin_context(plugin_context)\\n return mtp\",\n \"def create_factory_function(tool_func):\\n base = tool_function.__bases__[0]\\n if base == Tool:\\n def tool_factory_function(sources, alignment_node=None, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param sources: source nodes\\n :param alignment_node: alignment node\\n :return: the created factor\\n :type sources: list[Node] | tuple[Node] | None\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.sources == sources\\n and m.alignment_node == alignment_node\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(**parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n sources=sources,\\n alignment_node=alignment_node)\\n\\n return tool_factory_function\\n elif base == MultiOutputTool:\\n def tool_factory_function(source, splitting_node=None, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param source: source node\\n :param splitting_node: splitting node\\n :return: the created factor\\n :type source: Node\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if\\n f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.source == source\\n and m.splitting_node == splitting_node\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(**parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n source=source,\\n splitting_node=splitting_node)\\n\\n return tool_factory_function\\n\\n elif base == AggregateTool:\\n def tool_factory_function(sources, alignment_node, aggregation_meta_data, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param aggregation_meta_data: the meta data to aggregate over\\n :param sources: source nodes\\n :param alignment_node: alignment node\\n :return: the created factor\\n :type sources: list[Node] | tuple[Node] | None\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if\\n f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.sources == sources\\n and m.alignment_node == alignment_node\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(aggregation_meta_data=aggregation_meta_data, **parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n sources=sources,\\n alignment_node=alignment_node)\\n\\n return tool_factory_function\\n elif base == SelectorTool:\\n def tool_factory_function(sources, selector_meta_data, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param selector_meta_data: the meta data to select over\\n :param sources: source nodes\\n :return: the created factor\\n :type sources: list[Node] | tuple[Node] | None\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if\\n f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.sources == sources\\n and m.selector_meta_data == selector_meta_data\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(selector_meta_data=selector_meta_data, **parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n sources=sources)\\n\\n return tool_factory_function\\n elif base == PlateCreationTool:\\n def tool_factory_function(source, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param source: source node\\n :return: the created factor\\n :type source: Node\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool_func(**parameters),\\n source=source)\\n\\n return tool_factory_function\\n else:\\n raise NotImplementedError\",\n \"def __init__(self, windows):\\n super().__init__(self, windows) # this inherits the init from the previous building class\\n self.windows = windows\\n self.workbench = True\\n self.tools = []\",\n \"def test_create(self):\\n\\n adminuser,adminpass = self.testdata.find_account_for('toolmanager')\\n\\n self.utils.account.login_as(adminuser,adminpass)\\n\\n self.contribtool.create(TOOLNAME)\",\n \"def useBookTool(tool, arguments=[None]):\\n\\tif tool is None:\\n\\t\\treturn 3\\n\\tif tool in BOOK_UNITS.keys():\\n\\t\\tBOOK_UNITS[tool].main(arguments)\\n\\t\\treturn 0\\n\\telse:\\n\\t\\treturn 3\",\n \"def install(self,toolname,adminuser,adminpass):\\n\\n self.logger.info(\\\"installing the tool '%s'\\\" % (toolname))\\n\\n self.push_admin_install_button(toolname)\\n\\n self.compile_code(toolname,adminuser,adminpass)\\n\\n self.flip_tool_status('ToolsStatusUploadedAdminPage',toolname,'Installed')\",\n \"def __init__(self, argv):\\n tool_path = str(self.__find_tool_path().resolve())\\n\\n try:\\n result = subprocess.run(\\n [tool_path],\\n stdout=subprocess.PIPE,\\n universal_newlines=True\\n )\\n\\n if result.returncode != 0:\\n sys.exit(result.returncode)\\n\\n if (\\n len(argv) == 0 or\\n (len(argv) == 1 and argv[0] == '-h') or\\n (len(argv) == 1 and argv[0] == '--help')\\n ):\\n print(self.__edit_tool_help(result.stdout))\\n else:\\n # Call the tool\\n result = subprocess.run([tool_path] + argv)\\n if result.returncode != 0:\\n sys.exit(result.returncode)\\n\\n except KeyboardInterrupt:\\n # it lets the subprocess to handle the exception\\n pass\\n\\n except BaseException as e:\\n self.__help_message += str(e)\\n self.__help_message += '\\\\n fast-discovery-server tool not found!'\\n print(self.__help_message)\\n sys.exit(1)\",\n \"def __init__(self, args):\\n # etree.write(stdout, xml_declaration=True, encoding='UTF-8')\\n JsonShell.__init__(self, args)\\n self.args = args\\n tool = etree.Element('tool', id='gatk4_auto_' + self.shell_dict['id'], name=self.shell_dict['name'],\\n version=\\\"@WRAPPER_VERSION@0\\\", profile=self.profile)\\n description = etree.SubElement(tool, 'description')\\n description.text = '- ' + self.shell_dict['description']\\n macros = etree.SubElement(tool, 'macros')\\n macros_imp = etree.SubElement(macros, 'import')\\n macros_imp.text = 'macros.xml'\\n exp_reqs = etree.SubElement(tool, 'expand', macro='requirements')\\n exp_vers = etree.SubElement(tool, 'expand', macro='version_cmd')\\n command = etree.SubElement(tool, 'command', detect_errors='exit_code')\\n command.text = etree.CDATA(self.command_create())\\n\\n # INPUT section\\n self.inputs = etree.SubElement(tool, 'inputs')\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['pre_params']:\\n etree.SubElement(self.inputs, 'expand', macro=entry)\\n self.build_inputs(self.tool_xml, self.inputs, 'param')\\n if self.xml_opt or self.my_xml.tool_data[self.shell_dict['short_name']]['opt_params']:\\n self.opt_sect = etree.SubElement(self.inputs, 'section', name='optional', title='Optional Parameters', expanded='False')\\n self.build_inputs(self.xml_opt, self.opt_sect, 'param')\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['opt_params']:\\n etree.SubElement(self.opt_sect, 'expand', macro=entry)\\n# self.build_inputs(self.xml_opt, self.opt_sect, 'param')\\n\\n if self.xml_adv or self.my_xml.tool_data[self.shell_dict['short_name']]['adv_params']:\\n# self.adv_sect, self.when_yes = self._section_write('advanced', 'Advanced Parameters', 'advanced_sel')\\n self.adv_sect = etree.SubElement(self.inputs, 'section', name='advanced', title='Advanced Parameters', expanded='False')\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['adv_params']:\\n etree.SubElement(self.adv_sect, 'expand', macro=entry)\\n# if not self.args.old_galaxy:\\n self.build_inputs(self.xml_adv, self.adv_sect, 'param')\\n # else:\\n # self.build_inputs(self.xml_adv, self.when_yes, 'param')\\n\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['post_params']:\\n etree.SubElement(self.inputs, 'expand', macro=entry)\\n\\n # Temporary common section to work on macros.\\n if self.xml_comm:\\n# self.comm_sect, self.when_yes = self._section_write('common', 'Common Parameters', 'common_sel')\\n self.comm_sect = etree.SubElement(self.inputs, 'section', name='common', title='Common Parameters', expanded='False')\\n self.build_inputs(self.xml_comm, self.comm_sect, 'param')\\n\\n # OUTPUT section\\n if self.xml_out:\\n# self.output_sect, self.when_yes = self._section_write('output_opt', 'Additional Output Parameters', 'output_opt_sel')\\n if not self.args.old_galaxy:\\n self.output_sect = etree.SubElement(self.inputs, 'section', name='output_opt',\\n title='Additional Output Parameters',\\n expanded='False')\\n self.build_inputs_out_sel(self.xml_out, self.output_sect)\\n else:\\n self.build_inputs_out_sel(self.xml_out, self.inputs)\\n\\n self.outputs = etree.SubElement(tool, 'outputs')\\n for entry in self.my_xml.tool_data[self.shell_dict['short_name']]['output_params']:\\n etree.SubElement(self.outputs, 'expand', macro=entry)\\n self.build_inputs(self.xml_req_out, self.outputs, 'data')\\n self.build_inputs(self.xml_out, self.outputs, 'data', True)\\n\\n tests = etree.SubElement(tool, 'tests')\\n help = etree.SubElement(tool, 'help')\\n help.text = etree.CDATA(self.shell_dict['summary'])\\n citations = etree.SubElement(tool, 'citations')\\n exp_cit = etree.SubElement(citations, 'expand', macro='citations')\\n\\n self.to_write = etree.tostring(tool, pretty_print=True, encoding=\\\"unicode\\\")\",\n \"def get_name(self):\\n return \\\"make\\\"\",\n \"def setup(self, tool_id=None, tool_version=None, preserve_galaxy_python_environment=None):\\n setup_args = {\\\"job_id\\\": self.job_id}\\n if tool_id:\\n setup_args[\\\"tool_id\\\"] = tool_id\\n if tool_version:\\n setup_args[\\\"tool_version\\\"] = tool_version\\n if preserve_galaxy_python_environment:\\n setup_args[\\\"preserve_galaxy_python_environment\\\"] = preserve_galaxy_python_environment\\n return self.setup_handler.setup(**setup_args)\",\n \"def __init__(self, tool_dir, host_name):\\n self.tool_dir = tool_dir\\n if (not os.path.exists(self._get_rsg_path())):\\n raise RsgError(\\\"Can't find rsg tool. Path is invalid:%s\\\" \\\\\\n % self._get_rsg_path())\\n self.host_name = host_name\",\n \"def tool_name(self) -> str:\\n return \\\"BlackbirdOptional\\\"\",\n \"def test2SetToolProperties( self ):\\n\\n from AthExHelloWorld.AthExHelloWorldConf import HelloAlg\\n from AthExHelloWorld.AthExHelloWorldConf import HelloTool\\n\\n HelloWorld = HelloAlg( 'HelloWorld' )\\n\\n msg1 = \\\"A Private Message!\\\"\\n\\n HelloWorld.MyPrivateHelloTool = HelloTool( \\\"HelloTool\\\" )\\n HelloWorld.MyPrivateHelloTool.MyMessage = msg1\\n\\n HelloWorld.setup()\\n\\n global ToolSvc\\n\\n msg2 = \\\"A Public Message!\\\"\\n\\n ToolSvc += HelloTool( \\\"PublicHello\\\" )\\n ToolSvc.PublicHello.MyMessage = msg2\\n\\n ToolSvc.setup()\\n\\n self.assertEqual( HelloWorld.MyPrivateHelloTool.MyMessage, msg1 )\\n client = HelloWorld.getName() + '.' + HelloWorld.MyPrivateHelloTool.getName()\\n self.assertTrue( JobOptionsSvc.verify( client, 'MyMessage', msg1 ) )\\n\\n self.assertEqual( ToolSvc.PublicHello.MyMessage, msg2 )\\n self.assertTrue( JobOptionsSvc.verify( 'ToolSvc.PublicHello', 'MyMessage', msg2 ) )\",\n \"def AddCheckTool(self, tool_id, label, bitmap, disabled_bitmap, short_help_string=\\\"\\\", long_help_string=\\\"\\\", client_data=None):\\r\\n\\r\\n return self.AddTool(tool_id, label, bitmap, disabled_bitmap, ITEM_CHECK, short_help_string, long_help_string, client_data)\",\n \"def toolName(self):\\n return QCoreApplication.translate(\\\"VDLTools\\\", \\\"Multiselect\\\")\",\n \"def _check_toolplus(x):\\n Tool = collections.namedtuple(\\\"Tool\\\", [\\\"name\\\", \\\"fname\\\"])\\n if \\\"=\\\" in x and len(x.split(\\\"=\\\")) == 2:\\n name, fname = x.split(\\\"=\\\")\\n fname = os.path.normpath(os.path.realpath(fname))\\n if not os.path.exists(fname):\\n raise argparse.ArgumentTypeError(\\\"Unexpected --toolplus argument for %s. File does not exist: %s\\\"\\n % (name, fname))\\n return Tool(name, fname)\\n else:\\n raise argparse.ArgumentTypeError(\\\"Unexpected --toolplus argument. Expect toolname=filename.\\\")\",\n \"def SetToolLabel(self, tool_id, label):\\r\\n \\r\\n tool = self.FindTool(tool_id)\\r\\n if tool: \\r\\n tool.label = label\",\n \"def parse_tool_path(self):\",\n \"def __init__(self, name, description, cli_opts):\\n self.name = name\\n self.description = description\\n self.cli_opts = cli_opts\",\n \"def package_tool( self, trans, tool_id ):\\n # Make sure the tool is actually loaded.\\n if tool_id not in self._tools_by_id:\\n raise ObjectNotFound(\\\"No tool found with id '%s'.\\\" % escape( tool_id ))\\n else:\\n tool = self._tools_by_id[ tool_id ]\\n return tool.to_archive()\",\n \"def run(self):\\n self.iface.mapCanvas().setMapTool(self.tool)\",\n \"def tool_factory_function(source, splitting_node=None, **parameters):\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if\\n f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.source == source\\n and m.splitting_node == splitting_node\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(**parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n source=source,\\n splitting_node=splitting_node)\",\n \"def setup_tool(shell,tool_name,tool_revision,invoke_script,\\n test_program_name,test_program_script):\\n\\n # check that the user is in the apps group\\n groups,es = shell.execute(\\\"echo ${USER} | groups\\\")\\n if \\\"apps\\\" not in groups.split():\\n # user not in the apps group, bail\\n username,es = shell.execute(\\\"echo ${USER}\\\")\\n# raise RuntimeError(\\\"user %s not in apps group: %s\\\" % (username,groups))\\n raise GroupMembershipError(\\\"user %s not in apps group: %s\\\" % (username,groups))\\n\\n # become the apps user\\n shell.send('sudo su - apps')\\n shell.start_bash_shell()\\n\\n tool_revision_string = \\\"r%s\\\" % (tool_revision)\\n tool_path = \\\"/apps/%s/%s\\\" % (tool_name, tool_revision_string)\\n dev_path = \\\"/apps/%s/dev\\\" % (tool_name)\\n\\n # setup the new tool's invoke script\\n # mv %(tool_path)s %(tmp_tool_path)s;\\n # tmp_tool_path = tool_path + \\\".old\\\"\\n # \\\"\\\"\\\" % {'tool_path' : tool_path, 'tmp_tool_path' : tmp_tool_path}\\n script = \\\"\\\"\\\"\\n rm -rf %(tool_path)s;\\n mkdir %(tool_path)s;\\n rm -f %(dev_path)s;\\n ln -s %(tool_path)s %(dev_path)s;\\n cd %(tool_path)s;\\n mkdir middleware bin;\\n \\\"\\\"\\\" % {'tool_path' : tool_path,\\n 'dev_path' : dev_path}\\n\\n commands = script.strip().split('\\\\n')\\n shell.execute(commands)\\n\\n # write the invoke script to disk\\n shell.write_file('middleware/invoke', invoke_script)\\n shell.execute('chmod 755 middleware/invoke')\\n\\n # write the test program to disk\\n shell.write_file(\\\"bin/%s\\\" % (test_program_name), test_program_script)\\n shell.execute(\\\"chmod 755 bin/%s\\\" % (test_program_name))\\n\\n # exit from apps user\\n shell.stop_bash_shell()\\n shell.send('exit')\",\n \"def runmain(args):\\n\\n #case: no extra args, so return help\\n if len(args) == 0:\\n print USAGE\\n return\\n\\n toolname = args[1]\\n if toolname == 'help':\\n print USAGE\\n return\\n\\n elif toolname == 'splitdata':\\n splitdata(args)\\n return\\n \\n elif toolname == 'aboutdata':\\n aboutdata(args)\\n return\\n\\n elif toolname == 'test':\\n testffx(args)\\n return\\n \\n else:\\n print \\\"There is no toolname of '%s'.\\\" % toolname\\n print USAGE\\n return\",\n \"def SetupToolBar( self ):\\n tb = self.CreateToolBar( self.TBFLAGS )\\n tsize = (24,24)\\n tb.ToolBitmapSize = tsize\\n open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize)\\n tb.AddLabelTool(ID_OPEN, \\\"Open\\\", open_bmp, shortHelp=\\\"Open\\\", longHelp=\\\"Open a (c)Profile trace file\\\")\\n tb.AddSeparator()\\n# self.Bind(wx.EVT_TOOL, self.OnOpenFile, id=ID_OPEN)\\n self.rootViewTool = tb.AddLabelTool(\\n ID_ROOT_VIEW, _(\\\"Root View\\\"),\\n wx.ArtProvider.GetBitmap(wx.ART_GO_HOME, wx.ART_TOOLBAR, tsize),\\n shortHelp=_(\\\"Display the root of the current view tree (home view)\\\")\\n )\\n self.rootViewTool = tb.AddLabelTool(\\n ID_BACK_VIEW, _(\\\"Back\\\"), \\n wx.ArtProvider.GetBitmap(wx.ART_GO_BACK, wx.ART_TOOLBAR, tsize),\\n shortHelp=_(\\\"Back to the previously activated node in the call tree\\\")\\n )\\n self.upViewTool = tb.AddLabelTool(\\n ID_UP_VIEW, _(\\\"Up\\\"),\\n wx.ArtProvider.GetBitmap(wx.ART_GO_UP, wx.ART_TOOLBAR, tsize),\\n shortHelp=_(\\\"Go one level up the call tree (highest-percentage parent)\\\")\\n )\\n tb.AddSeparator()\\n # TODO: figure out why the control is sizing the label incorrectly on Linux\\n self.percentageViewTool = wx.CheckBox( tb, -1, _(\\\"Percent \\\") )\\n self.percentageViewTool.SetToolTip( wx.ToolTip(_(\\\"Toggle display of percentages in list views\\\")) )\\n tb.AddControl( self.percentageViewTool )\\n wx.EVT_CHECKBOX( self.percentageViewTool, self.percentageViewTool.GetId(), self.OnPercentageView )\\n \\n self.packageViewTool = wx.CheckBox( tb, -1, _(\\\"File View \\\") )\\n self.packageViewTool.SetToolTip( wx.ToolTip(_(\\\"Switch between call-hierarchy and package/module/function hierarchy\\\")) )\\n tb.AddControl( self.packageViewTool )\\n wx.EVT_CHECKBOX( self.packageViewTool, self.packageViewTool.GetId(), self.OnPackageView )\\n tb.Realize()\",\n \"def setup(self, optparser):\\n\\t\\tpass\",\n \"def find_and_register(cls, name, vers):\\n # locate the given tool using its name as an executable,\\n # and adjust the version to match the detected version (major.minor)\\n\\n tc = CLang(name, vers)\\n\\n if tc.version is None:\\n debug(\\\"looking for {}\\\".format(tc.name))\\n err = tc.detect_version_on_path_or_env('CC', tc.name, needs_version=False,\\n allow_unversioned=(vers is None))\\n if err is not None:\\n return\\n\\n try:\\n comp = subprocess.run([tc.name, '--version'],\\n stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n\\n # ignore stray intl chars\\n comp.stdout = str(comp.stdout, encoding='ascii', errors='ignore')\\n comp.stderr = str(comp.stderr, encoding='ascii', errors='ignore')\\n except OSError as e:\\n # e.g. PermissionError, from trying to run Cygwin softlink\\n debug(\\\"failed to invoke '{}', error '{}'\\\".format(tc.name, e))\\n return\\n\\n if comp.returncode == 0:\\n # e.g. clang version 3.8.0-2ubuntu3~trusty5 (tags/RELEASE_380/final)\\n # e.g. clang version 3.8.1 (branches/release_38)\\n # e.g. clang version 5.0.1-svn319952-1~exp1 (branches/release_50)\\n # and the outliers:\\n # e.g. Apple LLVM version 8.0.0 (clang-800.0.42.1)\\n # e.g. Apple LLVM version 10.0.0 (clang-1000.11.45.2)\\n # the version does not correspond to any actual upstream LLVM version :-p\\n stdout = comp.stdout\\n m = re.match(r'.*?\\\\s+version\\\\s+(\\\\d+\\\\.\\\\d+)(\\\\.\\\\d+)?.*', stdout, re.M)\\n if m:\\n version = m.group(1)\\n debug(\\\"matched {}\\\".format(version))\\n\\n # then rename this tool to be more specific\\n tc.name = 'clang-' + version\\n tc.version = version\\n else:\\n debug(\\\"did not find version information in output: {}\\\".format(\\n comp.stdout + comp.stderr))\\n else:\\n debug(\\\"failed to run '{} --version': {}\\\".format(tc.name, comp.stderr))\\n\\n if tc.version:\\n if version_compare(tc.version, cls.VERSION_CLANG_LATEST) > 0:\\n cls.VERSION_CLANG_LATEST = tc.version\\n\\n Toolchain.register(tc, force=True)\",\n \"def __init__(self, name=\\\"ProRobot\\\"):\\n super().__init__(name)\",\n \"def __init__(self, name, progname, progtype):\\n self.progargs = \\\"\\\"\\n self.name = name\\n if progtype in self.INTERPRETED:\\n #sys.chmod(progname, stat.S_IXUS)\\n self.progname = self.INTERPRETED[progtype]\\n self.progargs = progname\\n elif progtype in self.COMPILED:\\n self.progname = self.build(progname, progtype)\\n else:\\n raise AssertionError\",\n \"def get_tool_by_id(self, tool_id, package_name=None, dev=False, *args, **kwargs):\\n\\n if not package_name:\\n package_name = tool_id.replace('.', '-').split('-')[0]\\n\\n if package_name not in self._plugins:\\n LOGGER.warning('Impossible to load tool by id: package \\\"{}\\\" is not registered!'.format(package_name))\\n return None\\n\\n if tool_id in self._plugins[package_name]:\\n tool_inst = self._plugins[package_name][tool_id].get('tool_instance', None)\\n if tool_inst:\\n return tool_inst\\n\\n tool_to_run = None\\n\\n for plugin_id in self._plugins[package_name].keys():\\n tool_path = self._plugins[package_name][plugin_id]['plugin_package']\\n sec_path = tool_path.replace('.', '-')\\n if sec_path == tool_path or sec_path == tool_id:\\n tool_to_run = tool_id\\n break\\n else:\\n tool_name = tool_path.split('.')[-1]\\n if tool_name == tool_path:\\n tool_to_run = tool_id\\n break\\n\\n if not tool_to_run or tool_to_run not in self._plugins[package_name]:\\n LOGGER.warning('Tool \\\"{}\\\" is not registered!'.format(tool_id))\\n return None\\n\\n tool_loader = self._plugins[package_name][tool_to_run]['loader']\\n pkg_loader = self._plugins[package_name][tool_to_run]['loader']\\n tool_config = self._plugins[package_name][tool_to_run]['config']\\n tool_fullname = tool_loader.fullname if python.is_python2() else tool_loader.loader.name\\n tool_version = self._plugins[package_name][tool_to_run]['version']\\n\\n pkg_name = pkg_loader.filename if python.is_python2() else os.path.dirname(pkg_loader.loader.path)\\n pkg_path = pkg_loader.fullname if python.is_python2() else pkg_loader.loader.name\\n\\n tool_found = None\\n for sub_module in pkgutil.walk_packages([self._plugins[package_name][tool_to_run]['plugin_package_path']]):\\n tool_importer, sub_module_name, _ = sub_module\\n mod = tool_importer.find_module(sub_module_name).load_module(sub_module_name)\\n for cname, obj in inspect.getmembers(mod, inspect.isclass):\\n if issubclass(obj, tool.DccTool):\\n obj.FILE_NAME = pkg_name\\n obj.FULL_NAME = pkg_path\\n tool_found = obj\\n break\\n if tool_found:\\n break\\n\\n if not tool_found:\\n LOGGER.error(\\\"Error while launching tool: {}\\\".format(tool_fullname))\\n return None\\n\\n # if dcc_loader:\\n # tool_config = dcc_config\\n\\n tool_settings = self.get_tool_settings_file(tool_id)\\n if not tool_settings.has_setting('theme'):\\n tool_settings.set('theme', 'default')\\n tool_settings.setFallbacksEnabled(False)\\n\\n tool_inst = tool_found(self, config=tool_config, settings=tool_settings, dev=dev, *args, **kwargs)\\n tool_inst.ID = tool_id\\n tool_inst.VERSION = tool_version\\n tool_inst.AUTHOR = tool_inst.config_dict().get('creator', None)\\n tool_inst.PACKAGE = package_name\\n\\n self._plugins[package_name][tool_id]['tool_instance'] = tool_inst\\n # self._plugins[package_name][plugin_id]['tool_instance'] = tool_inst\\n\\n return tool_inst\",\n \"def createToolBar(self):\\n pass\",\n \"def __init__(self,name:str,int,str,dex):\\r\\n super(Warrior, self).__init__(name,int,str,dex)\\r\\n self._class = 'Warrior'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78886044","0.74191546","0.73680484","0.7317306","0.72275203","0.7022156","0.6999495","0.6988887","0.6932704","0.6919116","0.6890748","0.68180656","0.6817103","0.67857397","0.6773338","0.6738541","0.6737494","0.673033","0.6693258","0.6666185","0.6644223","0.66431016","0.66162163","0.6606282","0.6559455","0.6554128","0.64572334","0.6445579","0.6440499","0.64311796","0.6423979","0.6403357","0.6368358","0.63556623","0.63136107","0.6298381","0.6277835","0.6257583","0.6247587","0.6245328","0.62409705","0.6165334","0.6121878","0.6097154","0.6043976","0.604322","0.5937968","0.5919215","0.58983016","0.58941317","0.58876425","0.58861923","0.5885246","0.58525586","0.5849596","0.5838451","0.5807","0.57953787","0.5781627","0.57770514","0.5774754","0.5774535","0.5772337","0.5765827","0.575161","0.57452816","0.57367617","0.5729426","0.5726321","0.57252514","0.5721169","0.5700967","0.5697874","0.5684299","0.56707263","0.5669893","0.5669506","0.5663623","0.5659426","0.56428075","0.56320333","0.5617979","0.555667","0.5549475","0.5546859","0.55246496","0.551619","0.5512315","0.5507665","0.5502237","0.5489073","0.54851425","0.54845047","0.54808384","0.5478211","0.547497","0.54749554","0.5469796","0.54688245","0.54622364","0.54597896"],"string":"[\n \"0.78886044\",\n \"0.74191546\",\n \"0.73680484\",\n \"0.7317306\",\n \"0.72275203\",\n \"0.7022156\",\n \"0.6999495\",\n \"0.6988887\",\n \"0.6932704\",\n \"0.6919116\",\n \"0.6890748\",\n \"0.68180656\",\n \"0.6817103\",\n \"0.67857397\",\n \"0.6773338\",\n \"0.6738541\",\n \"0.6737494\",\n \"0.673033\",\n \"0.6693258\",\n \"0.6666185\",\n \"0.6644223\",\n \"0.66431016\",\n \"0.66162163\",\n \"0.6606282\",\n \"0.6559455\",\n \"0.6554128\",\n \"0.64572334\",\n \"0.6445579\",\n \"0.6440499\",\n \"0.64311796\",\n \"0.6423979\",\n \"0.6403357\",\n \"0.6368358\",\n \"0.63556623\",\n \"0.63136107\",\n \"0.6298381\",\n \"0.6277835\",\n \"0.6257583\",\n \"0.6247587\",\n \"0.6245328\",\n \"0.62409705\",\n \"0.6165334\",\n \"0.6121878\",\n \"0.6097154\",\n \"0.6043976\",\n \"0.604322\",\n \"0.5937968\",\n \"0.5919215\",\n \"0.58983016\",\n \"0.58941317\",\n \"0.58876425\",\n \"0.58861923\",\n \"0.5885246\",\n \"0.58525586\",\n \"0.5849596\",\n \"0.5838451\",\n \"0.5807\",\n \"0.57953787\",\n \"0.5781627\",\n \"0.57770514\",\n \"0.5774754\",\n \"0.5774535\",\n \"0.5772337\",\n \"0.5765827\",\n \"0.575161\",\n \"0.57452816\",\n \"0.57367617\",\n \"0.5729426\",\n \"0.5726321\",\n \"0.57252514\",\n \"0.5721169\",\n \"0.5700967\",\n \"0.5697874\",\n \"0.5684299\",\n \"0.56707263\",\n \"0.5669893\",\n \"0.5669506\",\n \"0.5663623\",\n \"0.5659426\",\n \"0.56428075\",\n \"0.56320333\",\n \"0.5617979\",\n \"0.555667\",\n \"0.5549475\",\n \"0.5546859\",\n \"0.55246496\",\n \"0.551619\",\n \"0.5512315\",\n \"0.5507665\",\n \"0.5502237\",\n \"0.5489073\",\n \"0.54851425\",\n \"0.54845047\",\n \"0.54808384\",\n \"0.5478211\",\n \"0.547497\",\n \"0.54749554\",\n \"0.5469796\",\n \"0.54688245\",\n \"0.54622364\",\n \"0.54597896\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":77698,"cells":{"query":{"kind":"string","value":"Set whether tool is licensed to execute."},"document":{"kind":"string","value":"def isLicensed(self):\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def isLicensed(self):\r\n try:\r\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\r\n raise Exception\r\n except Exception:\r\n return False # tool cannot be executed\r\n return True # tool can be executed\r","def isLicensed(self):\r\n try:\r\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\r\n raise Exception\r\n except Exception:\r\n return False # tool cannot be executed\r\n return True # tool can be executed\r","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed \n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed \n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed \n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed \n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed \n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed \n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed \n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed \n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\n try:\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\n raise Exception\n except Exception:\n return False # tool cannot be executed\n return True","def isLicensed(self):\r\n\t\treturn True","def isLicensed(self):\r\n\t\treturn True","def isLicensed(self):\r\n\t\treturn True","def isLicensed(self):\r\n\t\treturn True","def isLicensed(self):\r\n\t\treturn True","def isLicensed(self):\r\n\t\treturn True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\r\n return True","def isLicensed(self):\n\t\treturn True","def isLicensed(self):\n return True #arcpy.CheckExtension(\"3D\") and arcpy.CheckExtension(\"Aeronautical\")","def license(new_key):\n if new_key is not None:\n # click.echo('Saving key to configuration')\n config.set_license(new_key)\n license_key = config.get_license()\n if license_key:\n click.echo(license_key)\n else:\n click.echo(\"No license found: Use --set to configure the key\")","def is_proprietary():\n return False","def EnableLicenseCheck(self):\n return self._get_attribute('enableLicenseCheck')","def activate_license(self):\n response = self.client.activate_license()\n if str(response[\"result\"][\"code\"]) == \"0\" and str(response[\"data\"][\"LicenseActiveResult\"]) == \"0\":\n self.module.exit_json(msg=\"Activate license file Success.\", changed=True, status='success')\n else:\n self.module.fail_json(msg=\"Activate license file fail.{0}\".format(response['result']['description']),\n status='fail', changed=False)","def test_approve(self):\n\n username,userpass = self.testdata.find_account_for('toolsubmitter')\n\n self.utils.account.login_as(username,userpass)\n\n self.contribtool.approve(TOOLNAME,TOOLLICENSEDATA)","def setToolTo(*args, **kwargs)->None:\n pass","def test_itar_restrict_software_asset(self):\n pass","def license(*args, borrow: bool=True, info: bool=True, isBorrowed: bool=True, isExported:\n bool=True, isTrial: bool=True, licenseMethod: bool=True, productChoice: bool=True,\n r: bool=True, showBorrowInfo: bool=True, showProductInfoDialog: bool=True, status:\n bool=True, usage: bool=True, **kwargs)->AnyStr:\n pass","def set_concluded_license(self, doc, lic):\n if self.has_package(doc) and self.has_file(doc):\n if not self.file_conc_lics_set:\n self.file_conc_lics_set = True\n if validations.validate_lics_conc(lic):\n self.file(doc).conc_lics = lic\n return True\n else:\n raise SPDXValueError('File::ConcludedLicense')\n else:\n raise CardinalityError('File::ConcludedLicense')\n else:\n raise OrderError('File::ConcludedLicense')","def set_pkg_license_declared(self, doc, lic):\n self.assert_package_exists()\n if not self.package_license_declared_set:\n self.package_license_declared_set = True\n if validations.validate_lics_conc(lic):\n doc.package.license_declared = lic\n return True\n else:\n raise SPDXValueError('Package::LicenseDeclared')\n else:\n raise CardinalityError('Package::LicenseDeclared')","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def set_pkg_license_from_file(self, doc, lic):\n self.assert_package_exists()\n if validations.validate_lics_from_file(lic):\n doc.package.licenses_from_files.append(lic)\n return True\n else:\n raise SPDXValueError('Package::LicensesFromFile')","def install_license():\n query = {\n \"type\": \"op\",\n \"cmd\": \"<request><license><install></install></license></request>\",\n }\n\n return __proxy__[\"panos.call\"](query)","def IsSet(self, *args):\n return _XCAFDoc.XCAFDoc_LayerTool_IsSet(self, *args)","def test_enable(self):\n # OSA script should have been installed and enabled in setUp function\n # Now let's disable it, which should return True.\n self.assertTrue(self.run_function(\"assistive.enable\", [OSA_SCRIPT, False]))\n # Double check the script was disabled, as intended.\n self.assertFalse(self.run_function(\"assistive.enabled\", [OSA_SCRIPT]))\n # Now re-enable\n self.assertTrue(self.run_function(\"assistive.enable\", [OSA_SCRIPT]))\n # Double check the script was enabled, as intended.\n self.assertTrue(self.run_function(\"assistive.enabled\", [OSA_SCRIPT]))","def _check_for_license_acceptance(self, dep):\n if \"license\" in self.dependency_dict[dep]:\n license_name = self.dependency_dict[dep][\"license\"]\n else:\n license_name = \"restrictive\"\n if \"license_file\" in self.dependency_dict[dep]:\n license_text = Path(\n self.dependency_dict[dep][\"license_file\"]\n ).read_text()\n logger.warning(license_text)\n while \"invalid answer\":\n reply = (\n str(\n input(\n f\"Do you accept this {license_name} license? (y/n): \"\n )\n )\n .lower()\n .strip()\n )\n if len(reply) > 0:\n if reply[0] == \"y\":\n return True\n if reply[0] == \"n\":\n return False","def test_default_license(self):\n # When no license is specified, the license should default to \"CC BY\"\n story = create_story(title=\"Test Story\", summary=\"Test Summary\",\n byline=\"Test Byline\")\n self.assertEqual(story.license, 'CC BY')\n\n # When a license is specified, it should be set\n story = create_story(title=\"Test Story\", summary=\"Test Summary\",\n byline=\"Test Byline\", license=\"CC BY-NC-SA\")\n self.assertEqual(story.license, 'CC BY-NC-SA')","def set_license_analytics(self, license_params: dict) -> PrivXAPIResponse:\n response_status, data = self._http_post(\n UrlEnum.LICENSE.OPT_IN,\n body=license_params,\n )\n return PrivXAPIResponse(response_status, HTTPStatus.OK, data)","def license(self, license):\n\n self._license = license","def software_license(self) -> str:\n return self.random.choice(LICENSES)","def test_enabled(self):\n # OSA script should have been installed in setUp function, which sets\n # enabled to True by default.\n self.assertTrue(self.run_function(\"assistive.enabled\", [OSA_SCRIPT]))\n # Disable OSA Script\n self.run_function(\"assistive.enable\", [OSA_SCRIPT, False])\n # Assert against new disabled status\n self.assertFalse(self.run_function(\"assistive.enabled\", [OSA_SCRIPT]))","def show_license(ctx, param, value):\n if not value or ctx.resilient_parsing:\n return\n click.echo(lic)\n ctx.exit()","def test_set_asset_license(self):\n\n story = create_story(title=\"Test Story\", summary=\"Test Summary\",\n byline=\"Test Byline\", status='published')\n asset = create_html_asset(type='text', title='Test Asset', \n body='Test content')\n story.assets.add(asset)\n story.save()\n self.assertNotEqual(story.license, 'CC BY-NC-SA')\n self.assertEqual(asset.license, '')\n story.license = 'CC BY-NC-SA'\n set_asset_license(sender=Story, instance=story)\n asset = Asset.objects.get(pk=asset.pk)\n self.assertEqual(asset.license, story.license)","def set_pkg_licenses_concluded(self, doc, licenses):\n self.assert_package_exists()\n if not self.package_conc_lics_set:\n self.package_conc_lics_set = True\n if validations.validate_lics_conc(licenses):\n doc.package.conc_lics = licenses\n return True\n else:\n raise SPDXValueError('Package::ConcludedLicenses')\n else:\n raise CardinalityError('Package::ConcludedLicenses')","def erase_licenses(self):\n res = self._dll.JLINK_EMU_EraseLicenses()\n return (res == 0)"],"string":"[\n \"def isLicensed(self):\\r\\n try:\\r\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\r\\n raise Exception\\r\\n except Exception:\\r\\n return False # tool cannot be executed\\r\\n return True # tool can be executed\\r\",\n \"def isLicensed(self):\\r\\n try:\\r\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\r\\n raise Exception\\r\\n except Exception:\\r\\n return False # tool cannot be executed\\r\\n return True # tool can be executed\\r\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed \\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed \\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed \\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed \\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed \\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed \\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed \\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed \\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\n try:\\n if arcpy.CheckExtension(\\\"Spatial\\\") != \\\"Available\\\":\\n raise Exception\\n except Exception:\\n return False # tool cannot be executed\\n return True\",\n \"def isLicensed(self):\\r\\n\\t\\treturn True\",\n \"def isLicensed(self):\\r\\n\\t\\treturn True\",\n \"def isLicensed(self):\\r\\n\\t\\treturn True\",\n \"def isLicensed(self):\\r\\n\\t\\treturn True\",\n \"def isLicensed(self):\\r\\n\\t\\treturn True\",\n \"def isLicensed(self):\\r\\n\\t\\treturn True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\r\\n return True\",\n \"def isLicensed(self):\\n\\t\\treturn True\",\n \"def isLicensed(self):\\n return True #arcpy.CheckExtension(\\\"3D\\\") and arcpy.CheckExtension(\\\"Aeronautical\\\")\",\n \"def license(new_key):\\n if new_key is not None:\\n # click.echo('Saving key to configuration')\\n config.set_license(new_key)\\n license_key = config.get_license()\\n if license_key:\\n click.echo(license_key)\\n else:\\n click.echo(\\\"No license found: Use --set to configure the key\\\")\",\n \"def is_proprietary():\\n return False\",\n \"def EnableLicenseCheck(self):\\n return self._get_attribute('enableLicenseCheck')\",\n \"def activate_license(self):\\n response = self.client.activate_license()\\n if str(response[\\\"result\\\"][\\\"code\\\"]) == \\\"0\\\" and str(response[\\\"data\\\"][\\\"LicenseActiveResult\\\"]) == \\\"0\\\":\\n self.module.exit_json(msg=\\\"Activate license file Success.\\\", changed=True, status='success')\\n else:\\n self.module.fail_json(msg=\\\"Activate license file fail.{0}\\\".format(response['result']['description']),\\n status='fail', changed=False)\",\n \"def test_approve(self):\\n\\n username,userpass = self.testdata.find_account_for('toolsubmitter')\\n\\n self.utils.account.login_as(username,userpass)\\n\\n self.contribtool.approve(TOOLNAME,TOOLLICENSEDATA)\",\n \"def setToolTo(*args, **kwargs)->None:\\n pass\",\n \"def test_itar_restrict_software_asset(self):\\n pass\",\n \"def license(*args, borrow: bool=True, info: bool=True, isBorrowed: bool=True, isExported:\\n bool=True, isTrial: bool=True, licenseMethod: bool=True, productChoice: bool=True,\\n r: bool=True, showBorrowInfo: bool=True, showProductInfoDialog: bool=True, status:\\n bool=True, usage: bool=True, **kwargs)->AnyStr:\\n pass\",\n \"def set_concluded_license(self, doc, lic):\\n if self.has_package(doc) and self.has_file(doc):\\n if not self.file_conc_lics_set:\\n self.file_conc_lics_set = True\\n if validations.validate_lics_conc(lic):\\n self.file(doc).conc_lics = lic\\n return True\\n else:\\n raise SPDXValueError('File::ConcludedLicense')\\n else:\\n raise CardinalityError('File::ConcludedLicense')\\n else:\\n raise OrderError('File::ConcludedLicense')\",\n \"def set_pkg_license_declared(self, doc, lic):\\n self.assert_package_exists()\\n if not self.package_license_declared_set:\\n self.package_license_declared_set = True\\n if validations.validate_lics_conc(lic):\\n doc.package.license_declared = lic\\n return True\\n else:\\n raise SPDXValueError('Package::LicenseDeclared')\\n else:\\n raise CardinalityError('Package::LicenseDeclared')\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def set_pkg_license_from_file(self, doc, lic):\\n self.assert_package_exists()\\n if validations.validate_lics_from_file(lic):\\n doc.package.licenses_from_files.append(lic)\\n return True\\n else:\\n raise SPDXValueError('Package::LicensesFromFile')\",\n \"def install_license():\\n query = {\\n \\\"type\\\": \\\"op\\\",\\n \\\"cmd\\\": \\\"<request><license><install></install></license></request>\\\",\\n }\\n\\n return __proxy__[\\\"panos.call\\\"](query)\",\n \"def IsSet(self, *args):\\n return _XCAFDoc.XCAFDoc_LayerTool_IsSet(self, *args)\",\n \"def test_enable(self):\\n # OSA script should have been installed and enabled in setUp function\\n # Now let's disable it, which should return True.\\n self.assertTrue(self.run_function(\\\"assistive.enable\\\", [OSA_SCRIPT, False]))\\n # Double check the script was disabled, as intended.\\n self.assertFalse(self.run_function(\\\"assistive.enabled\\\", [OSA_SCRIPT]))\\n # Now re-enable\\n self.assertTrue(self.run_function(\\\"assistive.enable\\\", [OSA_SCRIPT]))\\n # Double check the script was enabled, as intended.\\n self.assertTrue(self.run_function(\\\"assistive.enabled\\\", [OSA_SCRIPT]))\",\n \"def _check_for_license_acceptance(self, dep):\\n if \\\"license\\\" in self.dependency_dict[dep]:\\n license_name = self.dependency_dict[dep][\\\"license\\\"]\\n else:\\n license_name = \\\"restrictive\\\"\\n if \\\"license_file\\\" in self.dependency_dict[dep]:\\n license_text = Path(\\n self.dependency_dict[dep][\\\"license_file\\\"]\\n ).read_text()\\n logger.warning(license_text)\\n while \\\"invalid answer\\\":\\n reply = (\\n str(\\n input(\\n f\\\"Do you accept this {license_name} license? (y/n): \\\"\\n )\\n )\\n .lower()\\n .strip()\\n )\\n if len(reply) > 0:\\n if reply[0] == \\\"y\\\":\\n return True\\n if reply[0] == \\\"n\\\":\\n return False\",\n \"def test_default_license(self):\\n # When no license is specified, the license should default to \\\"CC BY\\\"\\n story = create_story(title=\\\"Test Story\\\", summary=\\\"Test Summary\\\",\\n byline=\\\"Test Byline\\\")\\n self.assertEqual(story.license, 'CC BY')\\n\\n # When a license is specified, it should be set\\n story = create_story(title=\\\"Test Story\\\", summary=\\\"Test Summary\\\",\\n byline=\\\"Test Byline\\\", license=\\\"CC BY-NC-SA\\\")\\n self.assertEqual(story.license, 'CC BY-NC-SA')\",\n \"def set_license_analytics(self, license_params: dict) -> PrivXAPIResponse:\\n response_status, data = self._http_post(\\n UrlEnum.LICENSE.OPT_IN,\\n body=license_params,\\n )\\n return PrivXAPIResponse(response_status, HTTPStatus.OK, data)\",\n \"def license(self, license):\\n\\n self._license = license\",\n \"def software_license(self) -> str:\\n return self.random.choice(LICENSES)\",\n \"def test_enabled(self):\\n # OSA script should have been installed in setUp function, which sets\\n # enabled to True by default.\\n self.assertTrue(self.run_function(\\\"assistive.enabled\\\", [OSA_SCRIPT]))\\n # Disable OSA Script\\n self.run_function(\\\"assistive.enable\\\", [OSA_SCRIPT, False])\\n # Assert against new disabled status\\n self.assertFalse(self.run_function(\\\"assistive.enabled\\\", [OSA_SCRIPT]))\",\n \"def show_license(ctx, param, value):\\n if not value or ctx.resilient_parsing:\\n return\\n click.echo(lic)\\n ctx.exit()\",\n \"def test_set_asset_license(self):\\n\\n story = create_story(title=\\\"Test Story\\\", summary=\\\"Test Summary\\\",\\n byline=\\\"Test Byline\\\", status='published')\\n asset = create_html_asset(type='text', title='Test Asset', \\n body='Test content')\\n story.assets.add(asset)\\n story.save()\\n self.assertNotEqual(story.license, 'CC BY-NC-SA')\\n self.assertEqual(asset.license, '')\\n story.license = 'CC BY-NC-SA'\\n set_asset_license(sender=Story, instance=story)\\n asset = Asset.objects.get(pk=asset.pk)\\n self.assertEqual(asset.license, story.license)\",\n \"def set_pkg_licenses_concluded(self, doc, licenses):\\n self.assert_package_exists()\\n if not self.package_conc_lics_set:\\n self.package_conc_lics_set = True\\n if validations.validate_lics_conc(licenses):\\n doc.package.conc_lics = licenses\\n return True\\n else:\\n raise SPDXValueError('Package::ConcludedLicenses')\\n else:\\n raise CardinalityError('Package::ConcludedLicenses')\",\n \"def erase_licenses(self):\\n res = self._dll.JLINK_EMU_EraseLicenses()\\n return (res == 0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67727894","0.67727894","0.65478224","0.65478224","0.65478224","0.65478224","0.65478224","0.65478224","0.65478224","0.65478224","0.64847887","0.64847887","0.64847887","0.64847887","0.64847887","0.64847887","0.64847887","0.64847887","0.64847887","0.63919765","0.63919765","0.63919765","0.63919765","0.63919765","0.63919765","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.63919127","0.6380334","0.6028479","0.5826984","0.569496","0.5688195","0.5665705","0.565657","0.5622036","0.5604026","0.55735934","0.55518556","0.547234","0.5450931","0.5450931","0.5450931","0.5450931","0.5450931","0.5450931","0.5450931","0.5450931","0.5450931","0.5450931","0.5450931","0.5449443","0.544055","0.5398713","0.5397981","0.5383721","0.53632706","0.536017","0.53122425","0.53030354","0.5295415","0.5271691","0.5265537","0.5260078","0.52307284"],"string":"[\n \"0.67727894\",\n \"0.67727894\",\n \"0.65478224\",\n \"0.65478224\",\n \"0.65478224\",\n \"0.65478224\",\n \"0.65478224\",\n \"0.65478224\",\n \"0.65478224\",\n \"0.65478224\",\n \"0.64847887\",\n \"0.64847887\",\n \"0.64847887\",\n \"0.64847887\",\n \"0.64847887\",\n \"0.64847887\",\n \"0.64847887\",\n \"0.64847887\",\n \"0.64847887\",\n \"0.63919765\",\n \"0.63919765\",\n \"0.63919765\",\n \"0.63919765\",\n \"0.63919765\",\n \"0.63919765\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.63919127\",\n \"0.6380334\",\n \"0.6028479\",\n \"0.5826984\",\n \"0.569496\",\n \"0.5688195\",\n \"0.5665705\",\n \"0.565657\",\n \"0.5622036\",\n \"0.5604026\",\n \"0.55735934\",\n \"0.55518556\",\n \"0.547234\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5450931\",\n \"0.5449443\",\n \"0.544055\",\n \"0.5398713\",\n \"0.5397981\",\n \"0.5383721\",\n \"0.53632706\",\n \"0.536017\",\n \"0.53122425\",\n \"0.53030354\",\n \"0.5295415\",\n \"0.5271691\",\n \"0.5265537\",\n \"0.5260078\",\n \"0.52307284\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63335377"},"document_rank":{"kind":"string","value":"57"}}},{"rowIdx":77699,"cells":{"query":{"kind":"string","value":"Modify the values and properties of parameters before internal validation is performed. This method is called whenever a parameter has been changed."},"document":{"kind":"string","value":"def updateParameters(self, parameters):\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def updateParameters(self, parameters):\n # if parameters[0].altered:\n # parameters[1].value = arcpy.ValidateFieldName(parameters[1].value,\n # parameters[0].value)\n return","def parameters_changed(self):\n pass","def _paramUpdate(self):\n\n # Update the database attributes accordingly.\n dt.utilities.DB_attrs_save(self.Database, self.newParam)","def adjust_parameter_validator(self, param):\n if not isinstance(param.vals, Numbers):\n raise Exception('Only the Numbers validator is supported.')\n min_val = param.vals._min_value\n max_val = param.vals._max_value\n\n min_val_upd = self.round_dac(min_val, param.name)\n max_val_upd = self.round_dac(max_val, param.name)\n\n param.vals = Numbers(min_val_upd, max_val_upd)","def _validate_parameters(self):\n super()._validate_parameters()\n\n #################### callbacks ####################\n self.callbacks = check_callback(self.callbacks)","def _validate_params(self):\n raise NotImplementedError('Must be implemented in subclasses.')","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self):\n\n return","def updateParameters(self, parameters):","def update_params(self):\n pass","def _set_params(self, *args, **kwargs):\n\n params = args[0]\n\n # check for attempt to set readonly parameters (read-only or immutable set outside startup)\n self._verify_not_readonly(*args, **kwargs)\n old_config = self._param_dict.get_config()\n\n for (key, val) in params.iteritems():\n log.debug(\"KEY = \" + str(key) + \" VALUE = \" + str(val))\n self._param_dict.set_value(key, val)\n\n new_config = self._param_dict.get_config()\n # check for parameter change\n if not dict_equal(old_config, new_config):\n self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)","def _update_params(self):\n raise NotImplementedException()","def _update_params(self):\n pass","def _validate_params(self):\n assert set(self.required_params) - set(self._params) == set()\n for par, val in self.optional_params.items():\n if par not in self._params:\n self._params[par] = val","def set_params(self):\r\n pass","def updateParameters(self, parameters):\n\t\treturn","def _parameters_changed_notification(self, me, which=None):\n self._optimizer_copy_transformed = False # tells the optimizer array to update on next request\n self.parameters_changed()","def parameters(self, new_params):\n if not self._is_parametric:\n raise AttributeError(\n f\"Object of type {self.__class__.__name__} has no attribute parameters\"\n )\n self.set(parameters=new_params)","def set_params(self):\n raise NotImplementedError","def _set_parameters(self, override_previous=True, validate_legality=False,\n **parameters):\n # The 'mode' parameter is only relevant to the current hierarchy\n self.mode = parameters.pop('mode', self.mode)\n\n for name, value in iteritems(parameters):\n if isinstance(value, Pipe):\n if override_previous or (name not in self.__dict__ and\n name not in self._pipes):\n\n self._pipes[name] = value\n\n else:\n if override_previous or (name not in self.__dict__ and\n name not in self._pipes):\n\n if isinstance(value, BaseResource):\n self.add_resources({name: value})\n\n else:\n setattr(self, name, value)\n\n if validate_legality and not self._is_valid_input(name):\n raise AttributeError(\"Unrecognized parameter %r passed to %r\" %\n (name, self.data.name))","def set_parameter(self, params, name, val):\n raise NotImplementedError()","def set_params(self, params):","def _validate(self):\n for p in self.parameters:\n #Check for missing required parameters:\n if p.is_required and not(p.is_set):\n raise ValueError(\"Parameter %s is not set.\" \\\n % p.names[-1])\n #Also repeat the parameter validation here, just in case?","def set_params(self, **params):\n return super().set_params(**params)","def paramValidationPref(self, setting):\n self.set_preference(setting,PARAM_VALIDATION_PREF)","def _postprocessing(self):\n # (in)validate\n if len(self._var_names) == 0:\n self.invalidate()\n else:\n self.put_param('is_valid', True)\n \n # set type\n self.put_param('type', 'Generic')","def params(self,new):\n self._params = new\n self._config_set()\n self._make_model()","def set_params(self, *, params: Params) -> None: # pragma: no cover\n\t\tsuper().set_params(params=params)","def _set_params(self, *args, **kwargs):\n try:\n params = args[0]\n except IndexError:\n raise InstrumentParameterException('Set command requires a parameter dict.')\n\n self._verify_not_readonly(*args, **kwargs)\n update_params = False\n\n # check values that the instrument doesn't validate\n # handle special cases for driver specific parameters\n for (key, val) in params.iteritems():\n if key == Parameter.PUMP_DELAY and (val < MIN_PUMP_DELAY or val > MAX_PUMP_DELAY):\n raise InstrumentParameterException(\"pump delay out of range\")\n elif key == Parameter.NUM_AVG_SAMPLES and (val < MIN_AVG_SAMPLES or val > MAX_AVG_SAMPLES):\n raise InstrumentParameterException(\"num average samples out of range\")\n\n for (key, val) in params.iteritems():\n\n old_val = self._param_dict.format(key)\n new_val = self._param_dict.format(key, val)\n log.debug(\"KEY = %r OLD VALUE = %r NEW VALUE = %r\", key, old_val, new_val)\n\n if old_val != new_val:\n update_params = True\n if ConfirmedParameter.has(key):\n # We add a write delay here because this command has to be sent\n # twice, the write delay allows it to process the first command\n # before it receives the beginning of the second.\n self._do_cmd_resp(Command.SET, key, val, write_delay=0.2)\n else:\n self._do_cmd_resp(Command.SET, key, val, **kwargs)\n\n log.debug(\"set complete, update params\")\n self._update_params()\n if update_params:\n self._update_params()","def set_params(self, **params):\n\n return super().set_params(**params)","def updateParameters(self, parameters):\n if parameters[0].value:\n parameters[1].enabled = True\n parameters[2].enabled = True\n else:\n parameters[1].enabled = False\n parameters[2].enabled = False\n return","def updateParameters(self, parameters):\n if parameters[0].value:\n parameters[1].enabled = True\n parameters[2].enabled = True\n else:\n parameters[1].enabled = False\n parameters[2].enabled = False\n return","def setParameter(self, name, value):","def em_update_params(self):\n for name in self.likelihood_params:\n with self.elbo_check(name):\n self.update_param(name)","def _update_parameters(self, delta):\n if delta is not None:\n self.SGD.update_with_L1_regularization(self.variables, delta, self.L1)","def set_parameter_value(self, parameter, value):\n pass","def update_values(self, to_update):\n for key, value in kwargs.iteritems():\n self.params[key] = value\n # update the possibly dependent parameters\n self.set_filenames()","def updateParameters(self, parameters):\r\n #return\r\n parameters[2].enabled = 0\r\n parameters[3].enabled = 0\r\n parameters[4].enabled = 0","def updateParameters(self, parameters):\r\n #return\r\n parameters[2].enabled = 0\r\n parameters[3].enabled = 0\r\n parameters[4].enabled = 0","def _setup_params(self,**params):\n ### a parameter might be passed in for one of the extra_pos;\n ### if a key in the params dict is not a *parameter* of this\n ### PO, then try it on the extra_pos\n for n,p in params.items():\n if n not in self.params():\n self.set_parameter_value(n,p)\n del params[n]\n\n Parameterized._setup_params(self,**params)","def _update_parameters(self, delta):\n if delta is not None:\n VectorRegression._update_parameters(self, delta)","def _set_parameters(self, parameters):\n self.parameters = parameters\n self._set_points_and_weights()","def set_params(self, **kwargs):\n ...","def set_parameters(self,params):\n K3Supervisor.set_parameters(self,params)\n self.blending.set_parameters(self.parameters)","def set_previous_parameters(self, params):\n\n self.param = params.copy()\n\n # save old params\n self.old_param = params.copy()","def set_params(self, params_):\n x_start, x_end = params_[\"lim_fit\"]\n self.find_idx_of_fit_limit(x_start, x_end)\n self.is_error_bar_for_fit = params_[\"use_error_bar\"]\n self.fitting_method1 = params_[\"method1\"]\n self.fitting_method2 = params_[\"method2\"]\n self.qty_to_min = params_[\"qty_to_min\"]\n\n for i, key in enumerate(self.params):\n # self.params[key].set(value=params_[\"val\"][i], min=params_[\"min\"][i], max=params_[\"max\"][i], vary=bool(params_[\"hold\"][i]), brute_step=params_[\"brute_step\"][i])\n if self.params[key].user_data is not None:\n if \"dontGenerate\" in self.params[key].user_data:\n continue\n self.params[key].set(value=params_[key][\"value\"], min=params_[key][\"min\"], max=params_[key][\"max\"], vary=params_[key][\"vary\"], brute_step=params_[key][\"b_step\"])","def _set_params(self, *args, **kwargs):\n startup = False\n try:\n params = args[0]\n except IndexError:\n raise InstrumentParameterException('Set command requires a parameter dict.')\n\n try:\n startup = args[1]\n except IndexError:\n pass\n\n # Only check for readonly parameters if we are not setting them from startup\n if not startup:\n readonly = self._param_dict.get_visibility_list(ParameterDictVisibility.READ_ONLY)\n\n log.debug(\"set param, but check visibility first\")\n log.debug(\"Read only keys: %s\", readonly)\n\n for (key, val) in params.iteritems():\n if key in readonly:\n raise InstrumentParameterException(\"Attempt to set read only parameter (%s)\" % key)\n\n # Make sure this method is overloaded because this just verifies, but doesn't\n # set a damn thing.","def _update_params(self):\n log.debug(\"Updating parameter dict\")\n old_config = self._param_dict.get_config()\n self._get_config()\n new_config = self._param_dict.get_config() \n if (new_config != old_config):\n self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)","def update(self, **params):\n self.parameters.update(params)","def update_parameters(self,like_params):\n\n # get current dictionary with parameters, update and setup again\n params=self.get_params()\n\n for par in like_params:\n if par.name in params:\n params[par.name]=par.value\n\n self._setup_from_parameters(params)\n return","def set_params(self, **kwargs) -> NoReturn:\n pass","def _check_params(self):\n pass","def update_parameter(self, param, val, force=False):\n self._update_dict[param] = val\n if force:\n self._cur_val[param] = None","def change_general_param(self, param, val):\n assert param in self.params, '%s is not recognized as a valid parameter' % param\n self.params[param].change_value(val)","def set_params(self, **params):\n if not hasattr(self, \"_non_sklearn_base\"):\n return super().set_params(**params)\n if not (\n len(params) == 1 and\n (\"nthreads\" in params or \"n_jobs\" in params)\n ):\n self.is_fitted_ = False\n valid_params = self.get_params(deep=False)\n for k,v in params.items():\n if k not in valid_params:\n raise ValueError(\"Invalid parameter: \", k)\n setattr(self, k, v)\n return self","def set_parameters(self):\n\n if self.model_with_set_params:\n return\n\n self._model_with_set_params = self._parameter_values.process_model(\n self._unprocessed_model, inplace=False\n )\n self._parameter_values.process_geometry(self.geometry)\n self.model = self._model_with_set_params","def _validate(self):\n if not isinstance(self.parameter_schema, dict):\n raise TypeError(\"parameter_schema must be a dictionary\")\n # TODO: Settle on an input file schema and validation library\n self._parameter_names = list(self.parameter_schema.keys())\n # List, sets, and tuples are the supported PyYAML iterables that will support expected behavior\n for name in self._parameter_names:\n if not isinstance(self.parameter_schema[name], (list, set, tuple)):\n raise TypeError(f\"Parameter '{name}' is not one of list, set, or tuple\")","def edit(self, params):\n for key, value in params.items():\n if hasattr(self, key):\n setattr(self, key, value)\n else:\n raise ValueError(\"{} has no attribute {}\".format(self, key))","def check_raw_parameters(self):\n # exclude some irrelevant or mandatory parameters\n excluded_keys = (\"cmd\", \"client\", \"resource_group_name\", \"name\")\n # check whether the remaining parameters are set\n # the default value None or False (and other empty values, like empty string) will be considered as not set\n is_changed = any(v for k, v in self.context.raw_param.items() if k not in excluded_keys)\n\n # special cases\n # some parameters support the use of empty string or dictionary to update/remove previously set values\n is_default = (\n self.context.get_cluster_autoscaler_profile() is None and\n self.context.get_api_server_authorized_ip_ranges() is None and\n self.context.get_nodepool_labels() is None and\n self.context.get_nodepool_taints() is None\n )\n\n if not is_changed and is_default:\n reconcilePrompt = 'no argument specified to update would you like to reconcile to current settings?'\n if not prompt_y_n(reconcilePrompt, default=\"n\"):\n # Note: Uncomment the followings to automatically generate the error message.\n option_names = [\n '\"{}\"'.format(format_parameter_name_to_option_name(x))\n for x in self.context.raw_param.keys()\n if x not in excluded_keys\n ]\n error_msg = \"Please specify one or more of {}.\".format(\n \" or \".join(option_names)\n )\n raise RequiredArgumentMissingError(error_msg)","def define_parameters(self):"],"string":"[\n \"def updateParameters(self, parameters):\\n # if parameters[0].altered:\\n # parameters[1].value = arcpy.ValidateFieldName(parameters[1].value,\\n # parameters[0].value)\\n return\",\n \"def parameters_changed(self):\\n pass\",\n \"def _paramUpdate(self):\\n\\n # Update the database attributes accordingly.\\n dt.utilities.DB_attrs_save(self.Database, self.newParam)\",\n \"def adjust_parameter_validator(self, param):\\n if not isinstance(param.vals, Numbers):\\n raise Exception('Only the Numbers validator is supported.')\\n min_val = param.vals._min_value\\n max_val = param.vals._max_value\\n\\n min_val_upd = self.round_dac(min_val, param.name)\\n max_val_upd = self.round_dac(max_val, param.name)\\n\\n param.vals = Numbers(min_val_upd, max_val_upd)\",\n \"def _validate_parameters(self):\\n super()._validate_parameters()\\n\\n #################### callbacks ####################\\n self.callbacks = check_callback(self.callbacks)\",\n \"def _validate_params(self):\\n raise NotImplementedError('Must be implemented in subclasses.')\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self):\\n\\n return\",\n \"def updateParameters(self, parameters):\",\n \"def update_params(self):\\n pass\",\n \"def _set_params(self, *args, **kwargs):\\n\\n params = args[0]\\n\\n # check for attempt to set readonly parameters (read-only or immutable set outside startup)\\n self._verify_not_readonly(*args, **kwargs)\\n old_config = self._param_dict.get_config()\\n\\n for (key, val) in params.iteritems():\\n log.debug(\\\"KEY = \\\" + str(key) + \\\" VALUE = \\\" + str(val))\\n self._param_dict.set_value(key, val)\\n\\n new_config = self._param_dict.get_config()\\n # check for parameter change\\n if not dict_equal(old_config, new_config):\\n self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)\",\n \"def _update_params(self):\\n raise NotImplementedException()\",\n \"def _update_params(self):\\n pass\",\n \"def _validate_params(self):\\n assert set(self.required_params) - set(self._params) == set()\\n for par, val in self.optional_params.items():\\n if par not in self._params:\\n self._params[par] = val\",\n \"def set_params(self):\\r\\n pass\",\n \"def updateParameters(self, parameters):\\n\\t\\treturn\",\n \"def _parameters_changed_notification(self, me, which=None):\\n self._optimizer_copy_transformed = False # tells the optimizer array to update on next request\\n self.parameters_changed()\",\n \"def parameters(self, new_params):\\n if not self._is_parametric:\\n raise AttributeError(\\n f\\\"Object of type {self.__class__.__name__} has no attribute parameters\\\"\\n )\\n self.set(parameters=new_params)\",\n \"def set_params(self):\\n raise NotImplementedError\",\n \"def _set_parameters(self, override_previous=True, validate_legality=False,\\n **parameters):\\n # The 'mode' parameter is only relevant to the current hierarchy\\n self.mode = parameters.pop('mode', self.mode)\\n\\n for name, value in iteritems(parameters):\\n if isinstance(value, Pipe):\\n if override_previous or (name not in self.__dict__ and\\n name not in self._pipes):\\n\\n self._pipes[name] = value\\n\\n else:\\n if override_previous or (name not in self.__dict__ and\\n name not in self._pipes):\\n\\n if isinstance(value, BaseResource):\\n self.add_resources({name: value})\\n\\n else:\\n setattr(self, name, value)\\n\\n if validate_legality and not self._is_valid_input(name):\\n raise AttributeError(\\\"Unrecognized parameter %r passed to %r\\\" %\\n (name, self.data.name))\",\n \"def set_parameter(self, params, name, val):\\n raise NotImplementedError()\",\n \"def set_params(self, params):\",\n \"def _validate(self):\\n for p in self.parameters:\\n #Check for missing required parameters:\\n if p.is_required and not(p.is_set):\\n raise ValueError(\\\"Parameter %s is not set.\\\" \\\\\\n % p.names[-1])\\n #Also repeat the parameter validation here, just in case?\",\n \"def set_params(self, **params):\\n return super().set_params(**params)\",\n \"def paramValidationPref(self, setting):\\n self.set_preference(setting,PARAM_VALIDATION_PREF)\",\n \"def _postprocessing(self):\\n # (in)validate\\n if len(self._var_names) == 0:\\n self.invalidate()\\n else:\\n self.put_param('is_valid', True)\\n \\n # set type\\n self.put_param('type', 'Generic')\",\n \"def params(self,new):\\n self._params = new\\n self._config_set()\\n self._make_model()\",\n \"def set_params(self, *, params: Params) -> None: # pragma: no cover\\n\\t\\tsuper().set_params(params=params)\",\n \"def _set_params(self, *args, **kwargs):\\n try:\\n params = args[0]\\n except IndexError:\\n raise InstrumentParameterException('Set command requires a parameter dict.')\\n\\n self._verify_not_readonly(*args, **kwargs)\\n update_params = False\\n\\n # check values that the instrument doesn't validate\\n # handle special cases for driver specific parameters\\n for (key, val) in params.iteritems():\\n if key == Parameter.PUMP_DELAY and (val < MIN_PUMP_DELAY or val > MAX_PUMP_DELAY):\\n raise InstrumentParameterException(\\\"pump delay out of range\\\")\\n elif key == Parameter.NUM_AVG_SAMPLES and (val < MIN_AVG_SAMPLES or val > MAX_AVG_SAMPLES):\\n raise InstrumentParameterException(\\\"num average samples out of range\\\")\\n\\n for (key, val) in params.iteritems():\\n\\n old_val = self._param_dict.format(key)\\n new_val = self._param_dict.format(key, val)\\n log.debug(\\\"KEY = %r OLD VALUE = %r NEW VALUE = %r\\\", key, old_val, new_val)\\n\\n if old_val != new_val:\\n update_params = True\\n if ConfirmedParameter.has(key):\\n # We add a write delay here because this command has to be sent\\n # twice, the write delay allows it to process the first command\\n # before it receives the beginning of the second.\\n self._do_cmd_resp(Command.SET, key, val, write_delay=0.2)\\n else:\\n self._do_cmd_resp(Command.SET, key, val, **kwargs)\\n\\n log.debug(\\\"set complete, update params\\\")\\n self._update_params()\\n if update_params:\\n self._update_params()\",\n \"def set_params(self, **params):\\n\\n return super().set_params(**params)\",\n \"def updateParameters(self, parameters):\\n if parameters[0].value:\\n parameters[1].enabled = True\\n parameters[2].enabled = True\\n else:\\n parameters[1].enabled = False\\n parameters[2].enabled = False\\n return\",\n \"def updateParameters(self, parameters):\\n if parameters[0].value:\\n parameters[1].enabled = True\\n parameters[2].enabled = True\\n else:\\n parameters[1].enabled = False\\n parameters[2].enabled = False\\n return\",\n \"def setParameter(self, name, value):\",\n \"def em_update_params(self):\\n for name in self.likelihood_params:\\n with self.elbo_check(name):\\n self.update_param(name)\",\n \"def _update_parameters(self, delta):\\n if delta is not None:\\n self.SGD.update_with_L1_regularization(self.variables, delta, self.L1)\",\n \"def set_parameter_value(self, parameter, value):\\n pass\",\n \"def update_values(self, to_update):\\n for key, value in kwargs.iteritems():\\n self.params[key] = value\\n # update the possibly dependent parameters\\n self.set_filenames()\",\n \"def updateParameters(self, parameters):\\r\\n #return\\r\\n parameters[2].enabled = 0\\r\\n parameters[3].enabled = 0\\r\\n parameters[4].enabled = 0\",\n \"def updateParameters(self, parameters):\\r\\n #return\\r\\n parameters[2].enabled = 0\\r\\n parameters[3].enabled = 0\\r\\n parameters[4].enabled = 0\",\n \"def _setup_params(self,**params):\\n ### a parameter might be passed in for one of the extra_pos;\\n ### if a key in the params dict is not a *parameter* of this\\n ### PO, then try it on the extra_pos\\n for n,p in params.items():\\n if n not in self.params():\\n self.set_parameter_value(n,p)\\n del params[n]\\n\\n Parameterized._setup_params(self,**params)\",\n \"def _update_parameters(self, delta):\\n if delta is not None:\\n VectorRegression._update_parameters(self, delta)\",\n \"def _set_parameters(self, parameters):\\n self.parameters = parameters\\n self._set_points_and_weights()\",\n \"def set_params(self, **kwargs):\\n ...\",\n \"def set_parameters(self,params):\\n K3Supervisor.set_parameters(self,params)\\n self.blending.set_parameters(self.parameters)\",\n \"def set_previous_parameters(self, params):\\n\\n self.param = params.copy()\\n\\n # save old params\\n self.old_param = params.copy()\",\n \"def set_params(self, params_):\\n x_start, x_end = params_[\\\"lim_fit\\\"]\\n self.find_idx_of_fit_limit(x_start, x_end)\\n self.is_error_bar_for_fit = params_[\\\"use_error_bar\\\"]\\n self.fitting_method1 = params_[\\\"method1\\\"]\\n self.fitting_method2 = params_[\\\"method2\\\"]\\n self.qty_to_min = params_[\\\"qty_to_min\\\"]\\n\\n for i, key in enumerate(self.params):\\n # self.params[key].set(value=params_[\\\"val\\\"][i], min=params_[\\\"min\\\"][i], max=params_[\\\"max\\\"][i], vary=bool(params_[\\\"hold\\\"][i]), brute_step=params_[\\\"brute_step\\\"][i])\\n if self.params[key].user_data is not None:\\n if \\\"dontGenerate\\\" in self.params[key].user_data:\\n continue\\n self.params[key].set(value=params_[key][\\\"value\\\"], min=params_[key][\\\"min\\\"], max=params_[key][\\\"max\\\"], vary=params_[key][\\\"vary\\\"], brute_step=params_[key][\\\"b_step\\\"])\",\n \"def _set_params(self, *args, **kwargs):\\n startup = False\\n try:\\n params = args[0]\\n except IndexError:\\n raise InstrumentParameterException('Set command requires a parameter dict.')\\n\\n try:\\n startup = args[1]\\n except IndexError:\\n pass\\n\\n # Only check for readonly parameters if we are not setting them from startup\\n if not startup:\\n readonly = self._param_dict.get_visibility_list(ParameterDictVisibility.READ_ONLY)\\n\\n log.debug(\\\"set param, but check visibility first\\\")\\n log.debug(\\\"Read only keys: %s\\\", readonly)\\n\\n for (key, val) in params.iteritems():\\n if key in readonly:\\n raise InstrumentParameterException(\\\"Attempt to set read only parameter (%s)\\\" % key)\\n\\n # Make sure this method is overloaded because this just verifies, but doesn't\\n # set a damn thing.\",\n \"def _update_params(self):\\n log.debug(\\\"Updating parameter dict\\\")\\n old_config = self._param_dict.get_config()\\n self._get_config()\\n new_config = self._param_dict.get_config() \\n if (new_config != old_config):\\n self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)\",\n \"def update(self, **params):\\n self.parameters.update(params)\",\n \"def update_parameters(self,like_params):\\n\\n # get current dictionary with parameters, update and setup again\\n params=self.get_params()\\n\\n for par in like_params:\\n if par.name in params:\\n params[par.name]=par.value\\n\\n self._setup_from_parameters(params)\\n return\",\n \"def set_params(self, **kwargs) -> NoReturn:\\n pass\",\n \"def _check_params(self):\\n pass\",\n \"def update_parameter(self, param, val, force=False):\\n self._update_dict[param] = val\\n if force:\\n self._cur_val[param] = None\",\n \"def change_general_param(self, param, val):\\n assert param in self.params, '%s is not recognized as a valid parameter' % param\\n self.params[param].change_value(val)\",\n \"def set_params(self, **params):\\n if not hasattr(self, \\\"_non_sklearn_base\\\"):\\n return super().set_params(**params)\\n if not (\\n len(params) == 1 and\\n (\\\"nthreads\\\" in params or \\\"n_jobs\\\" in params)\\n ):\\n self.is_fitted_ = False\\n valid_params = self.get_params(deep=False)\\n for k,v in params.items():\\n if k not in valid_params:\\n raise ValueError(\\\"Invalid parameter: \\\", k)\\n setattr(self, k, v)\\n return self\",\n \"def set_parameters(self):\\n\\n if self.model_with_set_params:\\n return\\n\\n self._model_with_set_params = self._parameter_values.process_model(\\n self._unprocessed_model, inplace=False\\n )\\n self._parameter_values.process_geometry(self.geometry)\\n self.model = self._model_with_set_params\",\n \"def _validate(self):\\n if not isinstance(self.parameter_schema, dict):\\n raise TypeError(\\\"parameter_schema must be a dictionary\\\")\\n # TODO: Settle on an input file schema and validation library\\n self._parameter_names = list(self.parameter_schema.keys())\\n # List, sets, and tuples are the supported PyYAML iterables that will support expected behavior\\n for name in self._parameter_names:\\n if not isinstance(self.parameter_schema[name], (list, set, tuple)):\\n raise TypeError(f\\\"Parameter '{name}' is not one of list, set, or tuple\\\")\",\n \"def edit(self, params):\\n for key, value in params.items():\\n if hasattr(self, key):\\n setattr(self, key, value)\\n else:\\n raise ValueError(\\\"{} has no attribute {}\\\".format(self, key))\",\n \"def check_raw_parameters(self):\\n # exclude some irrelevant or mandatory parameters\\n excluded_keys = (\\\"cmd\\\", \\\"client\\\", \\\"resource_group_name\\\", \\\"name\\\")\\n # check whether the remaining parameters are set\\n # the default value None or False (and other empty values, like empty string) will be considered as not set\\n is_changed = any(v for k, v in self.context.raw_param.items() if k not in excluded_keys)\\n\\n # special cases\\n # some parameters support the use of empty string or dictionary to update/remove previously set values\\n is_default = (\\n self.context.get_cluster_autoscaler_profile() is None and\\n self.context.get_api_server_authorized_ip_ranges() is None and\\n self.context.get_nodepool_labels() is None and\\n self.context.get_nodepool_taints() is None\\n )\\n\\n if not is_changed and is_default:\\n reconcilePrompt = 'no argument specified to update would you like to reconcile to current settings?'\\n if not prompt_y_n(reconcilePrompt, default=\\\"n\\\"):\\n # Note: Uncomment the followings to automatically generate the error message.\\n option_names = [\\n '\\\"{}\\\"'.format(format_parameter_name_to_option_name(x))\\n for x in self.context.raw_param.keys()\\n if x not in excluded_keys\\n ]\\n error_msg = \\\"Please specify one or more of {}.\\\".format(\\n \\\" or \\\".join(option_names)\\n )\\n raise RequiredArgumentMissingError(error_msg)\",\n \"def define_parameters(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7688436","0.75183314","0.70699507","0.7068056","0.70668334","0.6885432","0.6881135","0.6881135","0.6881135","0.6881135","0.6881135","0.6881135","0.6881135","0.6881135","0.684654","0.6841016","0.68276924","0.68104416","0.6776473","0.67577714","0.67530274","0.6643037","0.6606833","0.6597374","0.65949243","0.6561622","0.6538985","0.6490556","0.6484053","0.64754415","0.64600676","0.64367145","0.64363605","0.64164525","0.64082444","0.6375354","0.6363372","0.63604254","0.63604254","0.6350441","0.6342893","0.6341904","0.6302386","0.6269851","0.62537223","0.62537223","0.6252027","0.6250015","0.624282","0.6238406","0.62336916","0.6226914","0.6203369","0.61988443","0.61983395","0.6173895","0.61674976","0.6161404","0.6155931","0.6152704","0.6150988","0.6143536","0.6139071","0.6137571","0.61269575","0.61191905","0.6116598"],"string":"[\n \"0.7688436\",\n \"0.75183314\",\n \"0.70699507\",\n \"0.7068056\",\n \"0.70668334\",\n \"0.6885432\",\n \"0.6881135\",\n \"0.6881135\",\n \"0.6881135\",\n \"0.6881135\",\n \"0.6881135\",\n \"0.6881135\",\n \"0.6881135\",\n \"0.6881135\",\n \"0.684654\",\n \"0.6841016\",\n \"0.68276924\",\n \"0.68104416\",\n \"0.6776473\",\n \"0.67577714\",\n \"0.67530274\",\n \"0.6643037\",\n \"0.6606833\",\n \"0.6597374\",\n \"0.65949243\",\n \"0.6561622\",\n \"0.6538985\",\n \"0.6490556\",\n \"0.6484053\",\n \"0.64754415\",\n \"0.64600676\",\n \"0.64367145\",\n \"0.64363605\",\n \"0.64164525\",\n \"0.64082444\",\n \"0.6375354\",\n \"0.6363372\",\n \"0.63604254\",\n \"0.63604254\",\n \"0.6350441\",\n \"0.6342893\",\n \"0.6341904\",\n \"0.6302386\",\n \"0.6269851\",\n \"0.62537223\",\n \"0.62537223\",\n \"0.6252027\",\n \"0.6250015\",\n \"0.624282\",\n \"0.6238406\",\n \"0.62336916\",\n \"0.6226914\",\n \"0.6203369\",\n \"0.61988443\",\n \"0.61983395\",\n \"0.6173895\",\n \"0.61674976\",\n \"0.6161404\",\n \"0.6155931\",\n \"0.6152704\",\n \"0.6150988\",\n \"0.6143536\",\n \"0.6139071\",\n \"0.6137571\",\n \"0.61269575\",\n \"0.61191905\",\n \"0.6116598\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6615761"},"document_rank":{"kind":"string","value":"25"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":776,"numItemsPerPage":100,"numTotalItems":95772,"offset":77600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjM3NzY0NSwianRpIjoiOTA5YjlmZjItODM2YS00YTM0LTgyZDYtYzQ4YTA1ZWE0ZTE3Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzODEyNDUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Q_0eCq9JBfo1GXVCp_uW8AgON25A5Y5hRyfsiGtesEcXExBXG0od_HsYpR176DhfTqq0yUtuoSI15xLODP52Bw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
return dotdict object or list | def to_dotdict(data):
if isinstance(data, dict):
return dotdict(data)
elif isinstance(data, list):
return list_to_dotdict(data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n\n return DotDict(self.__iter__())",
"def test_dotwiz_plus_get_item():\n dd = DotWizPlus()\n dd.a = [{'one': 1, 'two': {'key': 'value'}}]\n\n item = dd['a'][0]\n assert isinstance(item, DotWizPlus)\n assert item['one'] == 1\n\n assert item['two']['key'] == 'value'",
... | [
"0.5945943",
"0.5873352",
"0.5810061",
"0.5800588",
"0.5748407",
"0.57315344",
"0.5581501",
"0.5569949",
"0.5481885",
"0.5452426",
"0.54393417",
"0.540381",
"0.53734374",
"0.5339806",
"0.5307873",
"0.5281563",
"0.5272191",
"0.5243142",
"0.5223164",
"0.5220962",
"0.51968324",
... | 0.6615638 | 0 |
Yield successive nsized chunks from l. | def chunks(l, n):
return[ l[i:i + n] for i in range(0, len(l), n)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _chunk(self, l, n):\n for i in range(0, len(l) + 1, n):\n yield l[i:i + n]",
"def chunks(self, l, n):\n for i in range(0, len(l), n):\n yield l[i:i + n]",
"def __chunks(l, n):\n for i in range(0, len(l), n):\n yield l[i:i + n]",
"def get_chunks(self, ... | [
"0.8038813",
"0.79248375",
"0.7923423",
"0.7885103",
"0.78773195",
"0.7815877",
"0.77655786",
"0.77556044",
"0.77441615",
"0.7731815",
"0.77288336",
"0.772473",
"0.77028215",
"0.76889825",
"0.76889825",
"0.7664208",
"0.76570904",
"0.7655856",
"0.7655856",
"0.76458347",
"0.764... | 0.0 | -1 |
Converts decimal number into sexagesimal number parts. ``deci`` is the decimal number to be converted. ``precision`` is how close the multiple of 60 and 3600, for example minutes and seconds, are to 60.0 before they are rounded to the higher quantity, for example hours and minutes. | def decimal_to_base60(deci,precision=1e-8):
sign = "+" # simple putting sign back at end gives errors for small
# deg. This is because -00 is 00 and hence ``format``,
# that constructs the delimited string will not add '-'
# sign. So, carry it as a character.
if deci < 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def precision(self):\n string = self.ask('od;E;') # get the actual output\n i1 = string.find('.')\n # find the indices of the dot before the decimal part and the E before\n # the exponent\n i2 = string.find('E', i1)\n # calculate the number of digit in the... | [
"0.5545609",
"0.54595983",
"0.5409595",
"0.5327562",
"0.5315469",
"0.52859825",
"0.52043194",
"0.519569",
"0.5193756",
"0.51741165",
"0.515108",
"0.515045",
"0.5112662",
"0.500345",
"0.49701056",
"0.49647292",
"0.4951426",
"0.49483728",
"0.49165738",
"0.48891824",
"0.4876071"... | 0.62166643 | 0 |
Given mjd return calendar date. Retrns a tuple (year,month,day,hour,minute,second). The last is a floating point number and others are integers. The precision in seconds is about 1e4. To convert jd to mjd use jd 2400000.5. In this module 2400000.5 is stored in MJD0. | def caldate(mjd):
MJD0 = 2400000.5 # 1858 November 17, 00:00:00 hours
modf = math.modf
a = long(mjd+MJD0+0.5)
# Julian calendar on or before 1582 October 4 and Gregorian calendar
# afterwards.
if a < 2299161:
b = 0
c = a + 1524
else:
b = long((a-1867216.25)/36524.25)
c = a+ b - long(modf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cmjd_to_mjd( cmjd):\n # only accurate to digits\n days = (cmjd.real+EPSILON) * FACTOR\n days = np.round(days, decimals=0)\n idays = np.int(days)\n fdays = np.float(idays)/FACTOR\n partdays = cmjd.imag # rest of days is in the hours part\n mjd = fdays + partdays\n return mjd",
"def ge... | [
"0.7360819",
"0.73290575",
"0.7209902",
"0.7089714",
"0.7082776",
"0.7072075",
"0.7059237",
"0.7000371",
"0.6946869",
"0.693835",
"0.69068015",
"0.68661994",
"0.6851522",
"0.6851298",
"0.67647004",
"0.6752787",
"0.6722145",
"0.6657841",
"0.65992653",
"0.6596479",
"0.6561866",... | 0.7805427 | 0 |
Parse an AIML text version of an aiml file and return all the cateogeries found in the file | def parse_from_text(self, text):
start = datetime.datetime.now()
aiml = ET.fromstring(text)
_, namespace = AIMLParser.check_aiml_tag(aiml)
num_categories = self.parse_aiml(aiml, namespace)
stop = datetime.datetime.now()
diff = stop - start
YLogger.info(self, "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_cuewords(self, cuewords, xml_file_path):\n\n # Create output files\n if not os.path.exists(CUEWORDS_DATA_PATH):\n self.create_directories(CUEWORDS_DATA_PATH)\n try:\n file_output = open(CUEWORDS_DATA_PATH+CUEWORDS_FILE, 'w', encoding='utf8')\n file_... | [
"0.57388943",
"0.57380986",
"0.5733026",
"0.5705951",
"0.5672007",
"0.56505924",
"0.56093127",
"0.5518221",
"0.5507609",
"0.5495509",
"0.5464741",
"0.54594886",
"0.5425296",
"0.53971124",
"0.5390651",
"0.5387091",
"0.53832227",
"0.53830737",
"0.5381347",
"0.53734255",
"0.5347... | 0.62207997 | 0 |
This is using recursion | def printLevelOrder(root):
print("---- printing below the level traversal of the tree -----")
print("=========================================================") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recursive():\n with Local() as tun:\n tun.call(recursive)",
"def lis_recursive(array):\n\n #TODO",
"def step(tree):\n if type(tree) == list and type(tree[0]) == tuple:#This basically looks for any applications it can do directly. These applications are the ones where the function is already... | [
"0.6281366",
"0.6184275",
"0.6161105",
"0.5972983",
"0.59151673",
"0.5840482",
"0.58125156",
"0.57481784",
"0.5735028",
"0.5651724",
"0.5645178",
"0.564305",
"0.56316143",
"0.5594576",
"0.55691177",
"0.5567865",
"0.5564364",
"0.5540909",
"0.5538929",
"0.55160964",
"0.550145",... | 0.0 | -1 |
This is using recursion | def printLevelOrder(root):
print("---- printing below the level traversal of the tree -----")
h = height(root)
for i in range(1, h+1):
printGivenLevel(root, i)
print("=========================================================") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recursive():\n with Local() as tun:\n tun.call(recursive)",
"def lis_recursive(array):\n\n #TODO",
"def step(tree):\n if type(tree) == list and type(tree[0]) == tuple:#This basically looks for any applications it can do directly. These applications are the ones where the function is already... | [
"0.6281366",
"0.6184275",
"0.6161105",
"0.5972983",
"0.59151673",
"0.5840482",
"0.58125156",
"0.57481784",
"0.5735028",
"0.5651724",
"0.5645178",
"0.564305",
"0.56316143",
"0.5594576",
"0.55691177",
"0.5567865",
"0.5564364",
"0.5540909",
"0.5538929",
"0.55160964",
"0.550145",... | 0.0 | -1 |
The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio=0.15.0 | def beta_create_SpiderServer_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
request_deserializers = {
('DistributeSpider.SpiderServer', 'keepalive'): Register.FromString,
('DistributeSpider.SpiderServer', 'req'): Request.FromString,
('DistributeSpider.Spid... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch_sdk():",
"def patch_sdk():",
"def patch_sdk():",
"def api(self) -> str:",
"def Version(self, request, context):\r\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\r\n context.set_details('Method not implemented!')\r\n raise NotImplementedError('Method not implemented!')",
"def _rpc(ht... | [
"0.5614376",
"0.5614376",
"0.5614376",
"0.5231222",
"0.516678",
"0.5120239",
"0.51101154",
"0.51041496",
"0.5075347",
"0.5075347",
"0.5021301",
"0.50079757",
"0.49987736",
"0.49987736",
"0.49885666",
"0.49841118",
"0.49763408",
"0.49653295",
"0.49615303",
"0.49615303",
"0.496... | 0.0 | -1 |
The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio=0.15.0 | def beta_create_SpiderServer_stub(channel, host=None, metadata_transformer=None, pool=None, pool_size=None):
request_serializers = {
('DistributeSpider.SpiderServer', 'keepalive'): Register.SerializeToString,
('DistributeSpider.SpiderServer', 'req'): Request.SerializeToString,
('DistributeSpider.S... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch_sdk():",
"def patch_sdk():",
"def patch_sdk():",
"def api(self) -> str:",
"def Version(self, request, context):\r\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\r\n context.set_details('Method not implemented!')\r\n raise NotImplementedError('Method not implemented!')",
"def _rpc(ht... | [
"0.5615912",
"0.5615912",
"0.5615912",
"0.52349323",
"0.5166791",
"0.5120645",
"0.51126444",
"0.5103273",
"0.5074809",
"0.5074809",
"0.5021775",
"0.5010595",
"0.50012255",
"0.50012255",
"0.49892133",
"0.49836612",
"0.49777785",
"0.49678397",
"0.496399",
"0.496399",
"0.496399"... | 0.0 | -1 |
A convenient string representation that contains the current yaml map of this yamlizable | def __repr__(self) -> str:
yaml_map = yamlmapper.yaml_map(self)
yaml_map_items = [f"{k}={v!r}" for k, v in sorted(yaml_map.items())]
return f"{self.__class__.__name__}({', '.join(yaml_map_items)})" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yaml(self):\n return str(self.data)",
"def __str__(self):\n _dict = self._def.default.copy()\n _dict.update(self.__dict__)\n #return '%s(%r)' % (self.__class__, _dict)\n # If the yaml is too slow revert to the line above\n name = '%s <%s>' % (self.__class__.__name__,... | [
"0.7816891",
"0.7704461",
"0.7668333",
"0.74728835",
"0.74209595",
"0.7258811",
"0.7217699",
"0.71320325",
"0.71031713",
"0.70095026",
"0.6967369",
"0.69200975",
"0.6897495",
"0.6850851",
"0.6836524",
"0.6836524",
"0.6836524",
"0.6836524",
"0.6836524",
"0.6836524",
"0.6836524... | 0.7610701 | 3 |
Set up a helical state in two meshes (one expressed in SI units the other expressed in nanometers) and compute energies and fields. | def test_dmi_uses_unit_length_2dmesh():
A = 8.78e-12 # J/m
D = 1.58e-3 # J/m^2
Ms = 3.84e5 # A/m
energies = []
# unit_lengths 1e-9 and 1 are common, let's throw in an intermediate length
# just to challenge the system a little:
for unit_length in (1, 1e-4, 1e-9):
radius = 200e-9... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_hf_state(n_electrons, m_spin_orbitals, exp_init_state):\n\n res_init_state = qchem.hf_state(n_electrons, m_spin_orbitals)\n\n assert len(res_init_state) == len(exp_init_state)\n assert np.allclose(res_init_state, exp_init_state)",
"def test_set_hs(self):\n s = State(substance=\"water\")\... | [
"0.6196272",
"0.5871681",
"0.57966113",
"0.57727325",
"0.57367516",
"0.5681394",
"0.56623125",
"0.56580096",
"0.56530404",
"0.56218076",
"0.55827063",
"0.5560695",
"0.5558276",
"0.55430007",
"0.55098903",
"0.55060786",
"0.55020607",
"0.54688966",
"0.54660153",
"0.54400545",
"... | 0.51074696 | 57 |
Check that the interaction accepts a 'name' argument and has a 'name' attribute. | def test_interaction_accepts_name():
dmi = DMI(1)
assert hasattr(dmi, 'name') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_interaction_accepts_name():\n demag = ThinFilmDemag()\n assert hasattr(demag, 'name')",
"def _check_name(self):\n\t\tpass",
"def test_should_name_field(self):\n self.assertIn(\"name\", self.fields)",
"def test_name(self):\n self.assertTrue(type(x.name) == str)",
"def test_name_... | [
"0.75773394",
"0.7110944",
"0.6599535",
"0.6579234",
"0.6573439",
"0.6570425",
"0.6569371",
"0.65498203",
"0.65390664",
"0.6503915",
"0.649423",
"0.64581394",
"0.64467174",
"0.64241993",
"0.6411254",
"0.6389162",
"0.6389162",
"0.63616997",
"0.6347092",
"0.6335511",
"0.6291245... | 0.7530854 | 1 |
This method used for display login page | def home():
return render_template('login.html') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self):\n self.render(\"login.html\")",
"def login(self):",
"def login():",
"def login():",
"def ShowLogin():\n current_user = helpers.get_current_user()\n if current_user is None:\n return render_template('login.html')\n else:\n return redirect('/')... | [
"0.7951904",
"0.7758108",
"0.77333164",
"0.77333164",
"0.7718853",
"0.7666449",
"0.7618106",
"0.7531756",
"0.75076485",
"0.7502553",
"0.7496109",
"0.7496109",
"0.74952745",
"0.7480008",
"0.7454812",
"0.74520165",
"0.7410382",
"0.7389123",
"0.7388959",
"0.7370175",
"0.7340623"... | 0.6831181 | 60 |
this method used for admin login | def do_admin_login():
if request.form['password'] == 'admin' and request.form['username'] == 'admin':
teams = get_team()
if teams:
return render_template('team-players.html', teams=teams)
else:
return render_template('team-players.html')
else:
flash('Inval... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login(self):\n\t\treturn",
"def login(self):",
"def login(self):\n #raise NotImplementedError(\"This method must be overridden\")",
"def log_in(self):\n\t\tpass",
"def login():",
"def login():",
"def _login(self, *args, **kwargs):\n pass",
"def login_user():\n pass",
"def login... | [
"0.82168025",
"0.8136677",
"0.7885547",
"0.7831707",
"0.7738362",
"0.7738362",
"0.77056754",
"0.72187483",
"0.7209008",
"0.7152261",
"0.7055392",
"0.7018007",
"0.699722",
"0.68738675",
"0.68244404",
"0.6804018",
"0.68002194",
"0.6776731",
"0.6769224",
"0.6765747",
"0.67484957... | 0.66606766 | 24 |
This method used for display add team /player button | def add_team_player():
if request.form['add_template'] == 'Add Team':
return render_template('addteam.html')
elif request.form['add_template'] == 'Add Player':
teams = get_team()
return render_template('addplayer.html', teams=teams)
else:
return getAllPlayers() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_player_button():\r\n global state\r\n if not state == \"add\":\r\n clear_frames()\r\n\r\n \"\"\"Changing state global variable and subtitle and showing on screen\"\"\"\r\n state = \"add\"\r\n sub_title[\"text\"] = \"ADD PLAYER\"\r\n sub_title.pack()\r\n \"\"\... | [
"0.70463204",
"0.6276204",
"0.6261729",
"0.62551904",
"0.62009877",
"0.61738485",
"0.6087262",
"0.6075263",
"0.60548",
"0.5982238",
"0.59647626",
"0.5960139",
"0.5945807",
"0.59443206",
"0.59304005",
"0.5914881",
"0.58859",
"0.58651036",
"0.5848743",
"0.5823961",
"0.58157766"... | 0.7212078 | 0 |
This method used for create player record | def add_team():
if request.method == 'POST':
result = request.form
teamImage = request.files['teamImage'].read()
team = Team.query.filter_by(team_name=result['team_name']).first()
if not team:
team1 = Team(team_name=result['team_name'], team_image=teamImage)
d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_player (self, username = None):\n # Get unique username if needed\n if (username == None):\n username = \"default_username\" + str (time.time ())\n self.username = username\n r = requests.post (self.url_endpoint, data = {\"new_player\": self.username})\n if ... | [
"0.6840854",
"0.68380654",
"0.6787083",
"0.67529166",
"0.66954476",
"0.66239595",
"0.6558398",
"0.65532523",
"0.6532968",
"0.6459993",
"0.6442115",
"0.6412653",
"0.63584226",
"0.6342014",
"0.6304426",
"0.6299078",
"0.6295376",
"0.6277291",
"0.623482",
"0.62126124",
"0.6199378... | 0.0 | -1 |
This method used for display team player details | def player_information():
if request.method == 'POST':
result = request.form
if request.files:
playerImage = request.files['playerImage'].read()
else:
playerImage = None
player = Player(player_image=playerImage, player_fname=result['player_first_name'],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_players_specific_tournament(self) -> None:\n id_choice = check.request_id(TOURNAMENTS)\n tournament_data = TOURNAMENTS.get(doc_id=id_choice)\n if tournament_data.get(\"players\") == {}:\n print(\"\\n This tournaments has no players yet\")\n else:\n players... | [
"0.7354015",
"0.7117312",
"0.69317603",
"0.68635464",
"0.68605345",
"0.6838008",
"0.67840564",
"0.6766929",
"0.6623634",
"0.65735716",
"0.65706027",
"0.6545617",
"0.6501806",
"0.6447435",
"0.63882464",
"0.6384302",
"0.63785684",
"0.6371603",
"0.63430077",
"0.6341268",
"0.6331... | 0.66942006 | 8 |
This method used for get all team information | def get_team():
teams = Team.query.all()
for each in teams:
if each.team_image is not None:
each.team_image = b64encode(each.team_image)
return teams | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_teams():",
"def get_all_team_info():\n # hit this url in browser or postman like http://127.0.0.1:5000/getAllTeamInfo and it will return json data\n final_team_list = []\n if request.method == 'GET':\n teams = Team.query.all()\n for rec in range(len(teams)):\n final_tea... | [
"0.83387434",
"0.7830692",
"0.77320063",
"0.7586736",
"0.7578475",
"0.73616064",
"0.7339716",
"0.73322433",
"0.729617",
"0.72424203",
"0.72424203",
"0.7144458",
"0.7142989",
"0.71325344",
"0.71232694",
"0.70133734",
"0.7008123",
"0.6986277",
"0.69839996",
"0.6940332",
"0.6920... | 0.0 | -1 |
This method used for edit team information | def team_edit(team_id):
if request.method == 'GET':
team = Team.query.filter_by(team_id=team_id).one()
return render_template('edit_team.html', team=team) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_owners_can_edit_team_data(self):\n\n data = {\n 'description': 'Edited description',\n 'name': 'Edited Name'\n }\n response = self.client.patch(reverse('api:teams-detail', kwargs={'pk': self.team.id}), data)\n self.assertEqual(response.status_code, status.... | [
"0.7191018",
"0.709394",
"0.7048175",
"0.680195",
"0.66895694",
"0.6678483",
"0.6646838",
"0.66090715",
"0.64634645",
"0.6432834",
"0.6409257",
"0.6398768",
"0.63267934",
"0.6316041",
"0.63043207",
"0.6287093",
"0.62806153",
"0.6216511",
"0.6209136",
"0.61889",
"0.61805123",
... | 0.7488611 | 0 |
This method used for update team information | def updateteam():
if request.method == 'POST':
result = request.form
teamImage = request.files['teamImage'].read()
team = Team.query.filter_by(team_id=result.get('team_id')).one()
team.team_name = result.get('team_name')
team.team_image = teamImage
db.session.commit()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_team(self):\n pass",
"def update(self, request, pk):\n print(\"Update a team\")\n serializer = data_serializers.UpdateTeamSerializer(data=request.data)\n if serializer.is_valid(raise_exception=True):\n request_data = serializer.save()\n new_team_e... | [
"0.78725547",
"0.724243",
"0.7214727",
"0.7058914",
"0.6833528",
"0.6831357",
"0.6818724",
"0.67664814",
"0.6736137",
"0.67109764",
"0.6687826",
"0.66369903",
"0.65911585",
"0.65373755",
"0.64549565",
"0.6447125",
"0.64403397",
"0.6366431",
"0.632347",
"0.6323166",
"0.6313954... | 0.6851629 | 4 |
This method used for delete the Team record from database | def delete_team(team_id):
if request.method == 'GET':
Team.query.filter_by(team_id=team_id).delete()
db.session.commit()
teams = get_team()
if teams:
return render_template('team-players.html', teams=teams)
else:
return render_template('team-players.ht... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_team(self):\n pass",
"async def delete(self):\n return await self._state.delete_team(self.id)",
"def test_teams_delete_team_v1(self):\n pass",
"async def delete_team(team_id: str = Path(..., description=\"ID value of the desired team\"),\n db_handler:... | [
"0.7857183",
"0.7828139",
"0.77602565",
"0.7557753",
"0.74525476",
"0.74125135",
"0.73758745",
"0.72441757",
"0.7106591",
"0.71004575",
"0.7047551",
"0.6960293",
"0.6867318",
"0.6826918",
"0.6826918",
"0.6826918",
"0.6826918",
"0.68234664",
"0.68062544",
"0.6723711",
"0.66972... | 0.74472725 | 5 |
Display selected team Details | def display_selected_team(team_id):
if request.method == 'GET':
result_dict = {}
teams = get_team()
players = Player.query.join(Team, Player.team_id==team_id).\
add_columns(Player.player_fname,Player.player_lname,Team.team_name,Player.player_id)
result_dict['teams'] = teams
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_team_page(request, team_pk):\n\t\n\tselected_team = ChallengeTeam.objects.get(pk = team_pk)\n\t\n\tusers = selected_team.team_members.all()\n\t\n\tteam_name = selected_team.team_name\n\t\n\tall_results = get_team_results(users, selected_team.challenge.schedule)\n\tteam_consistency = all_results[\"consiste... | [
"0.7378892",
"0.7202127",
"0.7011595",
"0.6845789",
"0.6786297",
"0.6735039",
"0.6540119",
"0.64731157",
"0.6464473",
"0.6359951",
"0.6321422",
"0.6250159",
"0.62016064",
"0.6165804",
"0.61371464",
"0.61025214",
"0.6068967",
"0.60541105",
"0.6038926",
"0.60297716",
"0.6023512... | 0.7938968 | 0 |
This method used for delete the player record from database | def delete_player(player_id):
if request.method == 'GET':
Player.query.filter_by(player_id=player_id).delete()
db.session.commit()
return getAllPlayers() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, player_id):\n current_player = DBPlayer.query.get(player_id)\n if not current_player:\n return get_response(404, 'Not exists.')\n try:\n db.session.delete(current_player)\n db.session.commit()\n except Exception as e:\n db.ses... | [
"0.79688334",
"0.79618365",
"0.76981676",
"0.76781356",
"0.76715004",
"0.76693827",
"0.763336",
"0.7630587",
"0.76232153",
"0.7562153",
"0.7543041",
"0.75104153",
"0.74908626",
"0.7459501",
"0.7441687",
"0.74217176",
"0.7401913",
"0.73951644",
"0.7351567",
"0.7345215",
"0.733... | 0.7211305 | 23 |
This method pull all player information from player table | def getAllPlayers():
result_dict = {}
teams = get_team()
players = db.session.query(Player, Team).join(Team, Player.team_id == Team.team_id)
for each in players:
if each.Player.player_image is not None:
each.Player.player_image = b64encode(each.Player.player_image)
result_dict['t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def players_list(self):\n self.db = TinyDB('Models/db.json')\n self.query = Query()\n player_table = self.db.table('player_table')\n return player_table",
"def _get_player_info(self):\n return [player._player_info() for player in self.players.values()]",
"async def get_player... | [
"0.724439",
"0.71141773",
"0.69476527",
"0.68183863",
"0.67419237",
"0.6687014",
"0.6661582",
"0.66249704",
"0.66111124",
"0.6560406",
"0.65440094",
"0.6526902",
"0.65245336",
"0.64350224",
"0.6427198",
"0.6422903",
"0.64129514",
"0.6401265",
"0.6377747",
"0.6361764",
"0.6349... | 0.61114275 | 33 |
This method used for edit player information | def player_edit(player_id):
if request.method == 'GET':
result = {}
player = Player.query.filter_by(player_id=player_id).one()
player.player_image = b64encode(player.player_image)
teams = get_team()
result['player'] = player
result['teams'] = teams
return rend... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, player_info):\n self.seat = player_info.get(\"seat\", -1)\n self.name = player_info.get(\"name\", \"unknown\")\n self.sit_out = player_info.get(\"sit_out\", True)",
"def edit_user(self):\n from editWindow import EditPlayer\n self.edit = EditPlayer(self.lang, se... | [
"0.70508623",
"0.691375",
"0.6630395",
"0.6581151",
"0.6499907",
"0.6449183",
"0.64047134",
"0.63949656",
"0.6385882",
"0.6316389",
"0.63095105",
"0.63081056",
"0.62880075",
"0.6282538",
"0.6196724",
"0.6143135",
"0.6126377",
"0.61088145",
"0.6087335",
"0.6076133",
"0.6074033... | 0.7211967 | 0 |
This method return all team information | def get_all_team_info():
# hit this url in browser or postman like http://127.0.0.1:5000/getAllTeamInfo and it will return json data
final_team_list = []
if request.method == 'GET':
teams = Team.query.all()
for rec in range(len(teams)):
final_team = {}
final_team['Te... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_teams():",
"def getAllTeams(self):\n return []",
"def getTeam(self):\n return [\"The A-Team\", \"some other bloke\"]",
"def get_people(team):",
"def get_teams(self):\n url = 'teams'\n result = self.get(url)\n return result.get('teams', result)",
"def get_team_li... | [
"0.8226794",
"0.75884455",
"0.7483768",
"0.74514127",
"0.73995537",
"0.7057975",
"0.7048445",
"0.70254403",
"0.6986613",
"0.6854374",
"0.67867225",
"0.67421323",
"0.6741827",
"0.67249024",
"0.66893196",
"0.668395",
"0.6670714",
"0.6653283",
"0.6628329",
"0.6627309",
"0.662307... | 0.7789952 | 1 |
This method return all players based on team name | def get_players_info(team_name):
# hit this url in browser or postman like http://127.0.0.1:5000/getPlayersInfo/TeamName and it will return json data
final_player_list = []
if request.method == 'GET':
team_res = Team.query.filter_by(team_name=team_name).first()
if team_res:
playe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def players(self):\n return Player.objects.filter(team=self)",
"def get_contracted_players(self, team):\n # setting up empty list of players\n players = list()\n\n # getting html document with team's contracted players\n doc = self.get_html_document(team, 'contracts')\n\n ... | [
"0.77261233",
"0.76394296",
"0.7557019",
"0.7309519",
"0.7277449",
"0.72452086",
"0.72448725",
"0.7179656",
"0.7172564",
"0.7118045",
"0.70307726",
"0.7022754",
"0.6972246",
"0.69710726",
"0.69181055",
"0.689715",
"0.68528575",
"0.68509346",
"0.68254",
"0.6812624",
"0.6722899... | 0.6573771 | 28 |
This method used for display all player information for read only user | def display_read_only_user():
# hit this url in browser.
if request.method == 'GET':
result_dict = {}
teams = get_team()
players = db.session.query(Player, Team).join(Team, Player.team_id == Team.team_id)
for each in players:
if each.Player.player_image is not None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_player_info(self):\n\t\tclear_screen()\n\n\t\tprint(\"# PLAYER INFO #\\n\")\n\t\tprint(\"Name{:.>17} \".format(self.info['Name']))\n\t\tprint(\"Race{:.>17} \".format(self.info['Race']))\n\t\tprint(\"Level{:.>16} \".format(self.stats['Level']))\n\t\tprint(\"Hit Points{:.>11} \".format(self.stats['HP... | [
"0.6989941",
"0.68834287",
"0.6581664",
"0.65732765",
"0.6539903",
"0.6517564",
"0.64415467",
"0.64375114",
"0.6384573",
"0.63242304",
"0.6293608",
"0.62828076",
"0.62666297",
"0.624345",
"0.6231377",
"0.6223611",
"0.61990607",
"0.61758673",
"0.61674625",
"0.6142857",
"0.6140... | 0.753156 | 0 |
Creates a Cell from a JSON dictionary. | def from_json(self, _json: Dict) -> "Cell":
cell = Cell(content=_json["content"], data=_json["data"])
cell.id = _json["id"]
return cell | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_json(cls, _json: Dict) -> \"Page\":\n\n page = cls(\n cells=[Cell.from_json(cell_json) for cell_json in _json[\"cells\"]],\n data=_json[\"data\"],\n )\n page.id = _json[\"id\"]\n return page",
"def from_dict(self, d):\n return Grid(**d)",
"def f... | [
"0.6552123",
"0.6535798",
"0.6277082",
"0.6269054",
"0.6266621",
"0.61997414",
"0.61492914",
"0.6125334",
"0.5983177",
"0.5935195",
"0.58735913",
"0.58735913",
"0.58735913",
"0.58735913",
"0.58735913",
"0.58735913",
"0.58735913",
"0.58735913",
"0.58735913",
"0.58735913",
"0.5... | 0.82266605 | 0 |
Converts the Cell to a JSON dictionary. | def json(self) -> CellJson:
return {"id": self.id, "content": self.content, "data": self.data} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_dict(self) -> Dict[str, Any]:\n return {\n column_title: cell.get_value()\n for column_title, cell in self.column_title_to_cell.items()\n }",
"def as_dict(self) -> Dict[str, Any]:\n return {\n column_title: cell.value\n for column_title, cel... | [
"0.6867866",
"0.67923075",
"0.66359794",
"0.6611153",
"0.64058787",
"0.6400758",
"0.6392397",
"0.6365426",
"0.6365426",
"0.6365426",
"0.6361674",
"0.63474494",
"0.63334906",
"0.63334906",
"0.6331991",
"0.6330032",
"0.6330032",
"0.6330032",
"0.6330032",
"0.6330032",
"0.6330032... | 0.80724275 | 0 |
Do the basic methods work? | def test_basic():
spec = IGRINSSpectrum(file=file, order=10)
assert spec is not None
assert isinstance(spec, Spectrum1D)
assert isinstance(spec.flux, np.ndarray)
assert len(spec.flux) == len(spec.wavelength)
assert spec.mask.sum() > 0
new_spec = spec.remove_nans()
assert new_spec.sha... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(self):\r\n pass",
"def main(self):",
"def basic(self):\n pass",
"def Run():\r\n pass",
"def main():\n pass",
"def RUN(self):",
"def simple():",
"def simple():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
... | [
"0.7232877",
"0.7179099",
"0.69246185",
"0.692093",
"0.6905209",
"0.6823088",
"0.67499316",
"0.67499316",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
"0.6743324",
... | 0.0 | -1 |
Does uncertainty propagation work? | def test_uncertainty():
spec = IGRINSSpectrum(file=file, order=10)
assert spec.uncertainty is not None
assert hasattr(spec.uncertainty, "array")
assert len(spec.flux) == len(spec.uncertainty.array)
assert spec.flux.unit == spec.uncertainty.unit
new_spec = spec.remove_nans()
assert len(ne... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uncertainty_ee(self,e1,e2):\n # reco\n unc = (self._eleRecoWeight[(e1.pt(),e1.eta())][1]/self._eleRecoWeight[(e1.pt(),e1.eta())][0] + \\\n self._eleRecoWeight[(e2.pt(),e2.eta())][1]/self._eleRecoWeight[(e2.pt(),e2.eta())][0])**2\n # id-isolation\n unc += (self._eleIdIsoWeight[(e1.... | [
"0.7023033",
"0.6477262",
"0.6477262",
"0.64747536",
"0.64158547",
"0.61617506",
"0.6103972",
"0.59602594",
"0.59567297",
"0.591283",
"0.591283",
"0.591283",
"0.5810102",
"0.5810102",
"0.5810102",
"0.57871217",
"0.57767254",
"0.5772044",
"0.57681143",
"0.57503945",
"0.5740525... | 0.0 | -1 |
Can we measure equivalent widths? | def test_equivalent_width():
spec = IGRINSSpectrum(file=file)
mu = np.median(spec.wavelength.value)
equivalent_width = spec.measure_ew(mu)
assert equivalent_width is not None
assert type(equivalent_width) is not int
assert type(equivalent_width) is astropy.units.quantity.Quantity
new_unit ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def width(self) -> int:",
"def width(self) -> int:",
"def widths(self):\n return self._widths",
"def estimate_width(start, end, numlabels=None, char_width=None):\n return 0, 0",
"def test_check_width(self):\n r1 = Rectangle(10, 2)\n self.assertEqual(r1.width, 10)\n\n r2 = Rec... | [
"0.7498377",
"0.7498377",
"0.72372097",
"0.69278175",
"0.67874897",
"0.67776704",
"0.6722984",
"0.6679934",
"0.66486084",
"0.6464722",
"0.6442885",
"0.6399709",
"0.6371484",
"0.6366305",
"0.6364684",
"0.6364684",
"0.6364684",
"0.6364684",
"0.6364684",
"0.6364684",
"0.6364684"... | 0.7152717 | 3 |
Does smoothing and outlier removal work? | def test_smoothing():
spec = IGRINSSpectrum(file=file)
new_spec = spec.remove_outliers(threshold=3)
assert len(new_spec.flux) > 0
assert new_spec.shape[0] <= spec.shape[0]
assert new_spec.shape[0] > 0
assert new_spec.mask is not None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def outlier(arr, as_nan=True, thresh=0.05, show=False, report=False):\n if len(arr) < 3:\n return arr\n if show:\n plt.subplot(1,2,1) # Plot part 1 first\n plt.plot(np.random.random(len(arr)), thing1, 'o', color='blue',\n markeredgecolor='none', alpha=0.4)\n plt.title('With outliers')\n ... | [
"0.69179946",
"0.6402754",
"0.63572776",
"0.62770617",
"0.62203604",
"0.61959535",
"0.6186184",
"0.6164992",
"0.6164357",
"0.61016166",
"0.6089655",
"0.60500485",
"0.60478014",
"0.6020404",
"0.6016225",
"0.6007301",
"0.6002241",
"0.597885",
"0.5976333",
"0.5957397",
"0.594395... | 0.6860557 | 1 |
Does RV shifting work | def test_RV():
spec = IGRINSSpectrum(file=file)
assert spec.uncertainty is not None
assert hasattr(spec, "barycentric_correct")
correction_velocity = spec.estimate_barycorr()
assert isinstance(spec.RA, astropy.units.quantity.Quantity)
assert isinstance(spec.DEC, astropy.units.quantity.Quanti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def right_shift_quirk(self):\n register = self.return_middle_registers(self.opcode)\n bits = self.registers[register[1]]\n self.registers[0xF] = bits & 0b1\n self.registers[register[0]] = self.registers[register[1]] >> 1\n logger.info(\"Shifted register V{} to the right into V{}(... | [
"0.69488525",
"0.68362254",
"0.67707986",
"0.67707986",
"0.66768026",
"0.6673234",
"0.66563946",
"0.66563946",
"0.64938307",
"0.64050066",
"0.63850296",
"0.6352056",
"0.6345997",
"0.6341593",
"0.62932235",
"0.62932235",
"0.62131655",
"0.61368865",
"0.6103431",
"0.6093303",
"0... | 0.0 | -1 |
Does uncertainty propagation work? | def test_deblaze():
spec = IGRINSSpectrum(file=file)
new_spec = spec.remove_nans().deblaze()
assert new_spec is not None
assert isinstance(new_spec, Spectrum1D) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uncertainty_ee(self,e1,e2):\n # reco\n unc = (self._eleRecoWeight[(e1.pt(),e1.eta())][1]/self._eleRecoWeight[(e1.pt(),e1.eta())][0] + \\\n self._eleRecoWeight[(e2.pt(),e2.eta())][1]/self._eleRecoWeight[(e2.pt(),e2.eta())][0])**2\n # id-isolation\n unc += (self._eleIdIsoWeight[(e1.... | [
"0.7023033",
"0.6477262",
"0.6477262",
"0.64747536",
"0.64158547",
"0.61617506",
"0.6103972",
"0.59602594",
"0.59567297",
"0.591283",
"0.591283",
"0.591283",
"0.5810102",
"0.5810102",
"0.5810102",
"0.57871217",
"0.57767254",
"0.5772044",
"0.57681143",
"0.57503945",
"0.5740525... | 0.0 | -1 |
Does the Spectrum List work? | def test_spectrumlist_performance(precache_hdus):
t0 = time.time()
spec_list = IGRINSSpectrumList.read(file, precache_hdus=precache_hdus)
t1 = time.time()
net_time = t1 - t0
print(f"\n\t Precached HDUs {precache_hdus}: {net_time:0.5f} seconds", end="\t")
assert spec_list is not None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spect(self):\n return 1",
"def getAllSpectrumMeasurements(self): \n return self.spectrum",
"def spectate(self):\n pass",
"def find_spectra(self):\r\n\r\n #### Begin functionality here\r\n\r\n return()",
"def isSpectrumRequested(self) -> bool:\n while True:\n ... | [
"0.6561537",
"0.6362145",
"0.6324333",
"0.63095045",
"0.61777866",
"0.6138286",
"0.6097585",
"0.60474753",
"0.6045568",
"0.601384",
"0.5990894",
"0.59334475",
"0.59300584",
"0.592409",
"0.5922526",
"0.59224993",
"0.5907508",
"0.58886427",
"0.5878402",
"0.58668196",
"0.5860067... | 0.6077373 | 7 |
Return CPU Usage in % | def cpuusage(request, host_id):
if not request.user.is_authenticated():
return HttpResponseRedirect('/login')
host = Host.objects.get(id=host_id)
try:
conn = ConnServer(host)
except:
conn = None
if conn:
cpu_usage = conn.cpu_get_usage()
return HttpResponse(cpu_u... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cpu_usage():\n return psutil.cpu_percent()",
"def cpu_usage():\n return str(_cpu_usage())",
"def get_cpu_use():\n cpu_cent = psutil.cpu_percent()\n return str(cpu_cent)",
"def getcpuusage(self):\n return ord(self.reg(0x11, write=1))",
"def cpu():\n sin = psutil.cpu_percent... | [
"0.87442744",
"0.8629406",
"0.858648",
"0.84777236",
"0.8238267",
"0.82277244",
"0.8201909",
"0.8173694",
"0.78069717",
"0.7805571",
"0.777815",
"0.77320904",
"0.76780444",
"0.76228017",
"0.7590143",
"0.75805867",
"0.7517144",
"0.7472642",
"0.7344525",
"0.7236686",
"0.7229302... | 0.63918686 | 87 |
Return Memory Usage in % | def memusage(request, host_id):
if not request.user.is_authenticated():
return HttpResponseRedirect('/login')
host = Host.objects.get(id=host_id)
try:
conn = ConnServer(host)
except:
conn = None
if conn:
mem_usage = conn.memory_get_usage()
return HttpResponse(me... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_memory_percent(self):\r\n rss = self.get_memory_info()[0]\r\n try:\r\n return (rss / float(TOTAL_PHYMEM)) * 100\r\n except ZeroDivisionError:\r\n return 0.0",
"def MemoryUsage(cls):\n\t\tmeminfo = cls.MemoryInfo()\n\t\treturn (meminfo[\"MemTotal\"] - meminfo[\"M... | [
"0.82312447",
"0.8034054",
"0.7917152",
"0.78094107",
"0.7602421",
"0.75550836",
"0.7521147",
"0.7441002",
"0.7327086",
"0.72985727",
"0.72715676",
"0.72538465",
"0.72340304",
"0.7212965",
"0.7159357",
"0.7099024",
"0.70843774",
"0.7078243",
"0.7077288",
"0.7062136",
"0.70602... | 0.0 | -1 |
\brief Default constructor, it initializes the databaseWiki variable. | def __init__(self):
##type:databaseWiki = access to the database
self.db = databaseWiki() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, host='localhost', user='wikiwsd', passwd='wikiwsd', database='wikiwsd3'):\n self._host = host\n self._user = user\n self._passwd = passwd\n self._database = database",
"def __init__(self, wiki_conn=None):\n self.wiki_conn = wiki_conn\n if self.wiki_con... | [
"0.708437",
"0.69342434",
"0.69288975",
"0.6805751",
"0.6754723",
"0.65667826",
"0.6545131",
"0.65421885",
"0.65306705",
"0.6463664",
"0.6458318",
"0.6417798",
"0.6396213",
"0.6387407",
"0.6325784",
"0.6324736",
"0.6317163",
"0.62913865",
"0.62650484",
"0.62550473",
"0.622171... | 0.83109426 | 0 |
\brief The function write a pickle file storing the element given in input. | def writeFile(self, f, fname):
with open(self.PATH + fname, 'wb') as handle:
pickle.dump(f, handle, protocol = pickle.HIGHEST_PROTOCOL) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def store (input, filename) :\n cout = open (filename, 'w')\n pickle.dump (input, cout)\n cout.close ()",
"def write_to_file(name, obj):\n\n print 'writing structures to pickle'\n print '----------------------------'\n\n path = os.getcwd() + '/pickles/' + name + '.pkl'\n file = open(path, 'w... | [
"0.80946714",
"0.73514223",
"0.7174753",
"0.7043321",
"0.6871412",
"0.6861126",
"0.6785245",
"0.67609954",
"0.6739979",
"0.6728062",
"0.66913444",
"0.6677265",
"0.666801",
"0.66588134",
"0.6634674",
"0.6615443",
"0.6602087",
"0.65985113",
"0.6567265",
"0.65144295",
"0.648098"... | 0.0 | -1 |
\brief The function read a pickle file and return the related structure. | def readFile(self, fname):
res = None
with open(self.PATH + fname, 'rb') as handle:
res = pickle.load(handle)
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_from_file(name):\n print 'reading structures from pickle'\n print '------------------------------'\n\n path = os.getcwd() + '/pickles/' + name + '.pkl'\n file = open(path, 'rb')\n new_obj = pickle.load(file)\n file.close()\n\n return new_obj",
"def read_pickle(file_name):\n with ... | [
"0.8217308",
"0.80409527",
"0.78461426",
"0.7821366",
"0.77141094",
"0.7711124",
"0.76885915",
"0.7572694",
"0.75610256",
"0.7456856",
"0.74414194",
"0.74295825",
"0.740508",
"0.7398977",
"0.73620373",
"0.7164559",
"0.7153945",
"0.71497643",
"0.7147033",
"0.7104803",
"0.71043... | 0.6882876 | 40 |
\brief The function computes the vector representation for all the Wikipedia pages contained in the dataset. \return dict = Dictionary containing the vectors representaion of the pages. | def getVectors(self):
vectors = dict()
i = 0
N = len(self.db.invertedIndex)
for w, (idf, docs) in self.db.invertedIndex.items():
for doc, tf in docs.items():
try:
vectors[doc][i] = tf * idf
except KeyError as k:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getVector(self, p):\n vector = {}\n i = 0\n tr = ParseDumpWiki.normName(p)\n if(self.db.isInPage(tr)):\n for w, (idf, docs) in self.db.invertedIndex.items():\n if (p in docs):\n vector[i] = idf * docs[p]\n i += 1\n e... | [
"0.6587773",
"0.58068377",
"0.57203215",
"0.5535077",
"0.5424847",
"0.53094625",
"0.5303565",
"0.5172667",
"0.5141664",
"0.514158",
"0.5138805",
"0.5123758",
"0.5084756",
"0.5056258",
"0.5039636",
"0.5034146",
"0.503222",
"0.50316185",
"0.5027339",
"0.5025092",
"0.5025092",
... | 0.58590835 | 1 |
\brief The function receives as input a and b which are the vector representions of two pages and computes the cosine distance between them. | def cosin_sim_pairs(a, b):
wordsA = set(a.keys())
wordsB = set(b.keys())
inter = wordsA.intersection(wordsB)
if(len(inter) == 0):
return 0.0
aa, bb, ab = 0, 0, 0
for k in inter:
aa += a[k] ** 2
bb += b[k] ** 2
ab += a[k] * b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cosine_sim_counters(a, b):\n union_ab = sorted((a | b).keys())\n veca = np.array([a[element] if element in a else 0 for element in union_ab])\n vecb = np.array([b[element] if element in b else 0 for element in union_ab])\n return np.dot(veca, vecb) / (np.linalg.norm(veca) * np.linalg.norm(vecb))",
... | [
"0.7354454",
"0.7341037",
"0.73363996",
"0.7245744",
"0.70223963",
"0.69380355",
"0.6905679",
"0.6857959",
"0.68225634",
"0.67990756",
"0.6796523",
"0.6744453",
"0.6743802",
"0.67340875",
"0.66509485",
"0.6621326",
"0.65913004",
"0.65491676",
"0.65478724",
"0.6521512",
"0.648... | 0.71980083 | 4 |
\brief The function create all the centroids of the categories with at least inferior_limit number of pages. | def getAllCentroids(self, inferior_limit = 5, withPrint = True, saveFile = True, test = []):
i = 0
if(withPrint):
print("I'm creating the page-categories dictionary")
pageCat = self.db.getAllCategoriesGivenAllPages(inferior_limit)
if(len(test) > 0):
for p in test:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in ran... | [
"0.591679",
"0.58336884",
"0.58054376",
"0.5760245",
"0.5747278",
"0.5706009",
"0.5687512",
"0.56336176",
"0.56279874",
"0.5624772",
"0.559929",
"0.55759454",
"0.5550014",
"0.5542134",
"0.5538682",
"0.55276316",
"0.5519205",
"0.55120516",
"0.5507998",
"0.55051845",
"0.5486359... | 0.80864805 | 0 |
\brief The function goes through the Wikipedia vectors and computes the clustering over them. | def getCluster(self, eps = None, minPts = None):
#D = getDistanceMatrix()
#print("Distance matrix completed, clustering in process")
clusters = DBSCAN(metric=Categorization.cosin_sim_pairs).fit_predict(np.arange(186696).reshape(-1, 1))
print("Clustering completed, writing pickle file")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n ... | [
"0.6328683",
"0.595852",
"0.59465694",
"0.59238094",
"0.5897435",
"0.5855392",
"0.5817326",
"0.5804965",
"0.5793152",
"0.57682014",
"0.57520354",
"0.57100016",
"0.57018745",
"0.5690092",
"0.56882155",
"0.5674623",
"0.5670595",
"0.5640571",
"0.56251144",
"0.5584446",
"0.557590... | 0.0 | -1 |
\brief The function computes the matrix containing the distances between the vector representations of the wikipedia pages. \return matrix = Matrix containing the Wikipedia pages distances. | def getDistanceMatrix(self):
v = self.getVectors()
vLis = v.keys()
N = len(v.keys())
D = np.zeros([N, N], dtype=np.float32)
print(N)
for i in range(N):
print("%d/%d" %(i, N))
D[i, i] = 1
for j in range(i + 1, N):
dist = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cal_distances(embeddings):\n # calculate\n dist = np.zeros([len(embeddings), len(embeddings)], dtype=float)\n for ii in xrange(len(embeddings)):\n for jj in xrange(ii + 1, len(embeddings)):\n dist[ii, jj] = np.linalg.norm(embeddings[ii] - embeddings[jj])\n dist[jj, ii] = d... | [
"0.63889927",
"0.6071922",
"0.6015121",
"0.5982461",
"0.5942183",
"0.58543384",
"0.57427573",
"0.57176197",
"0.56639916",
"0.55544895",
"0.5540237",
"0.55395204",
"0.5484299",
"0.54806894",
"0.5416728",
"0.54155767",
"0.54121035",
"0.53967595",
"0.5396559",
"0.53624177",
"0.5... | 0.5844763 | 6 |
\brief The function receives as input p which is a Wikipedia page name and it computes its vector representation. | def getVector(self, p):
vector = {}
i = 0
tr = ParseDumpWiki.normName(p)
if(self.db.isInPage(tr)):
for w, (idf, docs) in self.db.invertedIndex.items():
if (p in docs):
vector[i] = idf * docs[p]
i += 1
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_vector(word, model):\n return model.wv[word]",
"def geo2vec(p):\n ra, dec = map(radians, p)\n return numpy.array([cos(dec) * cos(ra),\n cos(dec) * sin(ra),\n sin(dec)])",
"def compute_paraphrase_vector(w1, w2, paraphrase, model, word2index, UNK):\n... | [
"0.5726636",
"0.5670378",
"0.56148446",
"0.5528788",
"0.55178714",
"0.54855853",
"0.5459716",
"0.5454969",
"0.5435176",
"0.5347205",
"0.5257061",
"0.5244839",
"0.5174825",
"0.5163313",
"0.5160711",
"0.5157782",
"0.51471853",
"0.5105118",
"0.5097582",
"0.50825983",
"0.5060565"... | 0.7949694 | 0 |
\brief The function receives as input page which is the name of the page to be recommended. Additionally, it returns the boolean, fractional and hierarchical measures. | def recommendCategory(self, page, randomWeb, centroids = None, nSugg = None, printRes = True):
if(centroids is None):
try:
centroids = self.readFile("centroids.pickle")
except:
centroids = self.getAllCentroids()
if(randomWeb):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_page(self, page, lang):\n\n sql = text(\n \"select tfd.tid, tfd.name, tfd.description__value \"\n \"from taxonomy_term_field_data tfd \"\n \"where tfd.langcode = :lang and tfd.tid = :tid \"\n \"order by tfd.name;\")\n\n results = self.conn.execute... | [
"0.5150827",
"0.5136092",
"0.51097214",
"0.502858",
"0.5004379",
"0.4993655",
"0.49898502",
"0.4927899",
"0.4912906",
"0.48907775",
"0.48756838",
"0.48688158",
"0.48327056",
"0.48163545",
"0.48052007",
"0.47910896",
"0.4765261",
"0.47638354",
"0.47518128",
"0.4677516",
"0.467... | 0.44206786 | 68 |
\brief The function receives as input actual, top and nSugg which are the real categories, the suggested categories and the number of suggested categories. Then, it returns the boolean, fractional and hierarchical measures. | def measures(self, actual, top, nSugg):
m2 = 0.0
m3 = 0.0
for categorySug, count in top:
if categorySug in actual:
m2 += 1.0
else:
for cR in actual:
if self.getFatherSon(cR, categorySug) != None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printStats(m2, m3, actual, top):\n print(\"\\nThe actual categories for this page are: %s\" % \", \".join(sorted(actual)))\n print(\"\\nThe suggested categories for this page are: %s\" % \", \".join(sorted([v for v, count in top])))\n print(\"\\nBOOLEAN MEASURE = %s\" %(m2 != 0))\n ... | [
"0.6279863",
"0.5812435",
"0.57591397",
"0.5720849",
"0.56757563",
"0.55937576",
"0.55148196",
"0.545167",
"0.54158485",
"0.53934085",
"0.53467155",
"0.5326005",
"0.529815",
"0.52958894",
"0.5240811",
"0.5219415",
"0.52064973",
"0.5205301",
"0.5186157",
"0.5183564",
"0.516829... | 0.7087484 | 0 |
\brief The function receives as input m2, m3, actual and top which are the fractional measure, the hierarchical measure, the real categories and the recommended categories. Then, it prints the reccomendation results. | def printStats(m2, m3, actual, top):
print("\nThe actual categories for this page are: %s" % ", ".join(sorted(actual)))
print("\nThe suggested categories for this page are: %s" % ", ".join(sorted([v for v, count in top])))
print("\nBOOLEAN MEASURE = %s" %(m2 != 0))
print("FRACTIONAL MEAS... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def measures(self, actual, top, nSugg):\n m2 = 0.0\n m3 = 0.0\n for categorySug, count in top:\n if categorySug in actual:\n m2 += 1.0\n else:\n for cR in actual:\n if self.getFatherSon(cR, categorySug) != None:\n ... | [
"0.6225919",
"0.6079369",
"0.60408586",
"0.58891267",
"0.58619076",
"0.5833258",
"0.58032775",
"0.57549334",
"0.5747019",
"0.57380384",
"0.57230663",
"0.56918466",
"0.56778634",
"0.560007",
"0.55710596",
"0.55510956",
"0.5533128",
"0.55227405",
"0.5505769",
"0.5481364",
"0.54... | 0.7809993 | 0 |
\brief The function receives as input catR and catS which are the name of the real and suggested category respectively. Then, it returns a list containing the brother categories. | def getBrothers(self, catR, catS):
c = self.db.db.cursor()
c.execute('SELECT * FROM catsub WHERE ? IN (SELECT cat_name FROM cat_name_sub WHERE cat_name_sub = ?)', [catS, catR])
return c.fetchall() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFatherSon(self, catR, catS):\n c = self.db.db.cursor()\n c.execute('SELECT * FROM catsub WHERE (cat_name_sub = ? AND cat_name = ?) OR (cat_name_sub = ? AND cat_name = ?)', [catS, catR, catR, catS])\n return c.fetchall()",
"def get_categories(race_name, event_discipline):\n # FIXME ... | [
"0.594012",
"0.591181",
"0.58667684",
"0.5775641",
"0.56613356",
"0.56484073",
"0.56390023",
"0.5602293",
"0.5578761",
"0.5563652",
"0.553586",
"0.551049",
"0.5499992",
"0.54530984",
"0.54503536",
"0.542002",
"0.54172385",
"0.5377499",
"0.5368948",
"0.53368497",
"0.53361046",... | 0.73143184 | 0 |
\brief The function receives as input catR and catS which are the name of the real and suggested category respectively. Then, it returns a list containing the father/son category. | def getFatherSon(self, catR, catS):
c = self.db.db.cursor()
c.execute('SELECT * FROM catsub WHERE (cat_name_sub = ? AND cat_name = ?) OR (cat_name_sub = ? AND cat_name = ?)', [catS, catR, catR, catS])
return c.fetchall() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getBrothers(self, catR, catS):\n c = self.db.db.cursor()\n c.execute('SELECT * FROM catsub WHERE ? IN (SELECT cat_name FROM cat_name_sub WHERE cat_name_sub = ?)', [catS, catR])\n return c.fetchall()",
"def getCatParent(mode, cat):\n rta = set([])\n if mode == 'n':\n cat = ge... | [
"0.62573487",
"0.6106083",
"0.60577494",
"0.56528056",
"0.5651913",
"0.558147",
"0.5531332",
"0.55153984",
"0.54351413",
"0.54163444",
"0.53731084",
"0.53554934",
"0.5351091",
"0.5313431",
"0.5312579",
"0.5300816",
"0.52691513",
"0.5245465",
"0.52395195",
"0.52258575",
"0.522... | 0.67822933 | 0 |
\brief The function receives as input npages which is the number of Wikipedia pages to be evaluated and pageWeb which is the page to be recommended. It computes the boolean, fractional and hierarchical measures and prints them. | def evaluation(self, npages, centroids = None, randomWeb = False, pageWeb = None):
if(centroids is None):
try:
centroids = self.readFile("centroids.pickle")
except:
centroids = self.getAllCentroids(5)
if(randomWeb):
pages = [pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _huge_math_page_to_pages( env_dict ):\n import _math\n wiki_xml_math_output = env_dict[\"wiki\"][\"xml_math_output_big\"]\n #wiki_xml_math_output = env_dict[\"wiki\"][\"xml_math_output_test\"]\n\n from indexer.egomath.interface import egomath_inst\n\n egomath_inst.reset_logging()\n\n wiki_pag... | [
"0.59357786",
"0.5932471",
"0.5842498",
"0.578283",
"0.57478404",
"0.5516917",
"0.5436369",
"0.5406314",
"0.5350473",
"0.53293777",
"0.5325934",
"0.53164136",
"0.52994996",
"0.5296685",
"0.5255585",
"0.52087426",
"0.520245",
"0.51963955",
"0.5173262",
"0.5158161",
"0.5156993"... | 0.6455389 | 0 |
\brief The function receives as input nPageRacc and percentageTest which are the number of pages to be recommended for each step and the dataset fraction to use as test set. It computes several test recommending every time nPageRacc pages. For each step it considers a different number of categories. Specifically, it st... | def measurements(self, minPag = 4, maxPag = 50, nPagesRacc = 100, percentageTest = 0.20):
allPages = self.db.getPages()
test = random.sample(allPages, int(len(allPages) * percentageTest))
avg = []
centroids = self.getAllCentroids(inferior_limit = minPag, withPrint = False, saveFile = Fal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluation(self, npages, centroids = None, randomWeb = False, pageWeb = None):\n if(centroids is None):\n try:\n centroids = self.readFile(\"centroids.pickle\")\n except:\n centroids = self.getAllCentroids(5)\n \n if(randomWeb):\n ... | [
"0.6586228",
"0.54735696",
"0.5389025",
"0.53873664",
"0.5326797",
"0.52404207",
"0.52213144",
"0.5221267",
"0.52032757",
"0.5190112",
"0.51853114",
"0.5179685",
"0.5139516",
"0.5075939",
"0.5066819",
"0.5063224",
"0.5048917",
"0.4999439",
"0.49959165",
"0.4967029",
"0.495851... | 0.7285168 | 0 |
\brief The function reads a pickle file containing the results of a precomputed recommendation and creates a plot. | def createGraph(self):
self.measurements(45,50,10)
avg = self.readFile("avg.pickle")
table = []
for a in avg:
table.append((a[0], a[1], a[2], a[3], a[4], "Boolean"))
table.append((a[0], a[1], a[2], a[5], a[6], "Fractional"))
table.append((a[0], a[1], a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_predicted_results(self):\n print(\"\\n\\nLoad prediction answers : \")\n with open(\"predicted_results\", \"rb\") as predicted_results:\n self.predicted_results = pickle.load(predicted_results)",
"def load_and_plot(file_name):\n data = loadtxt(file_name, delimiter=',') \n ... | [
"0.63101786",
"0.6110959",
"0.60890526",
"0.5957507",
"0.593092",
"0.57316566",
"0.5674381",
"0.5673797",
"0.5620238",
"0.5561095",
"0.55385715",
"0.5532282",
"0.55145824",
"0.54861766",
"0.5467465",
"0.54420614",
"0.54209906",
"0.5416908",
"0.5400912",
"0.53858835",
"0.53719... | 0.0 | -1 |
Create a new TestProperty. | def __init__(self, name: str, value: str, prompt_on_start: bool):
self._name = name
self._value = value
self._prompt_on_start = prompt_on_start | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_property(self, key, prop):\n\n setting = self.new_property(key, prop)\n setting.create()\n return setting",
"def _makeProperty( key, value ):\r\n property = PropertyValue()\r\n property.Name = key\r\n property.Value = value\r\n return property",
"def ... | [
"0.7377541",
"0.69545835",
"0.66893363",
"0.6443179",
"0.6308621",
"0.6186396",
"0.6117073",
"0.5987714",
"0.59646297",
"0.594769",
"0.59302294",
"0.59260756",
"0.5924119",
"0.59083",
"0.5882198",
"0.5846983",
"0.5811372",
"0.5779722",
"0.57644075",
"0.57415414",
"0.57031035"... | 0.0 | -1 |
The name of the property. | def name(self) -> str:
return self._name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def property_name(self) -> str:\n return str(self.prop_name)",
"def PropertyName(self) -> str:",
"def name(self):\n return self.prop.key",
"def name(self):\n return self.properties.get('name')",
"def name(self):\n return self.properties.get('name')",
"def name(self):\n ... | [
"0.90803915",
"0.87418354",
"0.8487143",
"0.8374365",
"0.8374365",
"0.8319438",
"0.8217758",
"0.8098709",
"0.80601984",
"0.8012581",
"0.7849445",
"0.78423166",
"0.7655662",
"0.7542669",
"0.7353873",
"0.7339226",
"0.72947204",
"0.72669065",
"0.7232947",
"0.72147584",
"0.721475... | 0.7171753 | 72 |
The value of the property. | def value(self) -> str:
return self._value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self):\n return self._value",
"def get_value(self):\n return self._value",
"def get_value(self):\n return self._value",
"def value(self):\n return self.__value",
"def value(self):\n return self.__value",
"def get_value(self):\n return self._value"... | [
"0.82087135",
"0.81645244",
"0.81645244",
"0.81625575",
"0.81625575",
"0.8161171",
"0.8161171",
"0.8161171",
"0.8132177",
"0.8132177",
"0.8132177",
"0.8080328",
"0.8080328",
"0.8080328",
"0.8080328",
"0.8080328",
"0.8080328",
"0.8080328",
"0.8080328",
"0.8080328",
"0.8080328"... | 0.80432713 | 44 |
Whether this property should be set when the test session starts. If this is set to true, the operator should be prompted to define this property when the test session starts. | def prompt_on_start(self) -> bool:
return self._prompt_on_start | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def use_in_test_console(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"use_in_test_console\")",
"def use_in_test_console(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"use_in_test_console\")",
"def setUp(self):\n self._value = True",
"def get_prog... | [
"0.6495761",
"0.6205219",
"0.61119777",
"0.59335816",
"0.587958",
"0.58611184",
"0.57824",
"0.57824",
"0.576163",
"0.5717222",
"0.56998116",
"0.5685739",
"0.56485736",
"0.5592741",
"0.55852425",
"0.55688953",
"0.55402637",
"0.5536345",
"0.5528514",
"0.55212355",
"0.5498861",
... | 0.59922504 | 3 |
Ordered dictionary of all objects to be simulated, keyed by their names. | def all_objects(self):
if self._all_objs is None:
objs = OrderedDict()
for o in self._objects:
if not o.enabled:
continue
for k,v in o.all_objects().items():
if k in objs:
raise NameError('Mul... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_obs_dict(self):\n arm_state = self.robot.get_state('arm')\n gripper_state = self.robot.get_state('gripper')\n # obj_state = self.robot.get_state('object')\n obs_dict = collections.OrderedDict((\n ('t', self.robot.time),\n ('qp', np.concatenate([gripper_stat... | [
"0.6220388",
"0.614904",
"0.6138726",
"0.5957999",
"0.58871627",
"0.5881679",
"0.5880597",
"0.58215386",
"0.5781062",
"0.5751646",
"0.57378966",
"0.57372427",
"0.563681",
"0.563681",
"0.56242007",
"0.5596013",
"0.55933994",
"0.5520634",
"0.54944223",
"0.5470333",
"0.5457086",... | 0.5380367 | 28 |
Run the simulation until a number of samples have been acquired. Extra keyword arguments are passed to `scipy.integrate.odeint()`. | def run(self, samples=1000, **kwds):
opts = self.odeint_args.copy()
opts.update(kwds)
# reset all_objs cache in case some part of the sim has changed
self._all_objs = None
all_objs = self.all_objects().values()
# check that there is something to simulate... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _handler_sample(self, *args, **kwargs):\n next_state = None\n timeout = time.time() + SAMPLE_TIMEOUT\n\n for i in self._units:\n self._do_command(Command.READ, i)\n\n particles = self.wait_for_particles([DataParticleType.D1000_PARSED], timeout)\n\n return next_stat... | [
"0.5956003",
"0.5825392",
"0.5583392",
"0.5566894",
"0.551333",
"0.5512972",
"0.5506972",
"0.54876196",
"0.5475039",
"0.5444503",
"0.541932",
"0.5412775",
"0.5398358",
"0.53285867",
"0.53178716",
"0.53102845",
"0.5306154",
"0.5300801",
"0.5299684",
"0.52944416",
"0.5291731",
... | 0.5799795 | 2 |
Return the last values of all state variables in a SimState object. | def last_state(self):
return self._simstate | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_final_state(self):\n state = {}\n s = self.copy()\n clip = not np.isscalar(self['t'])\n if clip:\n # only get results for the last timepoint\n s.set_state(self.state[:, -1])\n \n for k in self.difeq_vars:\n state[k] = s[k]\n ... | [
"0.70501053",
"0.68264186",
"0.6813396",
"0.67094797",
"0.66886044",
"0.6674428",
"0.6615974",
"0.6521614",
"0.6480747",
"0.64383215",
"0.6368001",
"0.6361215",
"0.63596594",
"0.63395506",
"0.6314231",
"0.6235604",
"0.6213478",
"0.6176815",
"0.61695874",
"0.6163223",
"0.61559... | 0.7101281 | 0 |
Return a dictionary of all diff. eq. state variables and dependent variables for all objects in the simulation. | def get_final_state(self):
state = {}
s = self.copy()
clip = not np.isscalar(self['t'])
if clip:
# only get results for the last timepoint
s.set_state(self.state[:, -1])
for k in self.difeq_vars:
state[k] = s[k]
for k in self.d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def state_dict(self):\n return {k: getattr(self, k) for k in self.VARS}",
"def _map_state_vars_and_eqs(self):\n\n def get_used_eqs_and_state_vars(eq_to_expand, equations):\n \"\"\" Returns used equations and state vars for a given equation\n\n :param eq_to_expand: list contain... | [
"0.64888316",
"0.64769936",
"0.63034874",
"0.6238616",
"0.6224518",
"0.62226665",
"0.6172798",
"0.6081283",
"0.6061411",
"0.60162264",
"0.59225005",
"0.59200466",
"0.58960044",
"0.58875316",
"0.58743876",
"0.58677685",
"0.5862905",
"0.5849392",
"0.5827908",
"0.58276117",
"0.5... | 0.6228365 | 4 |
SimObjects are organized in a hierarchy. This method returns an ordered dictionary of all enabled SimObjects in this branch of the hierarchy, beginning with self. | def all_objects(self):
objs = OrderedDict()
objs[self.name] = self
for o in self._sub_objs:
if not o.enabled:
continue
objs.update(o.all_objects())
return objs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_all_objects(self):\n level_objects = Group()\n mobs_objects = Group()\n for sprite_group in self.sprite_level_blocks:\n for object_ in sprite_group:\n if str(object_) == 'Mob':\n mobs_objects.add(object_)\n elif str(object_) ... | [
"0.61496246",
"0.61296856",
"0.608513",
"0.5893054",
"0.5893054",
"0.58513844",
"0.58347917",
"0.576784",
"0.5687896",
"0.5657026",
"0.56417245",
"0.55909324",
"0.5588757",
"0.55806464",
"0.55752224",
"0.5573823",
"0.5544128",
"0.5508163",
"0.54780394",
"0.54708326",
"0.54590... | 0.6703417 | 0 |
An ordered dictionary of all variables required to solve the diff. eq. for this object. | def difeq_state(self):
return self._current_state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def variables(self) -> OrderedDict:\n return OrderedDict({'mu': self.mu, 'sig': self.sig})",
"def variables(self) -> OrderedDict:\n return OrderedDict({'m': self.m, 'c': self.c})",
"def variables(self) -> OrderedDict:\n return OrderedDict({'a': self.a, 'b': self.b, 'c': self.c})",
"def v... | [
"0.7248682",
"0.71558905",
"0.6962569",
"0.6884791",
"0.6548065",
"0.6319755",
"0.629784",
"0.6287567",
"0.62830275",
"0.6226725",
"0.6188233",
"0.6133646",
"0.61116743",
"0.6098625",
"0.6093391",
"0.60918874",
"0.6050224",
"0.6036763",
"0.6020341",
"0.6014623",
"0.60084933",... | 0.0 | -1 |
Update diffeq state variables with their last simulated values. These will be used to initialize the solver when the next simulation begins. | def update_state(self, result):
for i,k in enumerate(self._current_state.keys()):
self._current_state[k] = result[i] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_feq(self):\n\n sim = self.sim\n\n self.sim.kernels.update_feq_fluid(\n sim.queue, sim.two_d_global_size, sim.two_d_local_size,\n sim.feq.data,\n sim.rho.data,\n sim.u_bary.data, sim.v_bary.data,\n sim.w, sim.cx, sim.cy, sim.cs,\n ... | [
"0.63552344",
"0.6078575",
"0.6056346",
"0.5823179",
"0.5814604",
"0.5757745",
"0.5711599",
"0.5698494",
"0.5692954",
"0.5635986",
"0.5575828",
"0.5563461",
"0.5553724",
"0.5535413",
"0.55197155",
"0.55178094",
"0.5513537",
"0.55110824",
"0.54964936",
"0.54838675",
"0.5473986... | 0.0 | -1 |
Return derivatives of all state variables. Must be reimplemented in subclasses. This is used by the ODE solver to integrate during the simulation; should be as fast as possible. | def derivatives(self, state):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _derivatives(self, state, forces_moments):\n # extract the states\n pn = state.item(0)\n pe = state.item(1)\n pd = state.item(2)\n u = state.item(3)\n v = state.item(4)\n w = state.item(5)\n e0 = state.item(6)\n e1 = state.item(7)\n e2 = sta... | [
"0.7683193",
"0.7318128",
"0.7000159",
"0.68565035",
"0.67524266",
"0.67374635",
"0.6591703",
"0.6397337",
"0.6300758",
"0.6288592",
"0.6209557",
"0.6207909",
"0.618478",
"0.61518556",
"0.61518556",
"0.6109665",
"0.6108",
"0.60804623",
"0.6070026",
"0.6070026",
"0.5987634",
... | 0.78107053 | 0 |
The Sim instance in which this object is being used. | def sim(self):
return self._sim | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sim(self) -> Sim:\n\n return self._sim",
"def get_simulator(self) -> Game:\n return self.__sim",
"def sim(self):\n return self.mujoco_simulation.sim",
"def sim_info(self) -> SimInfo:\n return self._sim_info",
"def getSimulation(self):\r\n raise NotImplementedError()",... | [
"0.8274302",
"0.76091176",
"0.74165684",
"0.7305126",
"0.6934737",
"0.6901099",
"0.6809698",
"0.6788061",
"0.6562603",
"0.65560406",
"0.65333664",
"0.64729905",
"0.64492494",
"0.64492494",
"0.63692015",
"0.63296455",
"0.6318461",
"0.63045615",
"0.62786096",
"0.62221605",
"0.6... | 0.79484886 | 1 |
do action and return state. | def newstate(env, trigger, state, action):
if trigger(env):
if state:
return True
else:
result = action(env)
print "%s\t%r -> [%r] => %r" % (nowf(), trigger, action, result)
return bool(result)
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def take_action(self, state):",
"def result(self, state, action):\n print \"Ashish\"\n return 1",
"def result(self, state, action):\n\t\traise NotImplementedError",
"def act(self, state):\n return",
"def __call__(self, state, action):\n pass",
"def result(self, state, acti... | [
"0.7944721",
"0.76809496",
"0.750748",
"0.74055165",
"0.73374164",
"0.7325363",
"0.70580524",
"0.7040232",
"0.7018546",
"0.6981787",
"0.69742656",
"0.6899508",
"0.68732816",
"0.67997473",
"0.67997473",
"0.6712618",
"0.6712618",
"0.6696641",
"0.66902274",
"0.6675269",
"0.66181... | 0.0 | -1 |
Put trigger and action | def push(self, trigger, action):
self.queue.append((trigger, action)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trigger(self, type, event):",
"def fire_trigger(self, trigger):\n if not self.exists():\n return\n if trigger in self.events:\n for action in self.events[trigger]:\n action(requestor=self)",
"def __call__(self, trigger, type, event):",
"def changeTrigger... | [
"0.7347315",
"0.6795273",
"0.67381936",
"0.6464891",
"0.64134777",
"0.6370419",
"0.6218917",
"0.61916995",
"0.6181925",
"0.6171602",
"0.6161308",
"0.6034554",
"0.60305524",
"0.59762686",
"0.59295934",
"0.59295934",
"0.59295934",
"0.59295934",
"0.59207004",
"0.59207004",
"0.59... | 0.6640422 | 3 |
Given a pair of dates, creates iterator that returns (aMonday,theNextMonday) such that the first returned pair defines an interval holding minDate the last returned pair defines an interval holding maxDate if minDate or maxDate are not instances of datetime.date, raises TypeError if maxDate > minDate, raises ValueError | def mondayPairsIteratorFactory(minDate, maxDate):
if not (isinstance(minDate,dt.date) and isinstance(maxDate,dt.date)):
raise TypeError("minDate and maxDate must be instances of datetime.date")
if maxDate < minDate:
raise ValueError("minDate must be <= maxDate")
def anIterator():
oneWeek = dt.timedelt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def daterange(date1, date2):\n for n in range(int ((date2 - date1).days)+1):\n yield date1 + timedelta(n)",
"def iter_dates(start, end):\n one_day = timedelta(days=1)\n date = start\n while date <= end:\n yield date\n date += one_day",
"def _drange(start: Da... | [
"0.6606035",
"0.6605835",
"0.64703006",
"0.63616943",
"0.62733585",
"0.6229436",
"0.62277454",
"0.6221993",
"0.61602044",
"0.6106471",
"0.60732347",
"0.6054331",
"0.603127",
"0.5957231",
"0.58339053",
"0.5806204",
"0.57963264",
"0.57677",
"0.5739298",
"0.56889385",
"0.5613047... | 0.8523642 | 0 |
A helper function to get the correct order to create tables during setup. whichTables is a list of Tables, possibly empty, or None If not whichTables, then all the known tables are visited | def getOrderedSetupList(whichTables = None):
# if whichTables is None, then databaseDependenciesForSetup.keys() is used
return socorro_pri.dependencyOrder(databaseDependenciesForSetup,whichTables) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getOrderedPartitionList(whichTables):\n if not whichTables:\n return []\n order = socorro_pri.dependencyOrder(databaseDependenciesForPartition,whichTables)\n return order",
"def create_all_tables(self):\n pass",
"def create_tables( self ) :\n return self._create_tables",
"def init_tab... | [
"0.6438581",
"0.6068337",
"0.5827515",
"0.5818468",
"0.57141715",
"0.5701556",
"0.5697819",
"0.5639476",
"0.5597376",
"0.5596786",
"0.5568101",
"0.5547983",
"0.55355597",
"0.55066556",
"0.54814607",
"0.54805577",
"0.54765683",
"0.5469697",
"0.53908694",
"0.5388238",
"0.537485... | 0.7382621 | 0 |
A helper function to get the needed PartionedTables for a given set of PartitionedTables | def getOrderedPartitionList(whichTables):
if not whichTables:
return []
order = socorro_pri.dependencyOrder(databaseDependenciesForPartition,whichTables)
return order | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_partitions(self, table_name):\n partition_result = self.query(\n sql.fetch_partition,\n (\n self._current_db,\n table_name,\n ),\n )\n # If a table doesn't have partition schema the \"PARTITION_NAME\"\n # will be s... | [
"0.6315098",
"0.6028243",
"0.58734983",
"0.58222467",
"0.5769109",
"0.57545966",
"0.56962395",
"0.56682754",
"0.5640412",
"0.5635037",
"0.5578057",
"0.55250573",
"0.5516319",
"0.5486221",
"0.548598",
"0.5465969",
"0.53857803",
"0.5384892",
"0.5357559",
"0.5334161",
"0.5330704... | 0.65810615 | 0 |
Helper function to examine partitionCreationHistory | def partitionWasCreated(partitionTableName):
return partitionTableName in partitionCreationHistory | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def markPartitionCreated(partitionTableName):\n global partitionCreationHistory\n partitionCreationHistory.add(partitionTableName)",
"def _get_partition_list(self):\n raise NotImplementedError('Must be implemented in subclasses.')",
"def partition_book(self):\n ...",
"def _createOwnPartition(... | [
"0.65855694",
"0.59157133",
"0.5605107",
"0.5602883",
"0.5564097",
"0.55443454",
"0.5337288",
"0.53309625",
"0.5256756",
"0.511385",
"0.50445294",
"0.5031911",
"0.5025408",
"0.5014135",
"0.5008548",
"0.5005736",
"0.5003711",
"0.4998482",
"0.49464095",
"0.4941047",
"0.49375242... | 0.73551816 | 0 |
Helper function to update partitionCreationHistory | def markPartitionCreated(partitionTableName):
global partitionCreationHistory
partitionCreationHistory.add(partitionTableName) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def partitionWasCreated(partitionTableName):\n return partitionTableName in partitionCreationHistory",
"def on_partition_change(self, new_partitions):\n if new_partitions is None:\n self.conn.create(self.partition_path, value=self.partitions)\n return\n\n if new_partitions !=... | [
"0.6277444",
"0.5867328",
"0.5753557",
"0.57449204",
"0.5468491",
"0.54188854",
"0.5398478",
"0.5376595",
"0.5308092",
"0.52885246",
"0.52048874",
"0.5138754",
"0.5134442",
"0.51240784",
"0.5119822",
"0.49873483",
"0.49679628",
"0.49415168",
"0.4938052",
"0.49107817",
"0.4885... | 0.7366289 | 0 |
Internal method that assumes all precursor partitions are already in place before creating this one. Called from createPartitions(same parameters) to avoid bottomless recursion. Creates one or more partitions for this particular table, (more if uniqueItems has more than one element) | def _createOwnPartition(self, databaseCursor, uniqueItems):
self.logger.debug("%s - in createOwnPartition for %s",threading.currentThread().getName(),self.name)
for x in uniqueItems:
#self.logger.debug("DEBUG - item value is %s",x)
partitionCreationParameters = self.partitionCreationParameters(x)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createPartitions(self, databaseCursor, iterator):\n self.logger.debug(\"%s - in createPartitions\", threading.currentThread().getName())\n partitionTableClasses = getOrderedPartitionList([self.__class__])\n #self.logger.debug(\"DEBUG - Classes are %s\",partitionTableClasses)\n uniqueItems = [x for ... | [
"0.64606357",
"0.5514394",
"0.5317253",
"0.5310833",
"0.5189379",
"0.51807606",
"0.5172232",
"0.51274365",
"0.50877345",
"0.5060848",
"0.49768895",
"0.49730808",
"0.49422514",
"0.49221748",
"0.49219945",
"0.49001914",
"0.48978415",
"0.48882595",
"0.48838842",
"0.48623025",
"0... | 0.7701096 | 0 |
Create this table's partition(s) and all the precursor partition(s) needed to support this one | def createPartitions(self, databaseCursor, iterator):
self.logger.debug("%s - in createPartitions", threading.currentThread().getName())
partitionTableClasses = getOrderedPartitionList([self.__class__])
#self.logger.debug("DEBUG - Classes are %s",partitionTableClasses)
uniqueItems = [x for x in iterator... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _createOwnPartition(self, databaseCursor, uniqueItems):\n self.logger.debug(\"%s - in createOwnPartition for %s\",threading.currentThread().getName(),self.name)\n for x in uniqueItems:\n #self.logger.debug(\"DEBUG - item value is %s\",x)\n partitionCreationParameters = self.partitionCreationPar... | [
"0.72625685",
"0.6556742",
"0.64865416",
"0.64796466",
"0.6260575",
"0.6234208",
"0.6183316",
"0.6067094",
"0.6047013",
"0.60348827",
"0.59451205",
"0.592884",
"0.5903982",
"0.58994883",
"0.58899176",
"0.58500534",
"0.57829833",
"0.57518965",
"0.5745148",
"0.5699041",
"0.5686... | 0.72230065 | 1 |
Create a set of partitions for all the tables known to be efficient when they are created prior to being needed. see the list databaseObjectClassListForWeeklyParitions above | def createPartitions(config, logger):
databaseConnection, databaseCursor = connectToDatabase(config, logger)
try:
for aDatabaseObjectClass in databaseObjectClassListForWeeklyPartitions:
weekIterator = mondayPairsIteratorFactory(config.startDate, config.endDate)
aDatabaseObject = aDatabaseObjectClass... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createPartitions(self, databaseCursor, iterator):\n self.logger.debug(\"%s - in createPartitions\", threading.currentThread().getName())\n partitionTableClasses = getOrderedPartitionList([self.__class__])\n #self.logger.debug(\"DEBUG - Classes are %s\",partitionTableClasses)\n uniqueItems = [x for ... | [
"0.78974897",
"0.6525179",
"0.6408025",
"0.6380735",
"0.62772876",
"0.6232555",
"0.6150809",
"0.60966617",
"0.60484344",
"0.59169513",
"0.59100777",
"0.5902835",
"0.5898807",
"0.5858238",
"0.58435506",
"0.58283883",
"0.57975763",
"0.5755997",
"0.5744674",
"0.57172894",
"0.571... | 0.7650467 | 1 |
Read a commaseparated values (.csv) file into DataFrame. | def makeDF(csv_path):
import pandas as pd
DF = pd.read_csv(csv_path)
# DF['height'] = DF.apply(lambda DF: abs(DF['ymax'] - DF['ymin']), axis=1)
# DF['width'] = DF.apply(lambda DF: abs(DF['xmax'] - DF['xmin']), axis=1)
# DF['objArea'] = DF.apply(lambda DF: (DF['width'] * DF['height']), axis=1)
H... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_csv(csv_file: str) -> pd.DataFrame:\n return pd.read_csv(csv_file, header=0)",
"def data_from_csv(self, filepath):\n self.dataframe = pd.load_csv(filepath, separator='')",
"def read_in_values(path: str) -> DataFrame:\n sep = _check_suffix(path)\n return pd.read_csv(_is_valid_file... | [
"0.7560159",
"0.72104675",
"0.7131028",
"0.70655996",
"0.7017841",
"0.69729435",
"0.6923881",
"0.6913294",
"0.68825763",
"0.6852916",
"0.6849474",
"0.67877716",
"0.67647284",
"0.67601335",
"0.67601335",
"0.67601335",
"0.67507124",
"0.674601",
"0.67313546",
"0.6713945",
"0.667... | 0.0 | -1 |
generated from code7.py. However, is not compatible with the 25, in convert_to_coco_json coco_dict = convert_to_coco_dict(dataset_name) File "/Users/mac7/opt/anaconda3/envs/myenvpy/lib/python3.7/sitepackages/detectron20.1.1py3.7macosx10.9x86_64.egg/detectron2/data/datasets/coco.py", line 314, in convert_to_coco_dict | def data_dict0():
# 0- Sample from detectron2 -> 5 different sections.
info_val0 = [{"date_created": "2020-03-15 04:59:45.442988",
"description": "Automatically generated COCO json file for Detectron2."}]
images0 = [{"id": "image", "width": 100,
"height": 100, "file_name":... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_coco_dataset():\n ds = AttrDict()\n # classes = [\n # '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',\n # 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',\n # 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',\n # ... | [
"0.7177033",
"0.6570015",
"0.6285049",
"0.6221178",
"0.611349",
"0.6035911",
"0.57440627",
"0.5730883",
"0.55947363",
"0.5550295",
"0.55144775",
"0.55096453",
"0.5449006",
"0.54164267",
"0.54066616",
"0.5378364",
"0.5358252",
"0.53523004",
"0.5315025",
"0.53006166",
"0.527519... | 0.56904554 | 8 |
Register a new strategy for generating data for specific string "format". | def register_string_format(name: str, strategy: st.SearchStrategy) -> None:
if not isinstance(name, str):
raise TypeError(f"name must be of type {str}, not {type(name)}")
if not isinstance(strategy, st.SearchStrategy):
raise TypeError(f"strategy must be of type {st.SearchStrategy}, not {type(str... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_data_format(format_name,parser):\n\n data_format_parser[format_name] = parser",
"def register_str_format(\n tag: Tag, conformer: Optional[Conformer] = None\n) -> Callable[[ValidatorFn], ValidatorFn]:\n\n def create_str_format(f: ValidatorFn) -> ValidatorFn:\n with _STR_FORMAT_LOCK:\n... | [
"0.67097753",
"0.56974983",
"0.55908847",
"0.55496186",
"0.5468228",
"0.5330458",
"0.52871567",
"0.5243602",
"0.52405083",
"0.51500815",
"0.51046956",
"0.51046956",
"0.5070095",
"0.4967492",
"0.4967349",
"0.49556667",
"0.49543664",
"0.49472272",
"0.49290946",
"0.49174467",
"0... | 0.7103577 | 0 |
Register all default "format" strategies. | def init_default_strategies() -> None:
register_string_format("binary", st.binary())
register_string_format("byte", st.binary().map(lambda x: b64encode(x).decode()))
def make_basic_auth_str(item: Tuple[str, str]) -> str:
return _basic_auth_str(*item)
latin1_text = st.text(alphabet=st.character... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_formats(cls):\n if cls._format_to_serializer is None:\n cls._register_subclasses()\n formats = ['auto']\n formats.extend(cls._format_to_serializer)\n return formats",
"def register_format(recipe):\n afr = AFMFormatRecipe(recipe)\n formats_available.append(afr)... | [
"0.67433965",
"0.62260413",
"0.6008091",
"0.5960222",
"0.5885646",
"0.58462405",
"0.57293695",
"0.5707574",
"0.5638043",
"0.5609508",
"0.5559438",
"0.5524077",
"0.5505028",
"0.5505028",
"0.54933727",
"0.547053",
"0.54281515",
"0.53969175",
"0.53580284",
"0.5356706",
"0.534757... | 0.57387257 | 6 |
Verify if the generated headers are valid. | def is_valid_header(headers: Dict[str, Any]) -> bool:
for name, value in headers.items():
if not utils.is_latin_1_encodable(value):
return False
if utils.has_invalid_characters(name, value):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_build_headers(self):\n\n headers = self_signed.build_headers()\n assert 'Content-Length' in headers\n assert 'X-Amz-Date' in headers\n assert 'Host' in headers\n assert 'X-Amz-Security-Token' in headers\n assert 'Content-Type' in headers\n assert 'Authoriza... | [
"0.73248684",
"0.71754396",
"0.71661705",
"0.69765127",
"0.6962748",
"0.6939488",
"0.6889487",
"0.68174773",
"0.68034554",
"0.6791674",
"0.6682548",
"0.6604471",
"0.6590226",
"0.6554132",
"0.6513857",
"0.6459408",
"0.6422941",
"0.640519",
"0.640519",
"0.63898265",
"0.6378792"... | 0.6863574 | 7 |
Surrogates are not allowed in a query string. `requests` and `werkzeug` will fail to send it to the application. | def is_valid_query(query: Dict[str, Any]) -> bool:
for name, value in query.items():
if is_illegal_surrogate(name) or is_illegal_surrogate(value):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_params_sanitize(query_params):\n def allow_func(n, v):\n # This gets rid of any params beginning with \"oauth_\"\n if not n.startswith(\"oauth_\"):\n return True\n else:\n logging.warning(\"Protocol parameter ignored from URL query parameters: `%r`\", n)\n ... | [
"0.65669465",
"0.65147066",
"0.6183156",
"0.6004749",
"0.5999434",
"0.5922218",
"0.59101033",
"0.5864199",
"0.5864199",
"0.57987845",
"0.57948476",
"0.5750507",
"0.57338244",
"0.5732014",
"0.5732014",
"0.57237566",
"0.5696393",
"0.5689057",
"0.56888187",
"0.5682486",
"0.56790... | 0.0 | -1 |
A strategy that creates `Case` instances. Explicit `path_parameters`, `headers`, `cookies`, `query`, `body` arguments will be used in the resulting `Case` object. | def get_case_strategy( # pylint: disable=too-many-locals
draw: Callable,
endpoint: Endpoint,
hooks: Optional[HookDispatcher] = None,
feedback: Optional[Feedback] = None,
data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
path_parameters: Any = NOT_SET,
headers: A... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request_case(self, casenum, case):\n # Anonymous or authenticated session?\n is_mod_request = case['method'].upper() in self.modification_methods\n needs_user = case.get('user', is_mod_request)\n if needs_user:\n session = self.user_session\n else:\n ses... | [
"0.575196",
"0.57027084",
"0.5673386",
"0.5494484",
"0.54804766",
"0.5334432",
"0.5334432",
"0.52071553",
"0.51731235",
"0.51614434",
"0.51614434",
"0.50898486",
"0.50793946",
"0.5054101",
"0.5024315",
"0.5018465",
"0.50131065",
"0.50022775",
"0.49648806",
"0.49112797",
"0.48... | 0.5888172 | 0 |
Create a new strategy for the case's component from the endpoint parameters. | def get_parameters_strategy(
endpoint: Endpoint, to_strategy: Callable[[Dict[str, Any]], st.SearchStrategy], location: str
) -> st.SearchStrategy:
parameters = getattr(endpoint, LOCATION_TO_CONTAINER[location])
if parameters:
schema = parameters_to_json_schema(parameters)
strategy = to_strat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_case_strategy( # pylint: disable=too-many-locals\n draw: Callable,\n endpoint: Endpoint,\n hooks: Optional[HookDispatcher] = None,\n feedback: Optional[Feedback] = None,\n data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),\n path_parameters: Any = NOT_SET,\n ... | [
"0.6418826",
"0.5800213",
"0.5728096",
"0.5714733",
"0.5632045",
"0.5582534",
"0.55530953",
"0.5522158",
"0.5477194",
"0.53526986",
"0.5237057",
"0.5194271",
"0.5176202",
"0.512805",
"0.5121639",
"0.5117651",
"0.51095563",
"0.510309",
"0.50945157",
"0.5078439",
"0.5024108",
... | 0.6061061 | 1 |
Single "." chars and empty strings "" are excluded from path by urllib3. A path containing to "/" or "%2F" will lead to ambiguous path resolution in many frameworks and libraries, such behaviour have been observed in both WSGI and ASGI applications. In this case one variable in the path template will be empty, which wi... | def is_valid_path(parameters: Dict[str, Any]) -> bool:
path_parameter_blacklist = (".", SLASH, "")
return not any(
(value in path_parameter_blacklist or is_illegal_surrogate(value) or isinstance(value, str) and SLASH in value)
for value in parameters.values()
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_path(path):\r\n while path[len(path) - 1] == '/' or path[len(path) - 1] == '\\\\':\r\n path = path[0:-1]\r\n\r\n return path",
"def _get_full_path(self, path, environ):\n if path.startswith('//'):\n path = path[1:]\n elif path.startswith('/'):\n path =... | [
"0.6272722",
"0.6118131",
"0.59735245",
"0.5902947",
"0.5849248",
"0.58329684",
"0.57983935",
"0.57708544",
"0.57563895",
"0.5733279",
"0.5692304",
"0.5686826",
"0.5673544",
"0.5606747",
"0.55980134",
"0.559067",
"0.55775833",
"0.5570223",
"0.55601454",
"0.55497587",
"0.55495... | 0.0 | -1 |
Apply URL quotation for all values in a dictionary. | def quote_all(parameters: Dict[str, Any]) -> Dict[str, Any]:
return {key: quote_plus(value) if isinstance(value, str) else value for key, value in parameters.items()} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def urllib_quote_parameters(inputdictionary):\r\n if type(inputdictionary) is not dict:\r\n raise TypeError(\"urllib_quote_parameters' inputstringdictionary parameter must be a dict, not '\"+str(type(inputstring))+\"'\")\r\n\r\n quoted_keyvals = []\r\n for key, val in inputdictionary.items():\r\n quoted_k... | [
"0.62306243",
"0.5637293",
"0.5618359",
"0.55986035",
"0.555752",
"0.55488056",
"0.5539878",
"0.5492487",
"0.548568",
"0.54376",
"0.5426715",
"0.5394386",
"0.53836554",
"0.53630733",
"0.5343481",
"0.5332934",
"0.5330379",
"0.53290695",
"0.5296179",
"0.5293168",
"0.5288468",
... | 0.5998401 | 1 |
Apply all `before_generate_` hooks related to the given location. | def apply_hooks(
endpoint: Endpoint,
context: HookContext,
hooks: Optional[HookDispatcher],
strategy: st.SearchStrategy[Case],
location: str,
) -> st.SearchStrategy[Case]:
strategy = _apply_hooks(context, GLOBAL_HOOK_DISPATCHER, strategy, location)
strategy = _apply_hooks(context, endpoint.s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _apply_hooks(\n context: HookContext, hooks: HookDispatcher, strategy: st.SearchStrategy[Case], location: str\n) -> st.SearchStrategy[Case]:\n container = LOCATION_TO_CONTAINER[location]\n for hook in hooks.get_all_by_name(f\"before_generate_{container}\"):\n strategy = hook(context, strategy)\... | [
"0.66052645",
"0.54367757",
"0.5335337",
"0.5200875",
"0.514125",
"0.5092376",
"0.50201553",
"0.49951658",
"0.49630007",
"0.49584186",
"0.4955014",
"0.49404222",
"0.491867",
"0.4910777",
"0.48239407",
"0.4786473",
"0.4785765",
"0.47504947",
"0.47237763",
"0.47235417",
"0.4710... | 0.42714888 | 87 |
Apply all `before_generate_` hooks related to the given location & dispatcher. | def _apply_hooks(
context: HookContext, hooks: HookDispatcher, strategy: st.SearchStrategy[Case], location: str
) -> st.SearchStrategy[Case]:
container = LOCATION_TO_CONTAINER[location]
for hook in hooks.get_all_by_name(f"before_generate_{container}"):
strategy = hook(context, strategy)
return s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_hooks(self):\n pass",
"def process_before_request_hooks(self):\n\n hooks = []\n\n if self.resource:\n hooks.extend(self.resource.api.before_all_hooks)\n hooks.extend(self.resource.before_all_hooks)\n\n hooks.extend(self.before_all_hooks)\n hooks.... | [
"0.56037354",
"0.5500859",
"0.5223152",
"0.52164966",
"0.5215929",
"0.5108552",
"0.5066924",
"0.5015762",
"0.49975643",
"0.4935562",
"0.49342433",
"0.49167737",
"0.48724824",
"0.48304024",
"0.48257065",
"0.48113218",
"0.48091397",
"0.4805462",
"0.47963923",
"0.47690478",
"0.4... | 0.6157746 | 0 |
Enables enriching test items with more properties to be used for grouping or other purposes. The goal is for whoever needs to be able to add item.test_group field | def pytest_before_group_items(session, config, items): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_test_inline_additional_properties(self):\n pass",
"def pytest_after_group_items(session, config, items):",
"def pytest_collection_modifyitems(config, items):\n # check if studio tests myst be skipped\n run_study = config.getoption(\"--runstudy\")\n # 'all' will match all studies, '' wi... | [
"0.5947742",
"0.5900158",
"0.5774352",
"0.573061",
"0.5615433",
"0.55916494",
"0.5568033",
"0.5543221",
"0.55160785",
"0.55160785",
"0.55108106",
"0.54705465",
"0.5394397",
"0.5350562",
"0.5348308",
"0.5344149",
"0.52992165",
"0.5255538",
"0.52473474",
"0.5215013",
"0.5209653... | 0.668921 | 0 |
receives 2 items and decides if they can run together. returns bool | def pytest_can_run_together(item1, item2): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def got_both(self):\r\n if Item.A in self.items and Item.B in self.items:\r\n return True",
"def valid_multiple_in_request(self):\n return self._repeatable[0] is True",
"def adaptable( item1, item2 ) :\n\n if( item2 is None ) : return( True )\n return re.fullmatch(item2, ... | [
"0.73054934",
"0.6250203",
"0.62348914",
"0.61885935",
"0.60863423",
"0.6018422",
"0.6008905",
"0.5933993",
"0.591542",
"0.5821401",
"0.58169997",
"0.5744042",
"0.57171375",
"0.57098925",
"0.5701733",
"0.570071",
"0.5699882",
"0.5689656",
"0.5678437",
"0.5675575",
"0.56661355... | 0.6191703 | 3 |
Allows doing manipulations or enriching with other data on test items (after grouping) Items have a test_group field. | def pytest_after_group_items(session, config, items): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pytest_before_group_items(session, config, items):",
"def test_add_group(self):\n pass",
"def test_grouping(self):\n s = self.create(ComponentItem, UML.Component)\n uc1 = self.create(UseCaseItem, UML.UseCase)\n uc2 = self.create(UseCaseItem, UML.UseCase)\n\n self.group(s,... | [
"0.684022",
"0.66695523",
"0.6552354",
"0.6369141",
"0.63321984",
"0.63281184",
"0.62650174",
"0.6235142",
"0.61431545",
"0.61334264",
"0.61311626",
"0.61311626",
"0.6118693",
"0.60952663",
"0.60952663",
"0.6080429",
"0.6080429",
"0.6024302",
"0.60169107",
"0.5959551",
"0.591... | 0.660266 | 2 |
This is the place to provision if grouper is invoked | def pytest_started_handling_group(session, worker): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __on_group_created(self, logger, *args):",
"def test_create_group(self):\n pass",
"def test_create_group(self):\n pass",
"def pre_security_group_create(self, resource_dict):\n pass",
"def test_create_device_group(self):\n pass",
"def _make_group(self, _rk, _group_hint):\n\... | [
"0.6569253",
"0.62589484",
"0.62589484",
"0.6143284",
"0.6102148",
"0.6084975",
"0.5941392",
"0.59400153",
"0.58592314",
"0.585574",
"0.58110565",
"0.5778987",
"0.5748649",
"0.5700932",
"0.5689231",
"0.56728923",
"0.5657217",
"0.5652605",
"0.560312",
"0.5590086",
"0.5553873",... | 0.5379457 | 37 |
This is the place to release if grouper is invoked (ie if hardware still exists on this hook call) | def pytest_finished_handling_group(session, worker): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __exit__(self, *_):\r\n\t\tself.ueye.is_FreeImageMem(self.hCam, self.pcImageMemory, self.MemID)\r\n\r\n\t\t# Disables the hCam camera handle and releases the data structures and memory areas taken up by the uEye camera\r\n\t\tself.ueye.is_ExitCamera(self.hCam)",
"def __del__(self):\n self.p.sleep()\n ... | [
"0.64408547",
"0.63653266",
"0.6343562",
"0.6335266",
"0.63285846",
"0.62338746",
"0.61478007",
"0.6144899",
"0.6130134",
"0.61175394",
"0.6112023",
"0.6108773",
"0.61039203",
"0.60399",
"0.60207015",
"0.5983089",
"0.5948264",
"0.59431905",
"0.5941086",
"0.5926044",
"0.592394... | 0.0 | -1 |
Define the toolbox (the name of the toolbox is the name of the .pyt file). | def __init__(self):
self.label = "PFRR Tools"
self.alias = "PFRR Tools"
# List of tool classes associated with this toolbox
self.tools = [Ending_Point, Range_Distance, PFRR] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_toolbox(self, engine_name, task_name, toolbox_name):\n pass",
"def __init__(self):\n self.label = \"Python ToolBox\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Tool]",
"def __init__(self):\n self.label = \"Crea... | [
"0.8001657",
"0.76821536",
"0.7338371",
"0.7278725",
"0.7259962",
"0.7148503",
"0.7061571",
"0.67234725",
"0.66628635",
"0.6649481",
"0.6587418",
"0.6583463",
"0.65043044",
"0.64949065",
"0.6422432",
"0.6311597",
"0.62550175",
"0.62525314",
"0.62455046",
"0.6217126",
"0.61207... | 0.64769334 | 14 |
Define the tool (tool name is the name of the class). | def __init__(self):
self.label = "Ending Point"
self.description = "This tool calculates the final point given" + \
"the initial point, range and bearing."
self.canRunInBackground = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, toolName):\n\t\tself.toolName = toolName",
"def __init__(self):\n self.label = \"Create\"\n self.alias = \"\"\n\n # List of tool classes associated with this toolbox\n if core.get_pass():\n self.tools = [Fbound, Roads, Diekdikisi]\n else:\n ... | [
"0.78886044",
"0.74191546",
"0.73680484",
"0.7317306",
"0.72275203",
"0.7022156",
"0.6999495",
"0.6988887",
"0.6932704",
"0.6919116",
"0.6890748",
"0.68180656",
"0.6817103",
"0.67857397",
"0.6773338",
"0.6738541",
"0.6737494",
"0.673033",
"0.6693258",
"0.6666185",
"0.6644223"... | 0.0 | -1 |
Set whether tool is licensed to execute. | def isLicensed(self):
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isLicensed(self):\r\n try:\r\n if arcpy.CheckExtension(\"Spatial\") != \"Available\":\r\n raise Exception\r\n except Exception:\r\n return False # tool cannot be executed\r\n return True ... | [
"0.67727894",
"0.67727894",
"0.65478224",
"0.65478224",
"0.65478224",
"0.65478224",
"0.65478224",
"0.65478224",
"0.65478224",
"0.65478224",
"0.64847887",
"0.64847887",
"0.64847887",
"0.64847887",
"0.64847887",
"0.64847887",
"0.64847887",
"0.64847887",
"0.64847887",
"0.63919765"... | 0.63335377 | 57 |
Modify the values and properties of parameters before internal validation is performed. This method is called whenever a parameter has been changed. | def updateParameters(self, parameters):
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateParameters(self, parameters):\n # if parameters[0].altered:\n # parameters[1].value = arcpy.ValidateFieldName(parameters[1].value,\n # parameters[0].value)\n return",
"def parameters_changed(self):\n pass",
"def ... | [
"0.7688436",
"0.75183314",
"0.70699507",
"0.7068056",
"0.70668334",
"0.6885432",
"0.6881135",
"0.6881135",
"0.6881135",
"0.6881135",
"0.6881135",
"0.6881135",
"0.6881135",
"0.6881135",
"0.684654",
"0.6841016",
"0.68276924",
"0.68104416",
"0.6776473",
"0.67577714",
"0.67530274... | 0.6615761 | 25 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.