0:\n return [int(i) for i in fid.split(',')]\n\n # A number?\n try:\n return int(fid)\n except ValueError:\n pass\n\n # A symbolic name!\n\n symbols = dict(\n all=set(range(1,25)),\n\n # functions that converge earlier than 7^3\n q=set([1,2,5]),\n\n # functions that have a single sharply optimal oracle\n single=set([2,3,4,6,7,10,11,12,13,15,16,17,18,19,20,21,22,23]),\n # functions that have multiple feasible candidates (#evals@optimal slowdown <2)\n many=set([1,5,8,9,14,24]),\n\n # functions whose optimal oracle did not dominate throughout the computation (i.e. was not best two powers of |pf| ago)\n volatile=set([6,8,9,10,11,12,13,14,15,19,20,21,22,23,24]),\n\n # functions whose oracle converges steadily\n steady=set([6,12,17,18,19,24]),\n # functions whose oracle converges unexpectedly\n sudden=set([1,2,3,4,5,7,8,9,10,11,13,14,15,16,20,21,22,23]),\n\n # functions where CMA (the by far best-performing pf member) converges\n CMAgood=set([6,7,10,11,12,13,16,17,18,21,22,23]),\n # functions where CMA (the by far best-performing pf member) does not converge\n CMAbad=set([1,2,3,4,5,8,9,14,15,19,20,24]),\n\n # original BBOB families\n separ=set(range(1,6)),\n lcond=set(range(6,10)),\n hcond=set(range(10,15)),\n multi=set(range(15,20)),\n mult2=set(range(20,25)),\n )\n\n fidset = set([])\n for m in re.finditer(r'([+:-])?([^+:-]+)', fid):\n if m.group(1) is None:\n fidset = symbols[m.group(2)]\n elif m.group(1) == '+':\n fidset |= symbols[m.group(2)]\n elif m.group(1) == ':':\n fidset &= symbols[m.group(2)]\n elif m.group(1) == '-':\n fidset -= symbols[m.group(2)]\n else:\n raise ValueError('bad fid syntax ' + fid)\n return list(fidset)","def protons ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n ## \n if self['NOPIDHADRONS'] :\n from StandardParticles import StdAllNoPIDsProtons as inpts\n protoncut = self['ProtonCut']\n else :\n from StandardParticles import StdAllLooseANNProtons as inpts \n protoncut = \"(%s)&(%s)\" % ( self['ProtonCut'] , self['ProtonPIDCut'] ) \n #\n ##\n return self.make_selection (\n 'Proton' ,\n FilterDesktop ,\n [ inpts ] ,\n Code = protoncut ,\n )","def multi_focus_TIE(fs, using_gpu=False, printing=False, *erps, **kwerps):\n mftie = MFTIE(fs, using_gpu, *erps, **kwerps)\n phase = mftie()\n if printing:\n mftie.print_k2_thres()\n return phase","def office_clean_event_kernels(parser, args, params):\n parser.parse_known_args(args)\n control.clean_event_kernels(params)","def setupDeterminer(exposure, nEigenComponents=3, starSelectorAlg=\"secondMoment\"):\n schema = afwTable.SourceTable.makeMinimalSchema()\n if starSelectorAlg == \"secondMoment\":\n starSelectorClass = measAlg.SecondMomentStarSelectorTask\n starSelectorConfig = starSelectorClass.ConfigClass()\n starSelectorConfig.clumpNSigma = 3.0\n starSelectorConfig.badFlags = [ ]\n elif starSelectorAlg == \"objectSize\":\n starSelectorClass = measAlg.ObjectSizeStarSelectorTask\n starSelectorConfig = starSelectorClass.ConfigClass()\n starSelectorConfig.badFlags = [\"base_PixelFlags_flag_edge\",\n \"base_PixelFlags_flag_interpolatedCenter\",\n \"base_PixelFlags_flag_saturatedCenter\",\n \"base_PixelFlags_flag_crCenter\",\n ]\n starSelectorConfig.widthStdAllowed = 0.5\n\n starSelector = starSelectorClass(config=starSelectorConfig,schema=schema)\n\n psfDeterminerFactory = measAlg.psfDeterminerRegistry[\"pca\"]\n psfDeterminerConfig = psfDeterminerFactory.ConfigClass()\n width, height = exposure.getMaskedImage().getDimensions()\n psfDeterminerConfig.sizeCellX = width\n psfDeterminerConfig.sizeCellY = height//3\n psfDeterminerConfig.nEigenComponents = nEigenComponents\n psfDeterminerConfig.spatialOrder = 1\n psfDeterminerConfig.spatialReject = 6.0\n psfDeterminerConfig.kernelSizeMin = 31\n psfDeterminerConfig.nStarPerCell = 0\n psfDeterminerConfig.nStarPerCellSpatialFit = 0 # unlimited\n psfDeterminer = psfDeterminerFactory(psfDeterminerConfig)\n\n return starSelector, psfDeterminer","def apply_science_modules_elasticc(df: DataFrame) -> DataFrame:\n # Required alert columns\n to_expand = ['midPointTai', 'filterName', 'psFlux', 'psFluxErr']\n\n # Use for creating temp name\n prefix = 'c'\n\n # Append temp columns with historical + current measurements\n for colname in to_expand:\n df = concat_col(\n df, colname, prefix=prefix,\n current='diaSource', history='prvDiaForcedSources'\n )\n expanded = [prefix + i for i in to_expand]\n\n _LOG.info(\"New processor: xmatch (random positions)\")\n # Assuming random positions\n df = df.withColumn('cdsxmatch', F.lit('Unknown'))\n\n _LOG.info(\"New processor: asteroids (random positions)\")\n df = df.withColumn('roid', F.lit(0))\n\n # add redshift\n df = df.withColumn('redshift', F.col('diaObject.z_final'))\n df = df.withColumn('redshift_err', F.col('diaObject.z_final_err'))\n\n _LOG.info(\"New processor: EarlySN\")\n args = ['cmidPointTai', 'cfilterName', 'cpsFlux', 'cpsFluxErr']\n\n # fake cdsxmatch and nobs\n args += [F.col('diaObject.ra'), F.col('diaObject.decl')]\n args += [F.col('diaObject.hostgal_ra'), F.col('diaObject.hostgal_dec')]\n args += [F.col('diaObject.hostgal_snsep')]\n args += [F.col('diaObject.hostgal_zphot')]\n args += [F.col('diaObject.hostgal_zphot_err')]\n\n df = df.withColumn('rf_snia_vs_nonia', rfscore_sigmoid_elasticc(*args))\n\n # Apply level one processor: superNNova\n _LOG.info(\"New processor: supernnova - Ia\")\n args = [F.col('diaSource.diaSourceId')]\n args += [F.col('cmidPointTai'), F.col('cfilterName'), F.col('cpsFlux'), F.col('cpsFluxErr')]\n args += [F.col('roid'), F.col('cdsxmatch'), F.array_min('cmidPointTai')]\n args += [F.col('diaObject.mwebv'), F.col('redshift'), F.col('redshift_err')]\n args += [F.lit('elasticc_ia')]\n df = df.withColumn('snn_snia_vs_nonia', snn_ia_elasticc(*args))\n\n _LOG.info(\"New processor: supernnova - Broad\")\n args = [F.col('diaSource.diaSourceId')]\n args += [F.col('cmidPointTai'), F.col('cfilterName'), F.col('cpsFlux'), F.col('cpsFluxErr')]\n args += [F.col('roid'), F.col('cdsxmatch'), F.array_min('cmidPointTai')]\n args += [F.col('diaObject.mwebv'), F.col('redshift'), F.col('redshift_err')]\n args += [F.lit('elasticc_broad')]\n df = df.withColumn('preds_snn', snn_broad_elasticc(*args))\n\n mapping_snn = {\n 0: 11,\n 1: 13,\n 2: 12,\n 3: 22,\n 4: 21,\n }\n mapping_snn_expr = F.create_map([F.lit(x) for x in chain(*mapping_snn.items())])\n\n col_class = F.col('preds_snn').getItem(0).astype('int')\n df = df.withColumn('snn_broad_class', mapping_snn_expr[col_class])\n df = df.withColumn('snn_broad_max_prob', F.col('preds_snn').getItem(1))\n\n # CBPF\n args = ['cmidPointTai', 'cpsFlux', 'cpsFluxErr', 'cfilterName']\n args += [F.col('diaObject.mwebv'), F.col('diaObject.z_final'), F.col('diaObject.z_final_err')]\n args += [F.col('diaObject.hostgal_zphot'), F.col('diaObject.hostgal_zphot_err')]\n df = df.withColumn('cbpf_preds', predict_nn(*args))\n\n mapping_cats_general = {\n 0: 11,\n 1: 12,\n 2: 13,\n 3: 21,\n 4: 22,\n }\n mapping_cats_general_expr = F.create_map([F.lit(x) for x in chain(*mapping_cats_general.items())])\n\n df = df.withColumn('argmax', F.expr('array_position(cbpf_preds, array_max(cbpf_preds)) - 1'))\n df = df.withColumn('cats_broad_class', mapping_cats_general_expr[df['argmax']])\n df = df.withColumn('cats_broad_max_prob', F.array_max(df['cbpf_preds']))\n\n # AGN\n args_forced = [\n 'diaObject.diaObjectId', 'cmidPointTai', 'cpsFlux', 'cpsFluxErr', 'cfilterName',\n 'diaSource.ra', 'diaSource.decl',\n 'diaObject.hostgal_zphot', 'diaObject.hostgal_zphot_err',\n 'diaObject.hostgal_ra', 'diaObject.hostgal_dec'\n ]\n df = df.withColumn('rf_agn_vs_nonagn', agn_elasticc(*args_forced))\n\n # SLSN\n args_forced = [\n 'diaObject.diaObjectId', 'cmidPointTai', 'cpsFlux', 'cpsFluxErr', 'cfilterName',\n 'diaSource.ra', 'diaSource.decl',\n 'diaObject.hostgal_zphot', 'diaObject.hostgal_zphot_err',\n 'diaObject.hostgal_ra', 'diaObject.hostgal_dec'\n ]\n df = df.withColumn('rf_slsn_vs_nonslsn', slsn_elasticc(*args_forced))\n\n # Drop temp columns\n df = df.drop(*expanded)\n df = df.drop(*['preds_snn', 'cbpf_preds', 'redshift', 'redshift_err', 'cdsxmatch', 'roid', 'argmax'])\n\n return df","def analyze(self, event):\n\t\tJets = Collection(event, \"Jet\")\n\t\tjets = [j for j in Jets if j.pt >= 20]\n\t\tgenpart = Collection(event, \"GenPart\")\n\t\tgenParts = [l for l in genpart]\n\t\t# get the particles when they have a mother ---> getting the daughters only \n\t\tdaughters = [l for l in genpart if l.genPartIdxMother>= 0 ]\n\t\tevent.nIsr = 0\n\t\tfor jet in jets:\n\t\t\tif jet.pt <30.0: continue\n\t\t\tif abs(jet.eta )>2.4: continue\n\t\t\tmatched = False\n\t\t\tfor i,mc in enumerate(genParts):\n\t\t\t\t# if it's matched doesn't make sence to correct it\n\t\t\t\tif matched: break\n\t\t\t\t# check if it's quark from top or not\n\t\t\t\tif (mc.status!=23 or abs(mc.pdgId)>5): continue\n\t\t\t\tmomid = abs(genParts[mc.genPartIdxMother].pdgId)\n\t\t\t\tif not (momid==6 or momid==23 or momid==24 or momid==25 or momid>1e6): continue\n\t\t\t\tfor idau in range(len(daughters)) :\n\t\t\t\t\t# look for the products of the jet and match jet with gen daughters of the quark \n\t\t\t\t\tif i == daughters[idau].genPartIdxMother:\n\t\t\t\t\t\tdR = math.sqrt(deltaR2(jet.eta,jet.phi, daughters[idau].eta,daughters[idau].phi))\n\t\t\t\t\t\tif dR<0.3:\n\t\t\t\t\t\t\t# if matched escape\n\t\t\t\t\t\t\tmatched = True\n\t\t\t\t\t\t\tbreak\n\t\t\t# if not matched correct it \n\t\t\tif not matched:\n\t\t\t\tevent.nIsr+=1\n\t\t# fill the output with nisr\n\t\tself.out.fillBranch(\"nIsr\",event.nIsr)\n\t\tnISRweight = 1\n\t\t#https://indico.cern.ch/event/592621/contributions/2398559/attachments/1383909/2105089/16-12-05_ana_manuelf_isr.pdf\n\t\tISRweights_Mar17 = { 0: 1, 1 : 0.920, 2 : 0.821, 3 : 0.715, 4 : 0.662, 5 : 0.561, 6 : 0.511}\n\t\tISRweights_ICHEP16 = { 0: 1, 1 : 0.882, 2 : 0.792, 3 : 0.702, 4 : 0.648, 5 : 0.601, 6 : 0.515}\n\t\tISRweightssyst_Mar17 = { 0: 0.0, 1 : 0.040, 2 : 0.090, 3 : 0.143, 4 : 0.169, 5 : 0.219, 6 : 0.244}\n\t\tISRweightssyst_ICHEP16 = { 0: 0.0, 1 : 0.059, 2 : 0.104, 3 : 0.149, 4 : 0.176, 5 : 0.199, 6 : 0.242}\n\t\t\n\t\tif self.ICHEP16 == True and self.Mar17 == False:\n\t\t\tISRweights = ISRweights_ICHEP16\n\t\t\tISRweightssyst = ISRweightssyst_ICHEP16\n\t\t\t\n\t\telif self.ICHEP16 == False and self.Mar17 == True: \n\t\t\tISRweights = ISRweights_Mar17\n\t\t\tISRweightssyst = ISRweightssyst_Mar17\n\t\t\t\n\t\tnISRforWeights = int(event.nIsr)\n\t\tif event.nIsr > 6:\n\t\t\tnISRforWeights = 6\n\t\tC_ISR = 1.090\n\t\tC_ISR_up = 1.043\n\t\tC_ISR_down = 1.141\n\t\tnISRweight = C_ISR * ISRweights[nISRforWeights]\n\t\tnISRweightsyst_up = C_ISR_up * (ISRweights[nISRforWeights] + ISRweightssyst[nISRforWeights])\n\t\tnISRweightsyst_down = C_ISR_down * (ISRweights[nISRforWeights] - ISRweightssyst[nISRforWeights])\n\t\t\n\t\tself.out.fillBranch(\"nISRweight\",nISRweight)\n\t\tself.out.fillBranch(\"nISRttweightsyst_up\",nISRweightsyst_up)\n\t\tself.out.fillBranch(\"nISRttweightsyst_down\",nISRweightsyst_down)\n\n\n # ------ Forwarded Message --------\n # Subject: Re: question for ttbar ISR reweighting\n # Date: Sat, 14 Jan 2017 20:24:14 +0100\n # From: Manuel Franco Sevilla <manuel.franco.sevilla@cern.ch>\n #The [Nom, Up, Down] values we find for the events with Nisr = 0 are:\n #[1.090, 1.043, 1.141]: TTJets_Tune\n #[1.096, 1.046, 1.151]: TTJets_SingleLeptFromT\n #[1.116, 1.055, 1.185]: TTJets_DiLept\n\t\t\n\t\t\n\t\treturn True","def launch_epidemic(self, source, max_time=np.inf):\n self._init_run(source, max_time)\n # Init epidemic time to 0\n time = 0\n last_print = 0\n while self.processing:\n last_time = time\n # Get the next event to process\n (node, event_type), time = self.processing.pop(0)\n if time > self.max_time:\n break # Stop at then end of the observation window\n # Process the event\n if event_type == 'inf':\n self._process_infection_event(node, time)\n elif event_type == 'rec':\n self._process_recovery_event(node, time)\n else:\n raise ValueError(\"Invalid event type\")\n self._printer.print(self, time)\n if time-last_time >= 1:\n self._update_SIR_stats(time)\n self._printer.println(self, time)\n self.max_time = time\n # Free memory\n del self.processing","def get_process_func(dataset_type, dsname):\n\n dsformat = 'VOL'\n if dataset_type == 'RAW':\n func_name = process_raw\n elif dataset_type == 'NCVOL':\n func_name = process_save_radar\n elif dataset_type == 'PWR':\n func_name = 'process_signal_power'\n elif dataset_type == 'SNR':\n func_name = 'process_snr'\n elif dataset_type == 'RHOHV_CORRECTION':\n func_name = 'process_correct_noise_rhohv'\n elif dataset_type == 'BIAS_CORRECTION':\n func_name = 'process_correct_bias'\n elif dataset_type == 'L':\n func_name = 'process_l'\n elif dataset_type == 'CDR':\n func_name = 'process_cdr'\n elif dataset_type == 'SAN':\n func_name = 'process_echo_id'\n elif dataset_type == 'ECHO_FILTER':\n func_name = 'process_echo_filter'\n elif dataset_type == 'SNR_FILTER':\n func_name = 'process_filter_snr'\n elif dataset_type == 'VIS_FILTER':\n func_name = 'process_filter_visibility'\n elif dataset_type == 'OUTLIER_FILTER':\n func_name = 'process_outlier_filter'\n elif dataset_type == 'PHIDP0_CORRECTION':\n func_name = 'process_correct_phidp0'\n elif dataset_type == 'PHIDP_SMOOTH_1W':\n func_name = 'process_smooth_phidp_single_window'\n elif dataset_type == 'PHIDP_SMOOTH_2W':\n func_name = 'process_smooth_phidp_double_window'\n elif dataset_type == 'PHIDP_KDP_MAESAKA':\n func_name = 'process_phidp_kdp_Maesaka'\n elif dataset_type == 'PHIDP_KDP_LP':\n func_name = 'process_phidp_kdp_lp'\n elif dataset_type == 'KDP_LEASTSQUARE_1W':\n func_name = 'process_kdp_leastsquare_single_window'\n elif dataset_type == 'KDP_LEASTSQUARE_2W':\n func_name = 'process_kdp_leastsquare_double_window'\n elif dataset_type == 'ATTENUATION':\n func_name = 'process_attenuation'\n elif dataset_type == 'RAINRATE':\n func_name = 'process_rainrate'\n elif dataset_type == 'WIND_VEL':\n func_name = 'process_wind_vel'\n elif dataset_type == 'WINDSHEAR':\n func_name = 'process_windshear'\n elif dataset_type == 'HYDROCLASS':\n func_name = 'process_hydroclass'\n elif dataset_type == 'PHIDP0_ESTIMATE':\n func_name = 'process_estimate_phidp0'\n elif dataset_type == 'RHOHV_RAIN':\n func_name = 'process_rhohv_rain'\n elif dataset_type == 'ZDR_RAIN':\n func_name = 'process_zdr_rain'\n elif dataset_type == 'SELFCONSISTENCY_KDP_PHIDP':\n func_name = 'process_selfconsistency_kdp_phidp'\n elif dataset_type == 'SELFCONSISTENCY_BIAS':\n func_name = 'process_selfconsistency_bias'\n elif dataset_type == 'TIME_AVG':\n func_name = 'process_time_avg'\n dsformat = 'TIMEAVG'\n elif dataset_type == 'WEIGHTED_TIME_AVG':\n func_name = 'process_weighted_time_avg'\n dsformat = 'TIMEAVG'\n elif dataset_type == 'FLAG_TIME_AVG':\n func_name = 'process_time_avg_flag'\n dsformat = 'TIMEAVG'\n elif dataset_type == 'COLOCATED_GATES':\n func_name = 'process_colocated_gates'\n dsformat = 'COLOCATED_GATES'\n elif dataset_type == 'INTERCOMP':\n func_name = 'process_intercomp'\n dsformat = 'INTERCOMP'\n elif dataset_type == 'INTERCOMP_TIME_AVG':\n func_name = 'process_intercomp_time_avg'\n dsformat = 'INTERCOMP'\n elif dataset_type == 'MONITORING':\n func_name = 'process_monitoring'\n dsformat = 'MONITORING'\n elif dataset_type == 'SUN_HITS':\n func_name = 'process_sun_hits'\n dsformat = 'SUN_HITS'\n elif dataset_type == 'POINT_MEASUREMENT':\n func_name = process_point_measurement\n dsformat = 'TIMESERIES'\n elif dataset_type == 'TRAJ':\n func_name = process_trajectory\n dsformat = 'TRAJ_ONLY'\n elif dataset_type == 'TRAJ_ATPLANE':\n func_name = process_traj_atplane\n dsformat = 'TIMESERIES'\n elif dataset_type == 'TRAJ_ANTENNA_PATTERN':\n func_name = process_traj_antenna_pattern\n dsformat = 'TIMESERIES'\n else:\n raise ValueError(\"ERROR: Unknown dataset type '%s' of dataset '%s'\"\n % (dataset_type, dsname))\n\n return func_name, dsformat","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--num', action='store', type=int, required=True)\n num = parser.parse_args().num\n # load ing subset and usda ingredients\n ing_path = 'data/join/%d.pkl' % num\n ings = pickle.load(open(ing_path, 'rb'))\n usda_path = 'data/join/usda.pkl'\n usda = pickle.load(open(usda_path, 'rb'))\n names = usda['desc']\n processed = names.apply(fuzz._process_and_sort)\n usda_id_map = get_usda_id_map(processed)\n name_id_map = {ing: usda_id_map[(fuzzy_match(\n fuzz._process_and_sort(ing), ing_ser=processed, comp=fuzz.token_set_ratio))] for ing in ings}\n peak(name_id_map, names)\n # save name_id_map\n out_path = 'data/join/%d_map.pkl' % num\n pickle.dump(name_id_map)","def Process(nc_path):\n\n fname = os.path.basename(nc_path)\n _, ext = os.path.splitext(fname)\n\n if fname.endswith('.nc'):\n open_dataset = xr.open_dataset\n elif fname.endswith('.zarr'):\n open_dataset = xr.open_zarr\n else:\n raise ValueError(f\"{ext} is not a valid file format.\")\n\n # Open nc file in order to determine what echosounder produced the original dataset\n with open_dataset(nc_path) as nc_file:\n try:\n echo_type = nc_file.keywords\n except AttributeError:\n raise ValueError(\"This file is incompatible with echopype functions.\")\n\n # Returns specific Process object\n if echo_type == \"EK60\":\n return ProcessEK60(nc_path)\n elif echo_type == \"EK80\":\n return ProcessEK80(nc_path)\n elif echo_type == \"AZFP\":\n return ProcessAZFP(nc_path)\n else:\n raise ValueError(\"Unsupported file type\")","def process_tree(tree):\n c = circuit()\n l = line()\n names = {}\n procedures = []\n for lst in tree.children:\n print(lst)\n if type(lst[0]) is str:\n names[lst[0]] = lst[1]\n else:\n procedures.append(lst)\n print(names)\n #print(procedures)\n\n for proc in procedures:\n\n proc_elements_names = proc[0]\n proc_name = proc[1]\n\n #print(proc_elements_names)\n #print(proc_name)\n\n if proc_name == \"set_mode\":\n mode_name = proc_elements_names[0]\n if mode_name != \"draw-mode\": \n c.set_mode(mode_name)\n elif mode_name == \"draw-mode\":\n l1 = line()\n # draw mode is different from other modes\n for element in names:\n e = CompleteElement(element)\n e.set_other_attrs(names[element])\n e.process_other_attrs()\n l1.addElement(e)\n c.connectInSeries(l1)\n c.set_mode(\"draw-mode\")\n \n \n if proc_name == \"series\":\n l1 = line()\n for element in proc_elements_names:\n l1.addElement(names[element])\n l = l1\n c.connectInSeries(l)\n #raise SyntaxError(\"Alias {0} referrenced before assignment\".format(item[0]))\n\n elif proc_name == \"parallel\":\n l1 = line()\n for element in proc_elements_names:\n l1.addElement(names[element])\n c.connectInParallel(l1)\n l1 = line()\n\n\n elif proc_name == \"add_parallel\":\n new_element = proc_elements_names[1]\n old_element = proc_elements_names[0]\n l1 = line()\n l1.addElement(names[new_element])\n c.connection.append(l1)\n\n\n elif proc_name == \"add_series\":\n new_element = proc_elements_names[1]\n old_element = proc_elements_names[0]\n for ln in c.connection:\n for e in ln.elements:\n if names[old_element] == e:\n ln.addElement(names[new_element])\n\n\n c.evaluate(\"output.png\")\n #print(c)","def get_raw_feature_name(self):\n # open a h5 file in case we need it\n f5 = h5py.File(self.train_database[0], 'r')\n mol_name = list(f5.keys())[0]\n raw_data = f5.get(mol_name + '/features/')\n\n # if we select all the features\n if self.select_feature == \"all\":\n self.select_feature = {}\n self.select_feature['AtomicDensities'] = config.atom_vdw_radius_noH\n self.select_feature['Features'] = [\n name for name in raw_data.keys()]\n\n # if a selection was made\n else:\n # we loop over the input dict\n for feat_type, feat_names in self.select_feature.items():\n\n # if for a given type we need all the feature\n if feat_names == 'all':\n if feat_type == 'AtomicDensities':\n self.select_feature['AtomicDensities'] = \\\n config.atom_vdw_radius_noH\n elif feat_type == 'Features':\n self.select_feature[feat_type] = list(\n raw_data.keys())\n else:\n raise KeyError(\n f'Wrong feature type {feat_type}. '\n f'It should be \"AtomicDensities\" or \"Features\".')\n\n else:\n if feat_type == 'AtomicDensities':\n assert isinstance(\n self.select_feature['AtomicDensities'], dict)\n elif feat_type == 'Features':\n self.select_feature[feat_type] = []\n for name in feat_names:\n if '*' in name:\n match = name.split('*')[0]\n possible_names = list(raw_data.keys())\n match_names = [\n n for n in possible_names\n if n.startswith(match)]\n self.select_feature[feat_type] += match_names\n else:\n self.select_feature[feat_type] += [name]\n else:\n raise KeyError(\n f'Wrong feature type {feat_type}. '\n f'It should be \"AtomicDensities\" or \"Features\".')\n\n f5.close()","def fullcore_detectors():\n\n cwd = os.getcwd()\n fname = get_sample_data('%s/oecd-fullcore_geom1.png' % (cwd))\n im = plt.imread(fname)\n\n # crop the image\n height, width, color = np.shape(im)\n y1 = int(height*0.15)\n y2 = int(height*0.6)\n x1 = int(width*0.45)\n x2 = int(width)\n plt.imshow(im[y1:y2,x1:x2,:])\n plt.axis('off')\n\n # Axial 1\n x = 158\n y = 291\n P = 55\n s = P/2/np.cos(np.pi/6)\n plt.plot([s+x, 2*s+x], [0+y, 0+y], 'r-', lw=1.5, label='1- Axial1')\n plt.plot([s+x, 2*s+x], [P+y, P+y], 'r-', lw=1.5)\n plt.plot([s+x, s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\n plt.plot([s/2+x, s+x], [P/2+y, P+y], 'r-', lw=1.5)\n plt.plot([2*s+x, 2*s+s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\n plt.plot([2*s+s/2+x, 2*s+x], [P/2+y, P+y], 'r-', lw=1.5)\n\n plt.text(x=x+37, y=y+40, s='1', fontsize=20, color='w')\n\n # Axial 2\n x = 210\n y = 321\n P = 55\n s = P/2/np.cos(np.pi/6)\n plt.plot([s+x, 2*s+x], [0+y, 0+y], 'r-', lw=1.5, label='2- Axial2')\n plt.plot([s+x, 2*s+x], [P+y, P+y], 'r-', lw=1.5)\n plt.plot([s+x, s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\n plt.plot([s/2+x, s+x], [P/2+y, P+y], 'r-', lw=1.5)\n plt.plot([2*s+x, 2*s+s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\n plt.plot([2*s+s/2+x, 2*s+x], [P/2+y, P+y], 'r-', lw=1.5)\n plt.text(x=x+37, y=y+40, s='2', fontsize=20, color='w')\n\n # Axial 3\n x = 262\n y = 291\n P = 55\n s = P/2/np.cos(np.pi/6)\n plt.plot([s+x, 2*s+x], [0+y, 0+y], 'r-', lw=1.5, label='3- Axial3')\n plt.plot([s+x, 2*s+x], [P+y, P+y], 'r-', lw=1.5)\n plt.plot([s+x, s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\n plt.plot([s/2+x, s+x], [P/2+y, P+y], 'r-', lw=1.5)\n plt.plot([2*s+x, 2*s+s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\n plt.plot([2*s+s/2+x, 2*s+x], [P/2+y, P+y], 'r-', lw=1.5)\n\n plt.text(x=x+37, y=y+40, s='3', fontsize=20, color='w')\n\n # Radial 1\n x = 52\n y = 349\n plt.plot([x, 495+x], [y, y], 'r-', lw=1.5, label='4- Radial1')\n plt.plot([x, 495+x], [y, y], 'r-', lw=1.5, label='5- Radial2')\n plt.text(x=x+380, y=y-10, s='4, 5', fontsize=20, color='black')\n\n # Radial 2\n x = 52\n y = 349\n L = 495\n plt.plot([x, L*np.cos(np.pi/6)+x], [y, -L/2+y], 'r-', lw=1.5, label='6- Radial3')\n plt.text(x=350, y=y-200, s='6', rotation=30, fontsize=20, color='black')\n plt.legend(loc='best')\n\n plt.savefig(\"oecd-fullcore-detectors\", dpi=300, bbox_inches=\"tight\")","def eog_removal(self):\n print('ch_names are: ' + str(self.raw.ch_names))\n ch_name = input(\"Enter a channel for eog detection. Best if the channel is near eyes, like Fp1 and Fp2. All channels will be named like 'CH_1': \")\n eog_projs, eog_events = mne.preprocessing.compute_proj_eog(self.raw, n_grad=0, n_mag=0, n_eeg=1, ch_name=ch_name, reject = None)\n projs = eog_projs\n self.epochs.add_proj(projs)\n self.epochs.apply_proj()\n return self.epochs","def parse_process_keywords(proc_kw, rfd_kwargs=None):\n\n rfd_kwargs = rfd_kwargs if rfd_kwargs is not None else dict()\n\n if proc_kw in ('fast', 'f', 'quick', 'short', None):\n if 'n_samples' not in rfd_kwargs:\n rfd_kwargs['n_samples'] = 600\n elif proc_kw in ('medium', 'm'):\n if 'n_samples' not in rfd_kwargs:\n rfd_kwargs['n_samples'] = 1000\n elif proc_kw in ('slow', 'full', 'f', 's'):\n if 'n_samples' not in rfd_kwargs:\n rfd_kwargs['n_samples'] = None\n elif proc_kw in ('i', 'ideal', 'transit_search', 'ts', 'main'):\n if 'n_samples' not in rfd_kwargs:\n rfd_kwargs['n_samples'] = 1000\n if 'ocut' not in rfd_kwargs:\n rfd_kwargs['ocut'] = (5, 5, 4, 4, 4)\n rfd_kwargs['n_iters'] = len(rfd_kwargs['ocut'])\n elif proc_kw in ('ie', 'ideal_e', 'main_e', 'semi_evolve'):\n if 'n_samples' not in rfd_kwargs:\n rfd_kwargs['n_samples'] = 1000\n if 'ocut' not in rfd_kwargs:\n rfd_kwargs['ocut'] = (5, 5, 4, 4, 4)\n if 'evolve' not in rfd_kwargs:\n rfd_kwargs['evolve'] = (True, True, True, False, False)\n if 'full_final' not in rfd_kwargs:\n rfd_kwargs['full_final'] = True\n if 'n_iters' not in rfd_kwargs:\n rfd_kwargs['n_iters'] = len(rfd_kwargs['ocut'])\n elif proc_kw in ('long'):\n if 'n_samples' not in rfd_kwargs:\n rfd_kwargs['n_samples'] = None\n if 'ocut' not in rfd_kwargs:\n rfd_kwargs['ocut'] = (5, 5, 4, 4, 4)\n if 'full_final' not in rfd_kwargs:\n rfd_kwargs['full_final'] = False\n if 'n_iters' not in rfd_kwargs:\n rfd_kwargs['n_iters'] = len(rfd_kwargs['ocut'])\n else:\n raise ValueError(\"proc_kw not recognised: {}\".format(proc_kw))\n\n if 'n_iters' not in rfd_kwargs:\n rfd_kwargs['n_iters'] = 4\n\n return rfd_kwargs","def AssignEpiNames(self):\n# Sort each run in the series by its acquisition time.\n epi_sort = self.epi_times.keys()\n epi_sort.sort()\n# Rewrite pfiles as an ordered list of p-files to be reconstructed.\n for idx in xrange(len(epi_sort)):\n entry = self.epi_times[epi_sort[idx]]\n info = self.info[entry]\n if info['data_filetype'] == 'ge_data':\n self.pfiles_recon.append(entry)\n info['run'] = '%0d' % (self.n_epi)\n self.n_epi = self.n_epi + 1\n plane = info['plane']\n if not self.epinames.has_key(plane):\n plane = 'any'\n n_epi = self.epinames[plane]['n_epi']\n if n_epi > len(self.epinames[plane]['names'])-1:\n if self.epinames.has_key('any') and \\\n n_epi < len(self.epinames['any']):\n plane = 'any'\n n_epi = self.epinames[plane]['n_epi']\n else:\n self.DumpInfo()\n errstr = 'Not enough EPI names in template file'\n raise RuntimeError(errstr)\n# epiname = self.epinames[plane]['names'][n_epi]\n\n filebase = os.path.basename(self.epinames[plane]['names'][n_epi])\n epi_mf_outdir = os.path.dirname(\\\n self.epinames[plane]['names'][n_epi])\n\n epi_base = self.epinames[plane]['subdir'][n_epi]\n tmp_outdir = '%s/%s' % (self.tmpdir, epi_base)\n# Get output directory for raw epis.\n if self.no_motcorr:\n epi_r_outdir = epi_mf_outdir\n elif self.keep_epi_raw:\n epi_r_outdir = self.epi_scratch_space\n else:\n epi_r_outdir = tmp_outdir\n\n# Get output directory for motion-corrected epis.\n if self.keep_epi_mot:\n epi_m_outdir = self.epi_scratch_space\n else:\n epi_m_outdir = tmp_outdir\n info['outdir'] = epi_mf_outdir\n if n_epi < len(self.epinames[plane]['names']):\n epiname = self.epinames[plane]['names'][n_epi]\n info['imgfile'] = '%s/%s' % (epi_r_outdir, filebase)\n else:\n info['imgfile'] = '%s/s%0d_epi_run%0d' % \\\n (epi_r_outdir, n_epi, idx+1)\n self.epinames[plane]['n_epi'] += 1\n\n info['mot_file'] = '%s/%s_mtn.txt' % (epi_mf_outdir, filebase)\n info['censor_prefix'] = '%s/%s' % (epi_mf_outdir, filebase)\n info['imgfile_t'] = '%s/%s_t' % (epi_m_outdir, filebase)\n if self.no_motcorr:\n info['imgfile_m'] = None\n info['imgfile_mf'] = None\n info['imgfile_final'] = info['imgfile']\n else:\n info['imgfile_m'] = '%s/%s_m' % (epi_m_outdir, filebase)\n if self.no_fmapcorr or info['fmap_entry'] is None:\n info['imgfile_m'] = '%s/%s_m' % (epi_mf_outdir, filebase)\n info['imgfile_mf'] = None\n info['imgfile_final'] = info['imgfile_m']\n else:\n info['imgfile_m'] = '%s/%s_m' % (epi_m_outdir, filebase)\n info['imgfile_mf'] = '%s/%s_mf' % (epi_mf_outdir, filebase)\n info['imgfile_final'] = info['imgfile_mf']\n info['skip'] = self.skip\n info['motion_ref_frame'] = self.tmplt['motion_ref_frame']\n\n info['motion_interp'] = self.tmplt['epi_motion_interp']\n if not info['motion_interp'].startswith('-'):\n info['motion_interp'] = '-%s' % info['motion_interp']\n\n info['filetype'] = self.tmplt['epi_file_format']\n info['valid'] = True\n self.info[entry] = info\n\n if not self.no_motcorr:\n epi_base = os.path.basename(info['imgfile_m'])\n info['matfile_m'] = '%s/%s.aff12.1D' % (info['outdir'], epi_base)\n info['matfile_mcat'] = '%s/%scat.aff12.1D' % (info['outdir'], epi_base)","def runErdosRenyi(n,p):\n s = z.Optimize()\n g = ig.Graph.Erdos_Renyi(n, p, directed=True, loops=True)\n while g.is_dag():\n g = ig.Graph.Erdos_Renyi(n, p, directed=True, loops=True)\n\n return MFAS_set_cover(s,g), u.get_feedback_arc_set(g)","def choose_psfs(tgt_cubes,cal_cubes,save_dir):","def onKeyPress(self, event):\n if event.key=='?':\n #return the help file\n self.help()\n elif event.key=='q':\n #exit the task\n self.emit(QtCore.SIGNAL(\"quit()\"))\n elif event.key=='c':\n #return the centroid\n if event.xdata:\n self.log.message(str(event.xdata), with_header=False)\n cx=st.mcentroid(self.xarr, self.farr, xc=event.xdata, xdiff=self.mdiff)\n self.emit(QtCore.SIGNAL(\"updatex(float)\"), cx)\n elif event.key=='x':\n #return the x position\n if event.xdata:\n self.log.message(str(event.xdata), with_header=False)\n self.emit(QtCore.SIGNAL(\"updatex(float)\"), event.xdata)\n elif event.key=='R':\n #reset the fit \n self.reset()\n elif event.key=='f':\n #find the fit\n self.findfit()\n self.emit(QtCore.SIGNAL(\"fitUpdate()\"))\n elif event.key=='b':\n #auto-idenitfy features\n self.isFeature=True\n self.findfeatures()\n elif event.key=='z':\n #Assume the solution is correct and find the zeropoint\n #that best matches it from cross correllation\n self.findzp()\n elif event.key=='Z':\n #Assume the solution is correct and find the zeropoint\n #that best matches it from cross correllation\n self.findzpd()\n elif event.key=='e':\n #find closest feature from existing fit and line list\n #and match it\n pass\n elif event.key=='i':\n #reset identified features\n pass\n elif event.key=='t':\n #reset identified features\n self.isFeature=True\n self.testfeatures()\n elif event.key=='l':\n #plot the features from existing list\n if self.isFeature: \n self.isFeature=False\n self.redraw_canvas()\n else:\n self.isFeature=True\n self.plotFeatures()\n self.redraw_canvas()\n elif event.key=='p':\n #print information about features\n for i in range(len(self.xp)):\n print self.xp[i], self.wp[i]\n elif event.key=='P':\n #print information about features\n print self.ws.coef\n elif event.key=='r':\n #redraw graph\n self.redraw_canvas()\n elif event.key=='a':\n #draw artificial spectrum\n self.isArt= not self.isArt\n self.redraw_canvas()\n elif event.key=='d':\n #Delete feature \n save=False\n y=None\n if event.canvas==self.errfigure: \n y=event.ydata\n save=True\n self.deletepoints(event.xdata, y=y, save=save)\n self.redraw_canvas(keepzoom=True)\n elif event.key=='u':\n #undelete\n self.undeletepoints(event.xdata, y=event.ydata)\n self.redraw_canvas(keepzoom=True)\n elif event.key:\n self.emit(QtCore.SIGNAL(\"keyPressEvent(string)\"), event.key)","def main_ededge(dataset):\n Application.set_input_image_folder('TestData/BSR/BSDS500/data/images/' + dataset)\n\n # Application.delete_folder_appl_out()\n # Benchmarking.delete_folder_benchmark_out()\n\n Application.do_get_image_job(port_output_name='RAW')\n Application.do_grayscale_transform_job(port_input_name='RAW', port_output_name='GRAY_RAW')\n blur = Application.do_gaussian_blur_image_job(port_input_name='GRAY_RAW', sigma=0, kernel_size=9)\n\n list_to_eval_edge = []\n\n first_order_edge = [\n CONFIG.FILTERS.PIXEL_DIFF_3x3, CONFIG.FILTERS.PIXEL_DIFF_SEPARATED_3x3\n , CONFIG.FILTERS.PIXEL_DIFF_SEPARATED_5x5, CONFIG.FILTERS.PIXEL_DIFF_SEPARATED_7x7\n , CONFIG.FILTERS.PIXEL_DIFF_5x5, CONFIG.FILTERS.PIXEL_DIFF_7x7\n\n , CONFIG.FILTERS.SOBEL_3x3, CONFIG.FILTERS.SOBEL_5x5, CONFIG.FILTERS.SOBEL_7x7\n , CONFIG.FILTERS.SOBEL_DILATED_5x5, CONFIG.FILTERS.SOBEL_DILATED_7x7\n\n , CONFIG.FILTERS.PREWITT_3x3, CONFIG.FILTERS.PREWITT_5x5, CONFIG.FILTERS.PREWITT_7x7\n , CONFIG.FILTERS.PREWITT_DILATED_5x5, CONFIG.FILTERS.PREWITT_DILATED_7x7\n\n , CONFIG.FILTERS.KIRSCH_3x3, CONFIG.FILTERS.KIRSCH_5x5\n , CONFIG.FILTERS.KIRSCH_DILATED_5x5, CONFIG.FILTERS.KIRSCH_DILATED_7x7\n\n , CONFIG.FILTERS.KITCHEN_MALIN_3x3\n , CONFIG.FILTERS.KITCHEN_MALIN_DILATED_5x5, CONFIG.FILTERS.KITCHEN_MALIN_DILATED_7x7\n\n , CONFIG.FILTERS.KAYYALI_3x3\n , CONFIG.FILTERS.KAYYALI_DILATED_5x5, CONFIG.FILTERS.KAYYALI_DILATED_7x7\n\n , CONFIG.FILTERS.SCHARR_3x3, CONFIG.FILTERS.SCHARR_5x5\n , CONFIG.FILTERS.SCHARR_DILATED_5x5, CONFIG.FILTERS.SCHARR_DILATED_7x7\n\n , CONFIG.FILTERS.KROON_3x3\n , CONFIG.FILTERS.KROON_DILATED_5x5, CONFIG.FILTERS.KROON_DILATED_7x7\n\n , CONFIG.FILTERS.ORHEI_3x3, CONFIG.FILTERS.ORHEI_B_5x5\n , CONFIG.FILTERS.ORHEI_DILATED_5x5, CONFIG.FILTERS.ORHEI_DILATED_7x7\n ]\n\n for edge in first_order_edge:\n for gr_thr in [50]:\n for anc_thr in [10]:\n e1, e2, = Application.do_edge_drawing_mod_job(port_input_name=blur, operator=edge,\n gradient_thr=gr_thr, anchor_thr=anc_thr, scan_interval=1,\n max_edges=100, max_points_edge=100)\n list_to_eval_edge.append(e1 + '_L0')\n\n Application.create_config_file(verbose=False)\n Application.configure_save_pictures(job_name_in_port=False, ports_to_save='ALL')\n # Application.configure_show_pictures(ports_to_show=list_to_save, time_to_show=200)\n\n # Application.run_application()\n\n # Do bsds benchmarking\n # Be ware not to activate job_name_in_port in Application.configure_save_pictures\n # Benchmarking.run_bsds500_boundary_benchmark(input_location='Logs/application_results',\n # gt_location='TestData/BSR/BSDS500/data/groundTruth/' + dataset,\n # raw_image='TestData/BSR/BSDS500/data/images/' + dataset,\n # jobs_set=list_to_eval_edge, do_thinning=False)\n\n Utils.plot_first_cpm_results(prefix='EDGE_DRAWING_MOD_', level='L0', order_by='f1', name='ed_results',\n list_of_data=list_to_eval_edge, number_of_series=50,\n inputs=[''], self_contained_list=True, set_legend_left=False,\n suffix_to_cut_legend='_S_0_GRAY_RAW_L0',\n replace_list=[('EDGE_DRAWING_MOD_THR_50_ANC_THR_10_SCAN_1_', ''),\n ('SEPARATED_PIXEL_DIFFERENCE_', 'Separated Px Dif '),\n ('PIXEL_DIFFERENCE_', 'Pixel Dif '),\n ('PREWITT_', 'Prewitt '), ('KIRSCH_', 'Kirsch '), ('SOBEL_', 'Sobel '),\n ('SCHARR_', 'Scharr '), ('KROON_', 'Kroon '), ('ORHEI_V1_', 'Orhei '),\n ('ORHEI_', 'Orhei '),\n ('KITCHEN_', 'Kitchen '), ('KAYYALI_', 'Kayyali '),\n ('DILATED_', 'dilated '),\n ('_GAUSS_BLUR_K_9', '')],\n save_plot=True, show_plot=False, set_all_to_legend=False)\n\n # Utils.create_latex_cpm_table_list()\n\n Utils.close_files()","def eta_ ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n from StandardParticles import StdLooseEta2gg as inpts \n ##\n return self.make_selection (\n 'EtaStd' ,\n FilterDesktop ,\n [ inpts ] ,\n Code = self['Eta2ggCut'] ,\n )","def start_kernel(self, kernel_name=None, **kwargs):","def run_pick_de_novo_otus(input_fp,\r\n output_dir,\r\n command_handler,\r\n params,\r\n qiime_config,\r\n parallel=False,\r\n logger=None,\r\n suppress_md5=False,\r\n status_update_callback=print_to_stdout):\r\n\r\n # Prepare some variables for the later steps\r\n input_dir, input_filename = split(input_fp)\r\n input_basename, input_ext = splitext(input_filename)\r\n create_dir(output_dir)\r\n commands = []\r\n cluster_failures = False\r\n if logger is None:\r\n logger = WorkflowLogger(generate_log_fp(output_dir),\r\n params=params,\r\n qiime_config=qiime_config)\r\n close_logger_on_success = True\r\n else:\r\n close_logger_on_success = False\r\n\r\n if not suppress_md5:\r\n log_input_md5s(logger, [input_fp])\r\n\r\n # Prep the OTU picking command\r\n try:\r\n otu_picking_method = params['pick_otus']['otu_picking_method']\r\n except KeyError:\r\n otu_picking_method = 'uclust'\r\n pick_otu_dir = '%s/%s_picked_otus' % (output_dir, otu_picking_method)\r\n otu_fp = '%s/%s_otus.txt' % (pick_otu_dir, input_basename)\r\n if parallel and (otu_picking_method == 'blast' or\r\n otu_picking_method == 'uclust_ref'):\r\n # Grab the parallel-specific parameters\r\n try:\r\n params_str = get_params_str(params['parallel'])\r\n except KeyError:\r\n params_str = ''\r\n\r\n # Grab the OTU picker parameters\r\n try:\r\n # Want to find a cleaner strategy for this: the parallel script\r\n # is method-specific, so doesn't take a --otu_picking_method\r\n # option. This works for now though.\r\n d = params['pick_otus'].copy()\r\n del d['otu_picking_method']\r\n except KeyError:\r\n pass\r\n\r\n if otu_picking_method == 'uclust_ref':\r\n try:\r\n suppress_new_clusters = d['suppress_new_clusters']\r\n del d['suppress_new_clusters']\r\n cluster_failures = False\r\n except KeyError:\r\n cluster_failures = True\r\n failure_otu_picking_method = 'uclust'\r\n\r\n params_str += ' %s' % get_params_str(d)\r\n otu_picking_script = 'parallel_pick_otus_%s.py' % otu_picking_method\r\n # Build the OTU picking command\r\n pick_otus_cmd = '%s -i %s -o %s -T %s' % (otu_picking_script,\r\n input_fp,\r\n pick_otu_dir,\r\n params_str)\r\n else:\r\n try:\r\n params_str = get_params_str(params['pick_otus'])\r\n except KeyError:\r\n params_str = ''\r\n # Build the OTU picking command\r\n pick_otus_cmd = 'pick_otus.py -i %s -o %s %s' %\\\r\n (input_fp, pick_otu_dir, params_str)\r\n\r\n commands.append([('Pick OTUs', pick_otus_cmd)])\r\n\r\n if cluster_failures:\r\n reference_otu_fp = otu_fp\r\n clustered_failures_dir = '%s/failure_otus/' % pick_otu_dir\r\n\r\n try:\r\n d = params['pick_otus'].copy()\r\n del d['otu_picking_method']\r\n except KeyError:\r\n pass\r\n\r\n if 'uclust_otu_id_prefix' not in d:\r\n d['uclust_otu_id_prefix'] = 'DeNovoOTU'\r\n params_str = ' %s' % get_params_str(d)\r\n\r\n failures_list_fp = '%s/%s_failures.txt' % \\\r\n (pick_otu_dir, input_basename)\r\n failures_fasta_fp = '%s/%s_failures.fasta' % \\\r\n (pick_otu_dir, input_basename)\r\n\r\n filter_fasta_cmd = 'filter_fasta.py -f %s -s %s -o %s' %\\\r\n (input_fp, failures_list_fp, failures_fasta_fp)\r\n\r\n commands.append([('Generate failures fasta file',\r\n filter_fasta_cmd)])\r\n\r\n # Prep the OTU picking command for\r\n failure_otu_fp = '%s/%s_failures_otus.txt' % (clustered_failures_dir,\r\n input_basename)\r\n # Build the OTU picking command\r\n pick_otus_cmd = 'pick_otus.py -i %s -o %s -m %s %s' %\\\r\n (failures_fasta_fp, clustered_failures_dir,\r\n failure_otu_picking_method, params_str)\r\n\r\n commands.append(\r\n [('Pick de novo OTUs for new clusters', pick_otus_cmd)])\r\n\r\n merged_otu_map_fp = '%s/merged_otu_map.txt' % clustered_failures_dir\r\n cat_otu_tables_cmd = 'cat %s %s >> %s' %\\\r\n (reference_otu_fp, failure_otu_fp, merged_otu_map_fp)\r\n commands.append([('Merge OTU maps', cat_otu_tables_cmd)])\r\n otu_fp = merged_otu_map_fp\r\n\r\n # Prep the representative set picking command\r\n rep_set_dir = '%s/rep_set/' % output_dir\r\n create_dir(rep_set_dir)\r\n rep_set_fp = '%s/%s_rep_set.fasta' % (rep_set_dir, input_basename)\r\n rep_set_log_fp = '%s/%s_rep_set.log' % (rep_set_dir, input_basename)\r\n\r\n try:\r\n params_str = get_params_str(params['pick_rep_set'])\r\n except KeyError:\r\n params_str = ''\r\n # Build the representative set picking command\r\n pick_rep_set_cmd = 'pick_rep_set.py -i %s -f %s -l %s -o %s %s' %\\\r\n (otu_fp, input_fp, rep_set_log_fp, rep_set_fp, params_str)\r\n commands.append([('Pick representative set', pick_rep_set_cmd)])\r\n\r\n # Prep the taxonomy assignment command\r\n try:\r\n assignment_method = params['assign_taxonomy']['assignment_method']\r\n except KeyError:\r\n assignment_method = 'uclust'\r\n assign_taxonomy_dir = '%s/%s_assigned_taxonomy' %\\\r\n (output_dir, assignment_method)\r\n taxonomy_fp = '%s/%s_rep_set_tax_assignments.txt' % \\\r\n (assign_taxonomy_dir, input_basename)\r\n if parallel and (assignment_method == 'rdp' or\r\n assignment_method == 'blast' or\r\n assignment_method == 'uclust'):\r\n # Grab the parallel-specific parameters\r\n try:\r\n params_str = get_params_str(params['parallel'])\r\n except KeyError:\r\n params_str = ''\r\n\r\n # Grab the taxonomy assignment parameters\r\n try:\r\n # Want to find a cleaner strategy for this: the parallel script\r\n # is method-specific, so doesn't take a --assignment_method\r\n # option. This works for now though.\r\n d = params['assign_taxonomy'].copy()\r\n if 'assignment_method' in d:\r\n del d['assignment_method']\r\n params_str += ' %s' % get_params_str(d)\r\n except KeyError:\r\n pass\r\n\r\n # Build the parallel taxonomy assignment command\r\n assign_taxonomy_cmd = \\\r\n 'parallel_assign_taxonomy_%s.py -i %s -o %s -T %s' %\\\r\n (assignment_method, rep_set_fp, assign_taxonomy_dir, params_str)\r\n else:\r\n try:\r\n params_str = get_params_str(params['assign_taxonomy'])\r\n except KeyError:\r\n params_str = ''\r\n # Build the taxonomy assignment command\r\n assign_taxonomy_cmd = 'assign_taxonomy.py -o %s -i %s %s' %\\\r\n (assign_taxonomy_dir, rep_set_fp, params_str)\r\n\r\n commands.append([('Assign taxonomy', assign_taxonomy_cmd)])\r\n\r\n # Prep the OTU table building command\r\n otu_table_fp = '%s/otu_table.biom' % output_dir\r\n try:\r\n params_str = get_params_str(params['make_otu_table'])\r\n except KeyError:\r\n params_str = ''\r\n # Build the OTU table building command\r\n make_otu_table_cmd = 'make_otu_table.py -i %s -t %s -o %s %s' %\\\r\n (otu_fp, taxonomy_fp, otu_table_fp, params_str)\r\n\r\n commands.append([('Make OTU table', make_otu_table_cmd)])\r\n\r\n if cluster_failures:\r\n reference_otu_table_fp = '%s/reference_only_otu_table.biom' % output_dir\r\n # Build the OTU table building command\r\n make_otu_table_cmd = 'make_otu_table.py -i %s -t %s -o %s %s' %\\\r\n (reference_otu_fp, taxonomy_fp, reference_otu_table_fp, params_str)\r\n\r\n commands.append(\r\n [('Make reference-only OTU table', make_otu_table_cmd)])\r\n\r\n # Prep the pynast alignment command\r\n try:\r\n alignment_method = params['align_seqs']['alignment_method']\r\n except KeyError:\r\n alignment_method = 'pynast'\r\n pynast_dir = '%s/%s_aligned_seqs' % (output_dir, alignment_method)\r\n aln_fp = '%s/%s_rep_set_aligned.fasta' % (pynast_dir, input_basename)\r\n if parallel and alignment_method == 'pynast':\r\n # Grab the parallel-specific parameters\r\n try:\r\n params_str = get_params_str(params['parallel'])\r\n except KeyError:\r\n params_str = ''\r\n\r\n # Grab the alignment parameters\r\n # Want to find a cleaner strategy for this: the parallel script\r\n # is method-specific, so doesn't take a --alignment_method\r\n # option. This works for now though.\r\n try:\r\n d = params['align_seqs'].copy()\r\n except KeyError:\r\n d = {}\r\n try:\r\n del d['alignment_method']\r\n except KeyError:\r\n pass\r\n params_str += ' %s' % get_params_str(d)\r\n\r\n # Build the parallel pynast alignment command\r\n align_seqs_cmd = 'parallel_align_seqs_pynast.py -i %s -o %s -T %s' %\\\r\n (rep_set_fp, pynast_dir, params_str)\r\n else:\r\n try:\r\n params_str = get_params_str(params['align_seqs'])\r\n except KeyError:\r\n params_str = ''\r\n # Build the pynast alignment command\r\n align_seqs_cmd = 'align_seqs.py -i %s -o %s %s' %\\\r\n (rep_set_fp, pynast_dir, params_str)\r\n commands.append([('Align sequences', align_seqs_cmd)])\r\n\r\n # Prep the alignment filtering command\r\n filtered_aln_fp = '%s/%s_rep_set_aligned_pfiltered.fasta' %\\\r\n (pynast_dir, input_basename)\r\n try:\r\n params_str = get_params_str(params['filter_alignment'])\r\n except KeyError:\r\n params_str = ''\r\n # Build the alignment filtering command\r\n filter_alignment_cmd = 'filter_alignment.py -o %s -i %s %s' %\\\r\n (pynast_dir, aln_fp, params_str)\r\n commands.append([('Filter alignment', filter_alignment_cmd)])\r\n\r\n # Prep the tree building command\r\n tree_fp = '%s/rep_set.tre' % output_dir\r\n try:\r\n params_str = get_params_str(params['make_phylogeny'])\r\n except KeyError:\r\n params_str = ''\r\n # Build the tree building command\r\n make_phylogeny_cmd = 'make_phylogeny.py -i %s -o %s %s' %\\\r\n (filtered_aln_fp, tree_fp, params_str)\r\n commands.append([('Build phylogenetic tree', make_phylogeny_cmd)])\r\n\r\n # Call the command handler on the list of commands\r\n command_handler(commands,\r\n status_update_callback,\r\n logger=logger,\r\n close_logger_on_success=close_logger_on_success)\r\n\r\n return abspath(tree_fp), abspath(otu_table_fp)","def __init__(self, epics_only=False, *args, **kwargs):\n self._kwargs = {}\n self._detectors = {}\n self._det_list = [] \n self._det_aliases = {}\n self._psplots = {}\n self._event_functions = {}\n self._source_attrs = []\n self._evt_time_last = (0,0)\n self.ievent = 0\n self._reloadOnLoadRun = False\n self._reloadOnNextEvent = False\n self.psana_cfg_dict = {}\n self._default_module_path = ''\n\n# self._user_attrs = {}\n# self._histograms = {}\n \n for key in kwargs:\n self._kwargs[key] = kwargs[key] \n if key in self._exp_defaults:\n setattr(self,key,kwargs[key])\n print 'setting ',key, kwargs[key]\n\n self._device_config = read_device_config(**kwargs)\n self._device_sets = self._device_config['device_sets'] \n self._device_types = self._device_config['device_types'] \n\n for det in self._device_sets:\n if 'det' in self._device_sets[det]:\n if ('detName' in self._device_sets[det]['det'] or\n 'typeName' in self._device_sets[det]['det']):\n self._det_list.append(det)\n if 'det_key' in self._device_sets[det]['det']:\n det_key = self._device_sets[det]['det']['det_key']\n self._det_aliases[det_key] = det \n else:\n pass\n \n# if 'pvs' in self._device_sets[det]:\n# for attr in self._device_sets[det]['pvs']:\n# pvbase = self._device_sets[det]['pvs'][attr]['base']\n# alias = '_'.join([det,attr])\n# self.add_pv(pvbase, alias)\n\n self.set_exp_defaults(**kwargs)\n if not self._kwargs.get('noload'):\n self.data_source = self.get_data_source(**kwargs)\n print 'Data Source = ', self.data_source\n else:\n self.data_source = None\n\n if not self.data_source:\n self._kwargs['noload'] = True\n else:\n kwargs['run'] = self.run\n\n# if self._kwargs.get('noload') or self.live:\n# if self._kwargs.get('epics_live'):\n# self.set_kwargs(ami=True)\n \n if self._kwargs.get('ami'):\n print 'loading ami'\n self.load_ami(**kwargs)\n\n if not self._kwargs.get('noload'):\n print 'loading run'\n self.load_run(*args, **kwargs)\n self._no_epicsStore = False\n \n print 'Instrument = ', self.instrument\n\n if self._kwargs.get('epics_live'): # and self._kwargs.get('epics_file'):\n print 'loading epics'\n self.load_epicsLive(**kwargs)\n\n if self.ds and self.live:\n self.next_event()\n \n if self.ds and self._reloadOnNextEvent:\n self.next_event()\n \n if not self.ds:\n self._no_epicsStore = True\n self._no_evtData = True\n for det in self._device_sets:\n if 'pvs' in self._device_sets[det]:\n print 'Adding epics ',det\n self.add_detector(det)","def handleEvent(eventname, *kwargs):\n stime = time.time()\n hdl = [hdl for hdl in classes.get('eventhandler').getEventhandlers(event=eventname) if hdl.handler == 'emonitor.modules.scripts.script.Script']\n\n scriptname = \"\"\n if len(hdl) == 1:\n if \"in.scriptname\" in hdl[0].getParameterList('in'):\n scriptname = hdl[0].getParameterValue(\"in.scriptname\")\n\n for m in classes.get('monitor').getMonitors():\n for l in m.getLayouts():\n if l.trigger == eventname: # find client id for defined event\n if 'mode' in kwargs[0].keys() and kwargs[0]['mode'] != 'test':\n monitorserver.sendMessage(str(m.id), 'execute|%s' % scriptname) # execute script on client\n\n if 'time' not in kwargs[0]:\n kwargs[0]['time'] = []\n kwargs[0]['time'].append('scripts: script \"%s\" done in %s sec.' % (scriptname, time.time() - stime))\n return kwargs","def pick(episodes, debug=False):\n\n if debug:\n print(\"begin pick()\")\n\n # pick episodes\n # if factored\n if len(episodes[\"weights\"]) != 0:\n e = choices(episodes[\"episodes\"],\n weights = episodes[\"weights\"])[0]\n # otherwise\n else:\n e = choices(episodes[\"episodes\"])[0]\n\n # gather the data\n episode = create_episode(e)\n\n return episode","def fselect(x, y, name, **kwargs):\n if isinstance(x, pd.DataFrame):\n x = x.values\n if isinstance(y, pd.Series):\n y = y.values\n if kwargs.get('verbose', False):\n print(datetime.datetime.now(), 'feature selection with', name)\n return globals()[name](x=x, y=y, **kwargs)","def make_odorant_selector(name):\n return dcc.Input(\n id=\"cid_%s\" % name,\n placeholder=\"Enter a PubChem ID number...\",\n type=\"number\",\n value=None,\n )","def plot_denoising(fname_raw, fmin=0, fmax=300, tmin=0.0, tmax=60.0,\n proj=False, n_fft=4096, color='blue',\n stim_name=None, event_id=1,\n tmin_stim=-0.2, tmax_stim=0.5,\n area_mode='range', area_alpha=0.33, n_jobs=1,\n title1='before denoising', title2='after denoising',\n info=None, show=True, fnout=None):\n\n from matplotlib import gridspec as grd\n import matplotlib.pyplot as plt\n from mne.time_frequency import psd_welch\n\n fnraw = get_files_from_list(fname_raw)\n\n # ---------------------------------\n # estimate power spectrum\n # ---------------------------------\n psds_all = []\n freqs_all = []\n\n # loop across all filenames\n for fname in fnraw:\n\n # read in data\n raw = mne.io.Raw(fname, preload=True)\n picks = mne.pick_types(raw.info, meg='mag', eeg=False,\n stim=False, eog=False, exclude='bads')\n\n if area_mode not in [None, 'std', 'range']:\n raise ValueError('\"area_mode\" must be \"std\", \"range\", or None')\n\n psds, freqs = psd_welch(raw, picks=picks, fmin=fmin, fmax=fmax,\n tmin=tmin, tmax=tmax, n_fft=n_fft,\n n_jobs=n_jobs, proj=proj)\n psds_all.append(psds)\n freqs_all.append(freqs)\n\n if stim_name:\n n_xplots = 2\n\n # get some infos\n events = mne.find_events(raw, stim_channel=stim_name, consecutive=True)\n\n else:\n n_xplots = 1\n\n fig = plt.figure('denoising', figsize=(16, 6 * n_xplots))\n gs = grd.GridSpec(n_xplots, int(len(psds_all)))\n\n # loop across all filenames\n for idx in range(int(len(psds_all))):\n\n # ---------------------------------\n # plot power spectrum\n # ---------------------------------\n p1 = plt.subplot(gs[0, idx])\n\n # Convert PSDs to dB\n psds = 10 * np.log10(psds_all[idx])\n psd_mean = np.mean(psds, axis=0)\n if area_mode == 'std':\n psd_std = np.std(psds, axis=0)\n hyp_limits = (psd_mean - psd_std, psd_mean + psd_std)\n elif area_mode == 'range':\n hyp_limits = (np.min(psds, axis=0), np.max(psds, axis=0))\n else: # area_mode is None\n hyp_limits = None\n\n p1.plot(freqs_all[idx], psd_mean, color=color)\n if hyp_limits is not None:\n p1.fill_between(freqs_all[idx], hyp_limits[0], y2=hyp_limits[1],\n color=color, alpha=area_alpha)\n\n if idx == 0:\n p1.set_title(title1)\n ylim = [np.min(psd_mean) - 10, np.max(psd_mean) + 10]\n else:\n p1.set_title(title2)\n\n p1.set_xlabel('Freq (Hz)')\n p1.set_ylabel('Power Spectral Density (dB/Hz)')\n p1.set_xlim(freqs_all[idx][0], freqs_all[idx][-1])\n p1.set_ylim(ylim[0], ylim[1])\n\n # ---------------------------------\n # plot signal around stimulus\n # onset\n # ---------------------------------\n if stim_name:\n raw = mne.io.Raw(fnraw[idx], preload=True)\n epochs = mne.Epochs(raw, events, event_id, proj=False,\n tmin=tmin_stim, tmax=tmax_stim, picks=picks,\n preload=True, baseline=(None, None))\n evoked = epochs.average()\n if idx == 0:\n ymin = np.min(evoked.data)\n ymax = np.max(evoked.data)\n\n times = evoked.times * 1e3\n p2 = plt.subplot(gs[1, idx])\n p2.plot(times, evoked.data.T, 'blue', linewidth=0.5)\n p2.set_xlim(times[0], times[len(times) - 1])\n p2.set_ylim(1.1 * ymin, 1.1 * ymax)\n\n if (idx == 1) and info:\n plt.text(times[0], 0.9 * ymax, ' ICs: ' + str(info))\n\n # save image\n if fnout:\n fig.savefig(fnout + '.png', format='png')\n\n # show image if requested\n if show:\n plt.show()\n\n plt.close('denoising')\n plt.ion()","def trigger_encoding_sending(obj_name, input_event, port='/dev/parport0'):\n\n task = {'Calibration': 10, 'QA': 40, 'Artifact': 70}\n digit_task = task[obj_name]\n trigger_table = np.array([[None, None],\n [None, None],\n [4, 5],\n [6, None],\n [8, 9],\n [None, 7],\n [62, 63]])\n\n if isinstance(input_event, numbers.Number):\n digit_event = str(input_event)\n data = digit_task + input_event\n trigger_sending(data, port=port)\n else:\n for ind in np.where(input_event[:, 0] == 1)[0]:\n digit_event = input_event[ind, 1]\n if ind == trigger_table.shape[0] - 1:\n data = trigger_table[ind, int(digit_event)]\n else:\n try:\n data = digit_task + trigger_table[ind, int(digit_event)]\n except:\n data = None\n\n trigger_sending(data, port=port)","def run(self, code, file_name):\n new_code = self._ieee_library_pattern.sub(r'\\1new_ieee, ieee\\2', code)\n\n matches = list(self._ieee_use_pattern.finditer(new_code))\n matches.sort(key=lambda match: match.start('package'), reverse=True)\n for match in matches:\n if match.group('package').lower() != 'std_logic_1164':\n new_code = new_code[:match.start('library')] + 'new_ieee' + new_code[match.end('library'):]\n\n return new_code","def _atom_selection(topology, residue_selection, selection, verbose):\n ## First have to load all the inputs if they are defined by a path\n if isinstance(topology, str):\n if os.path.exists(topology):\n try:\n md_topology = md.load_topology(topology)\n except:\n sys.exit('Make sure you have provided a valid path to topology file!')\n else:\n if verbose > 0:\n print 'The following topology file was succesfully loaded: \\n %s \\n' %(md_topology)\n\n elif isinstance(topology, md.core.topology.Topology):\n md_topology = topology\n if verbose > 0:\n print 'The following topology file was succesfully loaded: \\n %s \\n' %(md_topology)\n else:\n sys.exit('Invalid input! Must be a valid path to topology file or mdtraj.Topology object')\n \n ## if selection is True the function will try to obtain the specified atoms/residues\n ## if residue name is specified it will by default look for C-alpha atoms\n if selection:\n if isinstance(residue_selection, list):\n try:\n atom_subset = md_topology.select(residue_selection)\n except:\n sys.exit('Invalid atom selection in list!')\n else:\n if verbose > 1:\n print 'Your selection includes the following atom(s): \\n %s \\n' %(atom_subset)\n print 'Your selection includes the following residues: \\n'\n for residue in md_topology.subset(atom_subset).residues:\n print residue\n elif isinstance(residue_selection, str):\n try:\n atom_subset = md_topology.select('name CA and ' + residue_selection)\n except:\n sys.exit('Check if your atom selection command is recognized by the Mdtraj atom selection language!')\n else:\n if verbose > 1:\n print 'Your selection includes the following atom(s): \\n %s \\n' %(atom_subset)\n print 'Your selection includes the following residues: \\n'\n for residue in md_topology.subset(atom_subset).residues:\n print residue\n else:\n sys.exit('Make sure you provided a valid residue selection!')\n else:\n atom_subset=md_topology.select('name CA and ' + 'all')\n \n # now that we are sure that both topology and selection are valid we can return atom_subset\n # and use the loaded topology file\n \n \n return atom_subset, md_topology","def run(self, snr: float = 4, window_size: float = 2, f_min: float = None, f_max: float = None,\n skip_similar: bool = False, similar_chancel=True, extend_frequencies: int = 0, improve_fit=True,\n mode='lmfit',frequency_detection=None,fit_fun : Union[Tuple[callable,callable],callable] = None):\n\n if fit_fun is not None and not (callable(fit_fun) or (isinstance(fit_fun,tuple) and len(fit_fun)==2)):\n raise AttributeError(\"fit_fun must be either a function, or a tuple of two functions\")\n\n self.snr = snr\n self.window_size = window_size\n self.f_min = f_min\n self.f_max = f_max\n self.skip_similar = skip_similar\n self.similar_chanel = similar_chancel\n self.extend_frequencies = 0\n\n self._ff = FFinder(self, f_min, f_max)\n self._result = self._ff.run(snr=snr, window_size=window_size, skip_similar=skip_similar,\n similar_chancel=similar_chancel\n , extend_frequencies=extend_frequencies, improve_fit=improve_fit, mode=mode\n ,frequency_detection=frequency_detection,fit_fun=fit_fun)\n self._combinations = get_combinations((self._result[self._result.significant == True].index+1).tolist(),\n unp.nominal_values(\n self._result[self._result.significant == True].frequency.tolist())\n , unp.nominal_values(\n self._result[self._result.significant == True].amp.tolist()))\n\n self.res_lc = self._ff.res_lc\n\n mprint(f\"{self.label} Analysis done!\",info)","def main():\n # files\n summary_file = sys.argv[1]\n pwms_to_tfs_file = sys.argv[2]\n expressed_tfs_file = sys.argv[3] # TODO\n\n # TODO pull in num regions to resize things? but complicated with overlaps etc\n # TODO edit edges with type of interaction\n # TODO may want to color by trajectory, to demonstrate waves of trajectory\n \n # read in data\n summary = pd.read_csv(summary_file, sep=\"\\t\")\n pwms_to_tfs = pd.read_csv(pwms_to_tfs_file, sep=\"\\t\")\n pwms_to_tfs = pwms_to_tfs[pwms_to_tfs[\"expressed\"].notna()]\n pwms_to_filt_tfs = {} # dict: key - pwm names, vals - dict of ensembl ids to hgnc ids\n for line_idx in range(pwms_to_tfs.shape[0]):\n pwm_info = pwms_to_tfs.iloc[line_idx,:]\n pwm_name = pwm_info[\"hclust_model_name\"]\n pwm_to_tf = dict(zip(pwm_info[\"expressed\"].split(\";\"), pwm_info[\"expressed_hgnc\"].split(\";\")))\n pwms_to_filt_tfs[pwm_name] = pwm_to_tf\n\n \n # filter expressed hgncs for dynamic ones only\n tfs_filt = pd.read_csv(expressed_tfs_file, sep=\"\\t\", index_col=0)\n for pwm_name in pwms_to_filt_tfs.keys():\n tfs_tmp = pwms_to_filt_tfs[pwm_name]\n for ensembl_tf in tfs_tmp.keys():\n if ensembl_tf not in tfs_filt.index:\n del tfs_tmp[ensembl_tf]\n if len(tfs_tmp.keys()) == 0:\n del pwms_to_filt_tfs[pwm_name]\n pwms_to_filt_tfs[pwm_name] = tfs_tmp\n\n # add in tfs column\n tf1 = []\n for pwm in summary[\"pwm1\"]:\n tf_str = []\n for ensembl_id in pwms_to_filt_tfs[pwm]:\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\n # TODO try add in max point\n expression = tfs_filt.loc[ensembl_id,:]\n max_idx = np.argmax(expression.values)\n tf_str.append(str(max_idx))\n tf_str = (\";\").join(tf_str)\n tf1.append(tf_str)\n summary[\"tf1\"] = tf1\n\n tf2 = []\n for pwm in summary[\"pwm2\"]:\n tf_str = []\n for ensembl_id in pwms_to_filt_tfs[pwm]:\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\n expression = tfs_filt.loc[ensembl_id,:]\n max_idx = np.argmax(expression.values)\n tf_str.append(str(max_idx))\n tf_str = (\";\").join(tf_str)\n tf2.append(tf_str)\n summary[\"tf2\"] = tf2\n \n # remove failed rules\n summary = summary[~summary[\"interaction\"].str.contains(\"FAILED\")]\n \n # make graph\n graph = nx.from_pandas_edgelist(summary, \"tf1\", \"tf2\")\n\n # set up positions\n #pos = graphviz_layout(graph, prog=\"dot\")\n pos = graphviz_layout(graph, prog=\"neato\")\n scale_factor = 3\n for key in pos.keys():\n coords = pos[key]\n pos[key] = {\"x\": scale_factor*coords[0], \"y\": -scale_factor*coords[1]}\n nx.set_node_attributes(graph, pos, \"graphics\") # note this is diff from v1 to v2 in networkx\n \n # add graphics\n add_graphics_theme_to_nx_graph(graph)\n\n # write gml\n out_file = \"summary.gml\"\n nx.write_gml(stringize_nx_graph(graph), out_file, stringizer=str)\n\n # tfs: for each tf, get gene column\n \n \n return","def selection_correction_method1_v2(tree, scale, h_in, h_out):\n #h_in = ROOT.TH1D(\"h_in\", \"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\", 50, 0, 25)\n #h_out = ROOT.TH1D(\"h_out\", \"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\", 50, 0, 25)\n for event in tree:\n cut = [0, 0]\n S15_ch = i_channel(0, event)\n bpm_ch = i_channel(4, event)\n RT = event.DD_Rise[S15_ch]\n S15_w2 = event.DD_AmplADU[S15_ch]\n onset = event.DD_Rise10pct[S15_ch]\n if cut[0]==0:\n # first cut: for inside onset window\n # if event passes the first cuts\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n # calculation of the time of flight\n tof = (cfd_pmt-cfd_bpm)%400\n #cut on tof: time of flight of the neutron\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n # fill histogram inside onset window\n h_in.Fill(energy2)\n cut[0]=1\n break\n if cut[1]==0:\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n tof = (cfd_pmt-cfd_bpm)%400\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n h_out.Fill(energy2)\n cut[1]=1\n break","def selection_correction_method1(tree, scale, h_in, h_out):\n #h_in = ROOT.TH1D(\"h_in\", \"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\", 50, 0, 25)\n #h_out = ROOT.TH1D(\"h_out\", \"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\", 50, 0, 25)\n for event in tree:\n cut = [0, 0]\n S15_ch = i_channel(0, event)\n bpm_ch = i_channel(4, event)\n RT = event.DD_Rise[S15_ch]\n S15_w2 = event.DD_AmplADU[S15_ch]\n onset = event.DD_Rise10pct[S15_ch]\n if cut[0]==0:\n # first cut: for inside onset window\n # if event passes the first cuts\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n # calculation of the time of flight\n tof = (cfd_pmt-cfd_bpm)%400\n #cut on tof: time of flight of the neutron\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n # fill histogram inside onset window\n h_in.Fill(energy2)\n cut[0]=1\n break\n if cut[1]==0:\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n tof = (cfd_pmt-cfd_bpm)%400\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n h_out.Fill(energy2)\n cut[1]=1\n break\n return h_in, h_out","def test_apply_elf_conformer_selection(self, toolkit_wrapper, use_registry):\n\n if toolkit_wrapper == OpenEyeToolkitWrapper:\n pytest.importorskip(\"openeye\")\n elif toolkit_wrapper == RDKitToolkitWrapper:\n pytest.importorskip(\"rdkit\")\n\n if use_registry:\n toolkit = toolkit_wrapper()\n else:\n toolkit = ToolkitRegistry(toolkit_precedence=[toolkit_wrapper])\n\n molecule = Molecule.from_file(\n get_data_file_path(os.path.join(\"molecules\", \"z_3_hydroxy_propenal.sdf\")),\n \"SDF\",\n )\n\n initial_conformers = [\n # Add a conformer with an internal H-bond.\n unit.Quantity(\n np.array(\n [\n [0.5477, 0.3297, -0.0621],\n [-0.1168, -0.7881, 0.2329],\n [-1.4803, -0.8771, 0.1667],\n [-0.2158, 1.5206, -0.4772],\n [-1.4382, 1.5111, -0.5580],\n [1.6274, 0.3962, -0.0089],\n [0.3388, -1.7170, 0.5467],\n [-1.8612, -0.0347, -0.1160],\n [0.3747, 2.4222, -0.7115],\n ]\n ),\n unit.angstrom,\n ),\n # Add a conformer without an internal H-bond.\n unit.Quantity(\n np.array(\n [\n [0.5477, 0.3297, -0.0621],\n [-0.1168, -0.7881, 0.2329],\n [-1.4803, -0.8771, 0.1667],\n [-0.2158, 1.5206, -0.4772],\n [0.3353, 2.5772, -0.7614],\n [1.6274, 0.3962, -0.0089],\n [0.3388, -1.7170, 0.5467],\n [-1.7743, -1.7634, 0.4166],\n [-1.3122, 1.4082, -0.5180],\n ]\n ),\n unit.angstrom,\n ),\n ]\n\n molecule._conformers = [*initial_conformers]\n\n # Apply ELF10\n molecule.apply_elf_conformer_selection(toolkit_registry=toolkit)\n elf10_conformers = molecule.conformers\n\n assert len(elf10_conformers) == 1\n\n assert np.allclose(\n elf10_conformers[0].m_as(unit.angstrom),\n initial_conformers[1].m_as(unit.angstrom),\n )","def compute_prf_on_selection(arts, forms_set):\n tp=0\n fn=0\n fp=0\n for article in arts:\n for entity in article.entity_mentions:\n if entity.mention in forms_set:\n if entity.gold_link==entity.sys_link:\n tp+=1\n else:\n if entity.sys_link!='--NME--':\n fp+=1\n if entity.gold_link!='--NME--':\n fn+=1\n print(tp, fp, fn)\n p=tp/(tp+fp)\n r=tp/(tp+fn)\n f1=2*p*r/(p+r)\n print(p,r,f1)\n return f1","def main(dicom_dir, prostate_mask, debug):\n import arterys\n\n ## Custom I/O setup\n dicom_dir = Path(dicom_dir)\n prostate_mask = Path(prostate_mask)\n\n volumes_dir = dicom_dir.parent if debug else VOLUMES_DIR\n volumes_dir.mkdir(exist_ok=True)\n\n input_volume_stem = dicom_dir.name\n input_volume_name = input_volume_stem + '.nrrd'\n input_volume_path = volumes_dir / input_volume_name\n\n output_volume_name = input_volume_stem + '_needle_seg.nrrd'\n output_volume_path = volumes_dir / output_volume_name\n\n ## DICOM to volumes\n # Prostate MRI\n arterys.dicomvert(dicom_dir, input_volume_path)\n\n # Prostate mask\n if prostate_mask.is_dir():\n dicom_mask_dir = prostate_mask\n input_volume_mask_stem = 'input_seg'\n input_volume_mask_name = input_volume_mask_stem + '.nrrd'\n input_volume_mask_path = volumes_dir / input_volume_mask_name\n arterys.dicomvert(dicom_mask_dir, input_volume_mask_path)\n elif prostate_mask.suffix == '.nrrd':\n input_volume_mask_path = prostate_mask\n\n ## Run inference\n cmdline = (\n 'python3', '/deepinfer/fit.py',\n '--ModelName', 'prostate-needle-finder',\n '--InputVolume', input_volume_path,\n '--InputProstateMask', input_volume_mask_path,\n '--OutputLabel', output_volume_path,\n '--OutputFiducialList', '/tmp.fcsv',\n '--InferenceType', 'Ensemble',\n '--verbose',\n )\n cmdline = [str(arg) for arg in cmdline]\n arterys.utils.print_command(cmdline)\n call(cmdline)\n\n # Volumes to Arterys format\n output_dir = dicom_dir.parent / OUTPUT_DIR.name if debug else OUTPUT_DIR\n output_dir.mkdir(exist_ok=True)\n arterys.process_output(output_volume_path, output_dir)\n\n return 0","def glob_cmd(model, globular_name, features, filters, figname, mag=0,\n color={2:(-4, -3)}, xlim=(-0.5, 2), ylim=(23, 16)):\n # fetch data for the cluster\n X, Xcov = fetch_glob_data(globular_name, features, filters)\n\n # unpickle the XD model\n if type(model) == str: \n f = open(model, 'rb')\n model = cPickle.load(f)\n f.close()\n\n # Calculate the posteriors, record medians\n a, m, v = model.posterior(X, Xcov)\n posts = np.zeros_like(X)\n for i in range(X.shape[0]):\n posts[i] = np.median(model.sample(a[i], m[i], v[i], size=1000),\n axis=0)\n\n # Get PSF mags and colors\n k = color.keys()[0]\n orig_r = X[:, mag]\n orig_gr = X[:, k] + X[:, color[k][0]] + X[:, color[k][1]]\n post_r = posts[:, mag]\n post_gr = posts[:, k] + posts[:, color[k][0]] + posts[:, color[k][1]]\n \n fs = 5\n ms = 2\n size = 15\n lsize = 20\n f = pl.figure(figsize=(2 * fs, fs))\n for i in range(1, 3):\n if i == 1:\n gr = orig_gr\n r = orig_r\n l = 'SDSS DR10'\n else:\n gr = post_gr\n r = post_r\n l = 'XD Posterior'\n ax = pl.subplot(1, 2, i)\n pl.plot(gr, r, 'ko', ms=ms, alpha=0.5)\n pl.xlim(xlim)\n pl.ylim(ylim)\n pl.xlabel('psfmag $g - r$', fontsize=lsize)\n pl.ylabel('psfmag $r$', fontsize=lsize)\n ax.text(0.95, 0.95, l, va='top', ha='right', fontsize=size,\n transform=ax.transAxes)\n f.savefig(figname, bbox_inches='tight')","def miniAOD_customizeMETFiltersFastSim(process):\n for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter':\n process.globalReplace(X, cms.EDFilter(\"HLTBool\", result=cms.bool(True))) \n for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters':\n process.globalReplace(X, cms.EDFilter(\"HLTBool\", result=cms.bool(False)))\n return process","def plot_filters(fnames):\n if len(fnames) == 0:\n with Database() as base:\n fnames = base.get_filter_names()\n with mp.Pool(processes=mp.cpu_count()) as pool:\n pool.map(worker_plot, fnames)","def execute_file(self, files, **kw):\n\n mode = kw['mode'] if 'mode' in kw else 0\n\n # ranger can act as a file chooser when running with --choosefile=...\n if mode == 0 and 'label' not in kw:\n if ranger.args.choosefile:\n open(ranger.args.choosefile, 'w').write(self.fm.thisfile.path)\n\n if ranger.args.choosefiles:\n paths = []\n for hist in self.fm.thistab.history:\n for fobj in hist.files:\n if fobj.marked and fobj.path not in paths:\n paths += [fobj.path]\n paths += [f.path for f in self.fm.thistab.get_selection() if f.path not in paths]\n\n with open(ranger.args.choosefiles, 'w') as fobj:\n fobj.write('\\n'.join(paths) + '\\n')\n\n if ranger.args.choosefile or ranger.args.choosefiles:\n raise SystemExit\n\n if isinstance(files, set):\n files = list(files)\n elif not isinstance(files, (list, tuple)):\n files = [files]\n\n flags = kw.get('flags', '')\n if 'c' in squash_flags(flags):\n files = [self.fm.thisfile]\n\n self.signal_emit('execute.before', keywords=kw)\n filenames = [f.path for f in files]\n label = kw.get('label', kw.get('app', None))\n try:\n return self.rifle.execute(filenames, mode, label, flags, None)\n finally:\n self.signal_emit('execute.after')","def event_based_r_factor(self):\n # assign variables\n rain_energy = 'rain_energy'\n rain_volume = 'rain_volume'\n erosivity = 'erosivity'\n r_factor = 'r_factor'\n\n # derive rainfall energy (MJ ha^-1 mm^-1)\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_energy}\"\n \"=0.29*(1.-(0.72*exp(-0.05*{rain_intensity})))\".format(\n rain_energy=rain_energy,\n rain_intensity=self.rain_intensity),\n overwrite=True)\n\n # derive rainfall volume\n \"\"\"\n rainfall volume (mm)\n = rainfall intensity (mm/hr)\n * (rainfall interval (min)\n * (1 hr / 60 min))\n \"\"\"\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_volume}\"\n \"= {rain_intensity}\"\n \"*({rain_interval}\"\n \"/60.)\".format(\n rain_volume=rain_volume,\n rain_intensity=self.rain_intensity,\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # derive event erosivity index (MJ mm ha^-1 hr^-1)\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{erosivity}\"\n \"=({rain_energy}\"\n \"*{rain_volume})\"\n \"*{rain_intensity}\"\n \"*1.\".format(\n erosivity=erosivity,\n rain_energy=rain_energy,\n rain_volume=rain_volume,\n rain_intensity=self.rain_intensity),\n overwrite=True)\n\n # derive R factor (MJ mm ha^-1 hr^-1 yr^1)\n \"\"\"\n R factor (MJ mm ha^-1 hr^-1 yr^1)\n = EI (MJ mm ha^-1 hr^-1)\n / (rainfall interval (min)\n * (1 yr / 525600 min))\n \"\"\"\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{r_factor}\"\n \"={erosivity}\"\n \"/({rain_interval}\"\n \"/525600.)\".format(\n r_factor=r_factor,\n erosivity=erosivity,\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # remove temporary maps\n gscript.run_command(\n 'g.remove',\n type='raster',\n name=['rain_energy',\n 'rain_volume',\n 'erosivity'],\n flags='f')\n\n return r_factor","def name(inp, mode, **kwargs):\n return name.dispatch(inp, mode, **kwargs)","def run_selection(self, included_clusters, excluded_clusters, max_image_catalog_sep, ch1_min_cov, ch2_min_cov,\n ch1_bright_mag, ch2_bright_mag, selection_band_faint_mag, ch1_ch2_color, spt_colnames,\n output_name, output_colnames):\n self.file_pairing(include=included_clusters, exclude=excluded_clusters)\n self.image_to_catalog_match(max_image_catalog_sep=max_image_catalog_sep)\n self.coverage_mask(ch1_min_cov=ch1_min_cov, ch2_min_cov=ch2_min_cov)\n self.object_mask()\n # self.cluster_k_correction()\n self.object_selection(ch1_bright_mag=ch1_bright_mag, ch2_bright_mag=ch2_bright_mag,\n selection_band_faint_mag=selection_band_faint_mag)\n self.purify_selection(ch1_ch2_color_cut=ch1_ch2_color)\n self.j_band_abs_mag()\n self.catalog_merge(catalog_cols=spt_colnames)\n self.object_separations()\n self.completeness_value()\n final_catalog = self.final_catalogs(filename=output_name, catalog_cols=output_colnames)\n if final_catalog is not None:\n return final_catalog","def fit(self, fn_raw, stim_name=None, event_id=1,\n tmin_stim=0.0, tmax_stim=1.0, flow=4.0, fhigh=34.0,\n pca_dim=0.90, max_iter=10000, conv_eps=1e-16,\n verbose=True):\n\n # ------------------------------------------\n # import necessary module\n # ------------------------------------------\n from fourier_ica import JuMEG_fourier_ica\n from mne import find_events, pick_types, set_log_level\n from mne.io import Raw\n\n\n # set log level to 'WARNING'\n set_log_level('WARNING')\n\n # ------------------------------------------\n # prepare data to apply FourierICA\n # ------------------------------------------\n meg_raw = Raw(fn_raw, preload=True)\n meg_channels = pick_types(meg_raw.info, meg=True, eeg=False,\n eog=False, stim=False, exclude='bads')\n meg_data = meg_raw._data[meg_channels, :]\n\n if stim_name:\n events = find_events(meg_raw, stim_channel=stim_name, consecutive=True)\n events = events[events[:, 2] == event_id, 0]\n else:\n events = []\n\n\n # ------------------------------------------\n # generate FourierICA object\n # ------------------------------------------\n if verbose:\n print \">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<\"\n print \">>> Performing FourierICA estimation <<<\"\n print \">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<\"\n\n win_length_sec = tmax_stim - tmin_stim\n fourier_ica_obj = JuMEG_fourier_ica(events=events, tpre=tmin_stim,\n flow=flow, fhigh=fhigh,\n win_length_sec=win_length_sec,\n remove_outliers=True,\n hamming_data=True,\n complex_mixing=True,\n pca_dim=pca_dim,\n max_iter=max_iter,\n conv_eps=conv_eps)\n\n\n # ------------------------------------------\n # perform ICASSO ICA\n # ------------------------------------------\n for irep in range(self.nrep):\n # apply FourierICA\n W_orig, A_orig, _, _, _, whitenMat, dewhitenMat = fourier_ica_obj.fit(meg_data.copy(), verbose=False)\n\n if irep == 0:\n self.whitenMat = whitenMat\n self.dewhitenMat = dewhitenMat\n\n # save results in structure\n self.W_est.append(W_orig)\n self.A_est.append(A_orig)\n\n # print out some information\n if verbose:\n print \">>> Running FourierICA number %d of %d done\" % (irep+1, self.nrep)\n\n if irep == 0:\n str_hamming_window = \"True\" if fourier_ica_obj.hamming_data else \"False\"\n str_complex_mixing = \"True\" if fourier_ica_obj.complex_mixing else \"False\"\n print \"..... Fourier ICA parameter:\"\n print \".....\"\n print \"..... Sampling frequency set to: %d\" % fourier_ica_obj.sfreq\n print \"..... Start of frequency band set to: %d\" % fourier_ica_obj.flow\n print \"..... End of frequency band set to: %d\" % fourier_ica_obj.fhigh\n print \"..... Using hamming window: %s\" % str_hamming_window\n print \"..... Assume complex mixing: %s\" % str_complex_mixing\n print \"..... Number of independent components: %d\" % fourier_ica_obj.ica_dim\n print \".....\"\n\n\n # ------------------------------------------\n # perform cluster analysis\n # ------------------------------------------\n if verbose:\n print \">>>\"\"\"\n print \">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<\"\n print \">>> Performing cluster analysis <<<\"\n print \">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<\"\n\n Z, order, partitions, indexR, dis, sim = self.cluster()\n proj = self.projection(dis)\n A, W, Iq = self.get_results(partitions, sim)\n\n\n # ------------------------------------------\n # return results\n # ------------------------------------------\n return W, A, Iq, fourier_ica_obj","def exec_event_functions(self):\n for name, fdict in self._event_functions.items():\n exec_func=False\n if self.is_eventCodePresent(fdict['eventCode']) \\\n and (self.ievent % fdict['nevents']) == 0:\n exec_func = True\n \n det_class = psutils.getattr_complete(self,fdict['det'])\n \n if exec_func and det_class.is_in_keys:\n# print 'executing',det_class._name, fdict['attr']\n func = psutils.getattr_complete(det_class,fdict['attr']) \n func(**fdict['kwargs'])","def infer_eog_channels(ch_names):\n \n eog = ['EOG ROC', 'EOG LOC']\n found = []\n\n # find frontal channel\n for ch in ch_names:\n if any([x in ch for x in eog]):\n found.append(ch)\n return found","def run_slowfast_analysis(mousename, sessionname, sessionname_openloop, roi_selection, h5_filepath, json_path, subname, sess_subfolder, filterprop_short, filterprop_long, orderprop_short, orderprop_long, even_win, blackbox_win, session_rois):\n MOUSE = mousename\n SESSION = sessionname\n h5path = h5_filepath\n SUBNAME = subname\n subfolder = sess_subfolder + '_slowvfast'\n # write result to dictionary\n write_to_dict = True\n # create figure (WARNING: significantly slows down execution)\n make_figure = True\n\n # set up dictionary to hold result parameters from roi\n session_rois[SUBNAME+'_slow_short_mean'] = []\n session_rois[SUBNAME+'_fast_long_mean'] = []\n\n session_rois[SUBNAME+'_slow_std_short'] = []\n session_rois[SUBNAME+'_slow_std_long'] = []\n session_rois[SUBNAME+'_fast_std_short'] = []\n session_rois[SUBNAME+'_fast_std_long'] = []\n\n session_rois[SUBNAME+'_slow_active_short'] = []\n session_rois[SUBNAME+'_slow_active_long'] = []\n session_rois[SUBNAME+'_fast_active_short'] = []\n session_rois[SUBNAME+'_fast_active_long'] = []\n\n session_rois[SUBNAME+'_slow_peak_short'] = []\n session_rois[SUBNAME+'_slow_peak_long'] = []\n session_rois[SUBNAME+'_fast_peak_short'] = []\n session_rois[SUBNAME+'_fast_peak_long'] = []\n\n session_rois[SUBNAME+'_slow_peak_time_short'] = []\n session_rois[SUBNAME+'_slow_peak_time_long'] = []\n session_rois[SUBNAME+'_fast_peak_time_short'] = []\n session_rois[SUBNAME+'_fast_peak_time_long'] = []\n\n # if we want to run through all the rois, just say all\n if roi_selection == 'all':\n h5dat = h5py.File(h5path, 'r')\n dF_ds = np.copy(h5dat[SESSION + '/dF_win'])\n h5dat.close()\n num_rois = dF_ds.shape[1]\n roilist = np.arange(num_rois)\n print('analysing ' + roi_selection + ' rois: ' + str(roilist))\n elif roi_selection == 'valid':\n # only use valid rois\n with open(json_path, 'r') as f:\n sess_dict = json.load(f)\n roilist = sess_dict['valid_rois']\n print('analysing ' + roi_selection + ' rois: ' + str(roilist))\n else:\n roilist = roi_selection\n print('analysing custom list of rois: ' + str(roilist))\n\n # run analysis for vr session\n for i,r in enumerate(roilist):\n print(SUBNAME + ': ' + str(r))\n\n std_short, std_long, active_short, active_long, peak_short, peak_long, meanpeak_short_time, meanpeak_long_time, ylims, norm_value = fig_ordered_eventdiff(h5path, SESSION, r, MOUSE+'_'+SESSION+'_roi_'+str(r), filterprop_short, filterprop_long, orderprop_short,orderprop_long, even_win, blackbox_win, [], fformat, subfolder, [], False, make_figure)\n # session_rois[SUBNAME+'_slow_roi_number'].append(r)\n session_rois[SUBNAME+'_slow_std_short'].append(std_short[0])\n session_rois[SUBNAME+'_slow_std_long'].append(std_long[0])\n session_rois[SUBNAME+'_slow_active_short'].append(active_short[0])\n session_rois[SUBNAME+'_slow_active_long'].append(active_long[0])\n session_rois[SUBNAME+'_slow_peak_short'].append(peak_short[0])\n session_rois[SUBNAME+'_slow_peak_long'].append(peak_long[0])\n session_rois[SUBNAME+'_slow_peak_time_short'].append(meanpeak_short_time[0])\n session_rois[SUBNAME+'_slow_peak_time_long'].append(meanpeak_long_time[0])\n\n session_rois[SUBNAME+'_fast_std_short'].append(std_short[1])\n session_rois[SUBNAME+'_fast_std_long'].append(std_long[1])\n session_rois[SUBNAME+'_fast_active_short'].append(active_short[1])\n session_rois[SUBNAME+'_fast_active_long'].append(active_long[1])\n session_rois[SUBNAME+'_fast_peak_short'].append(peak_short[1])\n session_rois[SUBNAME+'_fast_peak_long'].append(peak_long[1])\n session_rois[SUBNAME+'_fast_peak_time_short'].append(meanpeak_short_time[1])\n session_rois[SUBNAME+'_fast_peak_time_long'].append(meanpeak_long_time[1])\n\n if write_to_dict:\n # print('writing to dict')\n # print(type(session_rois['reward_slow_peak_time_short']))\n # print(session_rois)\n write_dict(MOUSE, SESSION, session_rois)","def upsilons ( self ) :\n ##\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n ##\n return self.make_selection (\n 'Upsilon' ,\n FilterDesktop , \n [ self.dimuon () ] , \n ## algorithm parameters \n Code = self['UpsilonCut'] ,\n ## \n ReFitPVs = True\n ##\n )","def main(args):\n try:\n config_path = project_path + \"/\" + args.config\n input_data_path = project_path + \"/\" + args.input\n output_data_path = project_path + \"/\" + args.output\n\n config = load_config(config_path)\n\n # load data\n df = read_csv(input_data_path)\n df.loc[:, 'season'] = df['season'].astype('int')\n\n sys.stdout = open(output_data_path, 'w')\n check_balance(df)\n check_linelen(df, config['eda']['quantile'])\n\n groups = config['eda']['groups']\n\n for i in range(len(groups)):\n df_top_words = most_important_words(df, groups[i], **config['eda']['top_n_words'])\n fig = plot_tfidf_classfeats_h(df_top_words)\n fig.savefig('{}/EDA/top_words_{}.png'.format(project_path, i))\n\n\n except Exception as e:\n logger.error(\"Unexpected error occurred when eda: \" + str(e))","def etap2rhog ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays \n pre_etap = self.make_selection (\n ## the unique tag \n 'PreEtapRhoG' ,\n ## algorithm type to be used\n DaVinci__N3BodyDecays ,\n ## input selections \n [ self.pions () , self.gamma () ] ,\n ##\n DecayDescriptor = \" eta_prime -> pi+ pi- gamma\" ,\n ##\n DaughtersCuts = { 'gamma' : self['GammaCut'] } ,\n ## \n Combination12Cut = \"\"\" ( AM < 950 * MeV ) &\n ( ACHI2DOCA(1,2) < 12 ) \n \"\"\" , \n CombinationCut = \"\"\"\n ( APT > %s ) & \n in_range ( 500 * MeV , AM12 , 950 * MeV ) & \n ( ADAMASS ( 'eta_prime' ) < 100 * MeV ) \n \"\"\" % ( 0.9 * self['ETAP_PT'] ),\n ##\n MotherCut = \"\"\"\n ( PT > %s ) &\n ( chi2vx < 9 )\n \"\"\" % self['ETAP_PT'] \n )\n ## \n from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger\n ## \n return self.make_selection (\n 'Etap2rhogamma' ,\n Pi0Veto__Tagger ,\n [ pre_etap ] ,\n MassWindow = 25 * MeV ,\n MassChi2 = -1 ,\n ExtraInfoIndex = 25017 ## unique ! \n )","def OnAbout(self, event):\n messtr = u\"单细胞簇识别系统\\n\"\n messtr =messtr +u\"这是个识别单细胞簇的层次聚类系统，使用方法如下：\\n\" \n messtr =messtr +u\"1.将你的数据处理成三个文件expr.h5,features.txt,labels.txt,分别是用h5py.create_dataset创建的N细胞*M基因的细胞表达式矩阵和用np.savetxt函数保存的基因文件和标签文件(注意一行一个不能有空格）放在一个文件夹即可,可以参考prosess_sys.py\\n\"\n messtr =messtr +u\"2.点击选择文件按钮选择文件夹，此时右边会提示成功与否\\n\"\n messtr =messtr +u\"3.thresh表示过滤掉某个基因表达的细胞数少于百分比细胞数的，范围为0-1，为零时不过滤低表达基因\\n\" \n messtr =messtr +u\"z_cutoff是离散值，bins是分为几份，是整数，将基因按照在所有细胞表达均值分成bins份，然后去掉每一份zscore小于z_cutoff的基因\\n\"\n messtr =messtr +u\"4.可以选择不同的降维算法进行降维\\n\"\n messtr =messtr +u\"5.split_score和merge_score是聚类的两个超参数，一般后者是前者的一半，基于韦尔奇t检查的两个集群之间的距离度量如果大于这个split_score就分裂，小于merge_score就合并(采用的聚类方法是先分裂再合并的)\\n\"\n messtr =messtr +u\"6.ys是层次聚类分裂的结果，ym是分裂再凝聚后的结果，ySC3是SC3算法的结果，ySafe是SAFE算法的结果，yclf是一致性聚类的结果,yKmean是kmeans算法的结果\"\n wx.MessageBox(messtr,\n \"About System\",\n wx.OK|wx.ICON_INFORMATION)","def main():\n logging.getLogger(\"dance\").setLevel(logging.DEBUG)\n logging.getLogger(\"dance\").addHandler(logging.StreamHandler(sys.stderr))\n\n def relevant_if_has_t142(mol: oechem.OEMol):\n params = smirnoff_param_utils.read_params_from_mol(mol)\n return \"t142\" in params\n\n def size_and_wbo_fingerprint(mol: oechem.OEMol):\n \"\"\"Fingerprint with number of atoms in the mol and WBO between central atoms in the t142 param.\n\n (WBO is Wiberg Bond Order.)\n\n Note: The indices are the same in OpenEye and OFF molecules, so the\n parameter indices are correct, even though they were calculated for the\n OFF mol.\n \"\"\"\n oechem.OEAddExplicitHydrogens(mol)\n params = smirnoff_param_utils.read_params_from_mol(mol)\n return (\n mol.NumAtoms(),\n smirnoff_param_utils.calculate_t142_central_wbo(mol, params),\n )\n\n config = {\n \"database_type\": \"OEB\",\n \"database_info\": \"combined_molecules_with_parameters.oeb\",\n \"relevance_function\": relevant_if_has_t142,\n \"filter_output_oeb\": \"results/filter_output.oeb\",\n \"fingerprint_function\": size_and_wbo_fingerprint,\n \"fingerprint_output_oeb\": \"results/fingerprint_output.oeb\",\n \"selection_frequency\": 375, # To select ~20 molecules.\n \"dataset_type\": \"OEB\",\n \"dataset_info\": \"results/dataset.oeb\",\n \"sorted_by_fingerprint_oeb\": \"results/sorted_by_fingerprint.oeb\",\n \"in_memory_sorting_threshold\": 25000,\n \"tmpdir\": \"results/tmp\",\n }\n\n run_dance(config)","def launch ():\n #core.addListenerByName(\"UpEvent\", _go_up)\n core.registerNew(MAC_Filter)","def image_selection_change():\n\n def return_image(val, model_id, message_name, field_name, mime, sind):\n \"\"\"Returns a URL resolvable by the probe\"\"\"\n column_data_source = curdoc().get_model_by_name(sind)\n index = column_data_source.tags[0]\n url = \"http://{0}/image/\".format(_host) + \"---\".join([model_id, message_name, field_name, mime, sind, str(index)])\n return url\n\n d = curdoc()\n _remove_fig(d)\n model_id, message_name, _ = run_handlers.get_modelid_messagename_type(d)\n image_field = d.get_model_by_name(IMAGE_SELECTION).value.split(\" :\")[0]\n mime = d.get_model_by_name(MIME_SELECTION).value\n\n if image_field != DEFAULT_UNSELECTED and mime != DEFAULT_UNSELECTED:\n plot = figure(plot_width=500, plot_height=500, title=\"\", x_range=Range1d(start=0, end=1), y_range=Range1d(start=0, end=1), name=FIGURE_MODEL)\n sind = run_handlers.get_source_index(d.session_context.id, model_id, message_name, image_field + mime)\n\n _install_callback_and_cds(sind, model_id, message_name,\n {image_field: [return_image, {\"model_id\": model_id,\n \"message_name\": message_name,\n \"field_name\": image_field,\n \"mime\": mime,\n \"sind\": sind}]},\n stream_limit=1)\n plot.image_url(url=image_field, x=0, y=1, h=1, w=1, source=d.get_model_by_name(sind))\n d.add_root(plot)","def main():\n parser = argparse.ArgumentParser(\n description=\"making feature file argsurations.\")\n\n parser.add_argument(\n \"--waveforms\", default=None,\n help=\"directory or list of filename of input wavfile\")\n parser.add_argument(\n \"--hdf5dir\", default=None,\n help=\"directory to save hdf5\")\n parser.add_argument(\n \"--wavdir\", default=None,\n help=\"directory to save of preprocessed wav file\")\n parser.add_argument(\n \"--fs\", default=16000,\n type=int, help=\"Sampling frequency\")\n parser.add_argument(\n \"--shiftms\", default=5,\n type=float, help=\"Frame shift in msec\")\n parser.add_argument(\n \"--feature_type\", default=\"world\", choices=[\"world\", \"melspc\", \"mcep\"],\n type=str, help=\"feature type\")\n parser.add_argument(\n \"--mspc_dim\", default=80,\n type=int, help=\"Dimension of mel spectrogram\")\n parser.add_argument(\n \"--minf0\", default=40,\n type=int, help=\"minimum f0 for world analysis\")\n parser.add_argument(\n \"--maxf0\", default=400,\n type=int, help=\"maximum f0 for world analysis\")\n parser.add_argument(\n \"--fmin\", default=None, nargs=\"?\",\n type=int, help=\"minimum frequency for melspc\")\n parser.add_argument(\n \"--fmax\", default=None, nargs=\"?\",\n type=int, help=\"maximum frequency for melspc\")\n parser.add_argument(\n \"--mcep_dim\", default=24,\n type=int, help=\"Dimension of mel cepstrum\")\n parser.add_argument(\n \"--mcep_alpha\", default=0.41,\n type=float, help=\"Alpha of mel cepstrum\")\n parser.add_argument(\n \"--fftl\", default=1024,\n type=int, help=\"FFT length\")\n parser.add_argument(\n \"--highpass_cutoff\", default=70,\n type=int, help=\"Cut off frequency in lowpass filter\")\n parser.add_argument(\n \"--save_wav\", default=True,\n type=strtobool, help=\"Whether to save filtered wav file\")\n parser.add_argument(\n \"--n_jobs\", default=10,\n type=int, help=\"number of parallel jobs\")\n parser.add_argument(\n \"--verbose\", default=1,\n type=int, help=\"log message level\")\n\n args = parser.parse_args()\n\n # set log level\n if args.verbose == 1:\n logging.basicConfig(level=logging.INFO,\n format='%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',\n datefmt='%m/%d/%Y %I:%M:%S')\n elif args.verbose > 1:\n logging.basicConfig(level=logging.DEBUG,\n format='%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',\n datefmt='%m/%d/%Y %I:%M:%S')\n else:\n logging.basicConfig(level=logging.WARNING,\n format='%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',\n datefmt='%m/%d/%Y %I:%M:%S')\n logging.warning(\"logging is disabled.\")\n\n # show arguments\n for key, value in vars(args).items():\n logging.info(\"%s = %s\" % (key, str(value)))\n\n # read list\n if os.path.isdir(args.waveforms):\n file_list = sorted(find_files(args.waveforms, \"*.wav\"))\n else:\n file_list = read_txt(args.waveforms)\n logging.info(\"number of utterances = %d\" % len(file_list))\n\n # check directory existence\n if not os.path.exists(args.wavdir) and args.highpass_cutoff != 0 and args.save_wav:\n os.makedirs(args.wavdir)\n if not os.path.exists(args.hdf5dir):\n os.makedirs(args.hdf5dir)\n\n # divide list\n file_lists = np.array_split(file_list, args.n_jobs)\n file_lists = [f_list.tolist() for f_list in file_lists]\n\n # multi processing\n processes = []\n if args.feature_type == \"world\":\n target_fn = world_feature_extract\n elif args.feature_type == \"melspc\":\n target_fn = melspectrogram_extract\n else:\n target_fn = melcepstrum_extract\n for f in file_lists:\n p = mp.Process(target=target_fn, args=(f, args,))\n p.start()\n processes.append(p)\n\n # wait for all process\n for p in processes:\n p.join()","def filter_f(fns, ltaper, lowerp, upperp, utaper, eqband, eqltaper, equtaper, npow, bindir):\n # filtercmd = bindir+\"/filter4\"\n filtercmd = bindir + \"/filter4 1>/dev/null\"\n for src, tar, eqtar in fns:\n p = sp.Popen(filtercmd, shell=True, bufsize=0, stdin=sp.PIPE, stdout=None)\n child = p.stdin\n print >> child, ltaper, lowerp, upperp, utaper, npow, src, tar + '_tmp'\n err = child.close()\n ret = p.wait()\n if err or ret != 0:\n raise RuntimeError, '%r failed with exit code %d' % (filtercmd, err)\n p = sp.Popen(filtercmd, shell=True, bufsize=0, stdin=sp.PIPE, stdout=None)\n child = p.stdin\n print >> child, eqltaper, eqband[0], eqband[1], equtaper, npow, tar + '_tmp', eqtar + '_tmp'\n err = child.close()\n ret = p.wait()\n if err or ret != 0:\n raise RuntimeError, '%r failed with exit code %d' % (filtercmd, err)\n return 1","def getJetFinderTool(self, alg=\"AntiKt\", R=0.4, input=\"LCTopo\", algName=None, doArea=True, context=None, **userProp):\n # Use some default properties\n defaultProps = dict( PtMin = 5000, GhostArea = 0.01 if doArea else 0., RandomOption = 1, )\n\n if algName is None:\n algName = buildJetAlgName(alg,R)\n else:\n alg, R, input = interpretJetName( algName )\n \n if context:\n toolName = context.output+'.Finder'\n else:\n toolName = algName+\"Finder\"\n\n # Technically we need this tool to translate fastjet to xAOD::Jet \n jetFromPJ = JetFromPseudojet(toolName.replace('Finder',\"jetbuild\"),\n Attributes = [\"ActiveArea\", \"ActiveAreaFourVector\"] if doArea else [] )\n defaultProps['JetBuilder'] = jetFromPJ\n\n # overwrite with userProp\n defaultProps.update(userProp)\n defaultProps.update( JetAlgorithm = alg, JetRadius = R )\n\n if alg.startswith('Var'):\n # add Variable R jet params.\n # for now assuming large-R jet usage so fixed param :\n defaultProps.update(VariableRMinRadius=0.2, VariableRMassScale=600000,JetRadius=1.0,\n JetAlgorithm = dict(VarA='AntiKt',VarK='Kt',VarC='CamKt')[alg] )\n\n\n # pass all the options to the constructor :\n finder = JetFinder(toolName, **defaultProps)\n\n # incase of track jet, the finder is a bit more complex\n # we used a dedicated one which will build jets per vertex\n if \"Track\" in input:\n from ROOT import JetByVertexFinder\n vertexIndex = 0 # configure it to use PV0 (we could interpret input)\n vfinder = JetByVertexFinder(toolName + \"ByVertex\",\n JetFinder = finder,\n Vertex = vertexIndex) \n finder = vfinder\n\n return finder","def main(args=None):\n # ---------- build and read options ----------\n USAGE = \"\"\"Usage %prog -i <FCDDATA> [options] \nConverts the given fcd file (generated by sumo --fcd-output) into the selected\noutput format. Optionally the output can be sampled, filtered and distorted.\n\"\"\"\n\n from optparse import OptionParser\n optParser = OptionParser(usage=USAGE)\n optParser.add_option(\"-i\", \"--fcd-input\", dest=\"fcd\", metavar=\"FILE\",\n help=\"Defines the FCD-output file to use as input\")\n optParser.add_option(\"-n\", \"--net-input\", dest=\"net\", metavar=\"FILE\",\n help=\"Defines the network file to use as input\")\n optParser.add_option(\"-p\", \"--penetration\", type=\"float\", dest=\"penetration\",\n default=1., help=\"Defines the percentage (0-1) of vehicles to export\")\n optParser.add_option(\"-b\", \"--begin\", dest=\"begin\",\n type=\"float\", help=\"Defines the first step to export\")\n optParser.add_option(\"-e\", \"--end\", dest=\"end\",\n type=\"float\", help=\"Defines the first step not longer to export\")\n optParser.add_option(\"-d\", \"--delta-t\", dest=\"delta\",\n type=\"float\", help=\"Defines the export step length\")\n optParser.add_option(\"--gps-blur\", dest=\"blur\", default=0,\n type=\"float\", help=\"Defines the GPS blur\")\n optParser.add_option(\n \"--boundary\", help=\"Defines the bounding box as 'xmin,ymin,xmax,ymax'\")\n optParser.add_option(\"-s\", \"--seed\", dest=\"seed\", default=42,\n type=\"float\", help=\"Defines the randomizer seed\")\n optParser.add_option(\n \"--base-date\", dest=\"base\", default=-1, type=\"int\", help=\"Defines the base date\")\n optParser.add_option(\"--orig-ids\", dest=\"orig_ids\", default=False, action=\"store_true\",\n help=\"Write original vehicle IDs instead of a running index\")\n optParser.add_option(\"--ignore-gaps\", dest=\"ignore_gaps\", default=False, action=\"store_true\",\n help=\"Ignore steps where a vehicle is not in the network\")\n optParser.add_option(\"--persons\", default=False, action=\"store_true\",\n help=\"Include person data\")\n # PHEM\n optParser.add_option(\"--dri-output\", dest=\"dri\", metavar=\"FILE\",\n help=\"Defines the name of the PHEM .dri-file to generate\")\n optParser.add_option(\"--str-output\", dest=\"str\", metavar=\"FILE\",\n help=\"Defines the name of the PHEM .str-file to generate\")\n optParser.add_option(\"--fzp-output\", dest=\"fzp\", metavar=\"FILE\",\n help=\"Defines the name of the PHEM .fzp-file to generate\")\n optParser.add_option(\"--flt-output\", dest=\"flt\", metavar=\"FILE\",\n help=\"Defines the name of the PHEM .flt-file to generate\")\n # OMNET\n optParser.add_option(\"--omnet-output\", dest=\"omnet\", metavar=\"FILE\",\n help=\"Defines the name of the OMNET file to generate\")\n # Shawn\n optParser.add_option(\"--shawn-output\", dest=\"shawn\", metavar=\"FILE\",\n help=\"Defines the name of the Shawn file to generate\")\n # ns2\n optParser.add_option(\"--ns2activity-output\", dest=\"ns2activity\", metavar=\"FILE\",\n help=\"Defines the name of the ns2 file to generate\")\n optParser.add_option(\"--ns2config-output\", dest=\"ns2config\", metavar=\"FILE\",\n help=\"Defines the name of the ns2 file to generate\")\n optParser.add_option(\"--ns2mobility-output\", dest=\"ns2mobility\", metavar=\"FILE\",\n help=\"Defines the name of the ns2 file to generate\")\n # GPSDAT\n optParser.add_option(\"--gpsdat-output\", dest=\"gpsdat\", metavar=\"FILE\",\n help=\"Defines the name of the gpsdat file to generate\")\n\n # GPX\n optParser.add_option(\"--gpx-output\", dest=\"gpx\", metavar=\"FILE\",\n help=\"Defines the name of the gpx file to generate\")\n # POI\n optParser.add_option(\"--poi-output\", dest=\"poi\", metavar=\"FILE\",\n help=\"Defines the name of the poi file to generate\")\n # parse\n if len(args) == 1:\n sys.exit(USAGE.replace('%prog', os.path.basename(__file__)))\n options, remaining_args = optParser.parse_args(args=args)\n\n if options.seed:\n random.seed(options.seed)\n # ---------- process ----------\n net = None\n # ----- check needed values\n if options.delta and options.delta <= 0:\n print(\"delta-t must be a positive value.\")\n return 1\n # phem\n if (options.dri or options.fzp or options.flt) and not options.fcd:\n print(\"A fcd-output from SUMO must be given using the --fcd-input.\")\n return 1\n if (options.str or options.fzp or options.flt) and not options.net:\n print(\"A SUMO network must be given using the --net-input option.\")\n return 1\n # omnet\n if options.omnet and not options.fcd:\n print(\"A fcd-output from SUMO must be given using the --fcd-input.\")\n return 1\n # ----- check needed values\n\n ## ----- OMNET\n if options.omnet:\n runMethod(options.fcd, options.omnet, omnet.fcd2omnet, options)\n ## ----- OMNET\n\n ## ----- Shawn\n if options.shawn:\n runMethod(options.fcd, options.shawn, shawn.fcd2shawn, options)\n ## ----- Shawn\n\n ## ----- GPSDAT\n if options.gpsdat:\n runMethod(options.fcd, options.gpsdat, gpsdat.fcd2gpsdat, options)\n ## ----- GPSDAT\n\n ## ----- GPX\n if options.gpx:\n runMethod(options.fcd, options.gpx, gpx.fcd2gpx, options)\n ## ----- GPX\n\n ## ----- GPX\n if options.poi:\n runMethod(options.fcd, options.poi, poi.fcd2poi, options)\n ## ----- GPX\n\n ## ----- ns2\n if options.ns2mobility or options.ns2config or options.ns2activity:\n vIDm, vehInfo, begin, end, area = runMethod(\n options.fcd, options.ns2mobility, ns2.fcd2ns2mobility, options)\n if options.ns2activity:\n o = _getOutputStream(options.ns2activity)\n ns2.writeNS2activity(o, vehInfo)\n _closeOutputStream(o)\n if options.ns2config:\n o = _getOutputStream(options.ns2config)\n ns2.writeNS2config(\n o, vehInfo, options.ns2activity, options.ns2mobility, begin, end, area)\n _closeOutputStream(o)\n ## ----- ns2\n\n ## ----- PHEM\n # .dri\n if options.dri:\n runMethod(options.fcd, options.dri, phem.fcd2dri, options)\n # .str (we need the net for other outputs, too)\n if options.str or options.fzp or options.flt:\n if not options.net:\n print(\"A SUMO network must be given using the --net-input option.\")\n return 1\n if not net:\n net = sumolib.net.readNet(options.net)\n o = _getOutputStream(options.str)\n sIDm = phem.net2str(net, o)\n _closeOutputStream(o)\n # .fzp\n if options.flt or options.fzp:\n vIDm, vtIDm = runMethod(\n options.fcd, options.fzp, phem.fcd2fzp, options, {\"phemStreetMap\": sIDm})\n # .flt\n if options.flt:\n o = _getOutputStream(options.flt)\n phem.vehicleTypes2flt(o, vtIDm)\n _closeOutputStream(o)\n ## ----- PHEM\n return 0","def extract_features(audio_filename, args):\n #print(\"Extract_features\")\n spec_type = args['spec_type']\n\n if spec_type == 'cqt':\n bin_multiple = args['bin_multiple']\n max_midi = args['max_midi']\n min_midi = args['min_midi']\n note_range = max_midi - min_midi + 1\n sr = args['sr']\n hop_length = args['hop_length']\n window_size = args['window_size']\n\n bins_per_octave = 12 * bin_multiple # should be a multiple of 12\n n_bins = note_range * bin_multiple\n\n # down-sample,mono-channel\n y, _ = librosa.load(audio_filename, sr)\n # y: an np.ndarray[ shape=(n,) ] giving the audio time series. librosa.load automatically downsamples to the\n # required sample rate sr\n # doku on librosa.cqt:\n # https://librosa.github.io/librosa/generated/librosa.core.cqt.html?highlight=cqt#librosa.core.cqts\n S = librosa.cqt(y, fmin=librosa.midi_to_hz(min_midi), sr=sr, hop_length=hop_length,\n bins_per_octave=bins_per_octave, n_bins=n_bins)\n S = S.T\n S = np.abs(S)\n min_db = np.min(S)\n print(np.min(S), np.max(S), np.mean(S))\n S = np.pad(S, ((window_size // 2, window_size // 2), (0, 0)), 'constant', constant_values=min_db)\n\n windows = []\n\n # IMPORTANT NOTE:\n # Since we pad the the spectrogram frame,\n # the onset frames are actually `offset` frames.\n # To obtain a window of the center frame at each true index, we take a slice from i to i+window_size\n # starting at frame 0 of the padded spectrogram\n for i in range(S.shape[0] - window_size + 1):\n w = S[i:i + window_size, :]\n windows.append(w)\n\n # print inputs\n x = np.array(windows)\n return x\n\n else:\n print(\"WARNING: feature type \" + spec_type + \" not implemented.\")\n return 0","def featurize_kof(*args):\n\n df = args[0]\n\n # initial cleaning & changes to df\n df = df.drop(columns='Unnamed: 0')\n df = df.rename(columns = {'Code_Style':'code_style', 'Name':'name', 'Brand':'brand', 'Date':'date',\n 'Retail_Price': 'retail_price', 'Colorway':'colorway', 'Story':'story',\n 'KOF_Wants':'kof_wants', 'Avg_Resale':'avg_resale_stockx'})\n df['retail_price'] = df['retail_price'].astype(int)\n df['avg_resale_stockx'] = df['avg_resale_stockx'].str.replace('[^\\w\\s]','')\n df['avg_resale_stockx'] = df['avg_resale_stockx'].astype(int)\n\n # feature 1: merge silhouettes\n all_silhouettes = eval(args[1])\n # strip out brand name from silhouette name\n temp = []\n for i in range(len(all_silhouettes)):\n silhouette = all_silhouettes[i]\n silhouette = silhouette.replace(\"Nike \", \"\")\n silhouette = silhouette.replace(\"Adidas \", \"\")\n silhouette = silhouette.replace(\"adidas \", \"\")\n temp.append(silhouette)\n all_silhouettes = temp\n all_silhouettes.append('Air Jordan 1')\n all_silhouettes = list(set(all_silhouettes))\n df['silhouette'] = df['name'].apply(lambda x: silhouette_generator(x, all_silhouettes))\n\n #feature 2: profitable\n #create columns to calculate net profit\n df['price_diff'] = df['avg_resale_stockx'] - df['retail_price']\n df['commission_fee'] = abs((df['avg_resale_stockx']) * (9.5/100))\n df['seller_fee'] = 5\n df['total_credit'] = df['price_diff'] - df['commission_fee'] - df['seller_fee']\n df['cashout_fee'] = abs((df['total_credit']) * (2.9/100))\n df['net_profit'] = df['total_credit'] - df['cashout_fee']\n #create purchase feature if the net profit is greater than 0\n df['profitable'] = np.where(df['net_profit'] > 0, 1, 0)\n #drop columns used to calculate net profit\n df.drop(['commission_fee', 'seller_fee', 'total_credit', 'cashout_fee'], axis=1, inplace=True)\n\n #feature 3: brand code\n brand_code = df.groupby('brand').ngroup()\n df = pd.concat([df, brand_code], axis=1).rename(columns={0:'brand_code'})\n\n #feature 4: word2vec colors\n nlp = spacy.load('en_vectors_web_lg')\n df['black'] = df['colorway'].apply(lambda x: color_word2vec(x, \"black\", nlp))\n df['white'] = df['colorway'].apply(lambda x: color_word2vec(x, \"white\", nlp))\n df['brown'] = df['colorway'].apply(lambda x: color_word2vec(x, \"brown\", nlp))\n df['red'] = df['colorway'].apply(lambda x: color_word2vec(x, \"red\", nlp))\n df['blue'] = df['colorway'].apply(lambda x: color_word2vec(x, \"blue\", nlp))\n df['yellow'] = df['colorway'].apply(lambda x: color_word2vec(x, \"yellow\", nlp))\n df['orange'] = df['colorway'].apply(lambda x: color_word2vec(x, \"orange\", nlp))\n df['green'] = df['colorway'].apply(lambda x: color_word2vec(x, \"green\", nlp))\n df['purple'] = df['colorway'].apply(lambda x: color_word2vec(x, \"purple\", nlp))\n df['multi_color'] = df['colorway'].apply(lambda x: color_word2vec(x, \"multi color\", nlp))\n df['main_color'] = df[['black', 'white', 'brown', 'red', 'blue', 'yellow',\n 'orange', 'green', 'purple', 'multi_color']].idxmax(axis=1)\n df['main_color_id'] = df.groupby('main_color').ngroup()\n\n #boolean features\n df['womens'] = df['name'].apply(lambda x: label_womens(x))\n\n df['bcollab'] = df['name'].apply(lambda x: label_bcollab(x))\n\n df['og'] = df['name'].apply(lambda x: label_og(x))\n\n df['sp'] = df['name'].apply(lambda x: label_sp(x))\n\n df['qs'] = df['name'].apply(lambda x: label_qs(x))\n\n df['sb'] = df['name'].apply(lambda x: label_sb(x))\n\n df['ls'] = df['name'].apply(lambda x: label_ls(x))\n\n df['nrg'] = df['name'].apply(lambda x: label_nrg(x))\n\n df['prm'] = df['name'].apply(lambda x: label_prm(x))\n\n df['nsw'] = df['name'].apply(lambda x: label_nsw(x))\n\n df['retro'] = df['name'].apply(lambda x: label_retro(x))\n\n df['se'] = df['name'].apply(lambda x: label_se(x))\n\n df['pe'] = df['name'].apply(lambda x: label_pe(x))\n\n df['gs'] = df['name'].apply(lambda x: label_gs(x))\n\n df['hs'] = df['name'].apply(lambda x: label_hs(x))\n\n return df","def rbd_koon_parallel_args() -> dict:\n edges = [\n (\"s\", 1),\n (\"s\", 2),\n (\"s\", 3),\n (1, \"v\"),\n (2, \"v\"),\n (3, \"v\"),\n (\"v\", \"t\"),\n ]\n reliabilities = {\n 1: FixedEventProbability.from_params(1 - 0.85),\n 2: FixedEventProbability.from_params(1 - 0.8),\n 3: FixedEventProbability.from_params(1 - 0.9),\n \"v\": FixedEventProbability.from_params(1 - 0.85),\n }\n return {\"edges\": edges, \"reliabilities\": reliabilities}","def evolve(self, genomes, pool, params):\n pass","def call_modes(self, infname, outfname, no_of_genes, parameter_a=0.2, parameter_b=4):\n\t\tmodes_path = os.path.join(os.path.expanduser('~'), 'bin/hhu_clustering/bin/modes')\n\t\tif not os.path.isfile(modes_path):\n\t\t\tprint 'program %s not available'%modes_path\n\t\t\tsys.exit(1)\n\t\t###!!!, the argument list must comprise of all strings, not integer, or float.\n\t\twl = ['modes', infname, repr(no_of_genes), outfname, repr(parameter_b), '1', repr(int(parameter_a*10)), '80']\n\t\tif self.debug:\n\t\t\tprint \"modes' parameter is %s\",wl\n\t\treturn os.spawnvp(os.P_WAIT, modes_path, wl)","def get_ids_filter(grid, idsname='Ids', is_nids=True, is_eids=True):\n ids = vtk.vtkIdFilter()\n if isinstance(grid, vtk.vtkUnstructuredGrid):\n # this is typically what's called in the gui\n ids.SetInputData(grid)\n elif isinstance(grid, vtk.vtkPolyData): # pragma: no cover\n # this doesn't work...\n ids.SetCellIds(grid.GetCellData())\n ids.SetPointIds(grid.GetPointData())\n else:\n raise NotImplementedError(ids)\n\n #self.is_eids = False\n ids.CellIdsOn()\n ids.PointIdsOn()\n\n #print('is_eids=%s is_nids=%s' % (is_eids, is_nids))\n if not is_eids:\n ids.CellIdsOff()\n if not is_nids:\n ids.PointIdsOff()\n #ids.FieldDataOn()\n ids.SetIdsArrayName(idsname)\n return ids","def main() :\n\t\n\tusage = \"\"\"usage: %prog [options]\"\"\"\t\t\t\n\n\tparser = OptionParser(usage=usage)\n\tparser.add_option(\"-r\",\"--relocfile\", dest=\"relocfile\", type=\"string\",\n\t\t\t\t\t\thelp=\"hypoDD relocated file [hypoDD.reloc]\")\n\tparser.add_option(\"-l\",\"--locfile\", dest=\"locfile\", type=\"string\",\n\t\t\t\t\t\thelp=\"hypoDD non-relocated file [hypoDD.loc]\")\n\tparser.add_option(\"-o\",\"--outputPDF\", dest=\"pdffile\", type=\"string\",\n\t\t\t\t\t\thelp=\"output PDF filename [hypoDD.locreloc.pdf]\")\n\tparser.add_option(\"-p\",\"--outputPNG\", dest=\"pngfile\", type=\"string\",\n\t\t\t\t\t\thelp=\"output PNG filename [hypoDD.locreloc.png]\")\n#\tparser.add_option(\"-a\",\"--allEvents\", dest=\"plotAll\",\n#\t\t\t\t\t\taction=\"store_true\", help=\"print out all events (even unimproved)\")\n\tparser.add_option(\"-c\",\"--connectHypos\", dest=\"plotConnect\",\n\t\t\t\t\t\taction=\"store_true\", help=\"connect relocated and original events\")\n\tparser.add_option(\"-u\",\"--uncertLimit\", dest=\"uncertlimit\", type=\"float\",\n\t\t\t\t\t\thelp=\"print out only relocated events with all uncertainties (m) less than this (0 means print all) [0]\")\n\n\tparser.set_defaults(relocfile=\"hypoDD.reloc\",\n\t\t\t\t\t\tlocfile='hypoDD.loc', \n\t\t\t\t\t\tpdffile='hypoDD.locreloc.pdf',\n\t\t\t\t\t\tpngfile='hypoDD.locreloc.png',\n\t\t\t\t\t\tplotConnect=False,\n#\t\t\t\t\t\tplotAll=False,\n\t\t\t\t\t\tuncertlimit=0)\n\t(options, args) = parser.parse_args()\n\t\t\n\tpsfile='temp.ps'\n\tconnectFile='temp.connect'\n\tlocXY=options.locfile + '.xy'\n\trelocXY=options.relocfile + '.xy'\n\tprint(options.locfile, options.relocfile,locXY,relocXY)\n\t\n\tif len(args) != 0:\n\t\tprint(main.__doc__)\n\t\tparser.print_help()\n\t\treturn 2\n\n\t# Read relocated events into memory\n\tf=open(options.relocfile,'r');\n\treloc = [line.split() for line in f]\n\tf.close()\n\t\n\t# Read original events into memory\n\tf=open(options.locfile,'r');\n\t#loc = [map(float, line.split()) for line in f]\t# if I wanted all values as floats\n\tloc = [line.split() for line in f]\n\tf.close()\n\tlocindex=[a[0] for a in loc]\t# return list of line indices\n\n\tprint('{:20s} has {:d} events'.format(options.locfile, len(loc)) )\n\tprint('{:20s} has {:d} events'.format(options.relocfile,len(reloc)))\n\t\n\tmpdLat=1852*60\t# meters per degree latitude\n\tbaseLat=float(loc[0][1])\n\tlonmult=math.cos(baseLat*math.pi/180)\n\tprint(\"Base latitude = {:8.4f}, lon multiplier = {:.4f}\".format(baseLat,lonmult))\n\tmpdLon=mpdLat*lonmult\n\t\n\tmag_powerfact=3;\tmag_ref=2;\t# magnitude for 1 cm circle\n\tmagdivisor=pow(mag_powerfact,mag_ref)\n\t# Print original events in GMT format\n\tf=open(locXY,'w')\n\tfor line in loc :\n\t\tmagsize=pow(mag_powerfact,float(line[16]))/magdivisor\n\t\tf.write(\"{} {} {:8.3f} {:8.5f} {:8.5f}\\n\".format(\n\t\t\t\t\tline[2],line[1],magsize,float(line[7])/mpdLon, float(line[8])/mpdLat))\n\tf.close()\n\t\n\t# Write relocated events in GMT format\n\tf=open(relocXY,'w')\n\tif options.plotConnect :\t# connect original and new locations\n\t\tfc=open(connectFile,'w')\n\tfor relocLine in reloc :\n\t\tprintLine=True\n\t\tif options.uncertlimit > 0 :\n\t\t\tif float(relocLine[7]) > options.uncertlimit :\n\t\t\t\tprintLine=False\n\t\t\telif float(relocLine[8]) > options.uncertlimit :\n\t\t\t\tprintLine=False\n\t\t\tif printLine==False:\n\t\t\t\tprint('#{:5s}: Rejected relocated because x or y error > {:g} meters: x={:5s} y={:5s}'.format(\n\t\t\t\t\t\trelocLine[0],options.uncertlimit,relocLine[7],relocLine[8]))\n# \t\telif ~options.plotAll :\t# comparing to original's error doesn't work because original has zero error????\n# \t\t\ti = locindex.index(relocLine[0])\n# \t\t\t#print(i,relocLine[0])\n# \t\t\tlocLine=loc[i]\n# \t\t\tif locLine[0] != relocLine[0]:\n# \t\t\t\tprint(\"ERROR, reloc and loc line #s don't match!!! ({} and {})\".format(relocLine[0],locLine[0]));\n# \t\t\t\tsys.exit(2)\n# \t\t\tif float(locLine[7]) < float(relocLine[7]) :\t# original x error smaller than relocated\n# \t\t\t\tprintLine=False\n# \t\t\telif float(locLine[8]) < float(relocLine[8]):\n# \t\t\t\tprintLine=False\n# \t\t\tif printLine==False:\n# \t\t\t\tprint('Rejected relocated because worse than original')\n# \t\t\t\tprint('Original',locLine)\n# \t\t\t\tprint('Relocated',relocLine)\n\t\tif options.plotConnect :\t# connect original and new locations\n\t\t\ti = locindex.index(relocLine[0])\n\t\t\t#print(i,relocLine[0])\n\t\t\tlocLine=loc[i]\n\t\t\tif locLine[0] != relocLine[0]:\n\t\t\t\tprint(\"ERROR, reloc and loc index #s don't match!!! ({} and {})\".format(relocLine[0],locLine[0]));\n\t\t\tfc.write(\"{} {}\\n{} {}\\n>\\n\".format(locLine[2],locLine[1],relocLine[2],relocLine[1]))\n\t\tif printLine :\n\t\t\tmagsize=pow(mag_powerfact,float(relocLine[16]))/magdivisor\n\t\t\tf.write(\"{} {} {:8.3f} {:8.5f} {:8.5f}\\n\".format(\n\t\t\t\t\trelocLine[2],relocLine[1],magsize,\n\t\t\t\t\tfloat(relocLine[7])/mpdLon, float(relocLine[8])/mpdLat) )\n\tf.close()\n\tif options.plotConnect :\t# connect original and new locations\n\t\tfc.close()\n\n\t\n\t# Run GMT\n\tprocess = subprocess.Popen(\"cat {} {} | minmax -I1m\".format(locXY,relocXY),\n\t\t\t\tshell=True, stdout=subprocess.PIPE, universal_newlines=True)\n\trange=process.communicate()[0].strip();\n\tprint(range)\n\tprint(locXY,relocXY)\n\tprocess=subprocess.Popen(\"psbasemap -JM15c+ {} -B100m -P -K > {}\".format(range,psfile),shell=True);\n\tprocess.communicate()[0]\t# Waits until end of last process\n\tprocess=subprocess.Popen(\"psxy {} -JM -R -Sc0.1c -Glightgrey -Wlightgrey -O -K >> {}\".format(locXY,psfile),shell=True);\n\tprocess=subprocess.Popen(\"pscoast -JM -R -Df -W -O -K >> {}\".format(psfile),shell=True);\n\tprocess.communicate()[0]\t# Waits until end of last process\n\tif options.plotConnect :\n\t\tprocess=subprocess.Popen(\"psxy {} -JM -R -M -W1,darkgrey -O -K >> {}\".format(connectFile,psfile),shell=True);\n\t\tprocess.communicate()[0]\t# Waits until end of last process\n\t\t\n\tprocess=subprocess.Popen(\"psxy {} -JM -R -Sc0.1c -Wblack -O >> {}\".format(relocXY,psfile),shell=True);\n\tprocess.communicate()[0]\t# Waits until end of last process\n\tprocess=subprocess.Popen(\"ps2pdf {} {}\".format(psfile,options.pdffile),shell=True);\n\tprocess.communicate()[0]\t# Waits until end of last process\n\tprocess=subprocess.Popen(\"convert -density 300 {} -trim -alpha off {}\".format(options.pdffile,options.pngfile),shell=True);\n\tprocess.communicate()[0]\t# Waits until end of last process\n\tprocess=subprocess.Popen(\"rm {}\".format(psfile),shell=True);\n\tprocess.communicate()[0]\t# Waits until end of last process\n\tprocess=subprocess.Popen(\"open {}\".format(options.pngfile),shell=True);","def eda_eventrelated(epochs, silent=False):\n # Sanity checks\n epochs = _eventrelated_sanitizeinput(epochs, what=\"eda\", silent=silent)\n\n # Extract features and build dataframe\n data = {} # Initialize an empty dict\n for i in epochs.keys():\n\n data[i] = {} # Initialize an empty dict for the current epoch\n\n # Maximum phasic amplitude\n data[i] = _eda_eventrelated_eda(epochs[i], data[i])\n\n # Detect activity following the events\n if np.any(epochs[i][\"SCR_Peaks\"][epochs[i].index > 0] == 1) and np.any(\n epochs[i][\"SCR_Onsets\"][epochs[i].index > 0] == 1\n ):\n data[i][\"EDA_SCR\"] = 1\n else:\n data[i][\"EDA_SCR\"] = 0\n\n # Analyze based on if activations are present\n if data[i][\"EDA_SCR\"] != 0:\n data[i] = _eda_eventrelated_scr(epochs[i], data[i])\n else:\n data[i][\"SCR_Peak_Amplitude\"] = np.nan\n data[i][\"SCR_Peak_Amplitude_Time\"] = np.nan\n data[i][\"SCR_RiseTime\"] = np.nan\n data[i][\"SCR_RecoveryTime\"] = np.nan\n\n # Fill with more info\n data[i] = _eventrelated_addinfo(epochs[i], data[i])\n\n df = _eventrelated_sanitizeoutput(data)\n\n return df","def operation_on_events(path_to_data_dir, list_of_test_id, operation, num_of_proc=1):\n\ttest_id = [\"test%s\"%i for i in list_of_test_id]\n\tpool = Pool(processes = num_of_proc)\n\tpath_to_final_selected_events = path_to_data_dir + \"final_selected_events.json\"\n\tif os.path.exists(path_to_final_selected_events):\n\t\tfinal_selected_events = json.load(open(path_to_final_selected_events,\"r\"))\n\t\tfinal_interested_events = []\n\t\tfor event in final_selected_events:\n\t\t\tif event[0] in test_id:\n\t\t\t\tfinal_interested_events.append(event)\n\telse:\n\t\tfinal_interested_events = []\n\t\tfor test in list_of_test_id:\n\t\t\tpath_to_curr_test = data_dir_to_test_dir(path_to_data_dir, test)\n\t\t\tpath_to_test_result = path_to_curr_test +\"/results\"\n\t\t\tpath_to_event_list = path_to_test_result + \"/selected_events.json\"\n\t\t\tif os.path.exists(path_to_event_list):\n\t\t\t\tevent_list = json.load(open(path_to_event_list,\"r\"))\n\t\t\t\tfor value in event_list.values():\n\t\t\t\t\tevent = [\"test%s\"%test,[value[0],value[1],value[2]]]\n\t\t\t\t\tfinal_interested_events.append(event)\n\t\t\telse:\n\t\t\t\tprint \"skip current test:\", \"test%s\"%test, \"there is no selected events\"\n\t\n\t# if function operation has no return value, it will return a list of Nones\n\tresult_list = pool.map(operation,final_interested_events)\n\treturn result_list","def simulate(self, **kwargs):\n # First, update keys with new values\n for key, value in kwargs.items():\n if f\"_{key}\" in self.__dict__.keys():\n setattr(self, key, value)\n\n if self.as_version != EnergyPlusVersion(self.idd_version):\n raise EnergyPlusVersionError(\n None, self.idfname, EnergyPlusVersion(self.idd_version), self.as_version\n )\n\n start_time = time.time()\n include = self.include\n if isinstance(include, str):\n include = Path().abspath().glob(include)\n elif include is not None:\n include = [Path(file) for file in include]\n\n # check if a weather file is defined\n if not getattr(self, \"epw\", None):\n raise EnergyPlusWeatherError(\n f\"No weather file specified with {self}. Set 'epw' in IDF(\"\n f\"filename, epw='weather.epw').simulate() or in IDF.simulate(\"\n f\"epw='weather.epw')\"\n )\n\n # Todo: Add EpMacro Thread -> if exist in.imf \"%program_path%EPMacro\"\n # Run the expandobjects program if necessary\n with TemporaryDirectory(\n prefix=\"expandobjects_run_\",\n suffix=None,\n dir=self.output_directory,\n ) as tmp:\n # Run the ExpandObjects preprocessor program\n expandobjects_thread = ExpandObjectsThread(self, tmp)\n expandobjects_thread.start()\n expandobjects_thread.join()\n e = expandobjects_thread.exception\n if e is not None:\n raise e\n\n # Run the Basement preprocessor program if necessary\n with TemporaryDirectory(\n prefix=\"runBasement_run_\",\n suffix=None,\n dir=self.output_directory,\n ) as tmp:\n basement_thread = BasementThread(self, tmp)\n basement_thread.start()\n basement_thread.join()\n e = basement_thread.exception\n if e is not None:\n raise e\n\n # Run the Slab preprocessor program if necessary\n with TemporaryDirectory(\n prefix=\"runSlab_run_\",\n suffix=None,\n dir=self.output_directory,\n ) as tmp:\n slab_thread = SlabThread(self, tmp)\n slab_thread.start()\n slab_thread.join()\n e = slab_thread.exception\n if e is not None:\n raise e\n\n # Run the energyplus program\n with TemporaryDirectory(\n prefix=\"eplus_run_\",\n suffix=None,\n dir=self.output_directory,\n ) as tmp:\n running_simulation_thread = EnergyPlusThread(self, tmp)\n running_simulation_thread.start()\n running_simulation_thread.join()\n e = running_simulation_thread.exception\n if e is not None:\n raise e\n return self","def event(self, obj, mode=\"r\", clear=False, data=0):\n note = 0\n if mode == \"r\":\n event = (obj.fileno(), select.KQ_FILTER_READ)\n elif mode == \"w\":\n event = (obj.fileno(), select.KQ_FILTER_WRITE)\n elif mode == \"t\":\n event = (obj, select.KQ_FILTER_TIMER)\n data = int(data * 1000)\n elif mode.startswith(\"p\"):\n event = (obj.pid, select.KQ_FILTER_PROC)\n if \"f\" in mode[1:]:\n note |= select.KQ_NOTE_FORK\n elif \"e\" in mode[1:]:\n note |= select.KQ_NOTE_EXEC\n elif \"-\" in mode[1:]:\n if ISSUE11973:\n # HACK: work around python bug!!!\n note -= select.KQ_NOTE_EXIT\n else:\n note |= select.KQ_NOTE_EXIT\n elif mode == \"s\":\n event = (obj, select.KQ_FILTER_SIGNAL)\n else:\n raise ValueError(\"unknown event mode\")\n\n if clear:\n try:\n self._kq_events.pop(event)\n self._kq.control((select.kevent(event[0], event[1],\n select.KQ_EV_DELETE),), 0)\n except KeyError:\n raise KeyError(\"no event registered\")\n else:\n if event not in self._kq_events:\n from .signal import Signal\n kevent = select.kevent(event[0], event[1],\n select.KQ_EV_ADD | select.KQ_EV_ENABLE,\n note, data)\n self._kq.control((kevent,), 0)\n self._kq_events[event] = Signal()\n return self._kq_events[event]","def generalization_feature_selection(data1, data2, measure, cutoff):\n cor1 = np.corrcoef(np.transpose(data1))\n cor2 = np.corrcoef(np.transpose(data2))\n num = data1.shape[1]\n cor = []\n if measure == \"pearson\":\n for i in range(num):\n cor.append(\n np.corrcoef(\n np.vstack(\n (\n list(cor1[:i, i]) + list(cor1[(i + 1) :, i]),\n list(cor2[:i, i]) + list(cor2[(i + 1) :, i]),\n )\n )\n )[0, 1]\n )\n elif measure == \"ccc\":\n for i in range(num):\n cor.append(\n calculate_concordance_correlation_coefficient(\n np.array(list(cor1[:i, i]) + list(cor1[(i + 1) :, i])),\n np.array(list(cor2[:i, i]) + list(cor2[(i + 1) :, i])),\n )\n )\n cor = np.array(cor)\n fid = np.argsort(-cor)[: int(cutoff)]\n return fid","def ha(sf,sfn,mX,pX,params,verbose=[],onlySelected=False,hc=-2,div=8,L=30,fs=44100,gt=[]):\r\n \r\n M,N,H,B = params\r\n \r\n idx = candidSelection(sf,t=0.025,hw=25) \r\n idx = np.concatenate((np.zeros(1),idx,np.array([sf.shape[0]])))\r\n idx_orig = idx.copy()\r\n mask = np.ones(idx.shape)\r\n mask[0]=0\r\n mask[-1]=0\r\n errors = np.zeros(mX.shape[0])\r\n scores = np.zeros(idx.shape)\r\n freqs = []\r\n \r\n tFlag = False\r\n vFlag = False # flag to enable prints and plots\r\n \r\n rms = np.sum(mX,axis=1)\r\n rms = rms-np.mean(rms)\r\n rms = rms/np.max(rms)\r\n rms = savgol_filter(rms,3,1)\r\n \r\n rms_t = -0.1\r\n \r\n # sending every onset candidate to harmonic analysis\r\n for i in range(len(idx)-2,0,-1):\r\n \r\n if onlySelected:\r\n if idx[i] not in verbose:\r\n continue\r\n \r\n b = int((idx[i]-(10240/H)) if (idx[i]>(idx[i-1]+(10240/H))) else idx[i-1])\r\n e = int((idx[i]+(10240/H)) if (idx[i]<(idx[i+1]-(10240/H))) else idx[i+1])\r\n \r\n \r\n if np.mean(rms[int(idx[i]):int(idx[i])+50])<rms_t:\r\n continue\r\n \r\n onst = int(idx[i]-b)\r\n pmX = np.copy(mX[b:e])\r\n \r\n\r\n if idx[i] in verbose:\r\n print(\"\\nOnset candidate:\")\r\n print(\"onset frame: %d\" %idx[i])\r\n print(\"sf onset number: %d\" %i)\r\n vFlag = True\r\n y = MRStftSynth(pmX,pX[b:e],M,H,B)\r\n print(\"synthesized sound\")\r\n ipd.display(ipd.Audio(data=y, rate=fs))\r\n \r\n if vFlag:\r\n print(\"STFT around candidate\")\r\n plt.pcolormesh(np.arange(pmX.shape[0]), np.arange(pmX.shape[1]), np.transpose(pmX))\r\n plt.show()\r\n \r\n print(\"filtered spectral flux\")\r\n plt.plot(sf[b:e])\r\n plt.show()\r\n print(\"raw spectral flux\")\r\n plt.plot(sfn[b:e])\r\n plt.show()\r\n \r\n allErrors,allf0s,pmXv = f0detection(pmX,pX[b:e],sfn[b:e],-100,10,onst,vFlag,hc,div,params,fs,tFlag)\r\n\r\n aL = np.min((e-idx[i]/2,L)) \r\n segments = getSegments(allf0s,allErrors,onst,pmX,vFlag)\r\n scores[i],freq,segmentScores = harmonicScore(segments,aL,vFlag,tFlag)\r\n freqs.append(freq)\r\n \r\n if scores[i]<1: # prevent rejected candidates from creating boundary for adjacent onset\r\n idx[i] = sf.shape[0]\r\n \r\n if vFlag:\r\n print(\"Score for this onset: %d\" %scores[i])\r\n \r\n if tFlag and scores[i]<1:\r\n pred_time = np.abs(idx[i]*(H/fs))\r\n closest_gt_ind = np.argmin(pred_time-gt)[0]\r\n if np.abs(gt[closest_gt_ind]-pred_time)<0.05:\r\n if score[i]>1:\r\n tp.append[idx[i]]\r\n if score[i]<1:\r\n fn.append[idx[i]]\r\n \r\n print(\"STFT around onset\")\r\n plt.pcolormesh(np.arange(pmX.shape[0]), np.arange(pmX.shape[1]), np.transpose(pmX))\r\n plt.show()\r\n \r\n y = MRStftSynth(pmXv,pX,M,H,B)\r\n ipd.display(ipd.Audio(data=y, rate=fs))\r\n \r\n plt.pcolormesh(np.arange(pmXv.shape[0]), np.arange(pmXv.shape[1]), np.transpose(pmXv))\r\n plt.show()\r\n\r\n vFlag = False\r\n tFlag = False\r\n \r\n avg = np.mean(scores)\r\n mask[scores<1] = 0\r\n result = idx_orig[mask==1]\r\n return idx_orig[1:-1],result,freqs,scores[1:-1]","def get_picker_cmd(picker_args=None, fuzzy=True):\n\n if SYSTEM_NAME == \"Linux\":\n args = ['rofi', '-sort', '-no-levenshtein-sort']\n if fuzzy:\n args += ['-matching', 'fuzzy']\n args += ['-dmenu', '-p', \"Select Figure\", '-format', 's', '-i',\n '-lines', '5']\n elif SYSTEM_NAME == \"Darwin\":\n args = [\"choose\"]\n else:\n raise ValueError(\"No supported picker for {}\".format(SYSTEM_NAME))\n\n if picker_args is not None:\n args += picker_args\n\n return [str(arg) for arg in args]","def processElementClick(self, *argv):\n if argv[0]: #argv[0] is 0 for a click on an atom\n return\n hits = argv[:-1]\n event = argv[-1]\n if event.button() == QtCore.Qt.LeftButton:\n if event.modifiers() & QtCore.Qt.CTRL: #Multiple selection mode\n atom = CAlphaRenderer.getAtomFromHitStack(self.renderer, hits[0], False, *hits[1:])\n if atom.getResSeq() in self.main_chain.getSelection():\n self.main_chain.setSelection(removeOne=atom.getResSeq())\n else:\n self.main_chain.setSelection(addOne=atom.getResSeq())\n print self.main_chain.getSelection()\n else:\n atom = CAlphaRenderer.getAtomFromHitStack(self.renderer, hits[0], True, *hits[1:])\n print 'Residue #:', atom.getResSeq()\n self.main_chain.setSelection([atom.getResSeq()])\n self.emitAtomSelectionUpdated(self.main_chain.getSelection())\n \n if event.button() == QtCore.Qt.RightButton and self.centerOnRMB:\n self.centerOnSelectedAtoms(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6])","def get_actors_by_area_picker(gui, area_picker, model_name, is_nids=True, is_eids=True,\n representation='points', add_actors=False):\n frustum = area_picker.GetFrustum() # vtkPlanes\n\n ugrid, eids, nids = get_depth_ids(\n gui, frustum, model_name=model_name,\n is_nids=is_nids, is_eids=is_eids,\n representation=representation)\n\n actor = gui.create_highlighted_actor(\n ugrid, representation=representation, add_actor=add_actors)\n actors = [actor]\n return actors, eids, nids","def xmain(bids_dir, analysis_dir, freesurfer_dir, output_dir,\n acquisition='clinical', measure_modality=\"\", measure_column=\"\"):\n img_dir = output_dir / ELECSURF_DIR\n rmtree(img_dir, ignore_errors=True)\n img_dir.mkdir(exist_ok=True, parents=True)\n\n for electrode_path in find_in_bids(bids_dir, generator=True, acquisition=acquisition, modality='electrodes', extension='.tsv'):\n lg.debug(f'Reading electrodes from {electrode_path}')\n elec = Electrodes(electrode_path)\n fs = Freesurfer(freesurfer_dir / ('sub-' + elec.subject))\n\n labels = None\n if measure_modality != \"\":\n try:\n ecog_file = find_in_bids(\n analysis_dir,\n subject=elec.subject,\n modality=measure_modality,\n extension='.tsv')\n except FileNotFoundError as err:\n lg.warning(err)\n continue\n\n lg.debug(f'Reading {measure_column} from {ecog_file}')\n ecog_tsv = read_tsv(ecog_file)\n\n labels = [x['name'] for x in elec.electrodes.tsv]\n labels, vals = read_channels(ecog_tsv, labels, measure_column)\n\n else:\n vals = None\n\n v = plot_electrodes(elec, fs, labels, vals)\n\n png_file = img_dir / replace_underscore(elec.get_filename(), 'surfaceplot.png')\n lg.debug(f'Saving electrode plot on {png_file}')\n v.save(png_file)\n v.close()","def modelfactors(trace_files: List[str], trace_processes: Dict):\n traces = [load(file) for file in trace_files]\n df_mfactors = pd.DataFrame(columns=MOD_FACTORS_DOC.values())\n reference = True\n for (hdf5_file, trace, cpus) in zip(trace_files, traces, trace_processes.values()):\n MOD_FACTORS_VAL['num_processes'] = cpus\n print(\n f\"==INFO== Analysing {hdf5_file} ({MOD_FACTORS_VAL['num_processes']} processes, {human_readable(os.path.getsize(hdf5_file))})\")\n\n # Computes raw data\n ipc, freq, runtime, runtime_id, useful_av, useful_max, useful_tot, useful_id, useful_inst, useful_cyc = get_raw_data(\n trace, cmdl_args)\n\n MOD_FACTORS_VAL['ipc'] = ipc\n MOD_FACTORS_VAL['freq'] = freq\n MOD_FACTORS_VAL['runtime'] = runtime\n MOD_FACTORS_VAL['runtime_id'] = runtime_id\n MOD_FACTORS_VAL['useful_av'] = useful_av\n MOD_FACTORS_VAL['useful_max'] = useful_max\n MOD_FACTORS_VAL['useful_tot'] = useful_tot\n MOD_FACTORS_VAL['useful_id'] = useful_id\n MOD_FACTORS_VAL['useful_ins'] = useful_inst\n MOD_FACTORS_VAL['useful_cyc'] = useful_cyc\n\n # Computes efficiencies after getting the raw data\n parallel_eff, load_balance, comm_eff, serial_eff, transfer_eff = get_efficiencies(\n MOD_FACTORS_VAL['runtime'],\n MOD_FACTORS_VAL['runtime_id'],\n MOD_FACTORS_VAL['useful_av'],\n MOD_FACTORS_VAL['useful_max'],\n MOD_FACTORS_VAL['useful_id'],\n MOD_FACTORS_VAL['comp_scale'])\n\n MOD_FACTORS_VAL['parallel_eff'] = parallel_eff\n MOD_FACTORS_VAL['load_balance'] = load_balance\n MOD_FACTORS_VAL['comm_eff'] = comm_eff\n MOD_FACTORS_VAL['serial_eff'] = serial_eff\n MOD_FACTORS_VAL['transfer_eff'] = transfer_eff\n\n # Adds the new row with the raw data and efficiencies to the dataframe\n df_mfactors.loc[len(df_mfactors), :] = list(MOD_FACTORS_VAL.values())\n\n # Computes scalabilities\n df_mfactors = get_scalabilities(df_mfactors, cmdl_args)\n\n return df_mfactors","def finder_selector(module_name):\n if module_name.lower() == 'keras':\n return KerasResultFinder\n else:\n return ResultFinder","def pions ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n ##\n if self['NOPIDHADRONS'] :\n from StandardParticles import StdAllNoPIDsPions as inpts\n pioncut = self['PionCut']\n else :\n from StandardParticles import StdAllLooseANNPions as inpts\n pioncut = \"(%s)&(%s)\" % ( self['PionCut'] , self['PionPIDCut'] ) \n ##\n return self.make_selection (\n 'Pion' ,\n FilterDesktop ,\n [ inpts ] ,\n Code = pioncut ,\n )","def choose_algorithm(self,\n algorithm: str) -> None:\n # Initialize the empty string for selected algorithm\n self.selected_algorithm = ''\n\n # Executing the selected algorithm with respect to value of string\n if algorithm is not None:\n # First string value indicates the backbone of approach\n backbone = algorithm.split('-')[0]\n # Check the possible options\n if backbone == 'KNN' and len(algorithm.split('-')) == 3:\n print('KNN model based collaborative approach is selected!')\n similarity_measure = algorithm.split('-')[1]\n user_based = algorithm.split('-')[2]\n if (similarity_measure == 'cosine' or similarity_measure == 'msd' or similarity_measure == 'pearson' or similarity_measure == 'pearson_baseline') and (user_based == 'user'):\n self.selected_algorithm = KNNBaseline(sim_options={'name': similarity_measure,\n 'user_based': True})\n elif (similarity_measure == 'cosine' or similarity_measure == 'msd' or similarity_measure == 'pearson' or similarity_measure == 'pearson_baseline') and (user_based == 'item'):\n self.selected_algorithm = KNNBaseline(sim_options={'name': similarity_measure,\n 'user_based': False})\n else:\n raise ValueError('The given parameters {} for KNN algorithm is not recognized. Please check the propoer format'.format(str(backbone) + '-' + str(similarity_measure) + '-' + str(user_based)))\n elif backbone == 'SVD' and len(algorithm.split('-')) == 3:\n print('SVD model based collaborative approach is selected!')\n epoch = int(algorithm.split('-')[1])\n learning_rate = float(algorithm.split('-')[2])\n self.selected_algorithm = SVD(n_epochs=epoch, lr_all=learning_rate)\n elif backbone == '':\n raise ValueError('Please give an algorithm! Algorithm cannot be left empty')\n else:\n raise ValueError(\n 'The given algorithm format {} is not recognized. Please check the propoer format'.format(\n str(backbone)))\n elif algorithm is None:\n # Raise an error message for None value for algorithm\n raise ValueError('Please give an algorithm! Algorithm cannot be left empty')\n return","def select_features(self):\r\n \r\n features_list = list(self.feed_data.columns.values)\r\n features_list.remove(\"min_time\")\r\n thisrace = self.config.race_to_predict\r\n\r\n #if never ran race before, don't include these variables in feature\r\n #selection, they're just 0's anyway\r\n if self.config.first_time_running_race == True:\r\n unuseable_columns = [('min_time', thisrace),('std', thisrace),('num_races', thisrace),\r\n ('rainfall', thisrace),\r\n ('temp', thisrace),\r\n ('wind', thisrace),\r\n ('metersup', thisrace), \r\n 'sex_W']\r\n else:\r\n #drop this column...probs should have removed it earlier. \r\n unuseable_columns = ['sex_W']\r\n #print(features_list)\r\n for element in unuseable_columns:\r\n features_list.remove(element)\r\n data_with_all_feats = self.feed_data.drop(unuseable_columns,axis=1)\r\n colstodrop = features_list\r\n thiscols = []\r\n data_with_current_feats = data_with_all_feats.drop(features_list,axis=1)\r\n checkfit=100.0\r\n scores = []\r\n dropped_cols = []\r\n loopgain =True\r\n #mymod = RandomForestRegressor(n_estimators=80, oob_score = True, max_depth=10,\r\n # min_samples_split = 25, criterion='mse')\r\n thisloopfeatures_list = features_list\r\n curcols = data_with_current_feats.columns\r\n countgain=0\r\n #print(\"cc\",curcols)\r\n while loopgain == True:\r\n thisloopscore=100.0\r\n for fet in thisloopfeatures_list:\r\n data_with_current_feats[fet] = data_with_all_feats[fet]\r\n etrain=data_with_current_feats.sample(frac=0.8,random_state=200)\r\n etest=data_with_current_feats.drop(etrain.index)\r\n y = etrain.pop('min_time')\r\n ytest = etest.pop('min_time')\r\n #print(y)\r\n model = RandomForestRegressor(n_estimators=80, oob_score = True, max_depth=15,\r\n min_samples_split = 12, criterion='mse')\r\n model.fit(etrain,y)\r\n\r\n PRED = model.predict(etrain)\r\n predscore = self.mean_absolute_percentage_error(y,PRED)#= r2_score(y,PRED)\r\n oobs = self.mean_absolute_percentage_error(y,model.oob_prediction_)\r\n scores.append(oobs)\r\n if ((thisloopscore - oobs) > 0.0):\r\n thisloopscore = oobs\r\n fetwinner = fet\r\n data_with_current_feats.drop(fet,axis=1,inplace=True)\r\n etrain.drop(fet,axis=1,inplace=True)\r\n\r\n data_with_current_feats[fetwinner] = data_with_all_feats[fetwinner]\r\n etrain=data_with_current_feats.sample(frac=0.8,random_state=200)\r\n etest=data_with_current_feats.drop(etrain.index)\r\n y = etrain.pop('min_time')\r\n ytest = etest.pop('min_time')\r\n #print(y)\r\n model = RandomForestRegressor(n_estimators=80, oob_score = True, max_depth=30,\r\n min_samples_split = 12,min_samples_leaf =7, criterion='mse')\r\n model.fit(etrain,y)\r\n\r\n PRED = model.predict(etrain)\r\n predscore = self.mean_absolute_percentage_error(y,PRED)#= r2_score(y,PRED)\r\n #print(fetwinner,predscore)\r\n oobs = self.mean_absolute_percentage_error(y,model.oob_prediction_)\r\n scores.append(oobs)\r\n #print(fetwinner,\"~\",oobs)\r\n thisloopfeatures_list.remove(fetwinner)\r\n if ((checkfit-oobs)>0.0001):\r\n checkfit = oobs\r\n curcols = data_with_current_feats.columns\r\n #print(curcols)\r\n else:\r\n break\r\n\r\n\r\n self.final_df = self.feed_data[data_with_current_feats.columns]\r\n self.Xtrain=self.final_df.sample(frac=0.8,random_state=200)\r\n self.Xtest=self.final_df.drop(self.Xtrain.index)#\r\n self.ytrain = self.Xtrain.pop('min_time')\r\n self.ytest = self.Xtest.pop('min_time')\r\n self.model= RandomForestRegressor(n_estimators=80, oob_score = True, max_depth=30,\r\n min_samples_split = 12,min_samples_leaf =7, criterion='mse')\r\n self.model.fit(self.Xtrain,self.ytrain)\r\n #print(y)\r\n return","def __init__ (self, name=\"TrigEFMissingETCosmicMonitoring_other\"):\n super(TrigEFMissingETCosmicMonitoring_other, self).__init__(name)\n self.defineTarget(\"Cosmic\")\n # measurement\n self.Histograms = [ hMET_log, hSumEt_log ]\n self.Histograms += [ hMET_lin ]\n self.Histograms += [ hMETPhi ]","def selectName(self, absdirname):\n\n if opts.quiet: print \" \", self._salts + self._calts\n\n #\n # choose one representation for the imagepage\n #\n\n # 1) the first of the affinity repn which is an image file\n found = 0\n for ref in opts.repn_affinity:\n for f in self._salts + self._calts:\n if ref.search(f):\n ff = self._base + opts.separator + f\n paf = join(absdirname, ff)\n if imgwhat(paf, opts.fast):\n if f in self._salts:\n self._salts.remove(f)\n self._ext = f\n else:\n self._calts.remove(f)\n (self._repn, self._ext) = splitext(f)\n\n if opts.quiet: print \" choosing affinity '%s'\" % f\n return 1\n else:\n if opts.quiet: print \" ignoring non-image '%s'\" % f\n\n # 2) the first of the base files which is an image file\n if opts.use_repn:\n # 3) with the first of the alternate representations which\n # is an image file.\n eee = self._salts + self._calts\n else:\n eee = self._salts\n\n for f in eee:\n if not f.startswith('.'): f = opts.separator + f\n ff = self._base + f\n paf = join(absdirname, ff)\n if imgwhat(paf, opts.fast):\n if f in self._salts:\n self._salts.remove(f)\n self._ext = f\n else:\n self._calts.remove(f)\n (self._repn, self._ext) = splitext(f)\n# if opts.quiet: print \" choosing imagefile '%s'\" % f\n return 1\n else:\n if opts.quiet: print \" ignoring non-image '%s'\" % f\n\n# if opts.quiet: print \" no imagepage for base '%s'\" % self._base\n return 0","def main():\r\n option_parser, opts, args = parse_command_line_parameters(**script_info)\r\n\r\n sff_files = opts.sff_fps\r\n\r\n for f in sff_files:\r\n if (not exists(f)):\r\n option_parser.error(('Flowgram file path does not exist:\\n %s \\n' +\r\n 'Pass a valid one via -i.') % f)\r\n outdir = opts.output_dir\r\n\r\n create_dir(outdir, fail_on_exist=not opts.force)\r\n\r\n log_fh = None\r\n\r\n if (not (opts.primer or opts.map_fname)):\r\n raise ApplicationError(\"Either mapping file or primer required\")\r\n # Read primer from Meta data file if not set on command line\r\n if not opts.primer:\r\n mapping_data, header, comments = \\\r\n parse_mapping_file(open(opts.map_fname, \"U\"))\r\n\r\n index = header.index(\"LinkerPrimerSequence\")\r\n all_primers = set(array(mapping_data)[:, index])\r\n\r\n if len(all_primers) != 1:\r\n raise ValueError(\"Currently only data sets with one primer are allowed.\\n\" +\r\n \"Make separate mapping files with only one primer, re-run split_libraries and\\n\"\r\n + \"denoise with each split_library output separately.\")\r\n primer = list(all_primers)[0]\r\n last_char = primer[-1]\r\n if(last_char not in \"ACGT\"):\r\n raise ValueError(\"We currently do not support primer with \" +\r\n \"degenerate bases at it's 3' end.\")\r\n\r\n else:\r\n primer = opts.primer\r\n\r\n centroids, cluster_mapping = fast_denoiser(opts.sff_fps, opts.fasta_fp,\r\n outdir, opts.num_cpus, primer,\r\n titanium=opts.titanium)\r\n\r\n # store mapping file and centroids\r\n result_otu_path = '%s/denoised_clusters.txt' % outdir\r\n of = open(result_otu_path, 'w')\r\n for i, cluster in cluster_mapping.iteritems():\r\n of.write('%s\\t%s\\n' % (str(i), '\\t'.join(cluster)))\r\n of.close()\r\n\r\n result_fasta_path = '%s/denoised_seqs.fasta' % outdir\r\n oh = open(result_fasta_path, 'w')\r\n write_Fasta_from_name_seq_pairs(centroids, oh)"],"string":"[\n \"def execute(module_name):\\n\\n global clf_re\\n global filter_function\\n global remap_pairs\\n\\n # Get the window date to process events\\n (from_date, until_date) = rules_common.window_dates(module_name)\\n\\n # Get the files to process, lines and mark lines\\n (files, total_lines, mark_lines) = \\\\\\n rules_common.files_to_process(module_name)\\n\\n # Get the remap_pairs evaluated from the options\\n remap_pairs = eval('[' + rule_manager.get_property(None, module_name,\\n 'remap_pairs') + \\\\\\n ']')\\n remap_pairs = [(re.compile(x), y) for (x, y) in remap_pairs]\\n\\n # Fetch the word to detect an embeddedq to use it later\\n mark_word = rule_manager.get_property(None, module_name, 'mark_word')\\n\\n # Loop over all the given args\\n total_counter = 0\\n for file_annotation in files:\\n # Get the file name and (if it exists, the date of the last event)\\n filename = file_annotation[0]\\n last_event = datetime.datetime.min\\n if len(file_annotation[1]) != 0:\\n last_event = datetime.datetime.strptime(file_annotation[1][0], \\n '%Y-%m-%d %H:%M:%S')\\n new_last_event = last_event\\n\\n data_in = codecs.open(filename, 'r', encoding = 'utf8', \\n errors = 'replace')\\n old = ''\\n counter = 0\\n for line in data_in:\\n\\n counter += 1\\n total_counter += 1\\n \\n if total_counter % mark_lines == 0:\\n print >> sys.stderr, '+',\\n sys.stderr.flush()\\n\\n line = line[:-1]\\n \\n fields = clf_re.match(line).groups()\\n\\n if fields[2] == '':\\n raise ValueError('Empty string' + line)\\n\\n # Translate date time of the event\\n dtime = datetime.datetime.strptime(fields[3].strip()[:-6], \\n '%d/%b/%Y:%H:%M:%S')\\n\\n if dtime <= last_event:\\n # Event is older than what has been recorded in the\\n # detect_new_files. skip\\n continue\\n\\n if dtime < from_date or dtime > until_date:\\n # Ignore event because it is outside the given window\\n continue\\n \\n # Split the url to match and see if it has the mark word\\n (method, url, protocol) = fields[4].split()\\n\\n # Only 404 that have the mark word substring are accepted\\n if fields[5] != '404' or url.find(mark_word) == -1:\\n continue\\n\\n # If there is a filter function and returns None, skip this event\\n if filter_function != None and filter_function(fields) == None:\\n continue\\n\\n # Record the event with the highest datetime.\\n if dtime > new_last_event:\\n new_last_event = dtime\\n\\n # At this point we have an event of an embedded question.\\n\\n event_pairs = process_log_line(url, mark_word)\\n \\n for (event_suffix, question_id) in event_pairs:\\n event = ('embedded_question_' + event_suffix, \\n dtime,\\n anonymize.find_or_encode_string(fields[2]),\\n [('application', 'unknown'), \\n ('url', url),\\n ('ip', fields[0]),\\n ('question_id', question_id)])\\n \\n event_output.out(event)\\n\\n data_in.close()\\n detect_new_files.update(None, module_name + '//' + filename, \\n [new_last_event])\\n\\n print >> sys.stderr\",\n \"def analyze(self, event):\\n electrons = self.inputCollection(event)\\n muons = Collection(event, \\\"Muon\\\")\\n triggerObjects = self.triggerObjectCollection(event)\\n\\n selectedElectrons = []\\n unselectedElectrons = []\\n \\n weight_reco_nominal = 1.\\n weight_reco_up = 1.\\n weight_reco_down = 1.\\n\\n weight_id_nominal = 1.\\n weight_id_up = 1.\\n weight_id_down = 1.\\n\\n for electron in electrons:\\n # https://twiki.cern.ch/twiki/bin/view/CMS/CutBasedElectronIdentificationRun2\\n if electron.pt>self.electronMinPt \\\\\\n and math.fabs(electron.eta)<self.electronMaxEta \\\\\\n and self.electronID(electron)\\\\\\n and self.triggerMatched(electron, triggerObjects):\\n\\n dxy = math.fabs(electron.dxy)\\n dz = math.fabs(electron.dz)\\n \\n if math.fabs(electron.eta) < 1.479 and (dxy>0.05 or dz>0.10):\\n unselectedElectrons.append(electron)\\n continue\\n elif dxy>0.10 or dz>0.20:\\n unselectedElectrons.append(electron)\\n continue\\n\\n #reject electron if close-by muon\\n if len(muons)>0:\\n mindr = min(map(lambda muon: deltaR(muon, electron), muons))\\n if mindr < 0.05:\\n unselectedElectrons.append(electron)\\n continue\\n\\n selectedElectrons.append(electron)\\n \\n #TODO: electron reco/ID SFs\\n \\n \\n else:\\n unselectedElectrons.append(electron)\\n\\n \\n if not Module.globalOptions[\\\"isData\\\"] and self.storeWeights:\\n \\n self.out.fillBranch(self.outputName+\\\"_weight_reco_nominal\\\", weight_reco_nominal)\\n self.out.fillBranch(self.outputName+\\\"_weight_reco_up\\\", weight_reco_up)\\n self.out.fillBranch(self.outputName+\\\"_weight_reco_down\\\", weight_reco_down)\\n\\n self.out.fillBranch(self.outputName+\\\"_weight_id_nominal\\\",weight_id_nominal)\\n self.out.fillBranch(self.outputName+\\\"_weight_id_up\\\",weight_id_up)\\n self.out.fillBranch(self.outputName+\\\"_weight_id_down\\\",weight_id_down)\\n\\n self.out.fillBranch(\\\"n\\\"+self.outputName,len(selectedElectrons))\\n\\n for variable in self.storeKinematics:\\n self.out.fillBranch(self.outputName+\\\"_\\\"+variable,map(lambda electron: getattr(electron,variable), selectedElectrons))\\n\\n setattr(event,self.outputName,selectedElectrons)\\n setattr(event,self.outputName+\\\"_unselected\\\",unselectedElectrons)\\n\\n return True\",\n \"def ElectronIsEMH4l2011SelectorConfig(theTool):\\n\\n theTool = GetTool(theTool)\\n\\n # the eta ranges\\n theTool.CutBinEta += [0.1, 0.6, 0.8, 1.15,\\n 1.37, 1.52, 1.81, 2.01, 2.37, 2.47]\\n\\n # range of ET bins for e-ID\\n theTool.CutBinET += [\\n 5.0*GeV, 10.0*GeV, 15.0*GeV, 20.0*GeV,\\n 30.0*GeV, 40.0*GeV, 50.0*GeV, 60.0*GeV,\\n 70.0*GeV, 80.0*GeV]\\n # cut on fraction of energy deposited in 1st sampling\\n theTool.CutF1 += [0.005]\\n\\n # cut on hadronic energy\\n theTool.CutHadLeakage += [\\n 0.031, 0.031, 0.021, 0.021, 0.019, 0.028, 0.065, 0.065, 0.046, 0.034, # < 5\\n 0.018, 0.018, 0.016, 0.015, 0.016, 0.028, 0.053, 0.038, 0.028, 0.025, # 5-10\\n 0.018, 0.018, 0.018, 0.020, 0.016, 0.033, 0.036, 0.033, 0.024, 0.025, # 10-15\\n 0.015, 0.015, 0.015, 0.016, 0.014, 0.029, 0.033, 0.022, 0.019, 0.018, # 15-20\\n 0.012, 0.012, 0.012, 0.012, 0.012, 0.015, 0.030, 0.022, 0.016, 0.016, # 20-30\\n 0.011, 0.011, 0.011, 0.011, 0.011, 0.011, 0.021, 0.021, 0.015, 0.015, # 30-40\\n 0.011, 0.011, 0.011, 0.011, 0.011, 0.011, 0.015, 0.015, 0.010, 0.010, # 40-50\\n 0.011, 0.011, 0.011, 0.011, 0.011, 0.011, 0.015, 0.015, 0.010, 0.010, # 50-60\\n 0.011, 0.011, 0.011, 0.011, 0.011, 0.011, 0.015, 0.015, 0.010, 0.010, # 60-70\\n 0.011, 0.011, 0.011, 0.011, 0.011, 0.011, 0.015, 0.015, 0.010, 0.010, # 70-80\\n 0.011, 0.011, 0.011, 0.011, 0.011, 0.011, 0.015, 0.015, 0.010, 0.010, # >80\\n ]\\n\\n # cut on ratio e237/e277\\n theTool.CutReta37 += [\\n 0.700, 0.700, 0.700, 0.700, 0.700, 0.690, 0.848, 0.876, 0.870, 0.888, # < 5\\n 0.700, 0.700, 0.700, 0.700, 0.700, 0.715, 0.860, 0.880, 0.880, 0.880, # 5-10\\n 0.875, 0.875, 0.875, 0.875, 0.875, 0.740, 0.860, 0.875, 0.870, 0.870, # 10-15\\n 0.900, 0.900, 0.895, 0.895, 0.890, 0.740, 0.880, 0.900, 0.880, 0.880, # 15-20\\n 0.910, 0.910, 0.910, 0.910, 0.910, 0.750, 0.890, 0.900, 0.890, 0.890, # 20-30\\n 0.920, 0.920, 0.920, 0.915, 0.915, 0.790, 0.895, 0.915, 0.895, 0.890, # 30-40\\n 0.920, 0.920, 0.920, 0.915, 0.915, 0.790, 0.895, 0.915, 0.895, 0.890, # 40-50\\n 0.920, 0.920, 0.920, 0.915, 0.915, 0.790, 0.895, 0.915, 0.895, 0.890, # 50-60\\n 0.920, 0.920, 0.920, 0.915, 0.915, 0.790, 0.895, 0.915, 0.895, 0.890, # 60-70\\n 0.920, 0.920, 0.920, 0.915, 0.915, 0.790, 0.895, 0.915, 0.895, 0.890, # 70-80\\n 0.920, 0.920, 0.920, 0.915, 0.915, 0.790, 0.895, 0.915, 0.895, 0.890, # >80\\n ]\\n\\n # cut on shower width in 2nd sampling\\n theTool.CutWeta2c += [\\n 0.014, 0.014, 0.014, 0.014, 0.014, 0.028, 0.017, 0.014, 0.014, 0.014, # <5\\n 0.014, 0.014, 0.014, 0.014, 0.014, 0.026, 0.017, 0.014, 0.014, 0.014, # 5-10\\n 0.014, 0.014, 0.015, 0.016, 0.017, 0.025, 0.017, 0.015, 0.015, 0.015, # 10-15\\n 0.013, 0.013, 0.015, 0.016, 0.017, 0.025, 0.017, 0.015, 0.015, 0.014, # 15-20\\n 0.013, 0.013, 0.014, 0.015, 0.015, 0.025, 0.016, 0.015, 0.015, 0.014, # 20-30\\n 0.012, 0.012, 0.013, 0.013, 0.013, 0.025, 0.015, 0.014, 0.014, 0.013, # 30-40\\n 0.011, 0.011, 0.012, 0.013, 0.013, 0.025, 0.015, 0.014, 0.014, 0.013, # 40-50\\n 0.011, 0.011, 0.012, 0.013, 0.013, 0.025, 0.015, 0.014, 0.014, 0.013, # 50-60\\n 0.011, 0.011, 0.012, 0.013, 0.013, 0.025, 0.015, 0.014, 0.014, 0.013, # 60-70\\n 0.011, 0.011, 0.012, 0.013, 0.013, 0.025, 0.015, 0.014, 0.014, 0.013, # 70-80\\n 0.011, 0.011, 0.012, 0.013, 0.013, 0.025, 0.015, 0.014, 0.014, 0.013] # 80<\\n\\n # cut on total width in 1st sampling\\n theTool.CutWtot += [\\n 9999., 9999., 9999., 9999., 9999., 9999., 9999., 9999., 9999., 9999., # < 5\\n 9999., 9999., 9999., 9999., 9999., 9999., 9999., 9999., 9999., 9999., # 5-10\\n 3.20, 3.20, 3.20, 3.85, 3.85, 9999., 3.80, 3.00, 2.00, 9999., # 10-15\\n 3.00, 3.00, 3.00, 3.75, 3.75, 9999., 3.80, 3.00, 2.00, 9999., # 15-20\\n 2.90, 2.90, 2.90, 3.50, 3.50, 9999., 3.80, 3.00, 2.00, 9999., # 20-30\\n 2.80, 2.80, 2.80, 3.30, 3.40, 9999., 3.70, 3.00, 1.70, 9999., # 30-40\\n 2.80, 2.80, 2.80, 3.20, 3.40, 9999., 3.70, 2.90, 1.60, 9999., # 40-50\\n 2.80, 2.80, 2.80, 3.20, 3.40, 9999., 3.70, 2.90, 1.60, 9999., # 50-60\\n 2.80, 2.80, 2.80, 3.20, 3.40, 9999., 3.70, 2.90, 1.60, 9999., # 60-70\\n 2.80, 2.80, 2.80, 3.20, 3.40, 9999., 3.70, 2.90, 1.60, 9999., # 70-80\\n 2.80, 2.80, 2.80, 3.20, 3.40, 9999., 3.70, 2.90, 1.60, 9999., # >80\\n ]\\n\\n # cut on (Emax - Emax2)/(Emax + Emax2) in 1st sampling\\n theTool.CutDEmaxs1 += [\\n 0.390, 0.390, 0.200, 0.070, 0.060, -9999, 0.070, 0.430, 0.750, -9999, # < 5\\n 0.650, 0.660, 0.560, 0.460, 0.530, -9999, 0.600, 0.680, 0.750, -9999, # 5-10\\n 0.790, 0.790, 0.750, 0.590, 0.530, -9999., 0.600, 0.790, 0.840, -9999., # 10-15\\n 0.790, 0.790, 0.790, 0.700, 0.580, -9999., 0.600, 0.790, 0.850, -9999., # 15-20\\n 0.800, 0.800, 0.820, 0.720, 0.650, -9999., 0.780, 0.790, 0.850, -9999., # 20-30\\n 0.800, 0.800, 0.825, 0.720, 0.690, -9999., 0.780, 0.810, 0.880, -9999., # 30-40\\n 0.800, 0.800, 0.825, 0.730, 0.690, -9999., 0.790, 0.810, 0.880, -9999., # 40-50\\n 0.800, 0.800, 0.825, 0.730, 0.690, -9999., 0.790, 0.810, 0.880, -9999., # 50-60\\n 0.800, 0.800, 0.825, 0.730, 0.690, -9999., 0.790, 0.810, 0.880, -9999., # 60-70\\n 0.800, 0.800, 0.825, 0.730, 0.690, -9999., 0.790, 0.810, 0.880, -9999., # 70-80\\n 0.800, 0.800, 0.825, 0.730, 0.690, -9999., 0.790, 0.810, 0.880, -9999., # >80\\n ]\\n\\n # cut on Track quality cut\\n theTool.usePIXOutliers = True\\n theTool.useSCTOutliers = True\\n\\n # cut on pixel-layer hits\\n theTool.CutPi += [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\\n\\n # cut on precision hits\\n theTool.CutSi += [7, 7, 7, 7, 7, 7, 7, 7, 7, 7]\\n\\n # cut on delta eta\\n theTool.CutDeltaEta += [\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015\\n ]\\n\\n # END OF USEFULL CUTS\\n\\n # The following ARE NOT APPLIED FOR THE H4L or the LOOSE MENU ISEM\\n\\n # cut on transverse impact parameter\\n theTool.CutA0 += [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0]\\n\\n # cut on transverse impact parameter for tight selection\\n theTool.CutA0Tight += [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]\\n\\n # cut on delta eta for tight selection\\n theTool.CutDeltaEtaTight += [\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015\\n ]\\n theTool.useTRTOutliers = True\\n theTool.useBLOutliers = True\\n\\n # cut on b-layer hits\\n theTool.CutBL += [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\\n # cut max on delta phi\\n theTool.CutmaxDeltaPhi += [\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015,\\n 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015\\n ]\\n # cut min on deltaphi\\n theTool.CutminDeltaPhi += [\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n -0.03, -0.03, -0.03, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04, -0.04,\\n ]\\n\\n # cut min on E/P\\n theTool.CutminEp += [\\n 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80,\\n 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80,\\n 0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90,\\n 0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90,\\n 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80, 0.80,\\n 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70,\\n 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70,\\n 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70,\\n 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70,\\n 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70, 0.70,\\n 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00\\n ]\\n # cut max on E/P\\n theTool.CutmaxEp += [\\n 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 3.0, 3.0, 3.0, 3.0,\\n 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 3.0, 3.0, 3.0, 3.0,\\n 2.5, 2.5, 2.5, 2.5, 2.5, 3.0, 3.5, 3.5, 4.0, 4.0,\\n 2.5, 2.5, 2.5, 2.5, 2.5, 3.0, 3.5, 3.5, 4.0, 4.0,\\n 2.5, 2.5, 2.5, 2.5, 2.5, 3.0, 3.5, 3.5, 4.5, 4.5,\\n 3.0, 3.0, 3.0, 3.0, 3.0, 3.5, 3.5, 4.0, 4.5, 4.5,\\n 3.0, 3.0, 3.0, 3.0, 3.0, 3.5, 4.0, 5.0, 5.0, 5.0,\\n 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0,\\n 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0,\\n 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0,\\n 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.\\n ]\\n\\n # cuts on TRT\\n # range of eta bins for e-ID for TRT\\n theTool.CutBinEta_TRT += [0.1, 0.625, 1.07, 1.304, 1.752, 2.0]\\n # cuts on Number of TRT hits with Outliers\\n theTool.CutNumTRT += [-15., -15., -15., -15., -15., -15.]\\n # cuts on TRT ratio with Outliers\\n theTool.CutTRTRatio += [0.04, 0.04, 0.04, 0.05, 0.07, 0.07]\\n # cuts on TRT ratio with Outliers for 90% efficiency\\n theTool.CutTRTRatio90 += [0.10, 0.10, 0.125, 0.13, 0.13, 0.13]\",\n \"def fid_cuts(ptname, etaname):\\n cuts = []\\n cuts.append(combine_cuts([ptname + ' > 4.5',\\n 'TMath::Abs(' + etaname + ') < 1.2']))\\n cuts.append(combine_cuts([ptname + ' > 4.0',\\n var_selection('TMath::Abs('+etaname+')', 1.2, 1.4)\\n ]))\\n cuts.append(combine_cuts([ptname + ' > 3.5',\\n var_selection('TMath::Abs('+etaname+')', 1.4, 1.6)\\n ]))\\n return combine_cuts(cuts, ' || ')\",\n \"def AutoQuakePycker_run():\\n import glob\\n from itertools import product\\n import multiprocessing\\n import logging\\n import more_itertools as mit\\n from munch import munchify\\n import os\\n import yaml\\n from obspy import read_events, Catalog\\n\\n logger = multiprocessing.log_to_stderr(logging.DEBUG)\\n # Read in config file\\n with open(\\\"config.yaml\\\", \\\"r\\\") as ymlfile:\\n cfg = munchify(yaml.safe_load(ymlfile))\\n initial_cat = read_events(cfg.input.lassie_cat_file)\\n\\n # Read in station locations from file\\n sta_list = [[l.split()[1], float(l.split()[3]), float(l.split()[4])] for l\\n in open(\\\"NLLOC_run/run.in\\\", \\\"r\\\") if l.split()[0] == \\\"GTSRCE\\\"]\\n sta_locs = {sta[0]: {\\\"lat\\\": sta[1], \\\"lon\\\": sta[2]} for sta in sta_list}\\n if cfg.output.FORCE_RECALC is True:\\n filelist = glob.glob(os.path.join(\\\"refined_events\\\", \\\"*.xml\\\"))\\n for f in filelist:\\n os.remove(f)\\n if cfg.run.nproc == \\\"auto\\\":\\n nproc = multiprocessing.cpu_count()\\n else:\\n nproc = cfg.run.nproc\\n # Get events for which data currently is available\\n cat_filter = Catalog()\\n for n, event in enumerate(initial_cat):\\n e_id = event.event_descriptions[0].text\\n if e_id in os.listdir(\\\"{:}/\\\".format(cfg.input.DIR_TO_EVENTDIRS)):\\n if (cfg.output.FORCE_RECALC is False and\\n os.path.exists(\\\"refined_events/{:}.xml\\\".format(e_id))):\\n print(\\\"Already have this evening ... skipping\\\")\\n else:\\n cat_filter.append(event)\\n # Split catalogue across multiple processes and process in parallel\\n cat_split = [i for i in mit.divide(nproc, cat_filter)]\\n # process_events(cat_split[7], 7)\\n pool = multiprocessing.Pool(processes=nproc)\\n print(\\\"hello\\\")\\n a = pool.starmap(process_events, product(cat_split, range(nproc), cfg,\\n sta_locs))\\n\\n logger.debug(a)\",\n \"def main():\\n # Verbosity: 1=Selection Results, >1 is various debugging information\\n verbose = 0\\n print \\\"build_all.py running with verbose=%s\\\"%(str(verbose))\\n if verbose:\\n print \\\"Fiducial Cut: \\\",fid_cut_hex,\\\"(apethum, z_min, z_max)\\\"\\n print \\\"Max Drift Distance = %.4f us\\\"%(max_drift_time)\\n\\n tree = get_data_tree(list='All') # Golden All\\n \\n # We use the EXOFitting processed tree to get high-level physical quantities\\n # like the anticorrelated energy, etc. \\n #ptree_file = ROOT.TFile(preprocessed_tree)\\n #ptree = ROOT.Get(\\\"dataTree\\\")\\n #if verbose: print \\\"Indexing EXOFitting PreProcessed tree\\\"\\n #ptree.BuildIndex(\\\"runNum\\\", \\\"eventNum\\\")\\n #if verbose: print \\\" ...done\\\"\\n\\n cuts = \\\"\\\"\\n\\n #There must be at least 1 scintillation cluster:\\n #cuts = \\\"@fScintClusters.size()>=1\\\"\\n #cuts = \\\"(fScintClusters.GetCountsOnAPDPlane(0)+fScintClusters.GetCountsOnAPDPlane(1))>20000\\\"\\n\\n # The minimum scintinlation counts must be > 20000 and <70000\\n # I observe that three peaks presumable alphas are at 38500, 42200, and 55000\\n # So Rn222=5.4MeV, Po218=6MeV, Po214=7.7MeV\\n # calibrate:: y=mx+b, m=6167, b=5198\\n #cuts = \\\"fScintClusters.fRawEnergy>20000 && fScintClusters.fRawEnergy<70000\\\"\\n #cuts += \\\"&& fScintClusters.fRawEnergy>22000 && fScintClusters.fRawEnergy<80000\\\"\\n #cuts += \\\" && Sum$(fAPDs.fRawCounts) > 8000\\\"\\n\\n # Ignore Noise and Muon tagged events\\n cuts +=\\\"fEventHeader.fTaggedAsNoise==0 && fEventHeader.fTaggedAsMuon==0\\\" \\n\\n # That's the last of the cuts, lets show the user what the cut looks like\\n print \\\"Applying Cuts to data: \\\\n%s\\\"%cuts\\n\\n #Draw is the fastest method to apply cuts, in the end what we want is a reduced data list\\n # to perform a more targeted analysis...\\n tree.Draw(\\\">>+elist_alpha_canidates\\\",cuts,\\\"goff\\\")\\n elist_alpha_canidates = ROOT.gDirectory.Get(\\\"elist_alpha_canidates\\\")\\n print \\\"There are %d events passing the initial cuts\\\"%elist_alpha_canidates.GetN()\\n\\n #Now we have to look at events passing the cuts individually\\n tf = ROOT.TFile(\\\"all.root\\\",\\\"RECREATE\\\")\\n Rntree = tree.CloneTree(0)\\n \\n for i in range(elist_alpha_canidates.GetN()):\\n # Print Progress\\n if i%int(elist_alpha_canidates.GetN()/20) == 0:\\n print \\\"%d of %d\\\"%(i,elist_alpha_canidates.GetN())\\n\\n #Grab the event data\\n tree.GetEntry(elist_alpha_canidates.GetEntry(i))\\n #ed = tree.EventBranch\\n #if verbose>1: print_event_data(ed,verbose)\\n\\n #is_alphaish = check_alpha_like(ed,verbose)\\n \\n #is the event a fully reconstructed BiPo?\\n #is_bipo = check_full_BiPo(ed,verbose)\\n\\n # Case1 (position matched Bi-Po)\\n #is_case1 = check_case1(ed,verbose)\\n #print \\\"BiPo=%s, Case1=%s\\\"%(is_bipo, is_case1) \\n #raw_input('<hit any key to continue>')\\n #if is_bipo or is_alphaish:\\n # Write the EventData of events which pass any of our selection criteria\\n # to ROOT file\\n Rntree.Fill()\\n\\n Rntree.AutoSave()\",\n \"def analyze(self, event):\\n run = long(event.run) if self.run == None else self.run\\n if self.doApplyCor:\\n elecPtNom = []\\n elecMassNom = []\\n if self.doSysVar:\\n elecPtUp = []\\n elecPtDo = []\\n elecMassUp = []\\n elecMassDo = []\\n elec = Collection(event, 'Electron')\\n nrandom = ROOT.gRandom.Gaus(0,1)\\n for el in elec:\\n p = ROOT.TLorentzVector()\\n p.SetPtEtaPhiM(el.pt, el.eta, el.phi, el.mass)\\n r9 = el.r9\\n seed = el.seedGain if hasattr(el, 'seedGain') else 12\\n ecor = el.eCorr if hasattr(el, 'eCorr') else 1\\n et = p.Et()\\n abseta = abs(p.Eta()+el.deltaEtaSC)\\n if self.isData:\\n if not self.doApplyCor: return True\\n # Apply scale to data\\n praw = p*(1./ecor) # Correct back\\n et = praw.Et()\\n abseta = abs(praw.Eta()+el.deltaEtaSC)\\n escale = self.eleCorr.scaleCorr(run, et, abseta, r9)\\n vEle = praw*escale\\n elecPtNom.append(vEle.Pt())\\n elecMassNom.append(vEle.M())\\n else: # MC\\n if self.doApplyCor: # Apply smear to MC\\n praw = p*(1./ecor) # Correct back\\n et = praw.Et()\\n abseta = abs(praw.Eta()+el.deltaEtaSC)\\n eleSmear = self.eleCorr.smearingSigma(run, et, abseta, r9, 12, 0, 0.)\\n vEle = praw*(1+eleSmear*nrandom)\\n elecPtNom.append(vEle.Pt())\\n elecMassNom.append(vEle.M())\\n et = vEle.Et()\\n if self.doSysVar:\\n eleSmear = self.eleCorr.smearingSigma(run, et, abseta, r9, 12, 0, 0.)\\n escaleErr = self.eleCorr.scaleCorrUncert(run, et, abseta, r9)\\n eleSmearUp = self.eleCorr.smearingSigma(run, et, abseta, r9, 12, 1, 0.)\\n eleSmearDo = self.eleCorr.smearingSigma(run, et, abseta, r9, 12, -1, 0.)\\n eleSmearUnc = nrandom*np.sqrt( (eleSmearUp-eleSmear)*(eleSmearUp-eleSmear) + (eleSmearDo-eleSmear)*(eleSmearDo-eleSmear) )\\n vEleUp = p*(1+escaleErr+eleSmearUnc)\\n vEleDo = p*(1-escaleErr-eleSmearUnc)\\n elecPtUp.append(vEleUp.Pt())\\n elecPtDo.append(vEleDo.Pt())\\n elecMassUp.append(vEleUp.M())\\n elecMassDo.append(vEleDo.M())\\n if self.doApplyCor:\\n self.out.fillBranch(\\\"Electron_pt_nom\\\", elecPtNom)\\n self.out.fillBranch(\\\"Electron_mass_nom\\\", elecMassNom)\\n if self.doSysVar:\\n self.out.fillBranch(\\\"Electron_pt_up\\\", elecPtUp)\\n self.out.fillBranch(\\\"Electron_pt_down\\\", elecPtDo)\\n self.out.fillBranch(\\\"Electron_mass_up\\\", elecMassUp)\\n self.out.fillBranch(\\\"Electron_mass_down\\\", elecMassDo)\\n return True\",\n \"def perform_event_analysis():\\n\\n tol = 2.0 # Arcmin\\n calib_on_colours = False\\n\\n params = get_args()\\n\\n log = start_log(params)\\n\\n (star_catalog,image_trios,catalog_header) = read_combined_star_catalog(params,log)\\n\\n lightcurves = read_lightcurves(params,log)\\n\\n target = find_target_data(params,star_catalog,lightcurves,image_trios,log)\\n\\n (source, blend) = calc_source_blend_params(params,log)\\n\\n source = calc_source_lightcurve(source, target, log)\\n\\n measure_photometric_source_colours(params,target,log)\\n\\n (det_idx, cat_idx, close_cat_idx) = index_valid_star_entries(star_catalog,\\n target,tol,log,\\n valid_cat=True)\\n\\n deltas = calibrate_instrumental_colour_colour_diagram(params,star_catalog,\\n catalog_header,target,\\n det_idx,cat_idx,close_cat_idx,\\n log,\\n calib=calib_on_colours)\\n\\n RC = localize_red_clump(star_catalog,close_cat_idx,log)\\n\\n analyse_colour_mag_diagrams(params,star_catalog,catalog_header,\\n target, source,blend,RC,\\n det_idx,cat_idx,close_cat_idx,log)\\n\\n RC = measure_RC_offset(params,RC,target,log)\\n\\n (target,source,blend) = calc_phot_properties(target, source, blend, RC, log)\\n\\n plot_colour_colour_diagram(params,star_catalog,catalog_header,\\n target, source, blend, RC,\\n det_idx,cat_idx,close_cat_idx, log)\\n\\n (source, blend) = match_source_blend_isochrones(params,source,blend,log)\\n\\n (source, blend) = calc_source_blend_ang_radii(source, blend, log)\\n\\n (source, blend) = calc_source_blend_physical_radii(source, blend, log)\\n\\n (source,blend) = calc_source_blend_distance(source, blend, RC, log)\\n\\n lens = calc_lens_parameters(params, source, RC, log)\\n\\n output_red_clump_data_latex(params,RC,log)\\n\\n output_source_blend_data_latex(params,source,blend,log)\\n\\n output_lens_parameters_latex(params,source,lens,log)\",\n \"def as_exons(self,input={}):\\n # handle potentially applied input argument\\n self._handle_input_subdict(input)\\n # parse data in the AbgpGeneLocusDir\\n self.parseinputgff()\\n self.rungetorf()\\n # we need abgp_geneconfirmation.geneconfirmation first!\\n geneconfirmation( { self._create_auto_key(): self.input } )\\n\\n # get only the CDS-type of tracks that define the coding sequence\\n genecdstracks = filtergffs4fmethod( self._obtain_gene_gff(), GFF_CDS_FMETHOD ) \\n\\n if len(genecdstracks) == 1:\\n # deal with SingleExonOnOrf -> TSS + donor\\n orf = self.input['orfs'].get_orf_by_id(self.input['orfid-genestructure'][0])\\n tss = self._gene_cds_track_2_tss( genecdstracks[0], orf )\\n return [ SingleExonOnOrf(tss,genecdstracks[-1][4],orf,gff={}) ]\\n\\n elif len(genecdstracks) == 0:\\n # no tracks !?\\n return []\\n elif not self.input['orfid-genestructure']:\\n # not mappable on Orfs / or no genestructure provided\\n return []\\n else:\\n # list with exons,introns to return \\n exons = []\\n introns = []\\n exonsandintrons = []\\n\\n # deal with FirstExonOnOrf -> TSS + donor\\n try:\\n orf = self.input['orfs'].get_orf_by_id(self.input['orfid-genestructure'][0])\\n except:\\n print self.input.keys(), self.input['proteinfref']\\n orf = self.input['orfs'].get_orf_by_id(self.input['orfid-genestructure'][0])\\n\\n tss = self._gene_cds_track_2_tss( genecdstracks[0], orf )\\n donor = self._gene_cds_track_2_donor( genecdstracks[0], orf )\\n donor.phase = ( genecdstracks[0][4]-genecdstracks[0][3]-1 ) % 3\\n exons.append( FirstExonOnOrf(tss,donor,orf,gff={}) )\\n exonsandintrons.append( exons[-1] )\\n\\n # deal with internal ExonOnOrf(s): -> acceptor + donor\\n for pos in range(1,len(genecdstracks)-1):\\n orf = self.input['orfs'].get_orf_by_id(self.input['orfid-genestructure'][pos])\\n accep = self._gene_cds_track_2_acceptor( genecdstracks[pos], orf )\\n accep.phase = exons[-1].donor.phase\\n donor = self._gene_cds_track_2_donor( genecdstracks[pos], orf )\\n donor.phase = ( genecdstracks[pos][4]-genecdstracks[pos][3]-1+accep.phase ) % 3\\n exons.append( ExonOnOrf(accep,donor,orf,gff={}) )\\n sharednts = get_shared_nucleotides_at_splicesite(\\n exons[-1].orf, exons[-2].orf,\\n exons[-1].acceptor, exons[-2].donor,\\n )\\n intron = IntronConnectingOrfs(\\n exons[-2].donor, exons[-1].acceptor, sharednts,\\n exons[-2].orf, exons[-1].orf,\\n )\\n introns.append(intron)\\n exonsandintrons.append( introns[-1] )\\n exonsandintrons.append( exons[-1] )\\n\\n # deal with FinalExonOnOrf -> acceptor + StopCodon\\n orf = self.input['orfs'].get_orf_by_id(self.input['orfid-genestructure'][-1])\\n accep = self._gene_cds_track_2_acceptor( genecdstracks[-1], orf )\\n accep.phase = exons[-1].donor.phase\\n exons.append( FinalExonOnOrf(accep,genecdstracks[-1][4],orf,gff={}) )\\n sharednts = get_shared_nucleotides_at_splicesite(\\n exons[-1].orf,exons[-2].orf,\\n exons[-1].acceptor,exons[-2].donor,\\n )\\n intron = IntronConnectingOrfs(\\n exons[-2].donor, exons[-1].acceptor, sharednts,\\n exons[-2].orf, exons[-1].orf,\\n )\\n introns.append(intron)\\n exonsandintrons.append( introns[-1] )\\n exonsandintrons.append( exons[-1] )\\n\\n # return list of exons&introns\\n return exonsandintrons\",\n \"def remove_events(self):\\n tofiltercalibfnames1, tofiltercalibfnames2 = split_into_telescopes(self.tofiltercalibfnames)\\n\\n nameiter = tqdm(self.superstarmcolfnames)\\n for ssmcolfname in nameiter:\\n nameiter.set_description(f\\\"Processing {path.basename(ssmcolfname)}\\\")\\n currentrun = get_run(ssmcolfname)\\n ssmcoldf = pd.read_csv(ssmcolfname, index_col=False)\\n # newfname1 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames1, self.m1sscols)\\n # newfname2 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames2, self.m2sscols)\\n # if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\\n # os.remove(newfname1)\\n # os.remove(newfname2)\\n # continue\\n tofiltercalibdf1, oldname1 = self._merge_subruns(tofiltercalibfnames1,\\n currentrun, getoldname=True)\\n tofiltercalibdf2, oldname2 = self._merge_subruns(tofiltercalibfnames2,\\n currentrun, getoldname=True)\\n if len(tofiltercalibdf1) == 0:\\n logger.warning(f\\\"calibfiles already processed, skipping {path.basename(ssmcolfname)} current run: {currentrun} \\\\n\\\")\\n continue\\n\\n filtermask1 = self.get_filtermask(tofiltercalibdf1.iloc[:, self.mcolidx], ssmcoldf[self.m1sscols])\\n filtermask2 = self.get_filtermask(tofiltercalibdf2.iloc[:, self.mcolidx], ssmcoldf[self.m2sscols])\\n if self.invert is False:\\n filtermask1, tofiltercalibdf1 = self.fix_idiosyncracies(filtermask1, tofiltercalibdf1, ssmcoldf[self.m1sscols])\\n filtermask2, tofiltercalibdf2 = self.fix_idiosyncracies(filtermask2, tofiltercalibdf2, ssmcoldf[self.m2sscols])\\n\\n if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\\n continue\\n\\n newfname1 = self._get_newfilename(oldname=oldname1)\\n newfname2 = self._get_newfilename(oldname=oldname2)\\n\\n nameiter.set_description(f\\\"Saving {path.basename(newfname1)}\\\")\\n tofiltercalibdf1.iloc[filtermask1].to_csv(newfname1, header=False, index=False)\\n nameiter.set_description(f\\\"Saving {path.basename(newfname2)}\\\")\\n tofiltercalibdf2.iloc[filtermask2].to_csv(newfname2, header=False, index=False)\\n self.outfilenames.extend([newfname1, newfname2])\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun))\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun))\",\n \"def apply_science_modules(df: DataFrame, noscience: bool = False) -> DataFrame:\\n if noscience:\\n return df\\n\\n # Retrieve time-series information\\n to_expand = [\\n 'jd', 'fid', 'magpsf', 'sigmapsf',\\n 'magnr', 'sigmagnr', 'isdiffpos', 'distnr'\\n ]\\n\\n # Append temp columns with historical + current measurements\\n prefix = 'c'\\n for colname in to_expand:\\n df = concat_col(df, colname, prefix=prefix)\\n expanded = [prefix + i for i in to_expand]\\n\\n # Apply level one processor: cdsxmatch\\n _LOG.info(\\\"New processor: cdsxmatch\\\")\\n df = xmatch_cds(df)\\n\\n _LOG.info(\\\"New processor: Gaia xmatch\\\")\\n df = xmatch_cds(\\n df,\\n distmaxarcsec=1,\\n catalogname='vizier:I/355/gaiadr3',\\n cols_out=['DR3Name', 'Plx', 'e_Plx'],\\n types=['string', 'float', 'float']\\n )\\n\\n _LOG.info(\\\"New processor: GCVS\\\")\\n df = df.withColumn(\\n 'gcvs',\\n crossmatch_other_catalog(\\n df['candidate.candid'],\\n df['candidate.ra'],\\n df['candidate.dec'],\\n F.lit('gcvs')\\n )\\n )\\n\\n _LOG.info(\\\"New processor: VSX\\\")\\n df = df.withColumn(\\n 'vsx',\\n crossmatch_other_catalog(\\n df['candidate.candid'],\\n df['candidate.ra'],\\n df['candidate.dec'],\\n F.lit('vsx')\\n )\\n )\\n\\n _LOG.info(\\\"New processor: 3HSP (1 arcmin)\\\")\\n df = df.withColumn(\\n 'x3hsp',\\n crossmatch_other_catalog(\\n df['candidate.candid'],\\n df['candidate.ra'],\\n df['candidate.dec'],\\n F.lit('3hsp'),\\n F.lit(60.0)\\n )\\n )\\n\\n _LOG.info(\\\"New processor: 4LAC (1 arcmin)\\\")\\n df = df.withColumn(\\n 'x4lac',\\n crossmatch_other_catalog(\\n df['candidate.candid'],\\n df['candidate.ra'],\\n df['candidate.dec'],\\n F.lit('4lac'),\\n F.lit(60.0)\\n )\\n )\\n\\n _LOG.info(\\\"New processor: Mangrove (1 acrmin)\\\")\\n df = df.withColumn(\\n 'mangrove',\\n crossmatch_mangrove(\\n df['candidate.candid'],\\n df['candidate.ra'],\\n df['candidate.dec'],\\n F.lit(60.0)\\n )\\n )\\n\\n # Apply level one processor: asteroids\\n _LOG.info(\\\"New processor: asteroids\\\")\\n args_roid = [\\n 'cjd', 'cmagpsf',\\n 'candidate.ndethist', 'candidate.sgscore1',\\n 'candidate.ssdistnr', 'candidate.distpsnr1']\\n df = df.withColumn('roid', roid_catcher(*args_roid))\\n\\n _LOG.info(\\\"New processor: Active Learning\\\")\\n\\n # Perform the fit + classification.\\n # Note we can omit the model_path argument, and in that case the\\n # default model `data/models/default-model.obj` will be used.\\n rfscore_args = ['cjd', 'cfid', 'cmagpsf', 'csigmapsf']\\n rfscore_args += [F.col('cdsxmatch'), F.col('candidate.ndethist')]\\n df = df.withColumn(\\n 'rf_snia_vs_nonia',\\n rfscore_sigmoid_full(*rfscore_args)\\n )\\n\\n # Apply level one processor: superNNova\\n _LOG.info(\\\"New processor: supernnova\\\")\\n\\n snn_args = ['candid', 'cjd', 'cfid', 'cmagpsf', 'csigmapsf']\\n snn_args += [\\n F.col('roid'), F.col('cdsxmatch'), F.col('candidate.jdstarthist')\\n ]\\n snn_args += [F.lit('snn_snia_vs_nonia')]\\n df = df.withColumn('snn_snia_vs_nonia', snn_ia(*snn_args))\\n\\n snn_args = ['candid', 'cjd', 'cfid', 'cmagpsf', 'csigmapsf']\\n snn_args += [\\n F.col('roid'), F.col('cdsxmatch'), F.col('candidate.jdstarthist')\\n ]\\n snn_args += [F.lit('snn_sn_vs_all')]\\n df = df.withColumn('snn_sn_vs_all', snn_ia(*snn_args))\\n\\n # Apply level one processor: microlensing\\n _LOG.info(\\\"New processor: microlensing\\\")\\n\\n # Required alert columns - already computed for SN\\n mulens_args = [\\n 'cfid', 'cmagpsf', 'csigmapsf',\\n 'cmagnr', 'csigmagnr',\\n 'cisdiffpos', 'candidate.ndethist'\\n ]\\n df = df.withColumn('mulens', mulens(*mulens_args))\\n\\n # Apply level one processor: nalerthist\\n _LOG.info(\\\"New processor: nalerthist\\\")\\n df = df.withColumn('nalerthist', nalerthist(df['cmagpsf']))\\n\\n # Apply level one processor: kilonova detection\\n _LOG.info(\\\"New processor: kilonova\\\")\\n knscore_args = ['cjd', 'cfid', 'cmagpsf', 'csigmapsf']\\n knscore_args += [\\n F.col('candidate.jdstarthist'),\\n F.col('cdsxmatch'),\\n F.col('candidate.ndethist')\\n ]\\n df = df.withColumn('rf_kn_vs_nonkn', knscore(*knscore_args))\\n\\n _LOG.info(\\\"New processor: T2\\\")\\n # t2_args = ['candid', 'cjd', 'cfid', 'cmagpsf', 'csigmapsf']\\n # t2_args += [F.col('roid'), F.col('cdsxmatch'), F.col('candidate.jdstarthist')]\\n # df = df.withColumn('t2', t2(*t2_args))\\n df = df.withColumn('t2', fake_t2('objectId'))\\n\\n # Apply level one processor: snad (light curve features)\\n _LOG.info(\\\"New processor: ad_features\\\")\\n ad_args = [\\n 'cmagpsf', 'cjd', 'csigmapsf', 'cfid', 'objectId',\\n 'cdistnr', 'cmagnr', 'csigmagnr', 'cisdiffpos'\\n ]\\n\\n # Temporary fix -- add 100 do distnr to pretend\\n # extra-galactic and skip dcmag\\n df = df\\\\\\n .withColumn('tmp', F.expr('TRANSFORM(cdistnr, el -> el + 100)'))\\\\\\n .drop('cdistnr').withColumnRenamed('tmp', 'cdistnr')\\n\\n df = df.withColumn('lc_features', extract_features_ad(*ad_args))\\n\\n # Apply level one processor: anomaly_score\\n _LOG.info(\\\"New processor: Anomaly score\\\")\\n df = df.withColumn('anomaly_score', anomaly_score('lc_features'))\\n\\n # split features\\n df = df.withColumn(\\\"lc_features_g\\\", df['lc_features'].getItem(\\\"1\\\"))\\\\\\n .withColumn(\\\"lc_features_r\\\", df['lc_features'].getItem(\\\"2\\\"))\\\\\\n .drop('lc_features')\\n\\n # Drop temp columns\\n df = df.drop(*expanded)\\n\\n return df\",\n \"def setup_fermi(self):\\n eventclass=5 # 2 (Source) or 5 (UltracleanVeto)\\n eventtype=0 # 0 (all), 3 (bestpsf) or 5 (top3 quartiles)\\n mask_type='top300'\\n force_mask_at_bin_number=10\\n\\n self.f1 = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min=0,CTB_en_max=40,nside=self.nside,eventclass=eventclass,eventtype=eventtype,newstyle=1,data_July16=True)\\n\\n if mask_type != 'False':\\n self.f1.make_ps_mask(mask_type = mask_type,force_energy = True,energy_bin = force_mask_at_bin_number)\\n self.f1.add_diffuse_newstyle(comp = 'p7', eventclass = eventclass, eventtype = eventtype)\\n self.f1.add_bubbles(comp='bubs') #bubbles\\n self.f1.add_iso(comp='iso') #iso\\n self.f1.add_ps_model(comp='ps_model')\\n\\n # Exposure correct J_map_arr\\n self.J_map_arr *= self.f1.CTB_exposure_maps\\n\\n # Add J-factor map with mean 1 in each energy bin\\n self.f1.add_template_by_hand('J_map',np.array([self.J_map_arr[i]/np.mean(self.J_map_arr[i]) for i in range(40)]))\",\n \"def run_pick_de_novo_otus(input_fp, \\n output_dir, \\n command_handler,\\n params, \\n qiime_config,\\n parallel=False,\\n logger=None,\\n suppress_md5=False,\\n status_update_callback=print_to_stdout):\\n \\n # Prepare some variables for the later steps\\n input_dir, input_filename = split(input_fp)\\n input_basename, input_ext = splitext(input_filename)\\n create_dir(output_dir)\\n commands = []\\n python_exe_fp = qiime_config['python_exe_fp']\\n script_dir = get_qiime_scripts_dir()\\n cluster_failures = False\\n if logger == None:\\n logger = WorkflowLogger(generate_log_fp(output_dir),\\n params=params,\\n qiime_config=qiime_config)\\n close_logger_on_success = True\\n else:\\n close_logger_on_success = False\\n \\n if not suppress_md5:\\n log_input_md5s(logger,[input_fp])\\n \\n # Prep the OTU picking command\\n try:\\n otu_picking_method = params['pick_otus']['otu_picking_method']\\n except KeyError:\\n otu_picking_method = 'uclust'\\n pick_otu_dir = '%s/%s_picked_otus' % (output_dir, otu_picking_method)\\n otu_fp = '%s/%s_otus.txt' % (pick_otu_dir,input_basename)\\n if parallel and (otu_picking_method == 'blast' or \\n otu_picking_method == 'uclust_ref'):\\n # Grab the parallel-specific parameters\\n try:\\n params_str = get_params_str(params['parallel'])\\n except KeyError:\\n params_str = ''\\n \\n # Grab the OTU picker parameters\\n try:\\n # Want to find a cleaner strategy for this: the parallel script\\n # is method-specific, so doesn't take a --otu_picking_method\\n # option. This works for now though.\\n d = params['pick_otus'].copy()\\n del d['otu_picking_method']\\n except KeyError:\\n pass\\n \\n if otu_picking_method == 'uclust_ref':\\n try:\\n suppress_new_clusters = d['suppress_new_clusters']\\n del d['suppress_new_clusters']\\n cluster_failures = False\\n except KeyError:\\n cluster_failures = True\\n failure_otu_picking_method = 'uclust'\\n \\n params_str += ' %s' % get_params_str(d)\\n otu_picking_script = 'parallel_pick_otus_%s.py' % otu_picking_method\\n # Build the OTU picking command\\n pick_otus_cmd = '%s %s/%s -i %s -o %s -T %s' % (python_exe_fp, \\n script_dir, \\n otu_picking_script,\\n input_fp,\\n pick_otu_dir,\\n params_str)\\n else:\\n try:\\n params_str = get_params_str(params['pick_otus'])\\n except KeyError:\\n params_str = ''\\n # Build the OTU picking command\\n pick_otus_cmd = '%s %s/pick_otus.py -i %s -o %s %s' %\\\\\\n (python_exe_fp, script_dir, input_fp, pick_otu_dir, params_str)\\n\\n commands.append([('Pick OTUs', pick_otus_cmd)])\\n \\n if cluster_failures:\\n reference_otu_fp = otu_fp\\n clustered_failures_dir = '%s/failure_otus/' % pick_otu_dir\\n \\n try:\\n d = params['pick_otus'].copy()\\n del d['otu_picking_method']\\n except KeyError:\\n pass\\n\\n if 'uclust_otu_id_prefix' not in d:\\n d['uclust_otu_id_prefix'] = 'DeNovoOTU' \\n params_str = ' %s' % get_params_str(d)\\n\\n failures_list_fp = '%s/%s_failures.txt' % \\\\\\n (pick_otu_dir,input_basename)\\n failures_fasta_fp = '%s/%s_failures.fasta' % \\\\\\n (pick_otu_dir,input_basename)\\n \\n filter_fasta_cmd = 'filter_fasta.py -f %s -s %s -o %s' %\\\\\\n (input_fp,failures_list_fp,failures_fasta_fp)\\n \\n commands.append([('Generate failures fasta file',\\n filter_fasta_cmd)])\\n \\n # Prep the OTU picking command for\\n failure_otu_fp = '%s/%s_failures_otus.txt' % (clustered_failures_dir,input_basename)\\n # Build the OTU picking command\\n pick_otus_cmd = '%s %s/pick_otus.py -i %s -o %s -m %s %s' %\\\\\\n (python_exe_fp, script_dir, failures_fasta_fp, clustered_failures_dir, \\n failure_otu_picking_method, params_str)\\n\\n commands.append([('Pick de novo OTUs for new clusters', pick_otus_cmd)])\\n \\n merged_otu_map_fp = '%s/merged_otu_map.txt' % clustered_failures_dir\\n cat_otu_tables_cmd = 'cat %s %s >> %s' %\\\\\\n (reference_otu_fp,failure_otu_fp,merged_otu_map_fp)\\n commands.append([('Merge OTU maps',cat_otu_tables_cmd)])\\n otu_fp = merged_otu_map_fp\\n\\n # Prep the representative set picking command\\n rep_set_dir = '%s/rep_set/' % output_dir\\n create_dir(rep_set_dir)\\n rep_set_fp = '%s/%s_rep_set.fasta' % (rep_set_dir,input_basename)\\n rep_set_log_fp = '%s/%s_rep_set.log' % (rep_set_dir,input_basename)\\n \\n try:\\n params_str = get_params_str(params['pick_rep_set'])\\n except KeyError:\\n params_str = ''\\n # Build the representative set picking command\\n pick_rep_set_cmd = '%s %s/pick_rep_set.py -i %s -f %s -l %s -o %s %s' %\\\\\\n (python_exe_fp, script_dir, otu_fp, input_fp, rep_set_log_fp,\\\\\\n rep_set_fp, params_str)\\n commands.append([('Pick representative set', pick_rep_set_cmd)])\\n \\n # Prep the taxonomy assignment command\\n try:\\n assignment_method = params['assign_taxonomy']['assignment_method']\\n except KeyError:\\n assignment_method = 'uclust'\\n assign_taxonomy_dir = '%s/%s_assigned_taxonomy' %\\\\\\n (output_dir,assignment_method)\\n taxonomy_fp = '%s/%s_rep_set_tax_assignments.txt' % \\\\\\n (assign_taxonomy_dir,input_basename)\\n if parallel and (assignment_method == 'rdp' or\\n assignment_method == 'blast' or\\n assignment_method == 'uclust'):\\n # Grab the parallel-specific parameters\\n try:\\n params_str = get_params_str(params['parallel'])\\n except KeyError:\\n params_str = ''\\n \\n # Grab the taxonomy assignment parameters\\n try:\\n # Want to find a cleaner strategy for this: the parallel script\\n # is method-specific, so doesn't take a --assignment_method\\n # option. This works for now though.\\n d = params['assign_taxonomy'].copy()\\n if 'assignment_method' in d:\\n del d['assignment_method']\\n params_str += ' %s' % get_params_str(d)\\n except KeyError:\\n pass\\n \\n # Build the parallel taxonomy assignment command\\n assign_taxonomy_cmd = \\\\\\n '%s %s/parallel_assign_taxonomy_%s.py -i %s -o %s -T %s' %\\\\\\n (python_exe_fp, script_dir, assignment_method, rep_set_fp,\\\\\\n assign_taxonomy_dir, params_str)\\n else:\\n try:\\n params_str = get_params_str(params['assign_taxonomy'])\\n except KeyError:\\n params_str = ''\\n # Build the taxonomy assignment command\\n assign_taxonomy_cmd = '%s %s/assign_taxonomy.py -o %s -i %s %s' %\\\\\\n (python_exe_fp, script_dir, assign_taxonomy_dir,\\\\\\n rep_set_fp, params_str)\\n \\n commands.append([('Assign taxonomy',assign_taxonomy_cmd)])\\n \\n # Prep the OTU table building command\\n otu_table_fp = '%s/otu_table.biom' % output_dir\\n try:\\n params_str = get_params_str(params['make_otu_table'])\\n except KeyError:\\n params_str = ''\\n # Build the OTU table building command\\n make_otu_table_cmd = '%s %s/make_otu_table.py -i %s -t %s -o %s %s' %\\\\\\n (python_exe_fp, script_dir, otu_fp, taxonomy_fp, otu_table_fp, params_str)\\n \\n commands.append([('Make OTU table', make_otu_table_cmd)])\\n \\n if cluster_failures:\\n reference_otu_table_fp = '%s/reference_only_otu_table.biom' % output_dir\\n # Build the OTU table building command\\n make_otu_table_cmd = '%s %s/make_otu_table.py -i %s -t %s -o %s %s' %\\\\\\n (python_exe_fp, script_dir, reference_otu_fp, taxonomy_fp, \\n reference_otu_table_fp, params_str)\\n \\n commands.append([('Make reference-only OTU table', make_otu_table_cmd)])\\n \\n # Prep the pynast alignment command\\n try:\\n alignment_method = params['align_seqs']['alignment_method']\\n except KeyError:\\n alignment_method = 'pynast'\\n pynast_dir = '%s/%s_aligned_seqs' % (output_dir,alignment_method)\\n aln_fp = '%s/%s_rep_set_aligned.fasta' % (pynast_dir,input_basename)\\n if parallel and alignment_method == 'pynast':\\n # Grab the parallel-specific parameters\\n try:\\n params_str = get_params_str(params['parallel'])\\n except KeyError:\\n params_str = ''\\n \\n # Grab the alignment parameters \\n # Want to find a cleaner strategy for this: the parallel script\\n # is method-specific, so doesn't take a --alignment_method\\n # option. This works for now though.\\n try:\\n d = params['align_seqs'].copy()\\n except KeyError:\\n d = {}\\n try:\\n del d['alignment_method']\\n except KeyError:\\n pass\\n params_str += ' %s' % get_params_str(d)\\n \\n # Build the parallel pynast alignment command\\n align_seqs_cmd = '%s %s/parallel_align_seqs_pynast.py -i %s -o %s -T %s' %\\\\\\n (python_exe_fp, script_dir, rep_set_fp, pynast_dir, params_str)\\n else:\\n try:\\n params_str = get_params_str(params['align_seqs'])\\n except KeyError:\\n params_str = ''\\n # Build the pynast alignment command\\n align_seqs_cmd = '%s %s/align_seqs.py -i %s -o %s %s' %\\\\\\n (python_exe_fp, script_dir, rep_set_fp, pynast_dir, params_str)\\n commands.append([('Align sequences', align_seqs_cmd)])\\n \\n # Prep the alignment filtering command\\n filtered_aln_fp = '%s/%s_rep_set_aligned_pfiltered.fasta' %\\\\\\n (pynast_dir,input_basename)\\n try:\\n params_str = get_params_str(params['filter_alignment'])\\n except KeyError:\\n params_str = ''\\n # Build the alignment filtering command\\n filter_alignment_cmd = '%s %s/filter_alignment.py -o %s -i %s %s' %\\\\\\n (python_exe_fp, script_dir, pynast_dir, aln_fp, params_str)\\n commands.append([('Filter alignment', filter_alignment_cmd)])\\n \\n # Prep the tree building command\\n tree_fp = '%s/rep_set.tre' % output_dir\\n try:\\n params_str = get_params_str(params['make_phylogeny'])\\n except KeyError:\\n params_str = ''\\n # Build the tree building command\\n make_phylogeny_cmd = '%s %s/make_phylogeny.py -i %s -o %s %s' %\\\\\\n (python_exe_fp, script_dir, filtered_aln_fp, tree_fp,\\\\\\n params_str)\\n commands.append([('Build phylogenetic tree', make_phylogeny_cmd)])\\n \\n # Call the command handler on the list of commands\\n command_handler(commands,\\n status_update_callback,\\n logger=logger,\\n close_logger_on_success=close_logger_on_success)\\n \\n return abspath(tree_fp), abspath(otu_table_fp)\",\n \"def resolve_fid(fid):\\n # A list of numbers?\\n if fid.count(',') > 0:\\n return [int(i) for i in fid.split(',')]\\n\\n # A number?\\n try:\\n return int(fid)\\n except ValueError:\\n pass\\n\\n # A symbolic name!\\n\\n symbols = dict(\\n all=set(range(1,25)),\\n\\n # functions that converge earlier than 7^3\\n q=set([1,2,5]),\\n\\n # functions that have a single sharply optimal oracle\\n single=set([2,3,4,6,7,10,11,12,13,15,16,17,18,19,20,21,22,23]),\\n # functions that have multiple feasible candidates (#evals@optimal slowdown <2)\\n many=set([1,5,8,9,14,24]),\\n\\n # functions whose optimal oracle did not dominate throughout the computation (i.e. was not best two powers of |pf| ago)\\n volatile=set([6,8,9,10,11,12,13,14,15,19,20,21,22,23,24]),\\n\\n # functions whose oracle converges steadily\\n steady=set([6,12,17,18,19,24]),\\n # functions whose oracle converges unexpectedly\\n sudden=set([1,2,3,4,5,7,8,9,10,11,13,14,15,16,20,21,22,23]),\\n\\n # functions where CMA (the by far best-performing pf member) converges\\n CMAgood=set([6,7,10,11,12,13,16,17,18,21,22,23]),\\n # functions where CMA (the by far best-performing pf member) does not converge\\n CMAbad=set([1,2,3,4,5,8,9,14,15,19,20,24]),\\n\\n # original BBOB families\\n separ=set(range(1,6)),\\n lcond=set(range(6,10)),\\n hcond=set(range(10,15)),\\n multi=set(range(15,20)),\\n mult2=set(range(20,25)),\\n )\\n\\n fidset = set([])\\n for m in re.finditer(r'([+:-])?([^+:-]+)', fid):\\n if m.group(1) is None:\\n fidset = symbols[m.group(2)]\\n elif m.group(1) == '+':\\n fidset |= symbols[m.group(2)]\\n elif m.group(1) == ':':\\n fidset &= symbols[m.group(2)]\\n elif m.group(1) == '-':\\n fidset -= symbols[m.group(2)]\\n else:\\n raise ValueError('bad fid syntax ' + fid)\\n return list(fidset)\",\n \"def protons ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n ## \\n if self['NOPIDHADRONS'] :\\n from StandardParticles import StdAllNoPIDsProtons as inpts\\n protoncut = self['ProtonCut']\\n else :\\n from StandardParticles import StdAllLooseANNProtons as inpts \\n protoncut = \\\"(%s)&(%s)\\\" % ( self['ProtonCut'] , self['ProtonPIDCut'] ) \\n #\\n ##\\n return self.make_selection (\\n 'Proton' ,\\n FilterDesktop ,\\n [ inpts ] ,\\n Code = protoncut ,\\n )\",\n \"def multi_focus_TIE(fs, using_gpu=False, printing=False, *erps, **kwerps):\\n mftie = MFTIE(fs, using_gpu, *erps, **kwerps)\\n phase = mftie()\\n if printing:\\n mftie.print_k2_thres()\\n return phase\",\n \"def office_clean_event_kernels(parser, args, params):\\n parser.parse_known_args(args)\\n control.clean_event_kernels(params)\",\n \"def setupDeterminer(exposure, nEigenComponents=3, starSelectorAlg=\\\"secondMoment\\\"):\\n schema = afwTable.SourceTable.makeMinimalSchema()\\n if starSelectorAlg == \\\"secondMoment\\\":\\n starSelectorClass = measAlg.SecondMomentStarSelectorTask\\n starSelectorConfig = starSelectorClass.ConfigClass()\\n starSelectorConfig.clumpNSigma = 3.0\\n starSelectorConfig.badFlags = [ ]\\n elif starSelectorAlg == \\\"objectSize\\\":\\n starSelectorClass = measAlg.ObjectSizeStarSelectorTask\\n starSelectorConfig = starSelectorClass.ConfigClass()\\n starSelectorConfig.badFlags = [\\\"base_PixelFlags_flag_edge\\\",\\n \\\"base_PixelFlags_flag_interpolatedCenter\\\",\\n \\\"base_PixelFlags_flag_saturatedCenter\\\",\\n \\\"base_PixelFlags_flag_crCenter\\\",\\n ]\\n starSelectorConfig.widthStdAllowed = 0.5\\n\\n starSelector = starSelectorClass(config=starSelectorConfig,schema=schema)\\n\\n psfDeterminerFactory = measAlg.psfDeterminerRegistry[\\\"pca\\\"]\\n psfDeterminerConfig = psfDeterminerFactory.ConfigClass()\\n width, height = exposure.getMaskedImage().getDimensions()\\n psfDeterminerConfig.sizeCellX = width\\n psfDeterminerConfig.sizeCellY = height//3\\n psfDeterminerConfig.nEigenComponents = nEigenComponents\\n psfDeterminerConfig.spatialOrder = 1\\n psfDeterminerConfig.spatialReject = 6.0\\n psfDeterminerConfig.kernelSizeMin = 31\\n psfDeterminerConfig.nStarPerCell = 0\\n psfDeterminerConfig.nStarPerCellSpatialFit = 0 # unlimited\\n psfDeterminer = psfDeterminerFactory(psfDeterminerConfig)\\n\\n return starSelector, psfDeterminer\",\n \"def apply_science_modules_elasticc(df: DataFrame) -> DataFrame:\\n # Required alert columns\\n to_expand = ['midPointTai', 'filterName', 'psFlux', 'psFluxErr']\\n\\n # Use for creating temp name\\n prefix = 'c'\\n\\n # Append temp columns with historical + current measurements\\n for colname in to_expand:\\n df = concat_col(\\n df, colname, prefix=prefix,\\n current='diaSource', history='prvDiaForcedSources'\\n )\\n expanded = [prefix + i for i in to_expand]\\n\\n _LOG.info(\\\"New processor: xmatch (random positions)\\\")\\n # Assuming random positions\\n df = df.withColumn('cdsxmatch', F.lit('Unknown'))\\n\\n _LOG.info(\\\"New processor: asteroids (random positions)\\\")\\n df = df.withColumn('roid', F.lit(0))\\n\\n # add redshift\\n df = df.withColumn('redshift', F.col('diaObject.z_final'))\\n df = df.withColumn('redshift_err', F.col('diaObject.z_final_err'))\\n\\n _LOG.info(\\\"New processor: EarlySN\\\")\\n args = ['cmidPointTai', 'cfilterName', 'cpsFlux', 'cpsFluxErr']\\n\\n # fake cdsxmatch and nobs\\n args += [F.col('diaObject.ra'), F.col('diaObject.decl')]\\n args += [F.col('diaObject.hostgal_ra'), F.col('diaObject.hostgal_dec')]\\n args += [F.col('diaObject.hostgal_snsep')]\\n args += [F.col('diaObject.hostgal_zphot')]\\n args += [F.col('diaObject.hostgal_zphot_err')]\\n\\n df = df.withColumn('rf_snia_vs_nonia', rfscore_sigmoid_elasticc(*args))\\n\\n # Apply level one processor: superNNova\\n _LOG.info(\\\"New processor: supernnova - Ia\\\")\\n args = [F.col('diaSource.diaSourceId')]\\n args += [F.col('cmidPointTai'), F.col('cfilterName'), F.col('cpsFlux'), F.col('cpsFluxErr')]\\n args += [F.col('roid'), F.col('cdsxmatch'), F.array_min('cmidPointTai')]\\n args += [F.col('diaObject.mwebv'), F.col('redshift'), F.col('redshift_err')]\\n args += [F.lit('elasticc_ia')]\\n df = df.withColumn('snn_snia_vs_nonia', snn_ia_elasticc(*args))\\n\\n _LOG.info(\\\"New processor: supernnova - Broad\\\")\\n args = [F.col('diaSource.diaSourceId')]\\n args += [F.col('cmidPointTai'), F.col('cfilterName'), F.col('cpsFlux'), F.col('cpsFluxErr')]\\n args += [F.col('roid'), F.col('cdsxmatch'), F.array_min('cmidPointTai')]\\n args += [F.col('diaObject.mwebv'), F.col('redshift'), F.col('redshift_err')]\\n args += [F.lit('elasticc_broad')]\\n df = df.withColumn('preds_snn', snn_broad_elasticc(*args))\\n\\n mapping_snn = {\\n 0: 11,\\n 1: 13,\\n 2: 12,\\n 3: 22,\\n 4: 21,\\n }\\n mapping_snn_expr = F.create_map([F.lit(x) for x in chain(*mapping_snn.items())])\\n\\n col_class = F.col('preds_snn').getItem(0).astype('int')\\n df = df.withColumn('snn_broad_class', mapping_snn_expr[col_class])\\n df = df.withColumn('snn_broad_max_prob', F.col('preds_snn').getItem(1))\\n\\n # CBPF\\n args = ['cmidPointTai', 'cpsFlux', 'cpsFluxErr', 'cfilterName']\\n args += [F.col('diaObject.mwebv'), F.col('diaObject.z_final'), F.col('diaObject.z_final_err')]\\n args += [F.col('diaObject.hostgal_zphot'), F.col('diaObject.hostgal_zphot_err')]\\n df = df.withColumn('cbpf_preds', predict_nn(*args))\\n\\n mapping_cats_general = {\\n 0: 11,\\n 1: 12,\\n 2: 13,\\n 3: 21,\\n 4: 22,\\n }\\n mapping_cats_general_expr = F.create_map([F.lit(x) for x in chain(*mapping_cats_general.items())])\\n\\n df = df.withColumn('argmax', F.expr('array_position(cbpf_preds, array_max(cbpf_preds)) - 1'))\\n df = df.withColumn('cats_broad_class', mapping_cats_general_expr[df['argmax']])\\n df = df.withColumn('cats_broad_max_prob', F.array_max(df['cbpf_preds']))\\n\\n # AGN\\n args_forced = [\\n 'diaObject.diaObjectId', 'cmidPointTai', 'cpsFlux', 'cpsFluxErr', 'cfilterName',\\n 'diaSource.ra', 'diaSource.decl',\\n 'diaObject.hostgal_zphot', 'diaObject.hostgal_zphot_err',\\n 'diaObject.hostgal_ra', 'diaObject.hostgal_dec'\\n ]\\n df = df.withColumn('rf_agn_vs_nonagn', agn_elasticc(*args_forced))\\n\\n # SLSN\\n args_forced = [\\n 'diaObject.diaObjectId', 'cmidPointTai', 'cpsFlux', 'cpsFluxErr', 'cfilterName',\\n 'diaSource.ra', 'diaSource.decl',\\n 'diaObject.hostgal_zphot', 'diaObject.hostgal_zphot_err',\\n 'diaObject.hostgal_ra', 'diaObject.hostgal_dec'\\n ]\\n df = df.withColumn('rf_slsn_vs_nonslsn', slsn_elasticc(*args_forced))\\n\\n # Drop temp columns\\n df = df.drop(*expanded)\\n df = df.drop(*['preds_snn', 'cbpf_preds', 'redshift', 'redshift_err', 'cdsxmatch', 'roid', 'argmax'])\\n\\n return df\",\n \"def analyze(self, event):\\n\\t\\tJets = Collection(event, \\\"Jet\\\")\\n\\t\\tjets = [j for j in Jets if j.pt >= 20]\\n\\t\\tgenpart = Collection(event, \\\"GenPart\\\")\\n\\t\\tgenParts = [l for l in genpart]\\n\\t\\t# get the particles when they have a mother ---> getting the daughters only \\n\\t\\tdaughters = [l for l in genpart if l.genPartIdxMother>= 0 ]\\n\\t\\tevent.nIsr = 0\\n\\t\\tfor jet in jets:\\n\\t\\t\\tif jet.pt <30.0: continue\\n\\t\\t\\tif abs(jet.eta )>2.4: continue\\n\\t\\t\\tmatched = False\\n\\t\\t\\tfor i,mc in enumerate(genParts):\\n\\t\\t\\t\\t# if it's matched doesn't make sence to correct it\\n\\t\\t\\t\\tif matched: break\\n\\t\\t\\t\\t# check if it's quark from top or not\\n\\t\\t\\t\\tif (mc.status!=23 or abs(mc.pdgId)>5): continue\\n\\t\\t\\t\\tmomid = abs(genParts[mc.genPartIdxMother].pdgId)\\n\\t\\t\\t\\tif not (momid==6 or momid==23 or momid==24 or momid==25 or momid>1e6): continue\\n\\t\\t\\t\\tfor idau in range(len(daughters)) :\\n\\t\\t\\t\\t\\t# look for the products of the jet and match jet with gen daughters of the quark \\n\\t\\t\\t\\t\\tif i == daughters[idau].genPartIdxMother:\\n\\t\\t\\t\\t\\t\\tdR = math.sqrt(deltaR2(jet.eta,jet.phi, daughters[idau].eta,daughters[idau].phi))\\n\\t\\t\\t\\t\\t\\tif dR<0.3:\\n\\t\\t\\t\\t\\t\\t\\t# if matched escape\\n\\t\\t\\t\\t\\t\\t\\tmatched = True\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t# if not matched correct it \\n\\t\\t\\tif not matched:\\n\\t\\t\\t\\tevent.nIsr+=1\\n\\t\\t# fill the output with nisr\\n\\t\\tself.out.fillBranch(\\\"nIsr\\\",event.nIsr)\\n\\t\\tnISRweight = 1\\n\\t\\t#https://indico.cern.ch/event/592621/contributions/2398559/attachments/1383909/2105089/16-12-05_ana_manuelf_isr.pdf\\n\\t\\tISRweights_Mar17 = { 0: 1, 1 : 0.920, 2 : 0.821, 3 : 0.715, 4 : 0.662, 5 : 0.561, 6 : 0.511}\\n\\t\\tISRweights_ICHEP16 = { 0: 1, 1 : 0.882, 2 : 0.792, 3 : 0.702, 4 : 0.648, 5 : 0.601, 6 : 0.515}\\n\\t\\tISRweightssyst_Mar17 = { 0: 0.0, 1 : 0.040, 2 : 0.090, 3 : 0.143, 4 : 0.169, 5 : 0.219, 6 : 0.244}\\n\\t\\tISRweightssyst_ICHEP16 = { 0: 0.0, 1 : 0.059, 2 : 0.104, 3 : 0.149, 4 : 0.176, 5 : 0.199, 6 : 0.242}\\n\\t\\t\\n\\t\\tif self.ICHEP16 == True and self.Mar17 == False:\\n\\t\\t\\tISRweights = ISRweights_ICHEP16\\n\\t\\t\\tISRweightssyst = ISRweightssyst_ICHEP16\\n\\t\\t\\t\\n\\t\\telif self.ICHEP16 == False and self.Mar17 == True: \\n\\t\\t\\tISRweights = ISRweights_Mar17\\n\\t\\t\\tISRweightssyst = ISRweightssyst_Mar17\\n\\t\\t\\t\\n\\t\\tnISRforWeights = int(event.nIsr)\\n\\t\\tif event.nIsr > 6:\\n\\t\\t\\tnISRforWeights = 6\\n\\t\\tC_ISR = 1.090\\n\\t\\tC_ISR_up = 1.043\\n\\t\\tC_ISR_down = 1.141\\n\\t\\tnISRweight = C_ISR * ISRweights[nISRforWeights]\\n\\t\\tnISRweightsyst_up = C_ISR_up * (ISRweights[nISRforWeights] + ISRweightssyst[nISRforWeights])\\n\\t\\tnISRweightsyst_down = C_ISR_down * (ISRweights[nISRforWeights] - ISRweightssyst[nISRforWeights])\\n\\t\\t\\n\\t\\tself.out.fillBranch(\\\"nISRweight\\\",nISRweight)\\n\\t\\tself.out.fillBranch(\\\"nISRttweightsyst_up\\\",nISRweightsyst_up)\\n\\t\\tself.out.fillBranch(\\\"nISRttweightsyst_down\\\",nISRweightsyst_down)\\n\\n\\n # ------ Forwarded Message --------\\n # Subject: Re: question for ttbar ISR reweighting\\n # Date: Sat, 14 Jan 2017 20:24:14 +0100\\n # From: Manuel Franco Sevilla <manuel.franco.sevilla@cern.ch>\\n #The [Nom, Up, Down] values we find for the events with Nisr = 0 are:\\n #[1.090, 1.043, 1.141]: TTJets_Tune\\n #[1.096, 1.046, 1.151]: TTJets_SingleLeptFromT\\n #[1.116, 1.055, 1.185]: TTJets_DiLept\\n\\t\\t\\n\\t\\t\\n\\t\\treturn True\",\n \"def launch_epidemic(self, source, max_time=np.inf):\\n self._init_run(source, max_time)\\n # Init epidemic time to 0\\n time = 0\\n last_print = 0\\n while self.processing:\\n last_time = time\\n # Get the next event to process\\n (node, event_type), time = self.processing.pop(0)\\n if time > self.max_time:\\n break # Stop at then end of the observation window\\n # Process the event\\n if event_type == 'inf':\\n self._process_infection_event(node, time)\\n elif event_type == 'rec':\\n self._process_recovery_event(node, time)\\n else:\\n raise ValueError(\\\"Invalid event type\\\")\\n self._printer.print(self, time)\\n if time-last_time >= 1:\\n self._update_SIR_stats(time)\\n self._printer.println(self, time)\\n self.max_time = time\\n # Free memory\\n del self.processing\",\n \"def get_process_func(dataset_type, dsname):\\n\\n dsformat = 'VOL'\\n if dataset_type == 'RAW':\\n func_name = process_raw\\n elif dataset_type == 'NCVOL':\\n func_name = process_save_radar\\n elif dataset_type == 'PWR':\\n func_name = 'process_signal_power'\\n elif dataset_type == 'SNR':\\n func_name = 'process_snr'\\n elif dataset_type == 'RHOHV_CORRECTION':\\n func_name = 'process_correct_noise_rhohv'\\n elif dataset_type == 'BIAS_CORRECTION':\\n func_name = 'process_correct_bias'\\n elif dataset_type == 'L':\\n func_name = 'process_l'\\n elif dataset_type == 'CDR':\\n func_name = 'process_cdr'\\n elif dataset_type == 'SAN':\\n func_name = 'process_echo_id'\\n elif dataset_type == 'ECHO_FILTER':\\n func_name = 'process_echo_filter'\\n elif dataset_type == 'SNR_FILTER':\\n func_name = 'process_filter_snr'\\n elif dataset_type == 'VIS_FILTER':\\n func_name = 'process_filter_visibility'\\n elif dataset_type == 'OUTLIER_FILTER':\\n func_name = 'process_outlier_filter'\\n elif dataset_type == 'PHIDP0_CORRECTION':\\n func_name = 'process_correct_phidp0'\\n elif dataset_type == 'PHIDP_SMOOTH_1W':\\n func_name = 'process_smooth_phidp_single_window'\\n elif dataset_type == 'PHIDP_SMOOTH_2W':\\n func_name = 'process_smooth_phidp_double_window'\\n elif dataset_type == 'PHIDP_KDP_MAESAKA':\\n func_name = 'process_phidp_kdp_Maesaka'\\n elif dataset_type == 'PHIDP_KDP_LP':\\n func_name = 'process_phidp_kdp_lp'\\n elif dataset_type == 'KDP_LEASTSQUARE_1W':\\n func_name = 'process_kdp_leastsquare_single_window'\\n elif dataset_type == 'KDP_LEASTSQUARE_2W':\\n func_name = 'process_kdp_leastsquare_double_window'\\n elif dataset_type == 'ATTENUATION':\\n func_name = 'process_attenuation'\\n elif dataset_type == 'RAINRATE':\\n func_name = 'process_rainrate'\\n elif dataset_type == 'WIND_VEL':\\n func_name = 'process_wind_vel'\\n elif dataset_type == 'WINDSHEAR':\\n func_name = 'process_windshear'\\n elif dataset_type == 'HYDROCLASS':\\n func_name = 'process_hydroclass'\\n elif dataset_type == 'PHIDP0_ESTIMATE':\\n func_name = 'process_estimate_phidp0'\\n elif dataset_type == 'RHOHV_RAIN':\\n func_name = 'process_rhohv_rain'\\n elif dataset_type == 'ZDR_RAIN':\\n func_name = 'process_zdr_rain'\\n elif dataset_type == 'SELFCONSISTENCY_KDP_PHIDP':\\n func_name = 'process_selfconsistency_kdp_phidp'\\n elif dataset_type == 'SELFCONSISTENCY_BIAS':\\n func_name = 'process_selfconsistency_bias'\\n elif dataset_type == 'TIME_AVG':\\n func_name = 'process_time_avg'\\n dsformat = 'TIMEAVG'\\n elif dataset_type == 'WEIGHTED_TIME_AVG':\\n func_name = 'process_weighted_time_avg'\\n dsformat = 'TIMEAVG'\\n elif dataset_type == 'FLAG_TIME_AVG':\\n func_name = 'process_time_avg_flag'\\n dsformat = 'TIMEAVG'\\n elif dataset_type == 'COLOCATED_GATES':\\n func_name = 'process_colocated_gates'\\n dsformat = 'COLOCATED_GATES'\\n elif dataset_type == 'INTERCOMP':\\n func_name = 'process_intercomp'\\n dsformat = 'INTERCOMP'\\n elif dataset_type == 'INTERCOMP_TIME_AVG':\\n func_name = 'process_intercomp_time_avg'\\n dsformat = 'INTERCOMP'\\n elif dataset_type == 'MONITORING':\\n func_name = 'process_monitoring'\\n dsformat = 'MONITORING'\\n elif dataset_type == 'SUN_HITS':\\n func_name = 'process_sun_hits'\\n dsformat = 'SUN_HITS'\\n elif dataset_type == 'POINT_MEASUREMENT':\\n func_name = process_point_measurement\\n dsformat = 'TIMESERIES'\\n elif dataset_type == 'TRAJ':\\n func_name = process_trajectory\\n dsformat = 'TRAJ_ONLY'\\n elif dataset_type == 'TRAJ_ATPLANE':\\n func_name = process_traj_atplane\\n dsformat = 'TIMESERIES'\\n elif dataset_type == 'TRAJ_ANTENNA_PATTERN':\\n func_name = process_traj_antenna_pattern\\n dsformat = 'TIMESERIES'\\n else:\\n raise ValueError(\\\"ERROR: Unknown dataset type '%s' of dataset '%s'\\\"\\n % (dataset_type, dsname))\\n\\n return func_name, dsformat\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--num', action='store', type=int, required=True)\\n num = parser.parse_args().num\\n # load ing subset and usda ingredients\\n ing_path = 'data/join/%d.pkl' % num\\n ings = pickle.load(open(ing_path, 'rb'))\\n usda_path = 'data/join/usda.pkl'\\n usda = pickle.load(open(usda_path, 'rb'))\\n names = usda['desc']\\n processed = names.apply(fuzz._process_and_sort)\\n usda_id_map = get_usda_id_map(processed)\\n name_id_map = {ing: usda_id_map[(fuzzy_match(\\n fuzz._process_and_sort(ing), ing_ser=processed, comp=fuzz.token_set_ratio))] for ing in ings}\\n peak(name_id_map, names)\\n # save name_id_map\\n out_path = 'data/join/%d_map.pkl' % num\\n pickle.dump(name_id_map)\",\n \"def Process(nc_path):\\n\\n fname = os.path.basename(nc_path)\\n _, ext = os.path.splitext(fname)\\n\\n if fname.endswith('.nc'):\\n open_dataset = xr.open_dataset\\n elif fname.endswith('.zarr'):\\n open_dataset = xr.open_zarr\\n else:\\n raise ValueError(f\\\"{ext} is not a valid file format.\\\")\\n\\n # Open nc file in order to determine what echosounder produced the original dataset\\n with open_dataset(nc_path) as nc_file:\\n try:\\n echo_type = nc_file.keywords\\n except AttributeError:\\n raise ValueError(\\\"This file is incompatible with echopype functions.\\\")\\n\\n # Returns specific Process object\\n if echo_type == \\\"EK60\\\":\\n return ProcessEK60(nc_path)\\n elif echo_type == \\\"EK80\\\":\\n return ProcessEK80(nc_path)\\n elif echo_type == \\\"AZFP\\\":\\n return ProcessAZFP(nc_path)\\n else:\\n raise ValueError(\\\"Unsupported file type\\\")\",\n \"def process_tree(tree):\\n c = circuit()\\n l = line()\\n names = {}\\n procedures = []\\n for lst in tree.children:\\n print(lst)\\n if type(lst[0]) is str:\\n names[lst[0]] = lst[1]\\n else:\\n procedures.append(lst)\\n print(names)\\n #print(procedures)\\n\\n for proc in procedures:\\n\\n proc_elements_names = proc[0]\\n proc_name = proc[1]\\n\\n #print(proc_elements_names)\\n #print(proc_name)\\n\\n if proc_name == \\\"set_mode\\\":\\n mode_name = proc_elements_names[0]\\n if mode_name != \\\"draw-mode\\\": \\n c.set_mode(mode_name)\\n elif mode_name == \\\"draw-mode\\\":\\n l1 = line()\\n # draw mode is different from other modes\\n for element in names:\\n e = CompleteElement(element)\\n e.set_other_attrs(names[element])\\n e.process_other_attrs()\\n l1.addElement(e)\\n c.connectInSeries(l1)\\n c.set_mode(\\\"draw-mode\\\")\\n \\n \\n if proc_name == \\\"series\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n l = l1\\n c.connectInSeries(l)\\n #raise SyntaxError(\\\"Alias {0} referrenced before assignment\\\".format(item[0]))\\n\\n elif proc_name == \\\"parallel\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n c.connectInParallel(l1)\\n l1 = line()\\n\\n\\n elif proc_name == \\\"add_parallel\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n l1 = line()\\n l1.addElement(names[new_element])\\n c.connection.append(l1)\\n\\n\\n elif proc_name == \\\"add_series\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n for ln in c.connection:\\n for e in ln.elements:\\n if names[old_element] == e:\\n ln.addElement(names[new_element])\\n\\n\\n c.evaluate(\\\"output.png\\\")\\n #print(c)\",\n \"def get_raw_feature_name(self):\\n # open a h5 file in case we need it\\n f5 = h5py.File(self.train_database[0], 'r')\\n mol_name = list(f5.keys())[0]\\n raw_data = f5.get(mol_name + '/features/')\\n\\n # if we select all the features\\n if self.select_feature == \\\"all\\\":\\n self.select_feature = {}\\n self.select_feature['AtomicDensities'] = config.atom_vdw_radius_noH\\n self.select_feature['Features'] = [\\n name for name in raw_data.keys()]\\n\\n # if a selection was made\\n else:\\n # we loop over the input dict\\n for feat_type, feat_names in self.select_feature.items():\\n\\n # if for a given type we need all the feature\\n if feat_names == 'all':\\n if feat_type == 'AtomicDensities':\\n self.select_feature['AtomicDensities'] = \\\\\\n config.atom_vdw_radius_noH\\n elif feat_type == 'Features':\\n self.select_feature[feat_type] = list(\\n raw_data.keys())\\n else:\\n raise KeyError(\\n f'Wrong feature type {feat_type}. '\\n f'It should be \\\"AtomicDensities\\\" or \\\"Features\\\".')\\n\\n else:\\n if feat_type == 'AtomicDensities':\\n assert isinstance(\\n self.select_feature['AtomicDensities'], dict)\\n elif feat_type == 'Features':\\n self.select_feature[feat_type] = []\\n for name in feat_names:\\n if '*' in name:\\n match = name.split('*')[0]\\n possible_names = list(raw_data.keys())\\n match_names = [\\n n for n in possible_names\\n if n.startswith(match)]\\n self.select_feature[feat_type] += match_names\\n else:\\n self.select_feature[feat_type] += [name]\\n else:\\n raise KeyError(\\n f'Wrong feature type {feat_type}. '\\n f'It should be \\\"AtomicDensities\\\" or \\\"Features\\\".')\\n\\n f5.close()\",\n \"def fullcore_detectors():\\n\\n cwd = os.getcwd()\\n fname = get_sample_data('%s/oecd-fullcore_geom1.png' % (cwd))\\n im = plt.imread(fname)\\n\\n # crop the image\\n height, width, color = np.shape(im)\\n y1 = int(height*0.15)\\n y2 = int(height*0.6)\\n x1 = int(width*0.45)\\n x2 = int(width)\\n plt.imshow(im[y1:y2,x1:x2,:])\\n plt.axis('off')\\n\\n # Axial 1\\n x = 158\\n y = 291\\n P = 55\\n s = P/2/np.cos(np.pi/6)\\n plt.plot([s+x, 2*s+x], [0+y, 0+y], 'r-', lw=1.5, label='1- Axial1')\\n plt.plot([s+x, 2*s+x], [P+y, P+y], 'r-', lw=1.5)\\n plt.plot([s+x, s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\\n plt.plot([s/2+x, s+x], [P/2+y, P+y], 'r-', lw=1.5)\\n plt.plot([2*s+x, 2*s+s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\\n plt.plot([2*s+s/2+x, 2*s+x], [P/2+y, P+y], 'r-', lw=1.5)\\n\\n plt.text(x=x+37, y=y+40, s='1', fontsize=20, color='w')\\n\\n # Axial 2\\n x = 210\\n y = 321\\n P = 55\\n s = P/2/np.cos(np.pi/6)\\n plt.plot([s+x, 2*s+x], [0+y, 0+y], 'r-', lw=1.5, label='2- Axial2')\\n plt.plot([s+x, 2*s+x], [P+y, P+y], 'r-', lw=1.5)\\n plt.plot([s+x, s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\\n plt.plot([s/2+x, s+x], [P/2+y, P+y], 'r-', lw=1.5)\\n plt.plot([2*s+x, 2*s+s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\\n plt.plot([2*s+s/2+x, 2*s+x], [P/2+y, P+y], 'r-', lw=1.5)\\n plt.text(x=x+37, y=y+40, s='2', fontsize=20, color='w')\\n\\n # Axial 3\\n x = 262\\n y = 291\\n P = 55\\n s = P/2/np.cos(np.pi/6)\\n plt.plot([s+x, 2*s+x], [0+y, 0+y], 'r-', lw=1.5, label='3- Axial3')\\n plt.plot([s+x, 2*s+x], [P+y, P+y], 'r-', lw=1.5)\\n plt.plot([s+x, s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\\n plt.plot([s/2+x, s+x], [P/2+y, P+y], 'r-', lw=1.5)\\n plt.plot([2*s+x, 2*s+s/2+x], [0+y, P/2+y], 'r-', lw=1.5)\\n plt.plot([2*s+s/2+x, 2*s+x], [P/2+y, P+y], 'r-', lw=1.5)\\n\\n plt.text(x=x+37, y=y+40, s='3', fontsize=20, color='w')\\n\\n # Radial 1\\n x = 52\\n y = 349\\n plt.plot([x, 495+x], [y, y], 'r-', lw=1.5, label='4- Radial1')\\n plt.plot([x, 495+x], [y, y], 'r-', lw=1.5, label='5- Radial2')\\n plt.text(x=x+380, y=y-10, s='4, 5', fontsize=20, color='black')\\n\\n # Radial 2\\n x = 52\\n y = 349\\n L = 495\\n plt.plot([x, L*np.cos(np.pi/6)+x], [y, -L/2+y], 'r-', lw=1.5, label='6- Radial3')\\n plt.text(x=350, y=y-200, s='6', rotation=30, fontsize=20, color='black')\\n plt.legend(loc='best')\\n\\n plt.savefig(\\\"oecd-fullcore-detectors\\\", dpi=300, bbox_inches=\\\"tight\\\")\",\n \"def eog_removal(self):\\n print('ch_names are: ' + str(self.raw.ch_names))\\n ch_name = input(\\\"Enter a channel for eog detection. Best if the channel is near eyes, like Fp1 and Fp2. All channels will be named like 'CH_1': \\\")\\n eog_projs, eog_events = mne.preprocessing.compute_proj_eog(self.raw, n_grad=0, n_mag=0, n_eeg=1, ch_name=ch_name, reject = None)\\n projs = eog_projs\\n self.epochs.add_proj(projs)\\n self.epochs.apply_proj()\\n return self.epochs\",\n \"def parse_process_keywords(proc_kw, rfd_kwargs=None):\\n\\n rfd_kwargs = rfd_kwargs if rfd_kwargs is not None else dict()\\n\\n if proc_kw in ('fast', 'f', 'quick', 'short', None):\\n if 'n_samples' not in rfd_kwargs:\\n rfd_kwargs['n_samples'] = 600\\n elif proc_kw in ('medium', 'm'):\\n if 'n_samples' not in rfd_kwargs:\\n rfd_kwargs['n_samples'] = 1000\\n elif proc_kw in ('slow', 'full', 'f', 's'):\\n if 'n_samples' not in rfd_kwargs:\\n rfd_kwargs['n_samples'] = None\\n elif proc_kw in ('i', 'ideal', 'transit_search', 'ts', 'main'):\\n if 'n_samples' not in rfd_kwargs:\\n rfd_kwargs['n_samples'] = 1000\\n if 'ocut' not in rfd_kwargs:\\n rfd_kwargs['ocut'] = (5, 5, 4, 4, 4)\\n rfd_kwargs['n_iters'] = len(rfd_kwargs['ocut'])\\n elif proc_kw in ('ie', 'ideal_e', 'main_e', 'semi_evolve'):\\n if 'n_samples' not in rfd_kwargs:\\n rfd_kwargs['n_samples'] = 1000\\n if 'ocut' not in rfd_kwargs:\\n rfd_kwargs['ocut'] = (5, 5, 4, 4, 4)\\n if 'evolve' not in rfd_kwargs:\\n rfd_kwargs['evolve'] = (True, True, True, False, False)\\n if 'full_final' not in rfd_kwargs:\\n rfd_kwargs['full_final'] = True\\n if 'n_iters' not in rfd_kwargs:\\n rfd_kwargs['n_iters'] = len(rfd_kwargs['ocut'])\\n elif proc_kw in ('long'):\\n if 'n_samples' not in rfd_kwargs:\\n rfd_kwargs['n_samples'] = None\\n if 'ocut' not in rfd_kwargs:\\n rfd_kwargs['ocut'] = (5, 5, 4, 4, 4)\\n if 'full_final' not in rfd_kwargs:\\n rfd_kwargs['full_final'] = False\\n if 'n_iters' not in rfd_kwargs:\\n rfd_kwargs['n_iters'] = len(rfd_kwargs['ocut'])\\n else:\\n raise ValueError(\\\"proc_kw not recognised: {}\\\".format(proc_kw))\\n\\n if 'n_iters' not in rfd_kwargs:\\n rfd_kwargs['n_iters'] = 4\\n\\n return rfd_kwargs\",\n \"def AssignEpiNames(self):\\n# Sort each run in the series by its acquisition time.\\n epi_sort = self.epi_times.keys()\\n epi_sort.sort()\\n# Rewrite pfiles as an ordered list of p-files to be reconstructed.\\n for idx in xrange(len(epi_sort)):\\n entry = self.epi_times[epi_sort[idx]]\\n info = self.info[entry]\\n if info['data_filetype'] == 'ge_data':\\n self.pfiles_recon.append(entry)\\n info['run'] = '%0d' % (self.n_epi)\\n self.n_epi = self.n_epi + 1\\n plane = info['plane']\\n if not self.epinames.has_key(plane):\\n plane = 'any'\\n n_epi = self.epinames[plane]['n_epi']\\n if n_epi > len(self.epinames[plane]['names'])-1:\\n if self.epinames.has_key('any') and \\\\\\n n_epi < len(self.epinames['any']):\\n plane = 'any'\\n n_epi = self.epinames[plane]['n_epi']\\n else:\\n self.DumpInfo()\\n errstr = 'Not enough EPI names in template file'\\n raise RuntimeError(errstr)\\n# epiname = self.epinames[plane]['names'][n_epi]\\n\\n filebase = os.path.basename(self.epinames[plane]['names'][n_epi])\\n epi_mf_outdir = os.path.dirname(\\\\\\n self.epinames[plane]['names'][n_epi])\\n\\n epi_base = self.epinames[plane]['subdir'][n_epi]\\n tmp_outdir = '%s/%s' % (self.tmpdir, epi_base)\\n# Get output directory for raw epis.\\n if self.no_motcorr:\\n epi_r_outdir = epi_mf_outdir\\n elif self.keep_epi_raw:\\n epi_r_outdir = self.epi_scratch_space\\n else:\\n epi_r_outdir = tmp_outdir\\n\\n# Get output directory for motion-corrected epis.\\n if self.keep_epi_mot:\\n epi_m_outdir = self.epi_scratch_space\\n else:\\n epi_m_outdir = tmp_outdir\\n info['outdir'] = epi_mf_outdir\\n if n_epi < len(self.epinames[plane]['names']):\\n epiname = self.epinames[plane]['names'][n_epi]\\n info['imgfile'] = '%s/%s' % (epi_r_outdir, filebase)\\n else:\\n info['imgfile'] = '%s/s%0d_epi_run%0d' % \\\\\\n (epi_r_outdir, n_epi, idx+1)\\n self.epinames[plane]['n_epi'] += 1\\n\\n info['mot_file'] = '%s/%s_mtn.txt' % (epi_mf_outdir, filebase)\\n info['censor_prefix'] = '%s/%s' % (epi_mf_outdir, filebase)\\n info['imgfile_t'] = '%s/%s_t' % (epi_m_outdir, filebase)\\n if self.no_motcorr:\\n info['imgfile_m'] = None\\n info['imgfile_mf'] = None\\n info['imgfile_final'] = info['imgfile']\\n else:\\n info['imgfile_m'] = '%s/%s_m' % (epi_m_outdir, filebase)\\n if self.no_fmapcorr or info['fmap_entry'] is None:\\n info['imgfile_m'] = '%s/%s_m' % (epi_mf_outdir, filebase)\\n info['imgfile_mf'] = None\\n info['imgfile_final'] = info['imgfile_m']\\n else:\\n info['imgfile_m'] = '%s/%s_m' % (epi_m_outdir, filebase)\\n info['imgfile_mf'] = '%s/%s_mf' % (epi_mf_outdir, filebase)\\n info['imgfile_final'] = info['imgfile_mf']\\n info['skip'] = self.skip\\n info['motion_ref_frame'] = self.tmplt['motion_ref_frame']\\n\\n info['motion_interp'] = self.tmplt['epi_motion_interp']\\n if not info['motion_interp'].startswith('-'):\\n info['motion_interp'] = '-%s' % info['motion_interp']\\n\\n info['filetype'] = self.tmplt['epi_file_format']\\n info['valid'] = True\\n self.info[entry] = info\\n\\n if not self.no_motcorr:\\n epi_base = os.path.basename(info['imgfile_m'])\\n info['matfile_m'] = '%s/%s.aff12.1D' % (info['outdir'], epi_base)\\n info['matfile_mcat'] = '%s/%scat.aff12.1D' % (info['outdir'], epi_base)\",\n \"def runErdosRenyi(n,p):\\n s = z.Optimize()\\n g = ig.Graph.Erdos_Renyi(n, p, directed=True, loops=True)\\n while g.is_dag():\\n g = ig.Graph.Erdos_Renyi(n, p, directed=True, loops=True)\\n\\n return MFAS_set_cover(s,g), u.get_feedback_arc_set(g)\",\n \"def choose_psfs(tgt_cubes,cal_cubes,save_dir):\",\n \"def onKeyPress(self, event):\\n if event.key=='?':\\n #return the help file\\n self.help()\\n elif event.key=='q':\\n #exit the task\\n self.emit(QtCore.SIGNAL(\\\"quit()\\\"))\\n elif event.key=='c':\\n #return the centroid\\n if event.xdata:\\n self.log.message(str(event.xdata), with_header=False)\\n cx=st.mcentroid(self.xarr, self.farr, xc=event.xdata, xdiff=self.mdiff)\\n self.emit(QtCore.SIGNAL(\\\"updatex(float)\\\"), cx)\\n elif event.key=='x':\\n #return the x position\\n if event.xdata:\\n self.log.message(str(event.xdata), with_header=False)\\n self.emit(QtCore.SIGNAL(\\\"updatex(float)\\\"), event.xdata)\\n elif event.key=='R':\\n #reset the fit \\n self.reset()\\n elif event.key=='f':\\n #find the fit\\n self.findfit()\\n self.emit(QtCore.SIGNAL(\\\"fitUpdate()\\\"))\\n elif event.key=='b':\\n #auto-idenitfy features\\n self.isFeature=True\\n self.findfeatures()\\n elif event.key=='z':\\n #Assume the solution is correct and find the zeropoint\\n #that best matches it from cross correllation\\n self.findzp()\\n elif event.key=='Z':\\n #Assume the solution is correct and find the zeropoint\\n #that best matches it from cross correllation\\n self.findzpd()\\n elif event.key=='e':\\n #find closest feature from existing fit and line list\\n #and match it\\n pass\\n elif event.key=='i':\\n #reset identified features\\n pass\\n elif event.key=='t':\\n #reset identified features\\n self.isFeature=True\\n self.testfeatures()\\n elif event.key=='l':\\n #plot the features from existing list\\n if self.isFeature: \\n self.isFeature=False\\n self.redraw_canvas()\\n else:\\n self.isFeature=True\\n self.plotFeatures()\\n self.redraw_canvas()\\n elif event.key=='p':\\n #print information about features\\n for i in range(len(self.xp)):\\n print self.xp[i], self.wp[i]\\n elif event.key=='P':\\n #print information about features\\n print self.ws.coef\\n elif event.key=='r':\\n #redraw graph\\n self.redraw_canvas()\\n elif event.key=='a':\\n #draw artificial spectrum\\n self.isArt= not self.isArt\\n self.redraw_canvas()\\n elif event.key=='d':\\n #Delete feature \\n save=False\\n y=None\\n if event.canvas==self.errfigure: \\n y=event.ydata\\n save=True\\n self.deletepoints(event.xdata, y=y, save=save)\\n self.redraw_canvas(keepzoom=True)\\n elif event.key=='u':\\n #undelete\\n self.undeletepoints(event.xdata, y=event.ydata)\\n self.redraw_canvas(keepzoom=True)\\n elif event.key:\\n self.emit(QtCore.SIGNAL(\\\"keyPressEvent(string)\\\"), event.key)\",\n \"def main_ededge(dataset):\\n Application.set_input_image_folder('TestData/BSR/BSDS500/data/images/' + dataset)\\n\\n # Application.delete_folder_appl_out()\\n # Benchmarking.delete_folder_benchmark_out()\\n\\n Application.do_get_image_job(port_output_name='RAW')\\n Application.do_grayscale_transform_job(port_input_name='RAW', port_output_name='GRAY_RAW')\\n blur = Application.do_gaussian_blur_image_job(port_input_name='GRAY_RAW', sigma=0, kernel_size=9)\\n\\n list_to_eval_edge = []\\n\\n first_order_edge = [\\n CONFIG.FILTERS.PIXEL_DIFF_3x3, CONFIG.FILTERS.PIXEL_DIFF_SEPARATED_3x3\\n , CONFIG.FILTERS.PIXEL_DIFF_SEPARATED_5x5, CONFIG.FILTERS.PIXEL_DIFF_SEPARATED_7x7\\n , CONFIG.FILTERS.PIXEL_DIFF_5x5, CONFIG.FILTERS.PIXEL_DIFF_7x7\\n\\n , CONFIG.FILTERS.SOBEL_3x3, CONFIG.FILTERS.SOBEL_5x5, CONFIG.FILTERS.SOBEL_7x7\\n , CONFIG.FILTERS.SOBEL_DILATED_5x5, CONFIG.FILTERS.SOBEL_DILATED_7x7\\n\\n , CONFIG.FILTERS.PREWITT_3x3, CONFIG.FILTERS.PREWITT_5x5, CONFIG.FILTERS.PREWITT_7x7\\n , CONFIG.FILTERS.PREWITT_DILATED_5x5, CONFIG.FILTERS.PREWITT_DILATED_7x7\\n\\n , CONFIG.FILTERS.KIRSCH_3x3, CONFIG.FILTERS.KIRSCH_5x5\\n , CONFIG.FILTERS.KIRSCH_DILATED_5x5, CONFIG.FILTERS.KIRSCH_DILATED_7x7\\n\\n , CONFIG.FILTERS.KITCHEN_MALIN_3x3\\n , CONFIG.FILTERS.KITCHEN_MALIN_DILATED_5x5, CONFIG.FILTERS.KITCHEN_MALIN_DILATED_7x7\\n\\n , CONFIG.FILTERS.KAYYALI_3x3\\n , CONFIG.FILTERS.KAYYALI_DILATED_5x5, CONFIG.FILTERS.KAYYALI_DILATED_7x7\\n\\n , CONFIG.FILTERS.SCHARR_3x3, CONFIG.FILTERS.SCHARR_5x5\\n , CONFIG.FILTERS.SCHARR_DILATED_5x5, CONFIG.FILTERS.SCHARR_DILATED_7x7\\n\\n , CONFIG.FILTERS.KROON_3x3\\n , CONFIG.FILTERS.KROON_DILATED_5x5, CONFIG.FILTERS.KROON_DILATED_7x7\\n\\n , CONFIG.FILTERS.ORHEI_3x3, CONFIG.FILTERS.ORHEI_B_5x5\\n , CONFIG.FILTERS.ORHEI_DILATED_5x5, CONFIG.FILTERS.ORHEI_DILATED_7x7\\n ]\\n\\n for edge in first_order_edge:\\n for gr_thr in [50]:\\n for anc_thr in [10]:\\n e1, e2, = Application.do_edge_drawing_mod_job(port_input_name=blur, operator=edge,\\n gradient_thr=gr_thr, anchor_thr=anc_thr, scan_interval=1,\\n max_edges=100, max_points_edge=100)\\n list_to_eval_edge.append(e1 + '_L0')\\n\\n Application.create_config_file(verbose=False)\\n Application.configure_save_pictures(job_name_in_port=False, ports_to_save='ALL')\\n # Application.configure_show_pictures(ports_to_show=list_to_save, time_to_show=200)\\n\\n # Application.run_application()\\n\\n # Do bsds benchmarking\\n # Be ware not to activate job_name_in_port in Application.configure_save_pictures\\n # Benchmarking.run_bsds500_boundary_benchmark(input_location='Logs/application_results',\\n # gt_location='TestData/BSR/BSDS500/data/groundTruth/' + dataset,\\n # raw_image='TestData/BSR/BSDS500/data/images/' + dataset,\\n # jobs_set=list_to_eval_edge, do_thinning=False)\\n\\n Utils.plot_first_cpm_results(prefix='EDGE_DRAWING_MOD_', level='L0', order_by='f1', name='ed_results',\\n list_of_data=list_to_eval_edge, number_of_series=50,\\n inputs=[''], self_contained_list=True, set_legend_left=False,\\n suffix_to_cut_legend='_S_0_GRAY_RAW_L0',\\n replace_list=[('EDGE_DRAWING_MOD_THR_50_ANC_THR_10_SCAN_1_', ''),\\n ('SEPARATED_PIXEL_DIFFERENCE_', 'Separated Px Dif '),\\n ('PIXEL_DIFFERENCE_', 'Pixel Dif '),\\n ('PREWITT_', 'Prewitt '), ('KIRSCH_', 'Kirsch '), ('SOBEL_', 'Sobel '),\\n ('SCHARR_', 'Scharr '), ('KROON_', 'Kroon '), ('ORHEI_V1_', 'Orhei '),\\n ('ORHEI_', 'Orhei '),\\n ('KITCHEN_', 'Kitchen '), ('KAYYALI_', 'Kayyali '),\\n ('DILATED_', 'dilated '),\\n ('_GAUSS_BLUR_K_9', '')],\\n save_plot=True, show_plot=False, set_all_to_legend=False)\\n\\n # Utils.create_latex_cpm_table_list()\\n\\n Utils.close_files()\",\n \"def eta_ ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n from StandardParticles import StdLooseEta2gg as inpts \\n ##\\n return self.make_selection (\\n 'EtaStd' ,\\n FilterDesktop ,\\n [ inpts ] ,\\n Code = self['Eta2ggCut'] ,\\n )\",\n \"def start_kernel(self, kernel_name=None, **kwargs):\",\n \"def run_pick_de_novo_otus(input_fp,\\r\\n output_dir,\\r\\n command_handler,\\r\\n params,\\r\\n qiime_config,\\r\\n parallel=False,\\r\\n logger=None,\\r\\n suppress_md5=False,\\r\\n status_update_callback=print_to_stdout):\\r\\n\\r\\n # Prepare some variables for the later steps\\r\\n input_dir, input_filename = split(input_fp)\\r\\n input_basename, input_ext = splitext(input_filename)\\r\\n create_dir(output_dir)\\r\\n commands = []\\r\\n cluster_failures = False\\r\\n if logger is None:\\r\\n logger = WorkflowLogger(generate_log_fp(output_dir),\\r\\n params=params,\\r\\n qiime_config=qiime_config)\\r\\n close_logger_on_success = True\\r\\n else:\\r\\n close_logger_on_success = False\\r\\n\\r\\n if not suppress_md5:\\r\\n log_input_md5s(logger, [input_fp])\\r\\n\\r\\n # Prep the OTU picking command\\r\\n try:\\r\\n otu_picking_method = params['pick_otus']['otu_picking_method']\\r\\n except KeyError:\\r\\n otu_picking_method = 'uclust'\\r\\n pick_otu_dir = '%s/%s_picked_otus' % (output_dir, otu_picking_method)\\r\\n otu_fp = '%s/%s_otus.txt' % (pick_otu_dir, input_basename)\\r\\n if parallel and (otu_picking_method == 'blast' or\\r\\n otu_picking_method == 'uclust_ref'):\\r\\n # Grab the parallel-specific parameters\\r\\n try:\\r\\n params_str = get_params_str(params['parallel'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n\\r\\n # Grab the OTU picker parameters\\r\\n try:\\r\\n # Want to find a cleaner strategy for this: the parallel script\\r\\n # is method-specific, so doesn't take a --otu_picking_method\\r\\n # option. This works for now though.\\r\\n d = params['pick_otus'].copy()\\r\\n del d['otu_picking_method']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n if otu_picking_method == 'uclust_ref':\\r\\n try:\\r\\n suppress_new_clusters = d['suppress_new_clusters']\\r\\n del d['suppress_new_clusters']\\r\\n cluster_failures = False\\r\\n except KeyError:\\r\\n cluster_failures = True\\r\\n failure_otu_picking_method = 'uclust'\\r\\n\\r\\n params_str += ' %s' % get_params_str(d)\\r\\n otu_picking_script = 'parallel_pick_otus_%s.py' % otu_picking_method\\r\\n # Build the OTU picking command\\r\\n pick_otus_cmd = '%s -i %s -o %s -T %s' % (otu_picking_script,\\r\\n input_fp,\\r\\n pick_otu_dir,\\r\\n params_str)\\r\\n else:\\r\\n try:\\r\\n params_str = get_params_str(params['pick_otus'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n # Build the OTU picking command\\r\\n pick_otus_cmd = 'pick_otus.py -i %s -o %s %s' %\\\\\\r\\n (input_fp, pick_otu_dir, params_str)\\r\\n\\r\\n commands.append([('Pick OTUs', pick_otus_cmd)])\\r\\n\\r\\n if cluster_failures:\\r\\n reference_otu_fp = otu_fp\\r\\n clustered_failures_dir = '%s/failure_otus/' % pick_otu_dir\\r\\n\\r\\n try:\\r\\n d = params['pick_otus'].copy()\\r\\n del d['otu_picking_method']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n if 'uclust_otu_id_prefix' not in d:\\r\\n d['uclust_otu_id_prefix'] = 'DeNovoOTU'\\r\\n params_str = ' %s' % get_params_str(d)\\r\\n\\r\\n failures_list_fp = '%s/%s_failures.txt' % \\\\\\r\\n (pick_otu_dir, input_basename)\\r\\n failures_fasta_fp = '%s/%s_failures.fasta' % \\\\\\r\\n (pick_otu_dir, input_basename)\\r\\n\\r\\n filter_fasta_cmd = 'filter_fasta.py -f %s -s %s -o %s' %\\\\\\r\\n (input_fp, failures_list_fp, failures_fasta_fp)\\r\\n\\r\\n commands.append([('Generate failures fasta file',\\r\\n filter_fasta_cmd)])\\r\\n\\r\\n # Prep the OTU picking command for\\r\\n failure_otu_fp = '%s/%s_failures_otus.txt' % (clustered_failures_dir,\\r\\n input_basename)\\r\\n # Build the OTU picking command\\r\\n pick_otus_cmd = 'pick_otus.py -i %s -o %s -m %s %s' %\\\\\\r\\n (failures_fasta_fp, clustered_failures_dir,\\r\\n failure_otu_picking_method, params_str)\\r\\n\\r\\n commands.append(\\r\\n [('Pick de novo OTUs for new clusters', pick_otus_cmd)])\\r\\n\\r\\n merged_otu_map_fp = '%s/merged_otu_map.txt' % clustered_failures_dir\\r\\n cat_otu_tables_cmd = 'cat %s %s >> %s' %\\\\\\r\\n (reference_otu_fp, failure_otu_fp, merged_otu_map_fp)\\r\\n commands.append([('Merge OTU maps', cat_otu_tables_cmd)])\\r\\n otu_fp = merged_otu_map_fp\\r\\n\\r\\n # Prep the representative set picking command\\r\\n rep_set_dir = '%s/rep_set/' % output_dir\\r\\n create_dir(rep_set_dir)\\r\\n rep_set_fp = '%s/%s_rep_set.fasta' % (rep_set_dir, input_basename)\\r\\n rep_set_log_fp = '%s/%s_rep_set.log' % (rep_set_dir, input_basename)\\r\\n\\r\\n try:\\r\\n params_str = get_params_str(params['pick_rep_set'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n # Build the representative set picking command\\r\\n pick_rep_set_cmd = 'pick_rep_set.py -i %s -f %s -l %s -o %s %s' %\\\\\\r\\n (otu_fp, input_fp, rep_set_log_fp, rep_set_fp, params_str)\\r\\n commands.append([('Pick representative set', pick_rep_set_cmd)])\\r\\n\\r\\n # Prep the taxonomy assignment command\\r\\n try:\\r\\n assignment_method = params['assign_taxonomy']['assignment_method']\\r\\n except KeyError:\\r\\n assignment_method = 'uclust'\\r\\n assign_taxonomy_dir = '%s/%s_assigned_taxonomy' %\\\\\\r\\n (output_dir, assignment_method)\\r\\n taxonomy_fp = '%s/%s_rep_set_tax_assignments.txt' % \\\\\\r\\n (assign_taxonomy_dir, input_basename)\\r\\n if parallel and (assignment_method == 'rdp' or\\r\\n assignment_method == 'blast' or\\r\\n assignment_method == 'uclust'):\\r\\n # Grab the parallel-specific parameters\\r\\n try:\\r\\n params_str = get_params_str(params['parallel'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n\\r\\n # Grab the taxonomy assignment parameters\\r\\n try:\\r\\n # Want to find a cleaner strategy for this: the parallel script\\r\\n # is method-specific, so doesn't take a --assignment_method\\r\\n # option. This works for now though.\\r\\n d = params['assign_taxonomy'].copy()\\r\\n if 'assignment_method' in d:\\r\\n del d['assignment_method']\\r\\n params_str += ' %s' % get_params_str(d)\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n # Build the parallel taxonomy assignment command\\r\\n assign_taxonomy_cmd = \\\\\\r\\n 'parallel_assign_taxonomy_%s.py -i %s -o %s -T %s' %\\\\\\r\\n (assignment_method, rep_set_fp, assign_taxonomy_dir, params_str)\\r\\n else:\\r\\n try:\\r\\n params_str = get_params_str(params['assign_taxonomy'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n # Build the taxonomy assignment command\\r\\n assign_taxonomy_cmd = 'assign_taxonomy.py -o %s -i %s %s' %\\\\\\r\\n (assign_taxonomy_dir, rep_set_fp, params_str)\\r\\n\\r\\n commands.append([('Assign taxonomy', assign_taxonomy_cmd)])\\r\\n\\r\\n # Prep the OTU table building command\\r\\n otu_table_fp = '%s/otu_table.biom' % output_dir\\r\\n try:\\r\\n params_str = get_params_str(params['make_otu_table'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n # Build the OTU table building command\\r\\n make_otu_table_cmd = 'make_otu_table.py -i %s -t %s -o %s %s' %\\\\\\r\\n (otu_fp, taxonomy_fp, otu_table_fp, params_str)\\r\\n\\r\\n commands.append([('Make OTU table', make_otu_table_cmd)])\\r\\n\\r\\n if cluster_failures:\\r\\n reference_otu_table_fp = '%s/reference_only_otu_table.biom' % output_dir\\r\\n # Build the OTU table building command\\r\\n make_otu_table_cmd = 'make_otu_table.py -i %s -t %s -o %s %s' %\\\\\\r\\n (reference_otu_fp, taxonomy_fp, reference_otu_table_fp, params_str)\\r\\n\\r\\n commands.append(\\r\\n [('Make reference-only OTU table', make_otu_table_cmd)])\\r\\n\\r\\n # Prep the pynast alignment command\\r\\n try:\\r\\n alignment_method = params['align_seqs']['alignment_method']\\r\\n except KeyError:\\r\\n alignment_method = 'pynast'\\r\\n pynast_dir = '%s/%s_aligned_seqs' % (output_dir, alignment_method)\\r\\n aln_fp = '%s/%s_rep_set_aligned.fasta' % (pynast_dir, input_basename)\\r\\n if parallel and alignment_method == 'pynast':\\r\\n # Grab the parallel-specific parameters\\r\\n try:\\r\\n params_str = get_params_str(params['parallel'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n\\r\\n # Grab the alignment parameters\\r\\n # Want to find a cleaner strategy for this: the parallel script\\r\\n # is method-specific, so doesn't take a --alignment_method\\r\\n # option. This works for now though.\\r\\n try:\\r\\n d = params['align_seqs'].copy()\\r\\n except KeyError:\\r\\n d = {}\\r\\n try:\\r\\n del d['alignment_method']\\r\\n except KeyError:\\r\\n pass\\r\\n params_str += ' %s' % get_params_str(d)\\r\\n\\r\\n # Build the parallel pynast alignment command\\r\\n align_seqs_cmd = 'parallel_align_seqs_pynast.py -i %s -o %s -T %s' %\\\\\\r\\n (rep_set_fp, pynast_dir, params_str)\\r\\n else:\\r\\n try:\\r\\n params_str = get_params_str(params['align_seqs'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n # Build the pynast alignment command\\r\\n align_seqs_cmd = 'align_seqs.py -i %s -o %s %s' %\\\\\\r\\n (rep_set_fp, pynast_dir, params_str)\\r\\n commands.append([('Align sequences', align_seqs_cmd)])\\r\\n\\r\\n # Prep the alignment filtering command\\r\\n filtered_aln_fp = '%s/%s_rep_set_aligned_pfiltered.fasta' %\\\\\\r\\n (pynast_dir, input_basename)\\r\\n try:\\r\\n params_str = get_params_str(params['filter_alignment'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n # Build the alignment filtering command\\r\\n filter_alignment_cmd = 'filter_alignment.py -o %s -i %s %s' %\\\\\\r\\n (pynast_dir, aln_fp, params_str)\\r\\n commands.append([('Filter alignment', filter_alignment_cmd)])\\r\\n\\r\\n # Prep the tree building command\\r\\n tree_fp = '%s/rep_set.tre' % output_dir\\r\\n try:\\r\\n params_str = get_params_str(params['make_phylogeny'])\\r\\n except KeyError:\\r\\n params_str = ''\\r\\n # Build the tree building command\\r\\n make_phylogeny_cmd = 'make_phylogeny.py -i %s -o %s %s' %\\\\\\r\\n (filtered_aln_fp, tree_fp, params_str)\\r\\n commands.append([('Build phylogenetic tree', make_phylogeny_cmd)])\\r\\n\\r\\n # Call the command handler on the list of commands\\r\\n command_handler(commands,\\r\\n status_update_callback,\\r\\n logger=logger,\\r\\n close_logger_on_success=close_logger_on_success)\\r\\n\\r\\n return abspath(tree_fp), abspath(otu_table_fp)\",\n \"def __init__(self, epics_only=False, *args, **kwargs):\\n self._kwargs = {}\\n self._detectors = {}\\n self._det_list = [] \\n self._det_aliases = {}\\n self._psplots = {}\\n self._event_functions = {}\\n self._source_attrs = []\\n self._evt_time_last = (0,0)\\n self.ievent = 0\\n self._reloadOnLoadRun = False\\n self._reloadOnNextEvent = False\\n self.psana_cfg_dict = {}\\n self._default_module_path = ''\\n\\n# self._user_attrs = {}\\n# self._histograms = {}\\n \\n for key in kwargs:\\n self._kwargs[key] = kwargs[key] \\n if key in self._exp_defaults:\\n setattr(self,key,kwargs[key])\\n print 'setting ',key, kwargs[key]\\n\\n self._device_config = read_device_config(**kwargs)\\n self._device_sets = self._device_config['device_sets'] \\n self._device_types = self._device_config['device_types'] \\n\\n for det in self._device_sets:\\n if 'det' in self._device_sets[det]:\\n if ('detName' in self._device_sets[det]['det'] or\\n 'typeName' in self._device_sets[det]['det']):\\n self._det_list.append(det)\\n if 'det_key' in self._device_sets[det]['det']:\\n det_key = self._device_sets[det]['det']['det_key']\\n self._det_aliases[det_key] = det \\n else:\\n pass\\n \\n# if 'pvs' in self._device_sets[det]:\\n# for attr in self._device_sets[det]['pvs']:\\n# pvbase = self._device_sets[det]['pvs'][attr]['base']\\n# alias = '_'.join([det,attr])\\n# self.add_pv(pvbase, alias)\\n\\n self.set_exp_defaults(**kwargs)\\n if not self._kwargs.get('noload'):\\n self.data_source = self.get_data_source(**kwargs)\\n print 'Data Source = ', self.data_source\\n else:\\n self.data_source = None\\n\\n if not self.data_source:\\n self._kwargs['noload'] = True\\n else:\\n kwargs['run'] = self.run\\n\\n# if self._kwargs.get('noload') or self.live:\\n# if self._kwargs.get('epics_live'):\\n# self.set_kwargs(ami=True)\\n \\n if self._kwargs.get('ami'):\\n print 'loading ami'\\n self.load_ami(**kwargs)\\n\\n if not self._kwargs.get('noload'):\\n print 'loading run'\\n self.load_run(*args, **kwargs)\\n self._no_epicsStore = False\\n \\n print 'Instrument = ', self.instrument\\n\\n if self._kwargs.get('epics_live'): # and self._kwargs.get('epics_file'):\\n print 'loading epics'\\n self.load_epicsLive(**kwargs)\\n\\n if self.ds and self.live:\\n self.next_event()\\n \\n if self.ds and self._reloadOnNextEvent:\\n self.next_event()\\n \\n if not self.ds:\\n self._no_epicsStore = True\\n self._no_evtData = True\\n for det in self._device_sets:\\n if 'pvs' in self._device_sets[det]:\\n print 'Adding epics ',det\\n self.add_detector(det)\",\n \"def handleEvent(eventname, *kwargs):\\n stime = time.time()\\n hdl = [hdl for hdl in classes.get('eventhandler').getEventhandlers(event=eventname) if hdl.handler == 'emonitor.modules.scripts.script.Script']\\n\\n scriptname = \\\"\\\"\\n if len(hdl) == 1:\\n if \\\"in.scriptname\\\" in hdl[0].getParameterList('in'):\\n scriptname = hdl[0].getParameterValue(\\\"in.scriptname\\\")\\n\\n for m in classes.get('monitor').getMonitors():\\n for l in m.getLayouts():\\n if l.trigger == eventname: # find client id for defined event\\n if 'mode' in kwargs[0].keys() and kwargs[0]['mode'] != 'test':\\n monitorserver.sendMessage(str(m.id), 'execute|%s' % scriptname) # execute script on client\\n\\n if 'time' not in kwargs[0]:\\n kwargs[0]['time'] = []\\n kwargs[0]['time'].append('scripts: script \\\"%s\\\" done in %s sec.' % (scriptname, time.time() - stime))\\n return kwargs\",\n \"def pick(episodes, debug=False):\\n\\n if debug:\\n print(\\\"begin pick()\\\")\\n\\n # pick episodes\\n # if factored\\n if len(episodes[\\\"weights\\\"]) != 0:\\n e = choices(episodes[\\\"episodes\\\"],\\n weights = episodes[\\\"weights\\\"])[0]\\n # otherwise\\n else:\\n e = choices(episodes[\\\"episodes\\\"])[0]\\n\\n # gather the data\\n episode = create_episode(e)\\n\\n return episode\",\n \"def fselect(x, y, name, **kwargs):\\n if isinstance(x, pd.DataFrame):\\n x = x.values\\n if isinstance(y, pd.Series):\\n y = y.values\\n if kwargs.get('verbose', False):\\n print(datetime.datetime.now(), 'feature selection with', name)\\n return globals()[name](x=x, y=y, **kwargs)\",\n \"def make_odorant_selector(name):\\n return dcc.Input(\\n id=\\\"cid_%s\\\" % name,\\n placeholder=\\\"Enter a PubChem ID number...\\\",\\n type=\\\"number\\\",\\n value=None,\\n )\",\n \"def plot_denoising(fname_raw, fmin=0, fmax=300, tmin=0.0, tmax=60.0,\\n proj=False, n_fft=4096, color='blue',\\n stim_name=None, event_id=1,\\n tmin_stim=-0.2, tmax_stim=0.5,\\n area_mode='range', area_alpha=0.33, n_jobs=1,\\n title1='before denoising', title2='after denoising',\\n info=None, show=True, fnout=None):\\n\\n from matplotlib import gridspec as grd\\n import matplotlib.pyplot as plt\\n from mne.time_frequency import psd_welch\\n\\n fnraw = get_files_from_list(fname_raw)\\n\\n # ---------------------------------\\n # estimate power spectrum\\n # ---------------------------------\\n psds_all = []\\n freqs_all = []\\n\\n # loop across all filenames\\n for fname in fnraw:\\n\\n # read in data\\n raw = mne.io.Raw(fname, preload=True)\\n picks = mne.pick_types(raw.info, meg='mag', eeg=False,\\n stim=False, eog=False, exclude='bads')\\n\\n if area_mode not in [None, 'std', 'range']:\\n raise ValueError('\\\"area_mode\\\" must be \\\"std\\\", \\\"range\\\", or None')\\n\\n psds, freqs = psd_welch(raw, picks=picks, fmin=fmin, fmax=fmax,\\n tmin=tmin, tmax=tmax, n_fft=n_fft,\\n n_jobs=n_jobs, proj=proj)\\n psds_all.append(psds)\\n freqs_all.append(freqs)\\n\\n if stim_name:\\n n_xplots = 2\\n\\n # get some infos\\n events = mne.find_events(raw, stim_channel=stim_name, consecutive=True)\\n\\n else:\\n n_xplots = 1\\n\\n fig = plt.figure('denoising', figsize=(16, 6 * n_xplots))\\n gs = grd.GridSpec(n_xplots, int(len(psds_all)))\\n\\n # loop across all filenames\\n for idx in range(int(len(psds_all))):\\n\\n # ---------------------------------\\n # plot power spectrum\\n # ---------------------------------\\n p1 = plt.subplot(gs[0, idx])\\n\\n # Convert PSDs to dB\\n psds = 10 * np.log10(psds_all[idx])\\n psd_mean = np.mean(psds, axis=0)\\n if area_mode == 'std':\\n psd_std = np.std(psds, axis=0)\\n hyp_limits = (psd_mean - psd_std, psd_mean + psd_std)\\n elif area_mode == 'range':\\n hyp_limits = (np.min(psds, axis=0), np.max(psds, axis=0))\\n else: # area_mode is None\\n hyp_limits = None\\n\\n p1.plot(freqs_all[idx], psd_mean, color=color)\\n if hyp_limits is not None:\\n p1.fill_between(freqs_all[idx], hyp_limits[0], y2=hyp_limits[1],\\n color=color, alpha=area_alpha)\\n\\n if idx == 0:\\n p1.set_title(title1)\\n ylim = [np.min(psd_mean) - 10, np.max(psd_mean) + 10]\\n else:\\n p1.set_title(title2)\\n\\n p1.set_xlabel('Freq (Hz)')\\n p1.set_ylabel('Power Spectral Density (dB/Hz)')\\n p1.set_xlim(freqs_all[idx][0], freqs_all[idx][-1])\\n p1.set_ylim(ylim[0], ylim[1])\\n\\n # ---------------------------------\\n # plot signal around stimulus\\n # onset\\n # ---------------------------------\\n if stim_name:\\n raw = mne.io.Raw(fnraw[idx], preload=True)\\n epochs = mne.Epochs(raw, events, event_id, proj=False,\\n tmin=tmin_stim, tmax=tmax_stim, picks=picks,\\n preload=True, baseline=(None, None))\\n evoked = epochs.average()\\n if idx == 0:\\n ymin = np.min(evoked.data)\\n ymax = np.max(evoked.data)\\n\\n times = evoked.times * 1e3\\n p2 = plt.subplot(gs[1, idx])\\n p2.plot(times, evoked.data.T, 'blue', linewidth=0.5)\\n p2.set_xlim(times[0], times[len(times) - 1])\\n p2.set_ylim(1.1 * ymin, 1.1 * ymax)\\n\\n if (idx == 1) and info:\\n plt.text(times[0], 0.9 * ymax, ' ICs: ' + str(info))\\n\\n # save image\\n if fnout:\\n fig.savefig(fnout + '.png', format='png')\\n\\n # show image if requested\\n if show:\\n plt.show()\\n\\n plt.close('denoising')\\n plt.ion()\",\n \"def trigger_encoding_sending(obj_name, input_event, port='/dev/parport0'):\\n\\n task = {'Calibration': 10, 'QA': 40, 'Artifact': 70}\\n digit_task = task[obj_name]\\n trigger_table = np.array([[None, None],\\n [None, None],\\n [4, 5],\\n [6, None],\\n [8, 9],\\n [None, 7],\\n [62, 63]])\\n\\n if isinstance(input_event, numbers.Number):\\n digit_event = str(input_event)\\n data = digit_task + input_event\\n trigger_sending(data, port=port)\\n else:\\n for ind in np.where(input_event[:, 0] == 1)[0]:\\n digit_event = input_event[ind, 1]\\n if ind == trigger_table.shape[0] - 1:\\n data = trigger_table[ind, int(digit_event)]\\n else:\\n try:\\n data = digit_task + trigger_table[ind, int(digit_event)]\\n except:\\n data = None\\n\\n trigger_sending(data, port=port)\",\n \"def run(self, code, file_name):\\n new_code = self._ieee_library_pattern.sub(r'\\\\1new_ieee, ieee\\\\2', code)\\n\\n matches = list(self._ieee_use_pattern.finditer(new_code))\\n matches.sort(key=lambda match: match.start('package'), reverse=True)\\n for match in matches:\\n if match.group('package').lower() != 'std_logic_1164':\\n new_code = new_code[:match.start('library')] + 'new_ieee' + new_code[match.end('library'):]\\n\\n return new_code\",\n \"def _atom_selection(topology, residue_selection, selection, verbose):\\n ## First have to load all the inputs if they are defined by a path\\n if isinstance(topology, str):\\n if os.path.exists(topology):\\n try:\\n md_topology = md.load_topology(topology)\\n except:\\n sys.exit('Make sure you have provided a valid path to topology file!')\\n else:\\n if verbose > 0:\\n print 'The following topology file was succesfully loaded: \\\\n %s \\\\n' %(md_topology)\\n\\n elif isinstance(topology, md.core.topology.Topology):\\n md_topology = topology\\n if verbose > 0:\\n print 'The following topology file was succesfully loaded: \\\\n %s \\\\n' %(md_topology)\\n else:\\n sys.exit('Invalid input! Must be a valid path to topology file or mdtraj.Topology object')\\n \\n ## if selection is True the function will try to obtain the specified atoms/residues\\n ## if residue name is specified it will by default look for C-alpha atoms\\n if selection:\\n if isinstance(residue_selection, list):\\n try:\\n atom_subset = md_topology.select(residue_selection)\\n except:\\n sys.exit('Invalid atom selection in list!')\\n else:\\n if verbose > 1:\\n print 'Your selection includes the following atom(s): \\\\n %s \\\\n' %(atom_subset)\\n print 'Your selection includes the following residues: \\\\n'\\n for residue in md_topology.subset(atom_subset).residues:\\n print residue\\n elif isinstance(residue_selection, str):\\n try:\\n atom_subset = md_topology.select('name CA and ' + residue_selection)\\n except:\\n sys.exit('Check if your atom selection command is recognized by the Mdtraj atom selection language!')\\n else:\\n if verbose > 1:\\n print 'Your selection includes the following atom(s): \\\\n %s \\\\n' %(atom_subset)\\n print 'Your selection includes the following residues: \\\\n'\\n for residue in md_topology.subset(atom_subset).residues:\\n print residue\\n else:\\n sys.exit('Make sure you provided a valid residue selection!')\\n else:\\n atom_subset=md_topology.select('name CA and ' + 'all')\\n \\n # now that we are sure that both topology and selection are valid we can return atom_subset\\n # and use the loaded topology file\\n \\n \\n return atom_subset, md_topology\",\n \"def run(self, snr: float = 4, window_size: float = 2, f_min: float = None, f_max: float = None,\\n skip_similar: bool = False, similar_chancel=True, extend_frequencies: int = 0, improve_fit=True,\\n mode='lmfit',frequency_detection=None,fit_fun : Union[Tuple[callable,callable],callable] = None):\\n\\n if fit_fun is not None and not (callable(fit_fun) or (isinstance(fit_fun,tuple) and len(fit_fun)==2)):\\n raise AttributeError(\\\"fit_fun must be either a function, or a tuple of two functions\\\")\\n\\n self.snr = snr\\n self.window_size = window_size\\n self.f_min = f_min\\n self.f_max = f_max\\n self.skip_similar = skip_similar\\n self.similar_chanel = similar_chancel\\n self.extend_frequencies = 0\\n\\n self._ff = FFinder(self, f_min, f_max)\\n self._result = self._ff.run(snr=snr, window_size=window_size, skip_similar=skip_similar,\\n similar_chancel=similar_chancel\\n , extend_frequencies=extend_frequencies, improve_fit=improve_fit, mode=mode\\n ,frequency_detection=frequency_detection,fit_fun=fit_fun)\\n self._combinations = get_combinations((self._result[self._result.significant == True].index+1).tolist(),\\n unp.nominal_values(\\n self._result[self._result.significant == True].frequency.tolist())\\n , unp.nominal_values(\\n self._result[self._result.significant == True].amp.tolist()))\\n\\n self.res_lc = self._ff.res_lc\\n\\n mprint(f\\\"{self.label} Analysis done!\\\",info)\",\n \"def main():\\n # files\\n summary_file = sys.argv[1]\\n pwms_to_tfs_file = sys.argv[2]\\n expressed_tfs_file = sys.argv[3] # TODO\\n\\n # TODO pull in num regions to resize things? but complicated with overlaps etc\\n # TODO edit edges with type of interaction\\n # TODO may want to color by trajectory, to demonstrate waves of trajectory\\n \\n # read in data\\n summary = pd.read_csv(summary_file, sep=\\\"\\\\t\\\")\\n pwms_to_tfs = pd.read_csv(pwms_to_tfs_file, sep=\\\"\\\\t\\\")\\n pwms_to_tfs = pwms_to_tfs[pwms_to_tfs[\\\"expressed\\\"].notna()]\\n pwms_to_filt_tfs = {} # dict: key - pwm names, vals - dict of ensembl ids to hgnc ids\\n for line_idx in range(pwms_to_tfs.shape[0]):\\n pwm_info = pwms_to_tfs.iloc[line_idx,:]\\n pwm_name = pwm_info[\\\"hclust_model_name\\\"]\\n pwm_to_tf = dict(zip(pwm_info[\\\"expressed\\\"].split(\\\";\\\"), pwm_info[\\\"expressed_hgnc\\\"].split(\\\";\\\")))\\n pwms_to_filt_tfs[pwm_name] = pwm_to_tf\\n\\n \\n # filter expressed hgncs for dynamic ones only\\n tfs_filt = pd.read_csv(expressed_tfs_file, sep=\\\"\\\\t\\\", index_col=0)\\n for pwm_name in pwms_to_filt_tfs.keys():\\n tfs_tmp = pwms_to_filt_tfs[pwm_name]\\n for ensembl_tf in tfs_tmp.keys():\\n if ensembl_tf not in tfs_filt.index:\\n del tfs_tmp[ensembl_tf]\\n if len(tfs_tmp.keys()) == 0:\\n del pwms_to_filt_tfs[pwm_name]\\n pwms_to_filt_tfs[pwm_name] = tfs_tmp\\n\\n # add in tfs column\\n tf1 = []\\n for pwm in summary[\\\"pwm1\\\"]:\\n tf_str = []\\n for ensembl_id in pwms_to_filt_tfs[pwm]:\\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\\n # TODO try add in max point\\n expression = tfs_filt.loc[ensembl_id,:]\\n max_idx = np.argmax(expression.values)\\n tf_str.append(str(max_idx))\\n tf_str = (\\\";\\\").join(tf_str)\\n tf1.append(tf_str)\\n summary[\\\"tf1\\\"] = tf1\\n\\n tf2 = []\\n for pwm in summary[\\\"pwm2\\\"]:\\n tf_str = []\\n for ensembl_id in pwms_to_filt_tfs[pwm]:\\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\\n expression = tfs_filt.loc[ensembl_id,:]\\n max_idx = np.argmax(expression.values)\\n tf_str.append(str(max_idx))\\n tf_str = (\\\";\\\").join(tf_str)\\n tf2.append(tf_str)\\n summary[\\\"tf2\\\"] = tf2\\n \\n # remove failed rules\\n summary = summary[~summary[\\\"interaction\\\"].str.contains(\\\"FAILED\\\")]\\n \\n # make graph\\n graph = nx.from_pandas_edgelist(summary, \\\"tf1\\\", \\\"tf2\\\")\\n\\n # set up positions\\n #pos = graphviz_layout(graph, prog=\\\"dot\\\")\\n pos = graphviz_layout(graph, prog=\\\"neato\\\")\\n scale_factor = 3\\n for key in pos.keys():\\n coords = pos[key]\\n pos[key] = {\\\"x\\\": scale_factor*coords[0], \\\"y\\\": -scale_factor*coords[1]}\\n nx.set_node_attributes(graph, pos, \\\"graphics\\\") # note this is diff from v1 to v2 in networkx\\n \\n # add graphics\\n add_graphics_theme_to_nx_graph(graph)\\n\\n # write gml\\n out_file = \\\"summary.gml\\\"\\n nx.write_gml(stringize_nx_graph(graph), out_file, stringizer=str)\\n\\n # tfs: for each tf, get gene column\\n \\n \\n return\",\n \"def selection_correction_method1_v2(tree, scale, h_in, h_out):\\n #h_in = ROOT.TH1D(\\\"h_in\\\", \\\"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n #h_out = ROOT.TH1D(\\\"h_out\\\", \\\"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n for event in tree:\\n cut = [0, 0]\\n S15_ch = i_channel(0, event)\\n bpm_ch = i_channel(4, event)\\n RT = event.DD_Rise[S15_ch]\\n S15_w2 = event.DD_AmplADU[S15_ch]\\n onset = event.DD_Rise10pct[S15_ch]\\n if cut[0]==0:\\n # first cut: for inside onset window\\n # if event passes the first cuts\\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n # calculation of the time of flight\\n tof = (cfd_pmt-cfd_bpm)%400\\n #cut on tof: time of flight of the neutron\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n # fill histogram inside onset window\\n h_in.Fill(energy2)\\n cut[0]=1\\n break\\n if cut[1]==0:\\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n tof = (cfd_pmt-cfd_bpm)%400\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n h_out.Fill(energy2)\\n cut[1]=1\\n break\",\n \"def selection_correction_method1(tree, scale, h_in, h_out):\\n #h_in = ROOT.TH1D(\\\"h_in\\\", \\\"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n #h_out = ROOT.TH1D(\\\"h_out\\\", \\\"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n for event in tree:\\n cut = [0, 0]\\n S15_ch = i_channel(0, event)\\n bpm_ch = i_channel(4, event)\\n RT = event.DD_Rise[S15_ch]\\n S15_w2 = event.DD_AmplADU[S15_ch]\\n onset = event.DD_Rise10pct[S15_ch]\\n if cut[0]==0:\\n # first cut: for inside onset window\\n # if event passes the first cuts\\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n # calculation of the time of flight\\n tof = (cfd_pmt-cfd_bpm)%400\\n #cut on tof: time of flight of the neutron\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n # fill histogram inside onset window\\n h_in.Fill(energy2)\\n cut[0]=1\\n break\\n if cut[1]==0:\\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n tof = (cfd_pmt-cfd_bpm)%400\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n h_out.Fill(energy2)\\n cut[1]=1\\n break\\n return h_in, h_out\",\n \"def test_apply_elf_conformer_selection(self, toolkit_wrapper, use_registry):\\n\\n if toolkit_wrapper == OpenEyeToolkitWrapper:\\n pytest.importorskip(\\\"openeye\\\")\\n elif toolkit_wrapper == RDKitToolkitWrapper:\\n pytest.importorskip(\\\"rdkit\\\")\\n\\n if use_registry:\\n toolkit = toolkit_wrapper()\\n else:\\n toolkit = ToolkitRegistry(toolkit_precedence=[toolkit_wrapper])\\n\\n molecule = Molecule.from_file(\\n get_data_file_path(os.path.join(\\\"molecules\\\", \\\"z_3_hydroxy_propenal.sdf\\\")),\\n \\\"SDF\\\",\\n )\\n\\n initial_conformers = [\\n # Add a conformer with an internal H-bond.\\n unit.Quantity(\\n np.array(\\n [\\n [0.5477, 0.3297, -0.0621],\\n [-0.1168, -0.7881, 0.2329],\\n [-1.4803, -0.8771, 0.1667],\\n [-0.2158, 1.5206, -0.4772],\\n [-1.4382, 1.5111, -0.5580],\\n [1.6274, 0.3962, -0.0089],\\n [0.3388, -1.7170, 0.5467],\\n [-1.8612, -0.0347, -0.1160],\\n [0.3747, 2.4222, -0.7115],\\n ]\\n ),\\n unit.angstrom,\\n ),\\n # Add a conformer without an internal H-bond.\\n unit.Quantity(\\n np.array(\\n [\\n [0.5477, 0.3297, -0.0621],\\n [-0.1168, -0.7881, 0.2329],\\n [-1.4803, -0.8771, 0.1667],\\n [-0.2158, 1.5206, -0.4772],\\n [0.3353, 2.5772, -0.7614],\\n [1.6274, 0.3962, -0.0089],\\n [0.3388, -1.7170, 0.5467],\\n [-1.7743, -1.7634, 0.4166],\\n [-1.3122, 1.4082, -0.5180],\\n ]\\n ),\\n unit.angstrom,\\n ),\\n ]\\n\\n molecule._conformers = [*initial_conformers]\\n\\n # Apply ELF10\\n molecule.apply_elf_conformer_selection(toolkit_registry=toolkit)\\n elf10_conformers = molecule.conformers\\n\\n assert len(elf10_conformers) == 1\\n\\n assert np.allclose(\\n elf10_conformers[0].m_as(unit.angstrom),\\n initial_conformers[1].m_as(unit.angstrom),\\n )\",\n \"def compute_prf_on_selection(arts, forms_set):\\n tp=0\\n fn=0\\n fp=0\\n for article in arts:\\n for entity in article.entity_mentions:\\n if entity.mention in forms_set:\\n if entity.gold_link==entity.sys_link:\\n tp+=1\\n else:\\n if entity.sys_link!='--NME--':\\n fp+=1\\n if entity.gold_link!='--NME--':\\n fn+=1\\n print(tp, fp, fn)\\n p=tp/(tp+fp)\\n r=tp/(tp+fn)\\n f1=2*p*r/(p+r)\\n print(p,r,f1)\\n return f1\",\n \"def main(dicom_dir, prostate_mask, debug):\\n import arterys\\n\\n ## Custom I/O setup\\n dicom_dir = Path(dicom_dir)\\n prostate_mask = Path(prostate_mask)\\n\\n volumes_dir = dicom_dir.parent if debug else VOLUMES_DIR\\n volumes_dir.mkdir(exist_ok=True)\\n\\n input_volume_stem = dicom_dir.name\\n input_volume_name = input_volume_stem + '.nrrd'\\n input_volume_path = volumes_dir / input_volume_name\\n\\n output_volume_name = input_volume_stem + '_needle_seg.nrrd'\\n output_volume_path = volumes_dir / output_volume_name\\n\\n ## DICOM to volumes\\n # Prostate MRI\\n arterys.dicomvert(dicom_dir, input_volume_path)\\n\\n # Prostate mask\\n if prostate_mask.is_dir():\\n dicom_mask_dir = prostate_mask\\n input_volume_mask_stem = 'input_seg'\\n input_volume_mask_name = input_volume_mask_stem + '.nrrd'\\n input_volume_mask_path = volumes_dir / input_volume_mask_name\\n arterys.dicomvert(dicom_mask_dir, input_volume_mask_path)\\n elif prostate_mask.suffix == '.nrrd':\\n input_volume_mask_path = prostate_mask\\n\\n ## Run inference\\n cmdline = (\\n 'python3', '/deepinfer/fit.py',\\n '--ModelName', 'prostate-needle-finder',\\n '--InputVolume', input_volume_path,\\n '--InputProstateMask', input_volume_mask_path,\\n '--OutputLabel', output_volume_path,\\n '--OutputFiducialList', '/tmp.fcsv',\\n '--InferenceType', 'Ensemble',\\n '--verbose',\\n )\\n cmdline = [str(arg) for arg in cmdline]\\n arterys.utils.print_command(cmdline)\\n call(cmdline)\\n\\n # Volumes to Arterys format\\n output_dir = dicom_dir.parent / OUTPUT_DIR.name if debug else OUTPUT_DIR\\n output_dir.mkdir(exist_ok=True)\\n arterys.process_output(output_volume_path, output_dir)\\n\\n return 0\",\n \"def glob_cmd(model, globular_name, features, filters, figname, mag=0,\\n color={2:(-4, -3)}, xlim=(-0.5, 2), ylim=(23, 16)):\\n # fetch data for the cluster\\n X, Xcov = fetch_glob_data(globular_name, features, filters)\\n\\n # unpickle the XD model\\n if type(model) == str: \\n f = open(model, 'rb')\\n model = cPickle.load(f)\\n f.close()\\n\\n # Calculate the posteriors, record medians\\n a, m, v = model.posterior(X, Xcov)\\n posts = np.zeros_like(X)\\n for i in range(X.shape[0]):\\n posts[i] = np.median(model.sample(a[i], m[i], v[i], size=1000),\\n axis=0)\\n\\n # Get PSF mags and colors\\n k = color.keys()[0]\\n orig_r = X[:, mag]\\n orig_gr = X[:, k] + X[:, color[k][0]] + X[:, color[k][1]]\\n post_r = posts[:, mag]\\n post_gr = posts[:, k] + posts[:, color[k][0]] + posts[:, color[k][1]]\\n \\n fs = 5\\n ms = 2\\n size = 15\\n lsize = 20\\n f = pl.figure(figsize=(2 * fs, fs))\\n for i in range(1, 3):\\n if i == 1:\\n gr = orig_gr\\n r = orig_r\\n l = 'SDSS DR10'\\n else:\\n gr = post_gr\\n r = post_r\\n l = 'XD Posterior'\\n ax = pl.subplot(1, 2, i)\\n pl.plot(gr, r, 'ko', ms=ms, alpha=0.5)\\n pl.xlim(xlim)\\n pl.ylim(ylim)\\n pl.xlabel('psfmag $g - r$', fontsize=lsize)\\n pl.ylabel('psfmag $r$', fontsize=lsize)\\n ax.text(0.95, 0.95, l, va='top', ha='right', fontsize=size,\\n transform=ax.transAxes)\\n f.savefig(figname, bbox_inches='tight')\",\n \"def miniAOD_customizeMETFiltersFastSim(process):\\n for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter':\\n process.globalReplace(X, cms.EDFilter(\\\"HLTBool\\\", result=cms.bool(True))) \\n for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters':\\n process.globalReplace(X, cms.EDFilter(\\\"HLTBool\\\", result=cms.bool(False)))\\n return process\",\n \"def plot_filters(fnames):\\n if len(fnames) == 0:\\n with Database() as base:\\n fnames = base.get_filter_names()\\n with mp.Pool(processes=mp.cpu_count()) as pool:\\n pool.map(worker_plot, fnames)\",\n \"def execute_file(self, files, **kw):\\n\\n mode = kw['mode'] if 'mode' in kw else 0\\n\\n # ranger can act as a file chooser when running with --choosefile=...\\n if mode == 0 and 'label' not in kw:\\n if ranger.args.choosefile:\\n open(ranger.args.choosefile, 'w').write(self.fm.thisfile.path)\\n\\n if ranger.args.choosefiles:\\n paths = []\\n for hist in self.fm.thistab.history:\\n for fobj in hist.files:\\n if fobj.marked and fobj.path not in paths:\\n paths += [fobj.path]\\n paths += [f.path for f in self.fm.thistab.get_selection() if f.path not in paths]\\n\\n with open(ranger.args.choosefiles, 'w') as fobj:\\n fobj.write('\\\\n'.join(paths) + '\\\\n')\\n\\n if ranger.args.choosefile or ranger.args.choosefiles:\\n raise SystemExit\\n\\n if isinstance(files, set):\\n files = list(files)\\n elif not isinstance(files, (list, tuple)):\\n files = [files]\\n\\n flags = kw.get('flags', '')\\n if 'c' in squash_flags(flags):\\n files = [self.fm.thisfile]\\n\\n self.signal_emit('execute.before', keywords=kw)\\n filenames = [f.path for f in files]\\n label = kw.get('label', kw.get('app', None))\\n try:\\n return self.rifle.execute(filenames, mode, label, flags, None)\\n finally:\\n self.signal_emit('execute.after')\",\n \"def event_based_r_factor(self):\\n # assign variables\\n rain_energy = 'rain_energy'\\n rain_volume = 'rain_volume'\\n erosivity = 'erosivity'\\n r_factor = 'r_factor'\\n\\n # derive rainfall energy (MJ ha^-1 mm^-1)\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{rain_energy}\\\"\\n \\\"=0.29*(1.-(0.72*exp(-0.05*{rain_intensity})))\\\".format(\\n rain_energy=rain_energy,\\n rain_intensity=self.rain_intensity),\\n overwrite=True)\\n\\n # derive rainfall volume\\n \\\"\\\"\\\"\\n rainfall volume (mm)\\n = rainfall intensity (mm/hr)\\n * (rainfall interval (min)\\n * (1 hr / 60 min))\\n \\\"\\\"\\\"\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{rain_volume}\\\"\\n \\\"= {rain_intensity}\\\"\\n \\\"*({rain_interval}\\\"\\n \\\"/60.)\\\".format(\\n rain_volume=rain_volume,\\n rain_intensity=self.rain_intensity,\\n rain_interval=self.rain_interval),\\n overwrite=True)\\n\\n # derive event erosivity index (MJ mm ha^-1 hr^-1)\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{erosivity}\\\"\\n \\\"=({rain_energy}\\\"\\n \\\"*{rain_volume})\\\"\\n \\\"*{rain_intensity}\\\"\\n \\\"*1.\\\".format(\\n erosivity=erosivity,\\n rain_energy=rain_energy,\\n rain_volume=rain_volume,\\n rain_intensity=self.rain_intensity),\\n overwrite=True)\\n\\n # derive R factor (MJ mm ha^-1 hr^-1 yr^1)\\n \\\"\\\"\\\"\\n R factor (MJ mm ha^-1 hr^-1 yr^1)\\n = EI (MJ mm ha^-1 hr^-1)\\n / (rainfall interval (min)\\n * (1 yr / 525600 min))\\n \\\"\\\"\\\"\\n gscript.run_command(\\n 'r.mapcalc',\\n expression=\\\"{r_factor}\\\"\\n \\\"={erosivity}\\\"\\n \\\"/({rain_interval}\\\"\\n \\\"/525600.)\\\".format(\\n r_factor=r_factor,\\n erosivity=erosivity,\\n rain_interval=self.rain_interval),\\n overwrite=True)\\n\\n # remove temporary maps\\n gscript.run_command(\\n 'g.remove',\\n type='raster',\\n name=['rain_energy',\\n 'rain_volume',\\n 'erosivity'],\\n flags='f')\\n\\n return r_factor\",\n \"def name(inp, mode, **kwargs):\\n return name.dispatch(inp, mode, **kwargs)\",\n \"def run_selection(self, included_clusters, excluded_clusters, max_image_catalog_sep, ch1_min_cov, ch2_min_cov,\\n ch1_bright_mag, ch2_bright_mag, selection_band_faint_mag, ch1_ch2_color, spt_colnames,\\n output_name, output_colnames):\\n self.file_pairing(include=included_clusters, exclude=excluded_clusters)\\n self.image_to_catalog_match(max_image_catalog_sep=max_image_catalog_sep)\\n self.coverage_mask(ch1_min_cov=ch1_min_cov, ch2_min_cov=ch2_min_cov)\\n self.object_mask()\\n # self.cluster_k_correction()\\n self.object_selection(ch1_bright_mag=ch1_bright_mag, ch2_bright_mag=ch2_bright_mag,\\n selection_band_faint_mag=selection_band_faint_mag)\\n self.purify_selection(ch1_ch2_color_cut=ch1_ch2_color)\\n self.j_band_abs_mag()\\n self.catalog_merge(catalog_cols=spt_colnames)\\n self.object_separations()\\n self.completeness_value()\\n final_catalog = self.final_catalogs(filename=output_name, catalog_cols=output_colnames)\\n if final_catalog is not None:\\n return final_catalog\",\n \"def fit(self, fn_raw, stim_name=None, event_id=1,\\n tmin_stim=0.0, tmax_stim=1.0, flow=4.0, fhigh=34.0,\\n pca_dim=0.90, max_iter=10000, conv_eps=1e-16,\\n verbose=True):\\n\\n # ------------------------------------------\\n # import necessary module\\n # ------------------------------------------\\n from fourier_ica import JuMEG_fourier_ica\\n from mne import find_events, pick_types, set_log_level\\n from mne.io import Raw\\n\\n\\n # set log level to 'WARNING'\\n set_log_level('WARNING')\\n\\n # ------------------------------------------\\n # prepare data to apply FourierICA\\n # ------------------------------------------\\n meg_raw = Raw(fn_raw, preload=True)\\n meg_channels = pick_types(meg_raw.info, meg=True, eeg=False,\\n eog=False, stim=False, exclude='bads')\\n meg_data = meg_raw._data[meg_channels, :]\\n\\n if stim_name:\\n events = find_events(meg_raw, stim_channel=stim_name, consecutive=True)\\n events = events[events[:, 2] == event_id, 0]\\n else:\\n events = []\\n\\n\\n # ------------------------------------------\\n # generate FourierICA object\\n # ------------------------------------------\\n if verbose:\\n print \\\">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<\\\"\\n print \\\">>> Performing FourierICA estimation <<<\\\"\\n print \\\">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<\\\"\\n\\n win_length_sec = tmax_stim - tmin_stim\\n fourier_ica_obj = JuMEG_fourier_ica(events=events, tpre=tmin_stim,\\n flow=flow, fhigh=fhigh,\\n win_length_sec=win_length_sec,\\n remove_outliers=True,\\n hamming_data=True,\\n complex_mixing=True,\\n pca_dim=pca_dim,\\n max_iter=max_iter,\\n conv_eps=conv_eps)\\n\\n\\n # ------------------------------------------\\n # perform ICASSO ICA\\n # ------------------------------------------\\n for irep in range(self.nrep):\\n # apply FourierICA\\n W_orig, A_orig, _, _, _, whitenMat, dewhitenMat = fourier_ica_obj.fit(meg_data.copy(), verbose=False)\\n\\n if irep == 0:\\n self.whitenMat = whitenMat\\n self.dewhitenMat = dewhitenMat\\n\\n # save results in structure\\n self.W_est.append(W_orig)\\n self.A_est.append(A_orig)\\n\\n # print out some information\\n if verbose:\\n print \\\">>> Running FourierICA number %d of %d done\\\" % (irep+1, self.nrep)\\n\\n if irep == 0:\\n str_hamming_window = \\\"True\\\" if fourier_ica_obj.hamming_data else \\\"False\\\"\\n str_complex_mixing = \\\"True\\\" if fourier_ica_obj.complex_mixing else \\\"False\\\"\\n print \\\"..... Fourier ICA parameter:\\\"\\n print \\\".....\\\"\\n print \\\"..... Sampling frequency set to: %d\\\" % fourier_ica_obj.sfreq\\n print \\\"..... Start of frequency band set to: %d\\\" % fourier_ica_obj.flow\\n print \\\"..... End of frequency band set to: %d\\\" % fourier_ica_obj.fhigh\\n print \\\"..... Using hamming window: %s\\\" % str_hamming_window\\n print \\\"..... Assume complex mixing: %s\\\" % str_complex_mixing\\n print \\\"..... Number of independent components: %d\\\" % fourier_ica_obj.ica_dim\\n print \\\".....\\\"\\n\\n\\n # ------------------------------------------\\n # perform cluster analysis\\n # ------------------------------------------\\n if verbose:\\n print \\\">>>\\\"\\\"\\\"\\n print \\\">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<\\\"\\n print \\\">>> Performing cluster analysis <<<\\\"\\n print \\\">>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<\\\"\\n\\n Z, order, partitions, indexR, dis, sim = self.cluster()\\n proj = self.projection(dis)\\n A, W, Iq = self.get_results(partitions, sim)\\n\\n\\n # ------------------------------------------\\n # return results\\n # ------------------------------------------\\n return W, A, Iq, fourier_ica_obj\",\n \"def exec_event_functions(self):\\n for name, fdict in self._event_functions.items():\\n exec_func=False\\n if self.is_eventCodePresent(fdict['eventCode']) \\\\\\n and (self.ievent % fdict['nevents']) == 0:\\n exec_func = True\\n \\n det_class = psutils.getattr_complete(self,fdict['det'])\\n \\n if exec_func and det_class.is_in_keys:\\n# print 'executing',det_class._name, fdict['attr']\\n func = psutils.getattr_complete(det_class,fdict['attr']) \\n func(**fdict['kwargs'])\",\n \"def infer_eog_channels(ch_names):\\n \\n eog = ['EOG ROC', 'EOG LOC']\\n found = []\\n\\n # find frontal channel\\n for ch in ch_names:\\n if any([x in ch for x in eog]):\\n found.append(ch)\\n return found\",\n \"def run_slowfast_analysis(mousename, sessionname, sessionname_openloop, roi_selection, h5_filepath, json_path, subname, sess_subfolder, filterprop_short, filterprop_long, orderprop_short, orderprop_long, even_win, blackbox_win, session_rois):\\n MOUSE = mousename\\n SESSION = sessionname\\n h5path = h5_filepath\\n SUBNAME = subname\\n subfolder = sess_subfolder + '_slowvfast'\\n # write result to dictionary\\n write_to_dict = True\\n # create figure (WARNING: significantly slows down execution)\\n make_figure = True\\n\\n # set up dictionary to hold result parameters from roi\\n session_rois[SUBNAME+'_slow_short_mean'] = []\\n session_rois[SUBNAME+'_fast_long_mean'] = []\\n\\n session_rois[SUBNAME+'_slow_std_short'] = []\\n session_rois[SUBNAME+'_slow_std_long'] = []\\n session_rois[SUBNAME+'_fast_std_short'] = []\\n session_rois[SUBNAME+'_fast_std_long'] = []\\n\\n session_rois[SUBNAME+'_slow_active_short'] = []\\n session_rois[SUBNAME+'_slow_active_long'] = []\\n session_rois[SUBNAME+'_fast_active_short'] = []\\n session_rois[SUBNAME+'_fast_active_long'] = []\\n\\n session_rois[SUBNAME+'_slow_peak_short'] = []\\n session_rois[SUBNAME+'_slow_peak_long'] = []\\n session_rois[SUBNAME+'_fast_peak_short'] = []\\n session_rois[SUBNAME+'_fast_peak_long'] = []\\n\\n session_rois[SUBNAME+'_slow_peak_time_short'] = []\\n session_rois[SUBNAME+'_slow_peak_time_long'] = []\\n session_rois[SUBNAME+'_fast_peak_time_short'] = []\\n session_rois[SUBNAME+'_fast_peak_time_long'] = []\\n\\n # if we want to run through all the rois, just say all\\n if roi_selection == 'all':\\n h5dat = h5py.File(h5path, 'r')\\n dF_ds = np.copy(h5dat[SESSION + '/dF_win'])\\n h5dat.close()\\n num_rois = dF_ds.shape[1]\\n roilist = np.arange(num_rois)\\n print('analysing ' + roi_selection + ' rois: ' + str(roilist))\\n elif roi_selection == 'valid':\\n # only use valid rois\\n with open(json_path, 'r') as f:\\n sess_dict = json.load(f)\\n roilist = sess_dict['valid_rois']\\n print('analysing ' + roi_selection + ' rois: ' + str(roilist))\\n else:\\n roilist = roi_selection\\n print('analysing custom list of rois: ' + str(roilist))\\n\\n # run analysis for vr session\\n for i,r in enumerate(roilist):\\n print(SUBNAME + ': ' + str(r))\\n\\n std_short, std_long, active_short, active_long, peak_short, peak_long, meanpeak_short_time, meanpeak_long_time, ylims, norm_value = fig_ordered_eventdiff(h5path, SESSION, r, MOUSE+'_'+SESSION+'_roi_'+str(r), filterprop_short, filterprop_long, orderprop_short,orderprop_long, even_win, blackbox_win, [], fformat, subfolder, [], False, make_figure)\\n # session_rois[SUBNAME+'_slow_roi_number'].append(r)\\n session_rois[SUBNAME+'_slow_std_short'].append(std_short[0])\\n session_rois[SUBNAME+'_slow_std_long'].append(std_long[0])\\n session_rois[SUBNAME+'_slow_active_short'].append(active_short[0])\\n session_rois[SUBNAME+'_slow_active_long'].append(active_long[0])\\n session_rois[SUBNAME+'_slow_peak_short'].append(peak_short[0])\\n session_rois[SUBNAME+'_slow_peak_long'].append(peak_long[0])\\n session_rois[SUBNAME+'_slow_peak_time_short'].append(meanpeak_short_time[0])\\n session_rois[SUBNAME+'_slow_peak_time_long'].append(meanpeak_long_time[0])\\n\\n session_rois[SUBNAME+'_fast_std_short'].append(std_short[1])\\n session_rois[SUBNAME+'_fast_std_long'].append(std_long[1])\\n session_rois[SUBNAME+'_fast_active_short'].append(active_short[1])\\n session_rois[SUBNAME+'_fast_active_long'].append(active_long[1])\\n session_rois[SUBNAME+'_fast_peak_short'].append(peak_short[1])\\n session_rois[SUBNAME+'_fast_peak_long'].append(peak_long[1])\\n session_rois[SUBNAME+'_fast_peak_time_short'].append(meanpeak_short_time[1])\\n session_rois[SUBNAME+'_fast_peak_time_long'].append(meanpeak_long_time[1])\\n\\n if write_to_dict:\\n # print('writing to dict')\\n # print(type(session_rois['reward_slow_peak_time_short']))\\n # print(session_rois)\\n write_dict(MOUSE, SESSION, session_rois)\",\n \"def upsilons ( self ) :\\n ##\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n ##\\n return self.make_selection (\\n 'Upsilon' ,\\n FilterDesktop , \\n [ self.dimuon () ] , \\n ## algorithm parameters \\n Code = self['UpsilonCut'] ,\\n ## \\n ReFitPVs = True\\n ##\\n )\",\n \"def main(args):\\n try:\\n config_path = project_path + \\\"/\\\" + args.config\\n input_data_path = project_path + \\\"/\\\" + args.input\\n output_data_path = project_path + \\\"/\\\" + args.output\\n\\n config = load_config(config_path)\\n\\n # load data\\n df = read_csv(input_data_path)\\n df.loc[:, 'season'] = df['season'].astype('int')\\n\\n sys.stdout = open(output_data_path, 'w')\\n check_balance(df)\\n check_linelen(df, config['eda']['quantile'])\\n\\n groups = config['eda']['groups']\\n\\n for i in range(len(groups)):\\n df_top_words = most_important_words(df, groups[i], **config['eda']['top_n_words'])\\n fig = plot_tfidf_classfeats_h(df_top_words)\\n fig.savefig('{}/EDA/top_words_{}.png'.format(project_path, i))\\n\\n\\n except Exception as e:\\n logger.error(\\\"Unexpected error occurred when eda: \\\" + str(e))\",\n \"def etap2rhog ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays \\n pre_etap = self.make_selection (\\n ## the unique tag \\n 'PreEtapRhoG' ,\\n ## algorithm type to be used\\n DaVinci__N3BodyDecays ,\\n ## input selections \\n [ self.pions () , self.gamma () ] ,\\n ##\\n DecayDescriptor = \\\" eta_prime -> pi+ pi- gamma\\\" ,\\n ##\\n DaughtersCuts = { 'gamma' : self['GammaCut'] } ,\\n ## \\n Combination12Cut = \\\"\\\"\\\" ( AM < 950 * MeV ) &\\n ( ACHI2DOCA(1,2) < 12 ) \\n \\\"\\\"\\\" , \\n CombinationCut = \\\"\\\"\\\"\\n ( APT > %s ) & \\n in_range ( 500 * MeV , AM12 , 950 * MeV ) & \\n ( ADAMASS ( 'eta_prime' ) < 100 * MeV ) \\n \\\"\\\"\\\" % ( 0.9 * self['ETAP_PT'] ),\\n ##\\n MotherCut = \\\"\\\"\\\"\\n ( PT > %s ) &\\n ( chi2vx < 9 )\\n \\\"\\\"\\\" % self['ETAP_PT'] \\n )\\n ## \\n from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger\\n ## \\n return self.make_selection (\\n 'Etap2rhogamma' ,\\n Pi0Veto__Tagger ,\\n [ pre_etap ] ,\\n MassWindow = 25 * MeV ,\\n MassChi2 = -1 ,\\n ExtraInfoIndex = 25017 ## unique ! \\n )\",\n \"def OnAbout(self, event):\\n messtr = u\\\"单细胞簇识别系统\\\\n\\\"\\n messtr =messtr +u\\\"这是个识别单细胞簇的层次聚类系统，使用方法如下：\\\\n\\\" \\n messtr =messtr +u\\\"1.将你的数据处理成三个文件expr.h5,features.txt,labels.txt,分别是用h5py.create_dataset创建的N细胞*M基因的细胞表达式矩阵和用np.savetxt函数保存的基因文件和标签文件(注意一行一个不能有空格）放在一个文件夹即可,可以参考prosess_sys.py\\\\n\\\"\\n messtr =messtr +u\\\"2.点击选择文件按钮选择文件夹，此时右边会提示成功与否\\\\n\\\"\\n messtr =messtr +u\\\"3.thresh表示过滤掉某个基因表达的细胞数少于百分比细胞数的，范围为0-1，为零时不过滤低表达基因\\\\n\\\" \\n messtr =messtr +u\\\"z_cutoff是离散值，bins是分为几份，是整数，将基因按照在所有细胞表达均值分成bins份，然后去掉每一份zscore小于z_cutoff的基因\\\\n\\\"\\n messtr =messtr +u\\\"4.可以选择不同的降维算法进行降维\\\\n\\\"\\n messtr =messtr +u\\\"5.split_score和merge_score是聚类的两个超参数，一般后者是前者的一半，基于韦尔奇t检查的两个集群之间的距离度量如果大于这个split_score就分裂，小于merge_score就合并(采用的聚类方法是先分裂再合并的)\\\\n\\\"\\n messtr =messtr +u\\\"6.ys是层次聚类分裂的结果，ym是分裂再凝聚后的结果，ySC3是SC3算法的结果，ySafe是SAFE算法的结果，yclf是一致性聚类的结果,yKmean是kmeans算法的结果\\\"\\n wx.MessageBox(messtr,\\n \\\"About System\\\",\\n wx.OK|wx.ICON_INFORMATION)\",\n \"def main():\\n logging.getLogger(\\\"dance\\\").setLevel(logging.DEBUG)\\n logging.getLogger(\\\"dance\\\").addHandler(logging.StreamHandler(sys.stderr))\\n\\n def relevant_if_has_t142(mol: oechem.OEMol):\\n params = smirnoff_param_utils.read_params_from_mol(mol)\\n return \\\"t142\\\" in params\\n\\n def size_and_wbo_fingerprint(mol: oechem.OEMol):\\n \\\"\\\"\\\"Fingerprint with number of atoms in the mol and WBO between central atoms in the t142 param.\\n\\n (WBO is Wiberg Bond Order.)\\n\\n Note: The indices are the same in OpenEye and OFF molecules, so the\\n parameter indices are correct, even though they were calculated for the\\n OFF mol.\\n \\\"\\\"\\\"\\n oechem.OEAddExplicitHydrogens(mol)\\n params = smirnoff_param_utils.read_params_from_mol(mol)\\n return (\\n mol.NumAtoms(),\\n smirnoff_param_utils.calculate_t142_central_wbo(mol, params),\\n )\\n\\n config = {\\n \\\"database_type\\\": \\\"OEB\\\",\\n \\\"database_info\\\": \\\"combined_molecules_with_parameters.oeb\\\",\\n \\\"relevance_function\\\": relevant_if_has_t142,\\n \\\"filter_output_oeb\\\": \\\"results/filter_output.oeb\\\",\\n \\\"fingerprint_function\\\": size_and_wbo_fingerprint,\\n \\\"fingerprint_output_oeb\\\": \\\"results/fingerprint_output.oeb\\\",\\n \\\"selection_frequency\\\": 375, # To select ~20 molecules.\\n \\\"dataset_type\\\": \\\"OEB\\\",\\n \\\"dataset_info\\\": \\\"results/dataset.oeb\\\",\\n \\\"sorted_by_fingerprint_oeb\\\": \\\"results/sorted_by_fingerprint.oeb\\\",\\n \\\"in_memory_sorting_threshold\\\": 25000,\\n \\\"tmpdir\\\": \\\"results/tmp\\\",\\n }\\n\\n run_dance(config)\",\n \"def launch ():\\n #core.addListenerByName(\\\"UpEvent\\\", _go_up)\\n core.registerNew(MAC_Filter)\",\n \"def image_selection_change():\\n\\n def return_image(val, model_id, message_name, field_name, mime, sind):\\n \\\"\\\"\\\"Returns a URL resolvable by the probe\\\"\\\"\\\"\\n column_data_source = curdoc().get_model_by_name(sind)\\n index = column_data_source.tags[0]\\n url = \\\"http://{0}/image/\\\".format(_host) + \\\"---\\\".join([model_id, message_name, field_name, mime, sind, str(index)])\\n return url\\n\\n d = curdoc()\\n _remove_fig(d)\\n model_id, message_name, _ = run_handlers.get_modelid_messagename_type(d)\\n image_field = d.get_model_by_name(IMAGE_SELECTION).value.split(\\\" :\\\")[0]\\n mime = d.get_model_by_name(MIME_SELECTION).value\\n\\n if image_field != DEFAULT_UNSELECTED and mime != DEFAULT_UNSELECTED:\\n plot = figure(plot_width=500, plot_height=500, title=\\\"\\\", x_range=Range1d(start=0, end=1), y_range=Range1d(start=0, end=1), name=FIGURE_MODEL)\\n sind = run_handlers.get_source_index(d.session_context.id, model_id, message_name, image_field + mime)\\n\\n _install_callback_and_cds(sind, model_id, message_name,\\n {image_field: [return_image, {\\\"model_id\\\": model_id,\\n \\\"message_name\\\": message_name,\\n \\\"field_name\\\": image_field,\\n \\\"mime\\\": mime,\\n \\\"sind\\\": sind}]},\\n stream_limit=1)\\n plot.image_url(url=image_field, x=0, y=1, h=1, w=1, source=d.get_model_by_name(sind))\\n d.add_root(plot)\",\n \"def main():\\n parser = argparse.ArgumentParser(\\n description=\\\"making feature file argsurations.\\\")\\n\\n parser.add_argument(\\n \\\"--waveforms\\\", default=None,\\n help=\\\"directory or list of filename of input wavfile\\\")\\n parser.add_argument(\\n \\\"--hdf5dir\\\", default=None,\\n help=\\\"directory to save hdf5\\\")\\n parser.add_argument(\\n \\\"--wavdir\\\", default=None,\\n help=\\\"directory to save of preprocessed wav file\\\")\\n parser.add_argument(\\n \\\"--fs\\\", default=16000,\\n type=int, help=\\\"Sampling frequency\\\")\\n parser.add_argument(\\n \\\"--shiftms\\\", default=5,\\n type=float, help=\\\"Frame shift in msec\\\")\\n parser.add_argument(\\n \\\"--feature_type\\\", default=\\\"world\\\", choices=[\\\"world\\\", \\\"melspc\\\", \\\"mcep\\\"],\\n type=str, help=\\\"feature type\\\")\\n parser.add_argument(\\n \\\"--mspc_dim\\\", default=80,\\n type=int, help=\\\"Dimension of mel spectrogram\\\")\\n parser.add_argument(\\n \\\"--minf0\\\", default=40,\\n type=int, help=\\\"minimum f0 for world analysis\\\")\\n parser.add_argument(\\n \\\"--maxf0\\\", default=400,\\n type=int, help=\\\"maximum f0 for world analysis\\\")\\n parser.add_argument(\\n \\\"--fmin\\\", default=None, nargs=\\\"?\\\",\\n type=int, help=\\\"minimum frequency for melspc\\\")\\n parser.add_argument(\\n \\\"--fmax\\\", default=None, nargs=\\\"?\\\",\\n type=int, help=\\\"maximum frequency for melspc\\\")\\n parser.add_argument(\\n \\\"--mcep_dim\\\", default=24,\\n type=int, help=\\\"Dimension of mel cepstrum\\\")\\n parser.add_argument(\\n \\\"--mcep_alpha\\\", default=0.41,\\n type=float, help=\\\"Alpha of mel cepstrum\\\")\\n parser.add_argument(\\n \\\"--fftl\\\", default=1024,\\n type=int, help=\\\"FFT length\\\")\\n parser.add_argument(\\n \\\"--highpass_cutoff\\\", default=70,\\n type=int, help=\\\"Cut off frequency in lowpass filter\\\")\\n parser.add_argument(\\n \\\"--save_wav\\\", default=True,\\n type=strtobool, help=\\\"Whether to save filtered wav file\\\")\\n parser.add_argument(\\n \\\"--n_jobs\\\", default=10,\\n type=int, help=\\\"number of parallel jobs\\\")\\n parser.add_argument(\\n \\\"--verbose\\\", default=1,\\n type=int, help=\\\"log message level\\\")\\n\\n args = parser.parse_args()\\n\\n # set log level\\n if args.verbose == 1:\\n logging.basicConfig(level=logging.INFO,\\n format='%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',\\n datefmt='%m/%d/%Y %I:%M:%S')\\n elif args.verbose > 1:\\n logging.basicConfig(level=logging.DEBUG,\\n format='%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',\\n datefmt='%m/%d/%Y %I:%M:%S')\\n else:\\n logging.basicConfig(level=logging.WARNING,\\n format='%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',\\n datefmt='%m/%d/%Y %I:%M:%S')\\n logging.warning(\\\"logging is disabled.\\\")\\n\\n # show arguments\\n for key, value in vars(args).items():\\n logging.info(\\\"%s = %s\\\" % (key, str(value)))\\n\\n # read list\\n if os.path.isdir(args.waveforms):\\n file_list = sorted(find_files(args.waveforms, \\\"*.wav\\\"))\\n else:\\n file_list = read_txt(args.waveforms)\\n logging.info(\\\"number of utterances = %d\\\" % len(file_list))\\n\\n # check directory existence\\n if not os.path.exists(args.wavdir) and args.highpass_cutoff != 0 and args.save_wav:\\n os.makedirs(args.wavdir)\\n if not os.path.exists(args.hdf5dir):\\n os.makedirs(args.hdf5dir)\\n\\n # divide list\\n file_lists = np.array_split(file_list, args.n_jobs)\\n file_lists = [f_list.tolist() for f_list in file_lists]\\n\\n # multi processing\\n processes = []\\n if args.feature_type == \\\"world\\\":\\n target_fn = world_feature_extract\\n elif args.feature_type == \\\"melspc\\\":\\n target_fn = melspectrogram_extract\\n else:\\n target_fn = melcepstrum_extract\\n for f in file_lists:\\n p = mp.Process(target=target_fn, args=(f, args,))\\n p.start()\\n processes.append(p)\\n\\n # wait for all process\\n for p in processes:\\n p.join()\",\n \"def filter_f(fns, ltaper, lowerp, upperp, utaper, eqband, eqltaper, equtaper, npow, bindir):\\n # filtercmd = bindir+\\\"/filter4\\\"\\n filtercmd = bindir + \\\"/filter4 1>/dev/null\\\"\\n for src, tar, eqtar in fns:\\n p = sp.Popen(filtercmd, shell=True, bufsize=0, stdin=sp.PIPE, stdout=None)\\n child = p.stdin\\n print >> child, ltaper, lowerp, upperp, utaper, npow, src, tar + '_tmp'\\n err = child.close()\\n ret = p.wait()\\n if err or ret != 0:\\n raise RuntimeError, '%r failed with exit code %d' % (filtercmd, err)\\n p = sp.Popen(filtercmd, shell=True, bufsize=0, stdin=sp.PIPE, stdout=None)\\n child = p.stdin\\n print >> child, eqltaper, eqband[0], eqband[1], equtaper, npow, tar + '_tmp', eqtar + '_tmp'\\n err = child.close()\\n ret = p.wait()\\n if err or ret != 0:\\n raise RuntimeError, '%r failed with exit code %d' % (filtercmd, err)\\n return 1\",\n \"def getJetFinderTool(self, alg=\\\"AntiKt\\\", R=0.4, input=\\\"LCTopo\\\", algName=None, doArea=True, context=None, **userProp):\\n # Use some default properties\\n defaultProps = dict( PtMin = 5000, GhostArea = 0.01 if doArea else 0., RandomOption = 1, )\\n\\n if algName is None:\\n algName = buildJetAlgName(alg,R)\\n else:\\n alg, R, input = interpretJetName( algName )\\n \\n if context:\\n toolName = context.output+'.Finder'\\n else:\\n toolName = algName+\\\"Finder\\\"\\n\\n # Technically we need this tool to translate fastjet to xAOD::Jet \\n jetFromPJ = JetFromPseudojet(toolName.replace('Finder',\\\"jetbuild\\\"),\\n Attributes = [\\\"ActiveArea\\\", \\\"ActiveAreaFourVector\\\"] if doArea else [] )\\n defaultProps['JetBuilder'] = jetFromPJ\\n\\n # overwrite with userProp\\n defaultProps.update(userProp)\\n defaultProps.update( JetAlgorithm = alg, JetRadius = R )\\n\\n if alg.startswith('Var'):\\n # add Variable R jet params.\\n # for now assuming large-R jet usage so fixed param :\\n defaultProps.update(VariableRMinRadius=0.2, VariableRMassScale=600000,JetRadius=1.0,\\n JetAlgorithm = dict(VarA='AntiKt',VarK='Kt',VarC='CamKt')[alg] )\\n\\n\\n # pass all the options to the constructor :\\n finder = JetFinder(toolName, **defaultProps)\\n\\n # incase of track jet, the finder is a bit more complex\\n # we used a dedicated one which will build jets per vertex\\n if \\\"Track\\\" in input:\\n from ROOT import JetByVertexFinder\\n vertexIndex = 0 # configure it to use PV0 (we could interpret input)\\n vfinder = JetByVertexFinder(toolName + \\\"ByVertex\\\",\\n JetFinder = finder,\\n Vertex = vertexIndex) \\n finder = vfinder\\n\\n return finder\",\n \"def main(args=None):\\n # ---------- build and read options ----------\\n USAGE = \\\"\\\"\\\"Usage %prog -i <FCDDATA> [options] \\nConverts the given fcd file (generated by sumo --fcd-output) into the selected\\noutput format. Optionally the output can be sampled, filtered and distorted.\\n\\\"\\\"\\\"\\n\\n from optparse import OptionParser\\n optParser = OptionParser(usage=USAGE)\\n optParser.add_option(\\\"-i\\\", \\\"--fcd-input\\\", dest=\\\"fcd\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the FCD-output file to use as input\\\")\\n optParser.add_option(\\\"-n\\\", \\\"--net-input\\\", dest=\\\"net\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the network file to use as input\\\")\\n optParser.add_option(\\\"-p\\\", \\\"--penetration\\\", type=\\\"float\\\", dest=\\\"penetration\\\",\\n default=1., help=\\\"Defines the percentage (0-1) of vehicles to export\\\")\\n optParser.add_option(\\\"-b\\\", \\\"--begin\\\", dest=\\\"begin\\\",\\n type=\\\"float\\\", help=\\\"Defines the first step to export\\\")\\n optParser.add_option(\\\"-e\\\", \\\"--end\\\", dest=\\\"end\\\",\\n type=\\\"float\\\", help=\\\"Defines the first step not longer to export\\\")\\n optParser.add_option(\\\"-d\\\", \\\"--delta-t\\\", dest=\\\"delta\\\",\\n type=\\\"float\\\", help=\\\"Defines the export step length\\\")\\n optParser.add_option(\\\"--gps-blur\\\", dest=\\\"blur\\\", default=0,\\n type=\\\"float\\\", help=\\\"Defines the GPS blur\\\")\\n optParser.add_option(\\n \\\"--boundary\\\", help=\\\"Defines the bounding box as 'xmin,ymin,xmax,ymax'\\\")\\n optParser.add_option(\\\"-s\\\", \\\"--seed\\\", dest=\\\"seed\\\", default=42,\\n type=\\\"float\\\", help=\\\"Defines the randomizer seed\\\")\\n optParser.add_option(\\n \\\"--base-date\\\", dest=\\\"base\\\", default=-1, type=\\\"int\\\", help=\\\"Defines the base date\\\")\\n optParser.add_option(\\\"--orig-ids\\\", dest=\\\"orig_ids\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Write original vehicle IDs instead of a running index\\\")\\n optParser.add_option(\\\"--ignore-gaps\\\", dest=\\\"ignore_gaps\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Ignore steps where a vehicle is not in the network\\\")\\n optParser.add_option(\\\"--persons\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Include person data\\\")\\n # PHEM\\n optParser.add_option(\\\"--dri-output\\\", dest=\\\"dri\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the PHEM .dri-file to generate\\\")\\n optParser.add_option(\\\"--str-output\\\", dest=\\\"str\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the PHEM .str-file to generate\\\")\\n optParser.add_option(\\\"--fzp-output\\\", dest=\\\"fzp\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the PHEM .fzp-file to generate\\\")\\n optParser.add_option(\\\"--flt-output\\\", dest=\\\"flt\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the PHEM .flt-file to generate\\\")\\n # OMNET\\n optParser.add_option(\\\"--omnet-output\\\", dest=\\\"omnet\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the OMNET file to generate\\\")\\n # Shawn\\n optParser.add_option(\\\"--shawn-output\\\", dest=\\\"shawn\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the Shawn file to generate\\\")\\n # ns2\\n optParser.add_option(\\\"--ns2activity-output\\\", dest=\\\"ns2activity\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the ns2 file to generate\\\")\\n optParser.add_option(\\\"--ns2config-output\\\", dest=\\\"ns2config\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the ns2 file to generate\\\")\\n optParser.add_option(\\\"--ns2mobility-output\\\", dest=\\\"ns2mobility\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the ns2 file to generate\\\")\\n # GPSDAT\\n optParser.add_option(\\\"--gpsdat-output\\\", dest=\\\"gpsdat\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the gpsdat file to generate\\\")\\n\\n # GPX\\n optParser.add_option(\\\"--gpx-output\\\", dest=\\\"gpx\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the gpx file to generate\\\")\\n # POI\\n optParser.add_option(\\\"--poi-output\\\", dest=\\\"poi\\\", metavar=\\\"FILE\\\",\\n help=\\\"Defines the name of the poi file to generate\\\")\\n # parse\\n if len(args) == 1:\\n sys.exit(USAGE.replace('%prog', os.path.basename(__file__)))\\n options, remaining_args = optParser.parse_args(args=args)\\n\\n if options.seed:\\n random.seed(options.seed)\\n # ---------- process ----------\\n net = None\\n # ----- check needed values\\n if options.delta and options.delta <= 0:\\n print(\\\"delta-t must be a positive value.\\\")\\n return 1\\n # phem\\n if (options.dri or options.fzp or options.flt) and not options.fcd:\\n print(\\\"A fcd-output from SUMO must be given using the --fcd-input.\\\")\\n return 1\\n if (options.str or options.fzp or options.flt) and not options.net:\\n print(\\\"A SUMO network must be given using the --net-input option.\\\")\\n return 1\\n # omnet\\n if options.omnet and not options.fcd:\\n print(\\\"A fcd-output from SUMO must be given using the --fcd-input.\\\")\\n return 1\\n # ----- check needed values\\n\\n ## ----- OMNET\\n if options.omnet:\\n runMethod(options.fcd, options.omnet, omnet.fcd2omnet, options)\\n ## ----- OMNET\\n\\n ## ----- Shawn\\n if options.shawn:\\n runMethod(options.fcd, options.shawn, shawn.fcd2shawn, options)\\n ## ----- Shawn\\n\\n ## ----- GPSDAT\\n if options.gpsdat:\\n runMethod(options.fcd, options.gpsdat, gpsdat.fcd2gpsdat, options)\\n ## ----- GPSDAT\\n\\n ## ----- GPX\\n if options.gpx:\\n runMethod(options.fcd, options.gpx, gpx.fcd2gpx, options)\\n ## ----- GPX\\n\\n ## ----- GPX\\n if options.poi:\\n runMethod(options.fcd, options.poi, poi.fcd2poi, options)\\n ## ----- GPX\\n\\n ## ----- ns2\\n if options.ns2mobility or options.ns2config or options.ns2activity:\\n vIDm, vehInfo, begin, end, area = runMethod(\\n options.fcd, options.ns2mobility, ns2.fcd2ns2mobility, options)\\n if options.ns2activity:\\n o = _getOutputStream(options.ns2activity)\\n ns2.writeNS2activity(o, vehInfo)\\n _closeOutputStream(o)\\n if options.ns2config:\\n o = _getOutputStream(options.ns2config)\\n ns2.writeNS2config(\\n o, vehInfo, options.ns2activity, options.ns2mobility, begin, end, area)\\n _closeOutputStream(o)\\n ## ----- ns2\\n\\n ## ----- PHEM\\n # .dri\\n if options.dri:\\n runMethod(options.fcd, options.dri, phem.fcd2dri, options)\\n # .str (we need the net for other outputs, too)\\n if options.str or options.fzp or options.flt:\\n if not options.net:\\n print(\\\"A SUMO network must be given using the --net-input option.\\\")\\n return 1\\n if not net:\\n net = sumolib.net.readNet(options.net)\\n o = _getOutputStream(options.str)\\n sIDm = phem.net2str(net, o)\\n _closeOutputStream(o)\\n # .fzp\\n if options.flt or options.fzp:\\n vIDm, vtIDm = runMethod(\\n options.fcd, options.fzp, phem.fcd2fzp, options, {\\\"phemStreetMap\\\": sIDm})\\n # .flt\\n if options.flt:\\n o = _getOutputStream(options.flt)\\n phem.vehicleTypes2flt(o, vtIDm)\\n _closeOutputStream(o)\\n ## ----- PHEM\\n return 0\",\n \"def extract_features(audio_filename, args):\\n #print(\\\"Extract_features\\\")\\n spec_type = args['spec_type']\\n\\n if spec_type == 'cqt':\\n bin_multiple = args['bin_multiple']\\n max_midi = args['max_midi']\\n min_midi = args['min_midi']\\n note_range = max_midi - min_midi + 1\\n sr = args['sr']\\n hop_length = args['hop_length']\\n window_size = args['window_size']\\n\\n bins_per_octave = 12 * bin_multiple # should be a multiple of 12\\n n_bins = note_range * bin_multiple\\n\\n # down-sample,mono-channel\\n y, _ = librosa.load(audio_filename, sr)\\n # y: an np.ndarray[ shape=(n,) ] giving the audio time series. librosa.load automatically downsamples to the\\n # required sample rate sr\\n # doku on librosa.cqt:\\n # https://librosa.github.io/librosa/generated/librosa.core.cqt.html?highlight=cqt#librosa.core.cqts\\n S = librosa.cqt(y, fmin=librosa.midi_to_hz(min_midi), sr=sr, hop_length=hop_length,\\n bins_per_octave=bins_per_octave, n_bins=n_bins)\\n S = S.T\\n S = np.abs(S)\\n min_db = np.min(S)\\n print(np.min(S), np.max(S), np.mean(S))\\n S = np.pad(S, ((window_size // 2, window_size // 2), (0, 0)), 'constant', constant_values=min_db)\\n\\n windows = []\\n\\n # IMPORTANT NOTE:\\n # Since we pad the the spectrogram frame,\\n # the onset frames are actually `offset` frames.\\n # To obtain a window of the center frame at each true index, we take a slice from i to i+window_size\\n # starting at frame 0 of the padded spectrogram\\n for i in range(S.shape[0] - window_size + 1):\\n w = S[i:i + window_size, :]\\n windows.append(w)\\n\\n # print inputs\\n x = np.array(windows)\\n return x\\n\\n else:\\n print(\\\"WARNING: feature type \\\" + spec_type + \\\" not implemented.\\\")\\n return 0\",\n \"def featurize_kof(*args):\\n\\n df = args[0]\\n\\n # initial cleaning & changes to df\\n df = df.drop(columns='Unnamed: 0')\\n df = df.rename(columns = {'Code_Style':'code_style', 'Name':'name', 'Brand':'brand', 'Date':'date',\\n 'Retail_Price': 'retail_price', 'Colorway':'colorway', 'Story':'story',\\n 'KOF_Wants':'kof_wants', 'Avg_Resale':'avg_resale_stockx'})\\n df['retail_price'] = df['retail_price'].astype(int)\\n df['avg_resale_stockx'] = df['avg_resale_stockx'].str.replace('[^\\\\w\\\\s]','')\\n df['avg_resale_stockx'] = df['avg_resale_stockx'].astype(int)\\n\\n # feature 1: merge silhouettes\\n all_silhouettes = eval(args[1])\\n # strip out brand name from silhouette name\\n temp = []\\n for i in range(len(all_silhouettes)):\\n silhouette = all_silhouettes[i]\\n silhouette = silhouette.replace(\\\"Nike \\\", \\\"\\\")\\n silhouette = silhouette.replace(\\\"Adidas \\\", \\\"\\\")\\n silhouette = silhouette.replace(\\\"adidas \\\", \\\"\\\")\\n temp.append(silhouette)\\n all_silhouettes = temp\\n all_silhouettes.append('Air Jordan 1')\\n all_silhouettes = list(set(all_silhouettes))\\n df['silhouette'] = df['name'].apply(lambda x: silhouette_generator(x, all_silhouettes))\\n\\n #feature 2: profitable\\n #create columns to calculate net profit\\n df['price_diff'] = df['avg_resale_stockx'] - df['retail_price']\\n df['commission_fee'] = abs((df['avg_resale_stockx']) * (9.5/100))\\n df['seller_fee'] = 5\\n df['total_credit'] = df['price_diff'] - df['commission_fee'] - df['seller_fee']\\n df['cashout_fee'] = abs((df['total_credit']) * (2.9/100))\\n df['net_profit'] = df['total_credit'] - df['cashout_fee']\\n #create purchase feature if the net profit is greater than 0\\n df['profitable'] = np.where(df['net_profit'] > 0, 1, 0)\\n #drop columns used to calculate net profit\\n df.drop(['commission_fee', 'seller_fee', 'total_credit', 'cashout_fee'], axis=1, inplace=True)\\n\\n #feature 3: brand code\\n brand_code = df.groupby('brand').ngroup()\\n df = pd.concat([df, brand_code], axis=1).rename(columns={0:'brand_code'})\\n\\n #feature 4: word2vec colors\\n nlp = spacy.load('en_vectors_web_lg')\\n df['black'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"black\\\", nlp))\\n df['white'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"white\\\", nlp))\\n df['brown'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"brown\\\", nlp))\\n df['red'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"red\\\", nlp))\\n df['blue'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"blue\\\", nlp))\\n df['yellow'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"yellow\\\", nlp))\\n df['orange'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"orange\\\", nlp))\\n df['green'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"green\\\", nlp))\\n df['purple'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"purple\\\", nlp))\\n df['multi_color'] = df['colorway'].apply(lambda x: color_word2vec(x, \\\"multi color\\\", nlp))\\n df['main_color'] = df[['black', 'white', 'brown', 'red', 'blue', 'yellow',\\n 'orange', 'green', 'purple', 'multi_color']].idxmax(axis=1)\\n df['main_color_id'] = df.groupby('main_color').ngroup()\\n\\n #boolean features\\n df['womens'] = df['name'].apply(lambda x: label_womens(x))\\n\\n df['bcollab'] = df['name'].apply(lambda x: label_bcollab(x))\\n\\n df['og'] = df['name'].apply(lambda x: label_og(x))\\n\\n df['sp'] = df['name'].apply(lambda x: label_sp(x))\\n\\n df['qs'] = df['name'].apply(lambda x: label_qs(x))\\n\\n df['sb'] = df['name'].apply(lambda x: label_sb(x))\\n\\n df['ls'] = df['name'].apply(lambda x: label_ls(x))\\n\\n df['nrg'] = df['name'].apply(lambda x: label_nrg(x))\\n\\n df['prm'] = df['name'].apply(lambda x: label_prm(x))\\n\\n df['nsw'] = df['name'].apply(lambda x: label_nsw(x))\\n\\n df['retro'] = df['name'].apply(lambda x: label_retro(x))\\n\\n df['se'] = df['name'].apply(lambda x: label_se(x))\\n\\n df['pe'] = df['name'].apply(lambda x: label_pe(x))\\n\\n df['gs'] = df['name'].apply(lambda x: label_gs(x))\\n\\n df['hs'] = df['name'].apply(lambda x: label_hs(x))\\n\\n return df\",\n \"def rbd_koon_parallel_args() -> dict:\\n edges = [\\n (\\\"s\\\", 1),\\n (\\\"s\\\", 2),\\n (\\\"s\\\", 3),\\n (1, \\\"v\\\"),\\n (2, \\\"v\\\"),\\n (3, \\\"v\\\"),\\n (\\\"v\\\", \\\"t\\\"),\\n ]\\n reliabilities = {\\n 1: FixedEventProbability.from_params(1 - 0.85),\\n 2: FixedEventProbability.from_params(1 - 0.8),\\n 3: FixedEventProbability.from_params(1 - 0.9),\\n \\\"v\\\": FixedEventProbability.from_params(1 - 0.85),\\n }\\n return {\\\"edges\\\": edges, \\\"reliabilities\\\": reliabilities}\",\n \"def evolve(self, genomes, pool, params):\\n pass\",\n \"def call_modes(self, infname, outfname, no_of_genes, parameter_a=0.2, parameter_b=4):\\n\\t\\tmodes_path = os.path.join(os.path.expanduser('~'), 'bin/hhu_clustering/bin/modes')\\n\\t\\tif not os.path.isfile(modes_path):\\n\\t\\t\\tprint 'program %s not available'%modes_path\\n\\t\\t\\tsys.exit(1)\\n\\t\\t###!!!, the argument list must comprise of all strings, not integer, or float.\\n\\t\\twl = ['modes', infname, repr(no_of_genes), outfname, repr(parameter_b), '1', repr(int(parameter_a*10)), '80']\\n\\t\\tif self.debug:\\n\\t\\t\\tprint \\\"modes' parameter is %s\\\",wl\\n\\t\\treturn os.spawnvp(os.P_WAIT, modes_path, wl)\",\n \"def get_ids_filter(grid, idsname='Ids', is_nids=True, is_eids=True):\\n ids = vtk.vtkIdFilter()\\n if isinstance(grid, vtk.vtkUnstructuredGrid):\\n # this is typically what's called in the gui\\n ids.SetInputData(grid)\\n elif isinstance(grid, vtk.vtkPolyData): # pragma: no cover\\n # this doesn't work...\\n ids.SetCellIds(grid.GetCellData())\\n ids.SetPointIds(grid.GetPointData())\\n else:\\n raise NotImplementedError(ids)\\n\\n #self.is_eids = False\\n ids.CellIdsOn()\\n ids.PointIdsOn()\\n\\n #print('is_eids=%s is_nids=%s' % (is_eids, is_nids))\\n if not is_eids:\\n ids.CellIdsOff()\\n if not is_nids:\\n ids.PointIdsOff()\\n #ids.FieldDataOn()\\n ids.SetIdsArrayName(idsname)\\n return ids\",\n \"def main() :\\n\\t\\n\\tusage = \\\"\\\"\\\"usage: %prog [options]\\\"\\\"\\\"\\t\\t\\t\\n\\n\\tparser = OptionParser(usage=usage)\\n\\tparser.add_option(\\\"-r\\\",\\\"--relocfile\\\", dest=\\\"relocfile\\\", type=\\\"string\\\",\\n\\t\\t\\t\\t\\t\\thelp=\\\"hypoDD relocated file [hypoDD.reloc]\\\")\\n\\tparser.add_option(\\\"-l\\\",\\\"--locfile\\\", dest=\\\"locfile\\\", type=\\\"string\\\",\\n\\t\\t\\t\\t\\t\\thelp=\\\"hypoDD non-relocated file [hypoDD.loc]\\\")\\n\\tparser.add_option(\\\"-o\\\",\\\"--outputPDF\\\", dest=\\\"pdffile\\\", type=\\\"string\\\",\\n\\t\\t\\t\\t\\t\\thelp=\\\"output PDF filename [hypoDD.locreloc.pdf]\\\")\\n\\tparser.add_option(\\\"-p\\\",\\\"--outputPNG\\\", dest=\\\"pngfile\\\", type=\\\"string\\\",\\n\\t\\t\\t\\t\\t\\thelp=\\\"output PNG filename [hypoDD.locreloc.png]\\\")\\n#\\tparser.add_option(\\\"-a\\\",\\\"--allEvents\\\", dest=\\\"plotAll\\\",\\n#\\t\\t\\t\\t\\t\\taction=\\\"store_true\\\", help=\\\"print out all events (even unimproved)\\\")\\n\\tparser.add_option(\\\"-c\\\",\\\"--connectHypos\\\", dest=\\\"plotConnect\\\",\\n\\t\\t\\t\\t\\t\\taction=\\\"store_true\\\", help=\\\"connect relocated and original events\\\")\\n\\tparser.add_option(\\\"-u\\\",\\\"--uncertLimit\\\", dest=\\\"uncertlimit\\\", type=\\\"float\\\",\\n\\t\\t\\t\\t\\t\\thelp=\\\"print out only relocated events with all uncertainties (m) less than this (0 means print all) [0]\\\")\\n\\n\\tparser.set_defaults(relocfile=\\\"hypoDD.reloc\\\",\\n\\t\\t\\t\\t\\t\\tlocfile='hypoDD.loc', \\n\\t\\t\\t\\t\\t\\tpdffile='hypoDD.locreloc.pdf',\\n\\t\\t\\t\\t\\t\\tpngfile='hypoDD.locreloc.png',\\n\\t\\t\\t\\t\\t\\tplotConnect=False,\\n#\\t\\t\\t\\t\\t\\tplotAll=False,\\n\\t\\t\\t\\t\\t\\tuncertlimit=0)\\n\\t(options, args) = parser.parse_args()\\n\\t\\t\\n\\tpsfile='temp.ps'\\n\\tconnectFile='temp.connect'\\n\\tlocXY=options.locfile + '.xy'\\n\\trelocXY=options.relocfile + '.xy'\\n\\tprint(options.locfile, options.relocfile,locXY,relocXY)\\n\\t\\n\\tif len(args) != 0:\\n\\t\\tprint(main.__doc__)\\n\\t\\tparser.print_help()\\n\\t\\treturn 2\\n\\n\\t# Read relocated events into memory\\n\\tf=open(options.relocfile,'r');\\n\\treloc = [line.split() for line in f]\\n\\tf.close()\\n\\t\\n\\t# Read original events into memory\\n\\tf=open(options.locfile,'r');\\n\\t#loc = [map(float, line.split()) for line in f]\\t# if I wanted all values as floats\\n\\tloc = [line.split() for line in f]\\n\\tf.close()\\n\\tlocindex=[a[0] for a in loc]\\t# return list of line indices\\n\\n\\tprint('{:20s} has {:d} events'.format(options.locfile, len(loc)) )\\n\\tprint('{:20s} has {:d} events'.format(options.relocfile,len(reloc)))\\n\\t\\n\\tmpdLat=1852*60\\t# meters per degree latitude\\n\\tbaseLat=float(loc[0][1])\\n\\tlonmult=math.cos(baseLat*math.pi/180)\\n\\tprint(\\\"Base latitude = {:8.4f}, lon multiplier = {:.4f}\\\".format(baseLat,lonmult))\\n\\tmpdLon=mpdLat*lonmult\\n\\t\\n\\tmag_powerfact=3;\\tmag_ref=2;\\t# magnitude for 1 cm circle\\n\\tmagdivisor=pow(mag_powerfact,mag_ref)\\n\\t# Print original events in GMT format\\n\\tf=open(locXY,'w')\\n\\tfor line in loc :\\n\\t\\tmagsize=pow(mag_powerfact,float(line[16]))/magdivisor\\n\\t\\tf.write(\\\"{} {} {:8.3f} {:8.5f} {:8.5f}\\\\n\\\".format(\\n\\t\\t\\t\\t\\tline[2],line[1],magsize,float(line[7])/mpdLon, float(line[8])/mpdLat))\\n\\tf.close()\\n\\t\\n\\t# Write relocated events in GMT format\\n\\tf=open(relocXY,'w')\\n\\tif options.plotConnect :\\t# connect original and new locations\\n\\t\\tfc=open(connectFile,'w')\\n\\tfor relocLine in reloc :\\n\\t\\tprintLine=True\\n\\t\\tif options.uncertlimit > 0 :\\n\\t\\t\\tif float(relocLine[7]) > options.uncertlimit :\\n\\t\\t\\t\\tprintLine=False\\n\\t\\t\\telif float(relocLine[8]) > options.uncertlimit :\\n\\t\\t\\t\\tprintLine=False\\n\\t\\t\\tif printLine==False:\\n\\t\\t\\t\\tprint('#{:5s}: Rejected relocated because x or y error > {:g} meters: x={:5s} y={:5s}'.format(\\n\\t\\t\\t\\t\\t\\trelocLine[0],options.uncertlimit,relocLine[7],relocLine[8]))\\n# \\t\\telif ~options.plotAll :\\t# comparing to original's error doesn't work because original has zero error????\\n# \\t\\t\\ti = locindex.index(relocLine[0])\\n# \\t\\t\\t#print(i,relocLine[0])\\n# \\t\\t\\tlocLine=loc[i]\\n# \\t\\t\\tif locLine[0] != relocLine[0]:\\n# \\t\\t\\t\\tprint(\\\"ERROR, reloc and loc line #s don't match!!! ({} and {})\\\".format(relocLine[0],locLine[0]));\\n# \\t\\t\\t\\tsys.exit(2)\\n# \\t\\t\\tif float(locLine[7]) < float(relocLine[7]) :\\t# original x error smaller than relocated\\n# \\t\\t\\t\\tprintLine=False\\n# \\t\\t\\telif float(locLine[8]) < float(relocLine[8]):\\n# \\t\\t\\t\\tprintLine=False\\n# \\t\\t\\tif printLine==False:\\n# \\t\\t\\t\\tprint('Rejected relocated because worse than original')\\n# \\t\\t\\t\\tprint('Original',locLine)\\n# \\t\\t\\t\\tprint('Relocated',relocLine)\\n\\t\\tif options.plotConnect :\\t# connect original and new locations\\n\\t\\t\\ti = locindex.index(relocLine[0])\\n\\t\\t\\t#print(i,relocLine[0])\\n\\t\\t\\tlocLine=loc[i]\\n\\t\\t\\tif locLine[0] != relocLine[0]:\\n\\t\\t\\t\\tprint(\\\"ERROR, reloc and loc index #s don't match!!! ({} and {})\\\".format(relocLine[0],locLine[0]));\\n\\t\\t\\tfc.write(\\\"{} {}\\\\n{} {}\\\\n>\\\\n\\\".format(locLine[2],locLine[1],relocLine[2],relocLine[1]))\\n\\t\\tif printLine :\\n\\t\\t\\tmagsize=pow(mag_powerfact,float(relocLine[16]))/magdivisor\\n\\t\\t\\tf.write(\\\"{} {} {:8.3f} {:8.5f} {:8.5f}\\\\n\\\".format(\\n\\t\\t\\t\\t\\trelocLine[2],relocLine[1],magsize,\\n\\t\\t\\t\\t\\tfloat(relocLine[7])/mpdLon, float(relocLine[8])/mpdLat) )\\n\\tf.close()\\n\\tif options.plotConnect :\\t# connect original and new locations\\n\\t\\tfc.close()\\n\\n\\t\\n\\t# Run GMT\\n\\tprocess = subprocess.Popen(\\\"cat {} {} | minmax -I1m\\\".format(locXY,relocXY),\\n\\t\\t\\t\\tshell=True, stdout=subprocess.PIPE, universal_newlines=True)\\n\\trange=process.communicate()[0].strip();\\n\\tprint(range)\\n\\tprint(locXY,relocXY)\\n\\tprocess=subprocess.Popen(\\\"psbasemap -JM15c+ {} -B100m -P -K > {}\\\".format(range,psfile),shell=True);\\n\\tprocess.communicate()[0]\\t# Waits until end of last process\\n\\tprocess=subprocess.Popen(\\\"psxy {} -JM -R -Sc0.1c -Glightgrey -Wlightgrey -O -K >> {}\\\".format(locXY,psfile),shell=True);\\n\\tprocess=subprocess.Popen(\\\"pscoast -JM -R -Df -W -O -K >> {}\\\".format(psfile),shell=True);\\n\\tprocess.communicate()[0]\\t# Waits until end of last process\\n\\tif options.plotConnect :\\n\\t\\tprocess=subprocess.Popen(\\\"psxy {} -JM -R -M -W1,darkgrey -O -K >> {}\\\".format(connectFile,psfile),shell=True);\\n\\t\\tprocess.communicate()[0]\\t# Waits until end of last process\\n\\t\\t\\n\\tprocess=subprocess.Popen(\\\"psxy {} -JM -R -Sc0.1c -Wblack -O >> {}\\\".format(relocXY,psfile),shell=True);\\n\\tprocess.communicate()[0]\\t# Waits until end of last process\\n\\tprocess=subprocess.Popen(\\\"ps2pdf {} {}\\\".format(psfile,options.pdffile),shell=True);\\n\\tprocess.communicate()[0]\\t# Waits until end of last process\\n\\tprocess=subprocess.Popen(\\\"convert -density 300 {} -trim -alpha off {}\\\".format(options.pdffile,options.pngfile),shell=True);\\n\\tprocess.communicate()[0]\\t# Waits until end of last process\\n\\tprocess=subprocess.Popen(\\\"rm {}\\\".format(psfile),shell=True);\\n\\tprocess.communicate()[0]\\t# Waits until end of last process\\n\\tprocess=subprocess.Popen(\\\"open {}\\\".format(options.pngfile),shell=True);\",\n \"def eda_eventrelated(epochs, silent=False):\\n # Sanity checks\\n epochs = _eventrelated_sanitizeinput(epochs, what=\\\"eda\\\", silent=silent)\\n\\n # Extract features and build dataframe\\n data = {} # Initialize an empty dict\\n for i in epochs.keys():\\n\\n data[i] = {} # Initialize an empty dict for the current epoch\\n\\n # Maximum phasic amplitude\\n data[i] = _eda_eventrelated_eda(epochs[i], data[i])\\n\\n # Detect activity following the events\\n if np.any(epochs[i][\\\"SCR_Peaks\\\"][epochs[i].index > 0] == 1) and np.any(\\n epochs[i][\\\"SCR_Onsets\\\"][epochs[i].index > 0] == 1\\n ):\\n data[i][\\\"EDA_SCR\\\"] = 1\\n else:\\n data[i][\\\"EDA_SCR\\\"] = 0\\n\\n # Analyze based on if activations are present\\n if data[i][\\\"EDA_SCR\\\"] != 0:\\n data[i] = _eda_eventrelated_scr(epochs[i], data[i])\\n else:\\n data[i][\\\"SCR_Peak_Amplitude\\\"] = np.nan\\n data[i][\\\"SCR_Peak_Amplitude_Time\\\"] = np.nan\\n data[i][\\\"SCR_RiseTime\\\"] = np.nan\\n data[i][\\\"SCR_RecoveryTime\\\"] = np.nan\\n\\n # Fill with more info\\n data[i] = _eventrelated_addinfo(epochs[i], data[i])\\n\\n df = _eventrelated_sanitizeoutput(data)\\n\\n return df\",\n \"def operation_on_events(path_to_data_dir, list_of_test_id, operation, num_of_proc=1):\\n\\ttest_id = [\\\"test%s\\\"%i for i in list_of_test_id]\\n\\tpool = Pool(processes = num_of_proc)\\n\\tpath_to_final_selected_events = path_to_data_dir + \\\"final_selected_events.json\\\"\\n\\tif os.path.exists(path_to_final_selected_events):\\n\\t\\tfinal_selected_events = json.load(open(path_to_final_selected_events,\\\"r\\\"))\\n\\t\\tfinal_interested_events = []\\n\\t\\tfor event in final_selected_events:\\n\\t\\t\\tif event[0] in test_id:\\n\\t\\t\\t\\tfinal_interested_events.append(event)\\n\\telse:\\n\\t\\tfinal_interested_events = []\\n\\t\\tfor test in list_of_test_id:\\n\\t\\t\\tpath_to_curr_test = data_dir_to_test_dir(path_to_data_dir, test)\\n\\t\\t\\tpath_to_test_result = path_to_curr_test +\\\"/results\\\"\\n\\t\\t\\tpath_to_event_list = path_to_test_result + \\\"/selected_events.json\\\"\\n\\t\\t\\tif os.path.exists(path_to_event_list):\\n\\t\\t\\t\\tevent_list = json.load(open(path_to_event_list,\\\"r\\\"))\\n\\t\\t\\t\\tfor value in event_list.values():\\n\\t\\t\\t\\t\\tevent = [\\\"test%s\\\"%test,[value[0],value[1],value[2]]]\\n\\t\\t\\t\\t\\tfinal_interested_events.append(event)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint \\\"skip current test:\\\", \\\"test%s\\\"%test, \\\"there is no selected events\\\"\\n\\t\\n\\t# if function operation has no return value, it will return a list of Nones\\n\\tresult_list = pool.map(operation,final_interested_events)\\n\\treturn result_list\",\n \"def simulate(self, **kwargs):\\n # First, update keys with new values\\n for key, value in kwargs.items():\\n if f\\\"_{key}\\\" in self.__dict__.keys():\\n setattr(self, key, value)\\n\\n if self.as_version != EnergyPlusVersion(self.idd_version):\\n raise EnergyPlusVersionError(\\n None, self.idfname, EnergyPlusVersion(self.idd_version), self.as_version\\n )\\n\\n start_time = time.time()\\n include = self.include\\n if isinstance(include, str):\\n include = Path().abspath().glob(include)\\n elif include is not None:\\n include = [Path(file) for file in include]\\n\\n # check if a weather file is defined\\n if not getattr(self, \\\"epw\\\", None):\\n raise EnergyPlusWeatherError(\\n f\\\"No weather file specified with {self}. Set 'epw' in IDF(\\\"\\n f\\\"filename, epw='weather.epw').simulate() or in IDF.simulate(\\\"\\n f\\\"epw='weather.epw')\\\"\\n )\\n\\n # Todo: Add EpMacro Thread -> if exist in.imf \\\"%program_path%EPMacro\\\"\\n # Run the expandobjects program if necessary\\n with TemporaryDirectory(\\n prefix=\\\"expandobjects_run_\\\",\\n suffix=None,\\n dir=self.output_directory,\\n ) as tmp:\\n # Run the ExpandObjects preprocessor program\\n expandobjects_thread = ExpandObjectsThread(self, tmp)\\n expandobjects_thread.start()\\n expandobjects_thread.join()\\n e = expandobjects_thread.exception\\n if e is not None:\\n raise e\\n\\n # Run the Basement preprocessor program if necessary\\n with TemporaryDirectory(\\n prefix=\\\"runBasement_run_\\\",\\n suffix=None,\\n dir=self.output_directory,\\n ) as tmp:\\n basement_thread = BasementThread(self, tmp)\\n basement_thread.start()\\n basement_thread.join()\\n e = basement_thread.exception\\n if e is not None:\\n raise e\\n\\n # Run the Slab preprocessor program if necessary\\n with TemporaryDirectory(\\n prefix=\\\"runSlab_run_\\\",\\n suffix=None,\\n dir=self.output_directory,\\n ) as tmp:\\n slab_thread = SlabThread(self, tmp)\\n slab_thread.start()\\n slab_thread.join()\\n e = slab_thread.exception\\n if e is not None:\\n raise e\\n\\n # Run the energyplus program\\n with TemporaryDirectory(\\n prefix=\\\"eplus_run_\\\",\\n suffix=None,\\n dir=self.output_directory,\\n ) as tmp:\\n running_simulation_thread = EnergyPlusThread(self, tmp)\\n running_simulation_thread.start()\\n running_simulation_thread.join()\\n e = running_simulation_thread.exception\\n if e is not None:\\n raise e\\n return self\",\n \"def event(self, obj, mode=\\\"r\\\", clear=False, data=0):\\n note = 0\\n if mode == \\\"r\\\":\\n event = (obj.fileno(), select.KQ_FILTER_READ)\\n elif mode == \\\"w\\\":\\n event = (obj.fileno(), select.KQ_FILTER_WRITE)\\n elif mode == \\\"t\\\":\\n event = (obj, select.KQ_FILTER_TIMER)\\n data = int(data * 1000)\\n elif mode.startswith(\\\"p\\\"):\\n event = (obj.pid, select.KQ_FILTER_PROC)\\n if \\\"f\\\" in mode[1:]:\\n note |= select.KQ_NOTE_FORK\\n elif \\\"e\\\" in mode[1:]:\\n note |= select.KQ_NOTE_EXEC\\n elif \\\"-\\\" in mode[1:]:\\n if ISSUE11973:\\n # HACK: work around python bug!!!\\n note -= select.KQ_NOTE_EXIT\\n else:\\n note |= select.KQ_NOTE_EXIT\\n elif mode == \\\"s\\\":\\n event = (obj, select.KQ_FILTER_SIGNAL)\\n else:\\n raise ValueError(\\\"unknown event mode\\\")\\n\\n if clear:\\n try:\\n self._kq_events.pop(event)\\n self._kq.control((select.kevent(event[0], event[1],\\n select.KQ_EV_DELETE),), 0)\\n except KeyError:\\n raise KeyError(\\\"no event registered\\\")\\n else:\\n if event not in self._kq_events:\\n from .signal import Signal\\n kevent = select.kevent(event[0], event[1],\\n select.KQ_EV_ADD | select.KQ_EV_ENABLE,\\n note, data)\\n self._kq.control((kevent,), 0)\\n self._kq_events[event] = Signal()\\n return self._kq_events[event]\",\n \"def generalization_feature_selection(data1, data2, measure, cutoff):\\n cor1 = np.corrcoef(np.transpose(data1))\\n cor2 = np.corrcoef(np.transpose(data2))\\n num = data1.shape[1]\\n cor = []\\n if measure == \\\"pearson\\\":\\n for i in range(num):\\n cor.append(\\n np.corrcoef(\\n np.vstack(\\n (\\n list(cor1[:i, i]) + list(cor1[(i + 1) :, i]),\\n list(cor2[:i, i]) + list(cor2[(i + 1) :, i]),\\n )\\n )\\n )[0, 1]\\n )\\n elif measure == \\\"ccc\\\":\\n for i in range(num):\\n cor.append(\\n calculate_concordance_correlation_coefficient(\\n np.array(list(cor1[:i, i]) + list(cor1[(i + 1) :, i])),\\n np.array(list(cor2[:i, i]) + list(cor2[(i + 1) :, i])),\\n )\\n )\\n cor = np.array(cor)\\n fid = np.argsort(-cor)[: int(cutoff)]\\n return fid\",\n \"def ha(sf,sfn,mX,pX,params,verbose=[],onlySelected=False,hc=-2,div=8,L=30,fs=44100,gt=[]):\\r\\n \\r\\n M,N,H,B = params\\r\\n \\r\\n idx = candidSelection(sf,t=0.025,hw=25) \\r\\n idx = np.concatenate((np.zeros(1),idx,np.array([sf.shape[0]])))\\r\\n idx_orig = idx.copy()\\r\\n mask = np.ones(idx.shape)\\r\\n mask[0]=0\\r\\n mask[-1]=0\\r\\n errors = np.zeros(mX.shape[0])\\r\\n scores = np.zeros(idx.shape)\\r\\n freqs = []\\r\\n \\r\\n tFlag = False\\r\\n vFlag = False # flag to enable prints and plots\\r\\n \\r\\n rms = np.sum(mX,axis=1)\\r\\n rms = rms-np.mean(rms)\\r\\n rms = rms/np.max(rms)\\r\\n rms = savgol_filter(rms,3,1)\\r\\n \\r\\n rms_t = -0.1\\r\\n \\r\\n # sending every onset candidate to harmonic analysis\\r\\n for i in range(len(idx)-2,0,-1):\\r\\n \\r\\n if onlySelected:\\r\\n if idx[i] not in verbose:\\r\\n continue\\r\\n \\r\\n b = int((idx[i]-(10240/H)) if (idx[i]>(idx[i-1]+(10240/H))) else idx[i-1])\\r\\n e = int((idx[i]+(10240/H)) if (idx[i]<(idx[i+1]-(10240/H))) else idx[i+1])\\r\\n \\r\\n \\r\\n if np.mean(rms[int(idx[i]):int(idx[i])+50])<rms_t:\\r\\n continue\\r\\n \\r\\n onst = int(idx[i]-b)\\r\\n pmX = np.copy(mX[b:e])\\r\\n \\r\\n\\r\\n if idx[i] in verbose:\\r\\n print(\\\"\\\\nOnset candidate:\\\")\\r\\n print(\\\"onset frame: %d\\\" %idx[i])\\r\\n print(\\\"sf onset number: %d\\\" %i)\\r\\n vFlag = True\\r\\n y = MRStftSynth(pmX,pX[b:e],M,H,B)\\r\\n print(\\\"synthesized sound\\\")\\r\\n ipd.display(ipd.Audio(data=y, rate=fs))\\r\\n \\r\\n if vFlag:\\r\\n print(\\\"STFT around candidate\\\")\\r\\n plt.pcolormesh(np.arange(pmX.shape[0]), np.arange(pmX.shape[1]), np.transpose(pmX))\\r\\n plt.show()\\r\\n \\r\\n print(\\\"filtered spectral flux\\\")\\r\\n plt.plot(sf[b:e])\\r\\n plt.show()\\r\\n print(\\\"raw spectral flux\\\")\\r\\n plt.plot(sfn[b:e])\\r\\n plt.show()\\r\\n \\r\\n allErrors,allf0s,pmXv = f0detection(pmX,pX[b:e],sfn[b:e],-100,10,onst,vFlag,hc,div,params,fs,tFlag)\\r\\n\\r\\n aL = np.min((e-idx[i]/2,L)) \\r\\n segments = getSegments(allf0s,allErrors,onst,pmX,vFlag)\\r\\n scores[i],freq,segmentScores = harmonicScore(segments,aL,vFlag,tFlag)\\r\\n freqs.append(freq)\\r\\n \\r\\n if scores[i]<1: # prevent rejected candidates from creating boundary for adjacent onset\\r\\n idx[i] = sf.shape[0]\\r\\n \\r\\n if vFlag:\\r\\n print(\\\"Score for this onset: %d\\\" %scores[i])\\r\\n \\r\\n if tFlag and scores[i]<1:\\r\\n pred_time = np.abs(idx[i]*(H/fs))\\r\\n closest_gt_ind = np.argmin(pred_time-gt)[0]\\r\\n if np.abs(gt[closest_gt_ind]-pred_time)<0.05:\\r\\n if score[i]>1:\\r\\n tp.append[idx[i]]\\r\\n if score[i]<1:\\r\\n fn.append[idx[i]]\\r\\n \\r\\n print(\\\"STFT around onset\\\")\\r\\n plt.pcolormesh(np.arange(pmX.shape[0]), np.arange(pmX.shape[1]), np.transpose(pmX))\\r\\n plt.show()\\r\\n \\r\\n y = MRStftSynth(pmXv,pX,M,H,B)\\r\\n ipd.display(ipd.Audio(data=y, rate=fs))\\r\\n \\r\\n plt.pcolormesh(np.arange(pmXv.shape[0]), np.arange(pmXv.shape[1]), np.transpose(pmXv))\\r\\n plt.show()\\r\\n\\r\\n vFlag = False\\r\\n tFlag = False\\r\\n \\r\\n avg = np.mean(scores)\\r\\n mask[scores<1] = 0\\r\\n result = idx_orig[mask==1]\\r\\n return idx_orig[1:-1],result,freqs,scores[1:-1]\",\n \"def get_picker_cmd(picker_args=None, fuzzy=True):\\n\\n if SYSTEM_NAME == \\\"Linux\\\":\\n args = ['rofi', '-sort', '-no-levenshtein-sort']\\n if fuzzy:\\n args += ['-matching', 'fuzzy']\\n args += ['-dmenu', '-p', \\\"Select Figure\\\", '-format', 's', '-i',\\n '-lines', '5']\\n elif SYSTEM_NAME == \\\"Darwin\\\":\\n args = [\\\"choose\\\"]\\n else:\\n raise ValueError(\\\"No supported picker for {}\\\".format(SYSTEM_NAME))\\n\\n if picker_args is not None:\\n args += picker_args\\n\\n return [str(arg) for arg in args]\",\n \"def processElementClick(self, *argv):\\n if argv[0]: #argv[0] is 0 for a click on an atom\\n return\\n hits = argv[:-1]\\n event = argv[-1]\\n if event.button() == QtCore.Qt.LeftButton:\\n if event.modifiers() & QtCore.Qt.CTRL: #Multiple selection mode\\n atom = CAlphaRenderer.getAtomFromHitStack(self.renderer, hits[0], False, *hits[1:])\\n if atom.getResSeq() in self.main_chain.getSelection():\\n self.main_chain.setSelection(removeOne=atom.getResSeq())\\n else:\\n self.main_chain.setSelection(addOne=atom.getResSeq())\\n print self.main_chain.getSelection()\\n else:\\n atom = CAlphaRenderer.getAtomFromHitStack(self.renderer, hits[0], True, *hits[1:])\\n print 'Residue #:', atom.getResSeq()\\n self.main_chain.setSelection([atom.getResSeq()])\\n self.emitAtomSelectionUpdated(self.main_chain.getSelection())\\n \\n if event.button() == QtCore.Qt.RightButton and self.centerOnRMB:\\n self.centerOnSelectedAtoms(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6])\",\n \"def get_actors_by_area_picker(gui, area_picker, model_name, is_nids=True, is_eids=True,\\n representation='points', add_actors=False):\\n frustum = area_picker.GetFrustum() # vtkPlanes\\n\\n ugrid, eids, nids = get_depth_ids(\\n gui, frustum, model_name=model_name,\\n is_nids=is_nids, is_eids=is_eids,\\n representation=representation)\\n\\n actor = gui.create_highlighted_actor(\\n ugrid, representation=representation, add_actor=add_actors)\\n actors = [actor]\\n return actors, eids, nids\",\n \"def xmain(bids_dir, analysis_dir, freesurfer_dir, output_dir,\\n acquisition='clinical', measure_modality=\\\"\\\", measure_column=\\\"\\\"):\\n img_dir = output_dir / ELECSURF_DIR\\n rmtree(img_dir, ignore_errors=True)\\n img_dir.mkdir(exist_ok=True, parents=True)\\n\\n for electrode_path in find_in_bids(bids_dir, generator=True, acquisition=acquisition, modality='electrodes', extension='.tsv'):\\n lg.debug(f'Reading electrodes from {electrode_path}')\\n elec = Electrodes(electrode_path)\\n fs = Freesurfer(freesurfer_dir / ('sub-' + elec.subject))\\n\\n labels = None\\n if measure_modality != \\\"\\\":\\n try:\\n ecog_file = find_in_bids(\\n analysis_dir,\\n subject=elec.subject,\\n modality=measure_modality,\\n extension='.tsv')\\n except FileNotFoundError as err:\\n lg.warning(err)\\n continue\\n\\n lg.debug(f'Reading {measure_column} from {ecog_file}')\\n ecog_tsv = read_tsv(ecog_file)\\n\\n labels = [x['name'] for x in elec.electrodes.tsv]\\n labels, vals = read_channels(ecog_tsv, labels, measure_column)\\n\\n else:\\n vals = None\\n\\n v = plot_electrodes(elec, fs, labels, vals)\\n\\n png_file = img_dir / replace_underscore(elec.get_filename(), 'surfaceplot.png')\\n lg.debug(f'Saving electrode plot on {png_file}')\\n v.save(png_file)\\n v.close()\",\n \"def modelfactors(trace_files: List[str], trace_processes: Dict):\\n traces = [load(file) for file in trace_files]\\n df_mfactors = pd.DataFrame(columns=MOD_FACTORS_DOC.values())\\n reference = True\\n for (hdf5_file, trace, cpus) in zip(trace_files, traces, trace_processes.values()):\\n MOD_FACTORS_VAL['num_processes'] = cpus\\n print(\\n f\\\"==INFO== Analysing {hdf5_file} ({MOD_FACTORS_VAL['num_processes']} processes, {human_readable(os.path.getsize(hdf5_file))})\\\")\\n\\n # Computes raw data\\n ipc, freq, runtime, runtime_id, useful_av, useful_max, useful_tot, useful_id, useful_inst, useful_cyc = get_raw_data(\\n trace, cmdl_args)\\n\\n MOD_FACTORS_VAL['ipc'] = ipc\\n MOD_FACTORS_VAL['freq'] = freq\\n MOD_FACTORS_VAL['runtime'] = runtime\\n MOD_FACTORS_VAL['runtime_id'] = runtime_id\\n MOD_FACTORS_VAL['useful_av'] = useful_av\\n MOD_FACTORS_VAL['useful_max'] = useful_max\\n MOD_FACTORS_VAL['useful_tot'] = useful_tot\\n MOD_FACTORS_VAL['useful_id'] = useful_id\\n MOD_FACTORS_VAL['useful_ins'] = useful_inst\\n MOD_FACTORS_VAL['useful_cyc'] = useful_cyc\\n\\n # Computes efficiencies after getting the raw data\\n parallel_eff, load_balance, comm_eff, serial_eff, transfer_eff = get_efficiencies(\\n MOD_FACTORS_VAL['runtime'],\\n MOD_FACTORS_VAL['runtime_id'],\\n MOD_FACTORS_VAL['useful_av'],\\n MOD_FACTORS_VAL['useful_max'],\\n MOD_FACTORS_VAL['useful_id'],\\n MOD_FACTORS_VAL['comp_scale'])\\n\\n MOD_FACTORS_VAL['parallel_eff'] = parallel_eff\\n MOD_FACTORS_VAL['load_balance'] = load_balance\\n MOD_FACTORS_VAL['comm_eff'] = comm_eff\\n MOD_FACTORS_VAL['serial_eff'] = serial_eff\\n MOD_FACTORS_VAL['transfer_eff'] = transfer_eff\\n\\n # Adds the new row with the raw data and efficiencies to the dataframe\\n df_mfactors.loc[len(df_mfactors), :] = list(MOD_FACTORS_VAL.values())\\n\\n # Computes scalabilities\\n df_mfactors = get_scalabilities(df_mfactors, cmdl_args)\\n\\n return df_mfactors\",\n \"def finder_selector(module_name):\\n if module_name.lower() == 'keras':\\n return KerasResultFinder\\n else:\\n return ResultFinder\",\n \"def pions ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n ##\\n if self['NOPIDHADRONS'] :\\n from StandardParticles import StdAllNoPIDsPions as inpts\\n pioncut = self['PionCut']\\n else :\\n from StandardParticles import StdAllLooseANNPions as inpts\\n pioncut = \\\"(%s)&(%s)\\\" % ( self['PionCut'] , self['PionPIDCut'] ) \\n ##\\n return self.make_selection (\\n 'Pion' ,\\n FilterDesktop ,\\n [ inpts ] ,\\n Code = pioncut ,\\n )\",\n \"def choose_algorithm(self,\\n algorithm: str) -> None:\\n # Initialize the empty string for selected algorithm\\n self.selected_algorithm = ''\\n\\n # Executing the selected algorithm with respect to value of string\\n if algorithm is not None:\\n # First string value indicates the backbone of approach\\n backbone = algorithm.split('-')[0]\\n # Check the possible options\\n if backbone == 'KNN' and len(algorithm.split('-')) == 3:\\n print('KNN model based collaborative approach is selected!')\\n similarity_measure = algorithm.split('-')[1]\\n user_based = algorithm.split('-')[2]\\n if (similarity_measure == 'cosine' or similarity_measure == 'msd' or similarity_measure == 'pearson' or similarity_measure == 'pearson_baseline') and (user_based == 'user'):\\n self.selected_algorithm = KNNBaseline(sim_options={'name': similarity_measure,\\n 'user_based': True})\\n elif (similarity_measure == 'cosine' or similarity_measure == 'msd' or similarity_measure == 'pearson' or similarity_measure == 'pearson_baseline') and (user_based == 'item'):\\n self.selected_algorithm = KNNBaseline(sim_options={'name': similarity_measure,\\n 'user_based': False})\\n else:\\n raise ValueError('The given parameters {} for KNN algorithm is not recognized. Please check the propoer format'.format(str(backbone) + '-' + str(similarity_measure) + '-' + str(user_based)))\\n elif backbone == 'SVD' and len(algorithm.split('-')) == 3:\\n print('SVD model based collaborative approach is selected!')\\n epoch = int(algorithm.split('-')[1])\\n learning_rate = float(algorithm.split('-')[2])\\n self.selected_algorithm = SVD(n_epochs=epoch, lr_all=learning_rate)\\n elif backbone == '':\\n raise ValueError('Please give an algorithm! Algorithm cannot be left empty')\\n else:\\n raise ValueError(\\n 'The given algorithm format {} is not recognized. Please check the propoer format'.format(\\n str(backbone)))\\n elif algorithm is None:\\n # Raise an error message for None value for algorithm\\n raise ValueError('Please give an algorithm! Algorithm cannot be left empty')\\n return\",\n \"def select_features(self):\\r\\n \\r\\n features_list = list(self.feed_data.columns.values)\\r\\n features_list.remove(\\\"min_time\\\")\\r\\n thisrace = self.config.race_to_predict\\r\\n\\r\\n #if never ran race before, don't include these variables in feature\\r\\n #selection, they're just 0's anyway\\r\\n if self.config.first_time_running_race == True:\\r\\n unuseable_columns = [('min_time', thisrace),('std', thisrace),('num_races', thisrace),\\r\\n ('rainfall', thisrace),\\r\\n ('temp', thisrace),\\r\\n ('wind', thisrace),\\r\\n ('metersup', thisrace), \\r\\n 'sex_W']\\r\\n else:\\r\\n #drop this column...probs should have removed it earlier. \\r\\n unuseable_columns = ['sex_W']\\r\\n #print(features_list)\\r\\n for element in unuseable_columns:\\r\\n features_list.remove(element)\\r\\n data_with_all_feats = self.feed_data.drop(unuseable_columns,axis=1)\\r\\n colstodrop = features_list\\r\\n thiscols = []\\r\\n data_with_current_feats = data_with_all_feats.drop(features_list,axis=1)\\r\\n checkfit=100.0\\r\\n scores = []\\r\\n dropped_cols = []\\r\\n loopgain =True\\r\\n #mymod = RandomForestRegressor(n_estimators=80, oob_score = True, max_depth=10,\\r\\n # min_samples_split = 25, criterion='mse')\\r\\n thisloopfeatures_list = features_list\\r\\n curcols = data_with_current_feats.columns\\r\\n countgain=0\\r\\n #print(\\\"cc\\\",curcols)\\r\\n while loopgain == True:\\r\\n thisloopscore=100.0\\r\\n for fet in thisloopfeatures_list:\\r\\n data_with_current_feats[fet] = data_with_all_feats[fet]\\r\\n etrain=data_with_current_feats.sample(frac=0.8,random_state=200)\\r\\n etest=data_with_current_feats.drop(etrain.index)\\r\\n y = etrain.pop('min_time')\\r\\n ytest = etest.pop('min_time')\\r\\n #print(y)\\r\\n model = RandomForestRegressor(n_estimators=80, oob_score = True, max_depth=15,\\r\\n min_samples_split = 12, criterion='mse')\\r\\n model.fit(etrain,y)\\r\\n\\r\\n PRED = model.predict(etrain)\\r\\n predscore = self.mean_absolute_percentage_error(y,PRED)#= r2_score(y,PRED)\\r\\n oobs = self.mean_absolute_percentage_error(y,model.oob_prediction_)\\r\\n scores.append(oobs)\\r\\n if ((thisloopscore - oobs) > 0.0):\\r\\n thisloopscore = oobs\\r\\n fetwinner = fet\\r\\n data_with_current_feats.drop(fet,axis=1,inplace=True)\\r\\n etrain.drop(fet,axis=1,inplace=True)\\r\\n\\r\\n data_with_current_feats[fetwinner] = data_with_all_feats[fetwinner]\\r\\n etrain=data_with_current_feats.sample(frac=0.8,random_state=200)\\r\\n etest=data_with_current_feats.drop(etrain.index)\\r\\n y = etrain.pop('min_time')\\r\\n ytest = etest.pop('min_time')\\r\\n #print(y)\\r\\n model = RandomForestRegressor(n_estimators=80, oob_score = True, max_depth=30,\\r\\n min_samples_split = 12,min_samples_leaf =7, criterion='mse')\\r\\n model.fit(etrain,y)\\r\\n\\r\\n PRED = model.predict(etrain)\\r\\n predscore = self.mean_absolute_percentage_error(y,PRED)#= r2_score(y,PRED)\\r\\n #print(fetwinner,predscore)\\r\\n oobs = self.mean_absolute_percentage_error(y,model.oob_prediction_)\\r\\n scores.append(oobs)\\r\\n #print(fetwinner,\\\"~\\\",oobs)\\r\\n thisloopfeatures_list.remove(fetwinner)\\r\\n if ((checkfit-oobs)>0.0001):\\r\\n checkfit = oobs\\r\\n curcols = data_with_current_feats.columns\\r\\n #print(curcols)\\r\\n else:\\r\\n break\\r\\n\\r\\n\\r\\n self.final_df = self.feed_data[data_with_current_feats.columns]\\r\\n self.Xtrain=self.final_df.sample(frac=0.8,random_state=200)\\r\\n self.Xtest=self.final_df.drop(self.Xtrain.index)#\\r\\n self.ytrain = self.Xtrain.pop('min_time')\\r\\n self.ytest = self.Xtest.pop('min_time')\\r\\n self.model= RandomForestRegressor(n_estimators=80, oob_score = True, max_depth=30,\\r\\n min_samples_split = 12,min_samples_leaf =7, criterion='mse')\\r\\n self.model.fit(self.Xtrain,self.ytrain)\\r\\n #print(y)\\r\\n return\",\n \"def __init__ (self, name=\\\"TrigEFMissingETCosmicMonitoring_other\\\"):\\n super(TrigEFMissingETCosmicMonitoring_other, self).__init__(name)\\n self.defineTarget(\\\"Cosmic\\\")\\n # measurement\\n self.Histograms = [ hMET_log, hSumEt_log ]\\n self.Histograms += [ hMET_lin ]\\n self.Histograms += [ hMETPhi ]\",\n \"def selectName(self, absdirname):\\n\\n if opts.quiet: print \\\" \\\", self._salts + self._calts\\n\\n #\\n # choose one representation for the imagepage\\n #\\n\\n # 1) the first of the affinity repn which is an image file\\n found = 0\\n for ref in opts.repn_affinity:\\n for f in self._salts + self._calts:\\n if ref.search(f):\\n ff = self._base + opts.separator + f\\n paf = join(absdirname, ff)\\n if imgwhat(paf, opts.fast):\\n if f in self._salts:\\n self._salts.remove(f)\\n self._ext = f\\n else:\\n self._calts.remove(f)\\n (self._repn, self._ext) = splitext(f)\\n\\n if opts.quiet: print \\\" choosing affinity '%s'\\\" % f\\n return 1\\n else:\\n if opts.quiet: print \\\" ignoring non-image '%s'\\\" % f\\n\\n # 2) the first of the base files which is an image file\\n if opts.use_repn:\\n # 3) with the first of the alternate representations which\\n # is an image file.\\n eee = self._salts + self._calts\\n else:\\n eee = self._salts\\n\\n for f in eee:\\n if not f.startswith('.'): f = opts.separator + f\\n ff = self._base + f\\n paf = join(absdirname, ff)\\n if imgwhat(paf, opts.fast):\\n if f in self._salts:\\n self._salts.remove(f)\\n self._ext = f\\n else:\\n self._calts.remove(f)\\n (self._repn, self._ext) = splitext(f)\\n# if opts.quiet: print \\\" choosing imagefile '%s'\\\" % f\\n return 1\\n else:\\n if opts.quiet: print \\\" ignoring non-image '%s'\\\" % f\\n\\n# if opts.quiet: print \\\" no imagepage for base '%s'\\\" % self._base\\n return 0\",\n \"def main():\\r\\n option_parser, opts, args = parse_command_line_parameters(**script_info)\\r\\n\\r\\n sff_files = opts.sff_fps\\r\\n\\r\\n for f in sff_files:\\r\\n if (not exists(f)):\\r\\n option_parser.error(('Flowgram file path does not exist:\\\\n %s \\\\n' +\\r\\n 'Pass a valid one via -i.') % f)\\r\\n outdir = opts.output_dir\\r\\n\\r\\n create_dir(outdir, fail_on_exist=not opts.force)\\r\\n\\r\\n log_fh = None\\r\\n\\r\\n if (not (opts.primer or opts.map_fname)):\\r\\n raise ApplicationError(\\\"Either mapping file or primer required\\\")\\r\\n # Read primer from Meta data file if not set on command line\\r\\n if not opts.primer:\\r\\n mapping_data, header, comments = \\\\\\r\\n parse_mapping_file(open(opts.map_fname, \\\"U\\\"))\\r\\n\\r\\n index = header.index(\\\"LinkerPrimerSequence\\\")\\r\\n all_primers = set(array(mapping_data)[:, index])\\r\\n\\r\\n if len(all_primers) != 1:\\r\\n raise ValueError(\\\"Currently only data sets with one primer are allowed.\\\\n\\\" +\\r\\n \\\"Make separate mapping files with only one primer, re-run split_libraries and\\\\n\\\"\\r\\n + \\\"denoise with each split_library output separately.\\\")\\r\\n primer = list(all_primers)[0]\\r\\n last_char = primer[-1]\\r\\n if(last_char not in \\\"ACGT\\\"):\\r\\n raise ValueError(\\\"We currently do not support primer with \\\" +\\r\\n \\\"degenerate bases at it's 3' end.\\\")\\r\\n\\r\\n else:\\r\\n primer = opts.primer\\r\\n\\r\\n centroids, cluster_mapping = fast_denoiser(opts.sff_fps, opts.fasta_fp,\\r\\n outdir, opts.num_cpus, primer,\\r\\n titanium=opts.titanium)\\r\\n\\r\\n # store mapping file and centroids\\r\\n result_otu_path = '%s/denoised_clusters.txt' % outdir\\r\\n of = open(result_otu_path, 'w')\\r\\n for i, cluster in cluster_mapping.iteritems():\\r\\n of.write('%s\\\\t%s\\\\n' % (str(i), '\\\\t'.join(cluster)))\\r\\n of.close()\\r\\n\\r\\n result_fasta_path = '%s/denoised_seqs.fasta' % outdir\\r\\n oh = open(result_fasta_path, 'w')\\r\\n write_Fasta_from_name_seq_pairs(centroids, oh)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5087484","0.50239825","0.49709415","0.46197402","0.4569843","0.45122904","0.4461218","0.4412482","0.44032472","0.44027945","0.43926793","0.43906233","0.43781617","0.4360104","0.43565696","0.43386114","0.43149012","0.43059707","0.4303484","0.4274708","0.4265908","0.42597172","0.42575997","0.4206303","0.42013493","0.4194493","0.4164931","0.41633585","0.4156782","0.41472816","0.41416344","0.41219097","0.41198847","0.41144866","0.41102833","0.41045645","0.41008997","0.40954754","0.40933225","0.4093106","0.4078175","0.40679404","0.40648407","0.4062282","0.40524727","0.40498826","0.4048382","0.40351617","0.4034711","0.4034633","0.40319663","0.40124503","0.4011558","0.40092316","0.39970893","0.39957064","0.39902666","0.3984782","0.398387","0.398345","0.39759687","0.3973668","0.39721128","0.39719227","0.3970568","0.39647964","0.39592108","0.39555362","0.39481103","0.394702","0.39448085","0.39407536","0.39280653","0.392792","0.39271167","0.39265957","0.392586","0.39213347","0.3920999","0.39209223","0.39172164","0.39169252","0.39159748","0.39126614","0.3911128","0.390869","0.39084038","0.3906523","0.39033884","0.39020815","0.3901641","0.38996834","0.3899672","0.3890832","0.38894933","0.3888783","0.38848686","0.3878701","0.3867931","0.38678488"],"string":"[\n \"0.5087484\",\n \"0.50239825\",\n \"0.49709415\",\n \"0.46197402\",\n \"0.4569843\",\n \"0.45122904\",\n \"0.4461218\",\n \"0.4412482\",\n \"0.44032472\",\n \"0.44027945\",\n \"0.43926793\",\n \"0.43906233\",\n \"0.43781617\",\n \"0.4360104\",\n \"0.43565696\",\n \"0.43386114\",\n \"0.43149012\",\n \"0.43059707\",\n \"0.4303484\",\n \"0.4274708\",\n \"0.4265908\",\n \"0.42597172\",\n \"0.42575997\",\n \"0.4206303\",\n \"0.42013493\",\n \"0.4194493\",\n \"0.4164931\",\n \"0.41633585\",\n \"0.4156782\",\n \"0.41472816\",\n \"0.41416344\",\n \"0.41219097\",\n \"0.41198847\",\n \"0.41144866\",\n \"0.41102833\",\n \"0.41045645\",\n \"0.41008997\",\n \"0.40954754\",\n \"0.40933225\",\n \"0.4093106\",\n \"0.4078175\",\n \"0.40679404\",\n \"0.40648407\",\n \"0.4062282\",\n \"0.40524727\",\n \"0.40498826\",\n \"0.4048382\",\n \"0.40351617\",\n \"0.4034711\",\n \"0.4034633\",\n \"0.40319663\",\n \"0.40124503\",\n \"0.4011558\",\n \"0.40092316\",\n \"0.39970893\",\n \"0.39957064\",\n \"0.39902666\",\n \"0.3984782\",\n \"0.398387\",\n \"0.398345\",\n \"0.39759687\",\n \"0.3973668\",\n \"0.39721128\",\n \"0.39719227\",\n \"0.3970568\",\n \"0.39647964\",\n \"0.39592108\",\n \"0.39555362\",\n \"0.39481103\",\n \"0.394702\",\n \"0.39448085\",\n \"0.39407536\",\n \"0.39280653\",\n \"0.392792\",\n \"0.39271167\",\n \"0.39265957\",\n \"0.392586\",\n \"0.39213347\",\n \"0.3920999\",\n \"0.39209223\",\n \"0.39172164\",\n \"0.39169252\",\n \"0.39159748\",\n \"0.39126614\",\n \"0.3911128\",\n \"0.390869\",\n \"0.39084038\",\n \"0.3906523\",\n \"0.39033884\",\n \"0.39020815\",\n \"0.3901641\",\n \"0.38996834\",\n \"0.3899672\",\n \"0.3890832\",\n \"0.38894933\",\n \"0.3888783\",\n \"0.38848686\",\n \"0.3878701\",\n \"0.3867931\",\n \"0.38678488\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7302416"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":763,"numItemsPerPage":100,"numTotalItems":95772,"offset":76300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjUyODk1MSwianRpIjoiZTc0NGIxNTItZGIwZi00YjFjLTkxM2ItNDgzNzRiZTU3MzY2Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY1MzI1NTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.4INPF6sGisUxWpY674Dhlx8wZWPFdLmV49mLAeH1eAMfdSnxt6VT6gvW5FY_hU6ruLnCzvQ0f8Cx8Co4fULNAQ","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 |
|---|---|---|---|---|---|---|
to get the data in grid lines | def grid_line(object):
def __init__(self, casenum):
self.casenum = casenum
def getList(self):
"""
to get the whole list of grid line data
"""
lineList = get_array(self.casenum, 'branch')
self.lineList = lineList
return lineList
def getLin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grid_lines(self):\n # get edges initially in model coordinates\n use_ref_coords = self.use_ref_coords\n self.use_ref_coords = False\n xyedges = self.xyedges\n self.use_ref_coords = use_ref_coords\n\n xmin = xyedges[0][0]\n xmax = xyedges[0][-1]\n ymin = x... | [
"0.67843086",
"0.6667962",
"0.6639809",
"0.65646976",
"0.6479268",
"0.6388036",
"0.6334958",
"0.63266695",
"0.6300384",
"0.62831205",
"0.62409914",
"0.619513",
"0.61594695",
"0.61511624",
"0.61485094",
"0.6129613",
"0.61257434",
"0.61074805",
"0.60834837",
"0.60828245",
"0.60... | 0.72366786 | 0 |
to get the whole list of grid line data | def getList(self):
lineList = get_array(self.casenum, 'branch')
self.lineList = lineList
return lineList | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grid_line(object):\n def __init__(self, casenum):\n self.casenum = casenum\n \n def getList(self):\n \"\"\"\n to get the whole list of grid line data\n \"\"\"\n lineList = get_array(self.casenum, 'branch')\n self.lineList = lineList\n return lineLis... | [
"0.7344816",
"0.7205422",
"0.67930704",
"0.67659235",
"0.66508794",
"0.6500586",
"0.64731324",
"0.64722013",
"0.632781",
"0.62839407",
"0.62142247",
"0.618896",
"0.61152285",
"0.61150104",
"0.6106856",
"0.61065537",
"0.6069832",
"0.60571694",
"0.6055219",
"0.6054586",
"0.6045... | 0.0 | -1 |
in this example, there is only one thread | def example0(name):
print("main started")
my_func("realpython")
print("main ended") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_thread(self):",
"def executor(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def _make_thread(self):\r\n pass",
"def run(self):... | [
"0.7880205",
"0.73612",
"0.7268202",
"0.7268202",
"0.7268202",
"0.7268202",
"0.7268202",
"0.7268202",
"0.7268202",
"0.7268202",
"0.7268202",
"0.7268202",
"0.7105681",
"0.7069302",
"0.69082105",
"0.6903735",
"0.6903735",
"0.68982446",
"0.688398",
"0.6798316",
"0.6776921",
"0... | 0.0 | -1 |
in this example, multiple threads are run main started myfunc started with realpython myfunc1 started with foo myfunc2 started with haha myfunc ended myfunc2 ended myfunc1 ended main ended | def example4(name):
print("main started") # main thread
t1 = threading.Thread(target=my_func, args=['realpython']) # the second thread
t1.start()
t2 = threading.Thread(target=my_func1, args=['foo']) # the third thread
t2.start()
t3 = threading.Thread(target=my_func2, args=['haha']) # the fourth ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def example5(name):\n print(\"main started\") # main thread\n with concurrent.futures.ThreadPoolExecutor(max_workers=3) as e:\n e.map(my_func, ['realpython', 'bar', 'haha'])\n print(\"main ended\")",
"def example0(name):\n print(\"main started\")\n my_func(\"realpython\")\n print(\"main ... | [
"0.72712207",
"0.7134418",
"0.6344133",
"0.62373",
"0.5900686",
"0.58492994",
"0.57990813",
"0.57882786",
"0.5758856",
"0.5754322",
"0.5727432",
"0.5726683",
"0.5707882",
"0.5698103",
"0.5674418",
"0.564004",
"0.5619732",
"0.561841",
"0.5604227",
"0.5597306",
"0.55969626",
... | 0.756083 | 0 |
This example recreates example4 but in a more efficient way using thread pool main started myfunc started with realpython myfunc started with bar myfunc started with haha myfunc ended myfunc ended myfunc ended main ended | def example5(name):
print("main started") # main thread
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as e:
e.map(my_func, ['realpython', 'bar', 'haha'])
print("main ended") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def example0(name):\n print(\"main started\")\n my_func(\"realpython\")\n print(\"main ended\")",
"def example4(name):\n print(\"main started\") # main thread\n t1 = threading.Thread(target=my_func, args=['realpython']) # the second thread\n t1.start()\n t2 = threading.Thread(target=my_func1... | [
"0.7121908",
"0.70680535",
"0.6010677",
"0.5877939",
"0.58015925",
"0.5801124",
"0.5707956",
"0.56762254",
"0.5649907",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774",
"0.562774"... | 0.75483465 | 0 |
View to show the cart page. Get the products in the cart base on whether the user is logged in or not. Think about the idea when user is logged in and not logged in. | def get(self,request):
try:
if request.user.is_authenticated():
cart = self.cart_obj.get_cart_by_user(request.user)
else:
cart = self.cart_obj.get_cart_by_id(request.session.get('cart_id',None))
if not cart:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_cart(request):\n categories = all_categories()\n productTypes = all_productTypes()\n return render(request, \"cart.html\", {\"categories\": categories,\n \"productTypes\": productTypes})",
"def detail(request):\n # del request.session['cart_id']\n #... | [
"0.7836032",
"0.7605336",
"0.7576391",
"0.7427119",
"0.73779625",
"0.736863",
"0.7343909",
"0.7343909",
"0.73066235",
"0.73066235",
"0.73066235",
"0.72929233",
"0.7132074",
"0.7132074",
"0.71241754",
"0.7099787",
"0.70438397",
"0.69991326",
"0.6998831",
"0.6988149",
"0.696664... | 0.7479689 | 3 |
API Insert the files into Elasticsearch. | def insert_filedetails_ajax(request):
try:
file_path = request.GET.get('file_path')
file_name, extension = splitext(file_path)
date_time = datetime.datetime.now().strftime("%Y.%m.%d_%H:%M:%S")
json_obj = {"file_path": file_path, "extension": extension, "date_ingested": date_time}
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_to_index( env, meta_dict, file_str, logger ):\n global adapter_glob\n if adapter_glob is not None:\n adapter = adapter_glob\n else:\n logger.warning( u\"Connecting to index...\" )\n adapter = adapter_file.adapter(env)\n adapter_glob = adapter\n doc = document(\n ... | [
"0.6646253",
"0.649103",
"0.6468256",
"0.6400195",
"0.6380662",
"0.6347296",
"0.62993985",
"0.6227582",
"0.6178393",
"0.6102029",
"0.60767525",
"0.6047224",
"0.6043802",
"0.6040563",
"0.602994",
"0.60210097",
"0.5976548",
"0.5956317",
"0.5937528",
"0.5911576",
"0.5901469",
... | 0.0 | -1 |
API get all the documents from Elasticsearch. | def get_allfiles_ajax(request):
try:
get_all = fetch_all()
return JsonResponse({"fs_metadata": get_all['hits']['hits'], "message": "Success", "status_code": "200"})
except Exception as e:
print("Get All Documents Error : ", e)
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_all(): \n client, index_name = connection_es()\n res = client.search(index = index_name+\"*\")\n return res",
"def list_documents(\n self, index: str, query: Dict[str, Any] = None\n ) -> Iterable[Dict[str, Any]]:\n return es_scan(self.__client__, query=query or {}, index=in... | [
"0.7677105",
"0.72987986",
"0.71383095",
"0.70095366",
"0.69514704",
"0.6827761",
"0.6823215",
"0.6781777",
"0.6666381",
"0.6641504",
"0.6638397",
"0.6512604",
"0.6504365",
"0.6417668",
"0.6381008",
"0.63642246",
"0.63193834",
"0.626496",
"0.62535805",
"0.62307006",
"0.622177... | 0.0 | -1 |
API update using id and tag into Elasticsearch. | def update_filedetails_ajax(request):
try:
document_id = request.GET.get('document_id')
tag = request.GET.get('tag')
get_index = find_index_with_document(document_id)
updated_data = update(get_index, document_id, tag)
return JsonResponse({"fs_metadata": updated_data, "message... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(get_index, document_id, tag): \n client, index_name = connection_es()\n res = client.update(index = get_index, doc_type = 'nvisnx', id = document_id, body= {\"doc\" : {\"tag\": tag}})\n return res",
"def update(self, tag, params={}, **options):\n path = \"/tags/%s\" % (tag)\n ... | [
"0.7698348",
"0.7082211",
"0.6979634",
"0.6839155",
"0.6732194",
"0.672683",
"0.669146",
"0.666812",
"0.6547668",
"0.64642787",
"0.6374026",
"0.6337735",
"0.63087946",
"0.6255031",
"0.60572124",
"0.6016344",
"0.5969136",
"0.59264106",
"0.5920357",
"0.5919323",
"0.5915952",
... | 0.0 | -1 |
API delete documents using id from Elasticsearch. | def delete_filedetails_ajax(request):
try:
document_id = request.GET.get('document_id')
get_index = find_index_with_document(document_id)
deleted_data = delete(get_index, document_id)
return JsonResponse({"document_id": document_id, "message": "Success", "status_code": "200"})
ex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def document_delete(index_name, doc_type, doc_id):\n resp = es.delete(index=index_name, doc_type=doc_type, id=doc_id)\n print(resp)",
"def delete(get_index, document_id): \n client, index_name = connection_es()\n resp = client.delete(index = get_index, doc_type=\"nvisnx\", id = document_id)\n r... | [
"0.7428253",
"0.7047408",
"0.70071435",
"0.69630975",
"0.6870129",
"0.67370117",
"0.66782504",
"0.6675429",
"0.66510236",
"0.65836054",
"0.65232456",
"0.6499699",
"0.64743775",
"0.64278865",
"0.6404531",
"0.6381131",
"0.63614595",
"0.6350981",
"0.6345756",
"0.6326952",
"0.630... | 0.0 | -1 |
Generate a hex UID | def generate_uid(length=10):
uid = uuid.uuid4().hex[0:length]
return uid | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_uid():\n return random_string(5, string.hexdigits.lower())\n # return (\"%x\" % (int(time.time()) * 0x10 % 0x1000000000)\n # + random_string(7, string.hexdigits.lower()))",
"def generate_user_id() -> str:\n return 'u' + str((uuid.getnode()))",
"def new_uid():\n return str(uuid... | [
"0.8424885",
"0.77790034",
"0.77502453",
"0.76640016",
"0.7663068",
"0.75369626",
"0.75063133",
"0.7452815",
"0.7432415",
"0.7419043",
"0.74088436",
"0.74088436",
"0.73718894",
"0.72921085",
"0.7273682",
"0.7256061",
"0.7255503",
"0.7239619",
"0.7232834",
"0.7204194",
"0.7201... | 0.7920812 | 1 |
Generates the URL "slug" not predefined due changing titles | def slug(self):
slug = slugify(self.text)
return "%s/%s" % (self.uid, slug[:36]) # max 24 characters | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_slug(self):\n slug = slugify(self.title)\n new_slug = slug\n s = 1\n while Article.objects.filter(slug=new_slug).exists():\n \"\"\"increase value of slug by one\"\"\"\n new_slug = f'{slug}-{s}'\n s += 1\n return new_slug",
"def crea... | [
"0.74424213",
"0.74022186",
"0.73629117",
"0.71713024",
"0.70533115",
"0.69844365",
"0.69625795",
"0.6874045",
"0.6861308",
"0.6859211",
"0.6859211",
"0.6793881",
"0.6777502",
"0.67266905",
"0.6687068",
"0.6683898",
"0.6611359",
"0.65894544",
"0.65846866",
"0.6571645",
"0.654... | 0.6478431 | 24 |
Calculates the STIP features for a specified set of input files and stores them in the output location. | def calc_stip_features(path_to_videos, filename, path_to_output_file, ext=None, start_frame=None, end_frame=None,
overwrite=True):
if not overwrite and os.path.isfile(path_to_output_file):
# Skip if file already present
log("Ignoring file {}{}, because overwrite is disabled".... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_spec(input_filepath, output_filepath):\n file_list = glob.glob(input_filepath + '/*')\n file_list.sort()\n features_set = []\n with ShadyBar(f\"Extracting features {input_filepath}...\", max=len(file_list)) as bar:\n for f in file_list:\n interim_data = np.loadtxt(f, delimit... | [
"0.6002216",
"0.57004464",
"0.5582022",
"0.5469837",
"0.5357879",
"0.53559333",
"0.52715075",
"0.52210796",
"0.5204268",
"0.51967114",
"0.519573",
"0.5174511",
"0.51638204",
"0.5157115",
"0.51457024",
"0.51314926",
"0.51284796",
"0.5092859",
"0.50881195",
"0.5074976",
"0.5068... | 0.50084573 | 24 |
Process files from the queue. | def worker(queue, run):
for args in iter(queue.get, None):
try:
run(*args)
except Exception as e: # catch exceptions to avoid exiting the thread prematurely
print('{} failed: {}'.format(args, e), file=sys.stderr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task(self, chunk_filename_queue, writer):\n self.init_structs()\n while True:\n filename = chunk_filename_queue.get()\n for item in self.single_file_gen(filename):\n writer.send_bytes(item)",
"def process_queue(self):\n if not self.has_queue:\n ... | [
"0.70209163",
"0.6941973",
"0.68375695",
"0.6716875",
"0.6712224",
"0.66711754",
"0.6402412",
"0.6341205",
"0.6331502",
"0.6320673",
"0.63120264",
"0.62958574",
"0.62499005",
"0.62422794",
"0.62272096",
"0.62058926",
"0.6197084",
"0.6181007",
"0.6170086",
"0.6163313",
"0.6162... | 0.0 | -1 |
Starts threads to run the function with processes in parallel | def start_processes_in_parallel(queue, func, number_of_process=None):
if not number_of_process:
number_of_process = mp.cpu_count() - 1
# start threads
threads = [Thread(target=worker, args=(queue, func)) for _ in range(number_of_process)]
for t in threads:
t.daemon = True # threads... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_in_parallel(self):\n\t\tfor p in self.parallel_threads:\n\t\t\tp.start()\n\t\tfor p in self.parallel_threads:\n\t\t\tp.join()",
"def MultiProcesses( *functions ):\n \n # Variables\n processes = np.array( [] )\n \n # Sending processes in parallel\n for function in functions:\n proce... | [
"0.7552233",
"0.7321745",
"0.712635",
"0.702093",
"0.70002836",
"0.69785124",
"0.68648654",
"0.6764552",
"0.6708156",
"0.6672512",
"0.6651728",
"0.6645571",
"0.65197843",
"0.6495909",
"0.6478915",
"0.6467651",
"0.6460147",
"0.64334625",
"0.6405026",
"0.6401871",
"0.6387127",
... | 0.7281942 | 2 |
Computes the name of a county given it's zipcode | def county_name(zipcode):
search = SearchEngine(simple_zipcode=True) # set simple_zipcode=False to use rich info database
zipcode_query = search.by_zipcode(str(zipcode))
zipcode_query_dict = zipcode_query.to_dict()
county = zipcode_query_dict['county']
if county is None:
print('Invalid Coun... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def city_country(city_name, country_name):\n city_country_combo = city_name + ', ' + country_name\n return city_country_combo.title()",
"def city_country(city_name, country_name):\n combi = f\"{city_name.title()}, {country_name.title()}\"\n return combi.title()",
"def city_state_zip(**kwargs):\r\n ... | [
"0.6422869",
"0.63803333",
"0.63314253",
"0.6329193",
"0.6269642",
"0.6251078",
"0.6227773",
"0.6216738",
"0.618028",
"0.61654603",
"0.61536604",
"0.61536604",
"0.60994875",
"0.6088756",
"0.6076896",
"0.6072779",
"0.60661525",
"0.6040675",
"0.6012614",
"0.59852415",
"0.595690... | 0.8695817 | 0 |
For each test, build a new YaraAnalyzer. | def setUp(self):
self.setUpPyfakefs()
with mock.patch.object(subprocess, 'Popen', side_effect=thor_mocks.mock_thor_start):
self._analyzer = yara_analyzer.YaraAnalyzer()
# Write target file.
# pylint: disable=no-member
self.fs.create_file('./target.exe', contents='Thi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n super(TestAnalyzer, self).__init__()\n self._results = []",
"def testGetAnalyzerInstances(self):\n analyzer_names = manager.AnalyzersManager.GetAnalyzerNames()\n analyzers = manager.AnalyzersManager.GetAnalyzerInstances(analyzer_names)\n self.assertEqual(len(analyzer_names), ... | [
"0.61968255",
"0.5871857",
"0.56706536",
"0.5612355",
"0.5585955",
"0.55783165",
"0.5506784",
"0.5488338",
"0.54793984",
"0.5476998",
"0.54543394",
"0.5441958",
"0.5440611",
"0.5424232",
"0.5421577",
"0.5412421",
"0.54094994",
"0.54019105",
"0.5391985",
"0.5389894",
"0.538531... | 0.0 | -1 |
Verify the mocked request matches. | def _assert_request(mock_requests: mock.MagicMock, mock_output: mock.MagicMock):
# Verify UPX call
mock_output.assert_has_calls([
mock.call(['./upx', '-q', '-d', mock.ANY], stderr=subprocess.STDOUT),
])
mock_requests.assert_has_calls([
mock.call('http://127.0.0.1:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def match_request(\n self,\n method,\n url,\n *,\n data=None,\n auth=None,\n params=None,\n headers=None,\n allow_redirects=None,\n timeout=None,\n json=None,\n cookies=None,\n **kwargs,\n ):\n data = data or... | [
"0.6924573",
"0.67021644",
"0.6677142",
"0.66608727",
"0.66096157",
"0.65619034",
"0.6518308",
"0.64706886",
"0.6379971",
"0.63056576",
"0.622024",
"0.61340016",
"0.60706127",
"0.6043272",
"0.6036543",
"0.60285103",
"0.60253316",
"0.5987051",
"0.5979541",
"0.59752214",
"0.597... | 0.63318384 | 9 |
Analyze returns the expected list of rule matches. | def test_analyze(self, mock_requests: mock.MagicMock, mock_output: mock.MagicMock):
yara_matches = self._analyzer.analyze('/target.exe')
self._assert_request(mock_requests, mock_output)
self.assertEqual(1, len(yara_matches))
match = yara_matches[0]
self.assertEqual('THOR', match... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def match_rules(rules, wm):\n res = []\n for r in rules:\n new_patterns = match_rule(r[0],r[1],r[2], wm)\n if new_patterns:\n print(\" Match succeeds\")\n print(\" Adding assertions to WM\")\n else:\n print(\" Match fails\... | [
"0.5835707",
"0.58267164",
"0.55471814",
"0.5527018",
"0.5368063",
"0.5300912",
"0.52113616",
"0.51996094",
"0.5143646",
"0.5127022",
"0.51096666",
"0.5081547",
"0.50634825",
"0.506103",
"0.50559425",
"0.5054468",
"0.5012354",
"0.5004759",
"0.50028557",
"0.5001351",
"0.499751... | 0.5871569 | 0 |
Analyze returns empty list if no matches. | def test_analyze_no_matches(self, mock_requests: mock.MagicMock, mock_output: mock.MagicMock):
self.assertEqual([], self._analyzer.analyze('/target.exe'))
self._assert_request(mock_requests, mock_output) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_hits(self, broker, search):\n # TODO: Use sets when RHEL-4 is no longer supported\n hits = []\n for hit in search.findall(self._read_file(broker.log)):\n if hit not in hits:\n hits.append(hit)\n return hits",
"def analyzeAll(self, program: ghidra.pro... | [
"0.56661934",
"0.5630961",
"0.5487526",
"0.5433682",
"0.53892547",
"0.53883475",
"0.53814745",
"0.5375211",
"0.5301285",
"0.5206891",
"0.5190482",
"0.5187957",
"0.51719016",
"0.5168622",
"0.5146465",
"0.5142774",
"0.5142774",
"0.51228255",
"0.5053054",
"0.5051791",
"0.5048823... | 0.5484506 | 3 |
[(page_image, page_ocr), ...] > [(product_image, product), ...] >>> assert_excel_parser( ... parser=main, | def main(url):
return excel_parser(
url,
extract_product_from_data
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_parse_sample_sheet(self):\n pass",
"def parse_pages():\n\n excel_filename = 'Result_' + datetime.datetime.now().strftime('%Y-%m-%d %H-%M-%S') + '.xlsx'\n workbook = xlsxwriter.Workbook(excel_filename)\n worksheet_all = workbook.add_worksheet()\n\n create_headers(worksheet_all, workboo... | [
"0.6254735",
"0.5377421",
"0.5323541",
"0.5106242",
"0.50258374",
"0.49943188",
"0.49895155",
"0.4969769",
"0.4964595",
"0.49275738",
"0.4897017",
"0.4897017",
"0.48849654",
"0.48579365",
"0.48426545",
"0.48359296",
"0.48239824",
"0.47577006",
"0.47136748",
"0.4708069",
"0.47... | 0.52425975 | 3 |
After each test, rolls back the sandboxed_session | def rollback_session_after_test(self, sandboxed_session):
yield
sandboxed_session.rollback() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tearDown(self):\n self.session.close()",
"def teardown_session(e):\n my_db.close()\n OT_spider.close()",
"def tearDown(self): \n db.session.rollback()",
"def tearDown(self): \n db.session.rollback()",
"def tearDown(self):\n self.sess.close()",
"... | [
"0.7122727",
"0.6794178",
"0.6663135",
"0.6663135",
"0.66445196",
"0.66358507",
"0.66308486",
"0.6602018",
"0.65987426",
"0.6561146",
"0.6548552",
"0.6548552",
"0.6532302",
"0.6532302",
"0.6532302",
"0.6532302",
"0.6532302",
"0.6532302",
"0.65306467",
"0.6514152",
"0.6481635"... | 0.8207038 | 0 |
(Computed) The etag of the IAM policy. | def etag(self) -> str:
return pulumi.get(self, "etag") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def etag(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"etag\")",
"def etag(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"etag\")",
"def etag(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"etag\")",
"def etag(self) -> pulumi.Output[str]:\n return pul... | [
"0.70715654",
"0.70715654",
"0.70715654",
"0.70715654",
"0.70715654",
"0.70715654",
"0.70715654",
"0.6971113",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.6930204",
"0.693020... | 0.71049285 | 6 |
The providerassigned unique ID for this managed resource. | def id(self) -> str:
return pulumi.get(self, "id") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def provider_id(self):\n return self.get('_id')",
"def provider_id(self):\n raise NotImplementedError",
"def id(self):\n return self.raw_resource.uuid",
"def healthcare_provider_id(self):\n return self._healthcare_provider_id",
"def unique_identifier(self) -> str:\n retur... | [
"0.8193402",
"0.7851373",
"0.77124894",
"0.7604287",
"0.7477648",
"0.7476093",
"0.7476093",
"0.7476093",
"0.7425807",
"0.7380237",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.735787",
"0.735787",
"0.73477197",
"... | 0.0 | -1 |
(Required only by `storage.BucketIAMPolicy`) The policy data generated by a `organizations_get_iam_policy` data source. | def policy_data(self) -> str:
return pulumi.get(self, "policy_data") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def policy_data(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"policy_data\")",
"def policy_data(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"policy_data\")",
"def policy_data(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"policy_data\")",
"def pol... | [
"0.80894715",
"0.79416263",
"0.7624144",
"0.75112396",
"0.75105304",
"0.7228022",
"0.71576035",
"0.71576035",
"0.71576035",
"0.7105232",
"0.6949225",
"0.69218427",
"0.69218427",
"0.69131845",
"0.6870519",
"0.6870519",
"0.68398976",
"0.6836218",
"0.6836218",
"0.6814781",
"0.68... | 0.7941598 | 4 |
Retrieves the current IAM policy data for bucket example ```python import pulumi import pulumi_gcp as gcp policy = gcp.storage.get_bucket_iam_policy(bucket=google_storage_bucket["default"]["name"]) ``` | def get_bucket_iam_policy(bucket: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetBucketIamPolicyResult:
__args__ = dict()
__args__['bucket'] = bucket
opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
__ret__ = pulu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bucket_iam_policy_output(bucket: Optional[pulumi.Input[str]] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetBucketIamPolicyResult]:\n ...",
"def get_bucket_policy(Bucket=None):\n pass",
"def policy(self) -> typing.Optional[\"BucketPolicy... | [
"0.8047549",
"0.7948865",
"0.69205636",
"0.69205636",
"0.6630802",
"0.6520681",
"0.63187873",
"0.6244433",
"0.6199992",
"0.6199992",
"0.61718905",
"0.61498356",
"0.61498356",
"0.6139455",
"0.6080319",
"0.60535866",
"0.6042336",
"0.600247",
"0.598721",
"0.592493",
"0.5898587",... | 0.8031223 | 1 |
Retrieves the current IAM policy data for bucket example ```python import pulumi import pulumi_gcp as gcp policy = gcp.storage.get_bucket_iam_policy(bucket=google_storage_bucket["default"]["name"]) ``` | def get_bucket_iam_policy_output(bucket: Optional[pulumi.Input[str]] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetBucketIamPolicyResult]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bucket_iam_policy(bucket: Optional[str] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetBucketIamPolicyResult:\n __args__ = dict()\n __args__['bucket'] = bucket\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\n __re... | [
"0.8031692",
"0.79494417",
"0.6921183",
"0.6921183",
"0.6630346",
"0.6521183",
"0.63191986",
"0.6243815",
"0.6201865",
"0.6201865",
"0.6170791",
"0.6149633",
"0.6149633",
"0.61402816",
"0.60815215",
"0.6054667",
"0.6043298",
"0.60041904",
"0.5985827",
"0.59267944",
"0.5898068... | 0.80478656 | 0 |
Fetch data from Genesys and save it into Json files. This data is used to study the duplication level between USDA and CGN. | def fetch_data():
log = logging.getLogger(__name__)
log.info('Checking data files...')
if not os.path.isfile('CGN.txt'):
params_cgn = {
'institute.code': ['NLD037'],
# 'crops': ['tomato'],
'taxonomy.genus': ['Solanum', 'Lycopersicon'],
'taxonomy.specie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_genotype_data():\n print(\"downloading genotype data\")\n download_from_url(PSAM_PATH, dst=f\"{GENOTYPE_DATA_PATH}/{MERGED_GENOTYPE_FILE}.psam\", desc=\"downloading psam\")\n download_from_url(PVAR_PATH, dst=f\"{GENOTYPE_DATA_PATH}/{MERGED_GENOTYPE_FILE}.pvar.zst\",\n des... | [
"0.5973477",
"0.5803134",
"0.57299006",
"0.5714865",
"0.56429684",
"0.56429684",
"0.56427765",
"0.56059736",
"0.55862916",
"0.55444044",
"0.55252194",
"0.54157865",
"0.53990847",
"0.53948665",
"0.53821665",
"0.5366713",
"0.53538084",
"0.5352743",
"0.53450966",
"0.5336839",
"0... | 0.76027054 | 0 |
Print a list. Start with the name, then iter through items. Finally print its length. Also works with sets, tuples... | def printL(L, L_name='List', verbose=True):
if verbose:
('\n[' + L_name + ']:')
if verbose:
for item in list(L):
print('\t' + str(item))
print('[' + L_name + '] length: ' + str(len(L)) + '\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_list(l, name=None, output=sys.stdout):\n if not name:\n name = '<no name given>'\n\n if not l or len(l) == 0:\n print('>>>>>>> list = ' + name + ' - EMPTY', file=output)\n return\n\n if name is None:\n name = str(l[0].__class__)\n\n print('>>>>>>> list = ' + name +... | [
"0.7141043",
"0.6907795",
"0.6866269",
"0.6848637",
"0.6724731",
"0.6533302",
"0.64033216",
"0.6328528",
"0.62946206",
"0.62609035",
"0.62533116",
"0.62444794",
"0.62444794",
"0.6242436",
"0.62266845",
"0.6219947",
"0.621447",
"0.61818296",
"0.615832",
"0.6102063",
"0.609076"... | 0.6851405 | 3 |
Get all instances of this class in the registry. | def get_instances(cls, recursive=False):
instances = list(cls._instances)
if recursive:
for Child in cls.__subclasses__():
instances += Child.get_instances(recursive=recursive)
# Remove duplicates from multiple inheritance.
return list(set(instances)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_instances(cls):\n raise NotImplementedError",
"def get_all_cached_instances(cls):\n return list(cls.__dbclass__.__instance_cache__.values())",
"def getinstances(cls):\n\t\t\tdead = set()\n\t\t\tfor ref in cls._instances:\n\t\t\t\tobj = ref()\n\t\t\t\tif obj is not None:\n\t\t\t\t\tyield o... | [
"0.7619687",
"0.72287494",
"0.70653266",
"0.7045179",
"0.6888304",
"0.68455154",
"0.68399835",
"0.6827565",
"0.6720347",
"0.6706184",
"0.66594434",
"0.6623655",
"0.6620567",
"0.65878433",
"0.65827703",
"0.6566919",
"0.6550206",
"0.65336657",
"0.6468475",
"0.64582914",
"0.6431... | 0.732727 | 1 |
Gets all the models which share the MetaModel origin. | def get_models(cls, recursive=False):
models = list(cls._models)
if recursive:
for child in cls.__subclasses__():
models += child.get_models(recursive=recursive)
return list(models) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def models(self):\r\n return self.get_field('model')",
"def models(self):\r\n return self.get_field('model')",
"def peak_all_models(self) -> List:\n models = list(self.meta.name)\n print(models)\n return models",
"def get_related_models(self):\n\t\tmodels = []\n\t\tif not s... | [
"0.67832965",
"0.67832965",
"0.6562437",
"0.6512124",
"0.6445747",
"0.63675845",
"0.63225657",
"0.62866795",
"0.6277958",
"0.62186563",
"0.61224395",
"0.6100776",
"0.6088184",
"0.6084223",
"0.6077946",
"0.6038946",
"0.6030036",
"0.6029571",
"0.5980312",
"0.5946005",
"0.594548... | 0.5592448 | 28 |
Instantiate a new build rule based on kwargs. Appropriate args list varies with rule type. | def new(ruletype, **kwargs):
try:
ruleclass = TYPE_MAP[ruletype]
except KeyError:
raise error.InvalidRule('Unrecognized rule type: %s' % ruletype)
try:
return ruleclass(**kwargs)
except TypeError:
log.error('BADNESS. ruletype: %s, data: %s', ruletype, kwargs)
rai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build(cls, **kwargs):\n return cls(kwargs) #pylint: disable=no-value-for-parameter",
"def __init__(self, *args):\n this = _libsbml.new_Rule(*args)\n try: self.this.append(this)\n except: self.this = this",
"def construct(args,\n **kwargs):\n kw = parse_args(args)... | [
"0.6302051",
"0.61495674",
"0.5984927",
"0.59743166",
"0.5813008",
"0.5790656",
"0.5728552",
"0.57015586",
"0.5655793",
"0.5636998",
"0.5636998",
"0.5636998",
"0.5636998",
"0.5636998",
"0.56218827",
"0.56109154",
"0.55799127",
"0.55431616",
"0.54849225",
"0.54520905",
"0.5445... | 0.69835865 | 0 |
simply returns a splash for not logged in users or its mailbox if the user is logged in | def index():
if current_user.is_authenticated:
return redirect(url_for("mailbox.mailbox_list_received"))
return render_template("index_bs.html") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def me():\n return current_user.get()",
"def GET_validuser(self):\r\n c.response_content_type = 'text/plain'\r\n if c.user_is_loggedin:\r\n return c.user.name\r\n else:\r\n return ''",
"def get_current_user(self):\n try:\n user = super().get_curre... | [
"0.601104",
"0.5755353",
"0.57426095",
"0.5733698",
"0.56513757",
"0.5626156",
"0.5553362",
"0.5520831",
"0.5493673",
"0.5485242",
"0.54466677",
"0.54420096",
"0.5426605",
"0.5426264",
"0.53759664",
"0.53759664",
"0.5362569",
"0.5355861",
"0.5355861",
"0.53546566",
"0.534246"... | 0.5122155 | 54 |
Returns a JSON containing unread notifications for the user | def notification():
# pop-up notification
notifies = NotifyModel.get_notify(current_user.get_id())
return jsonify(notifications=notifies) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_unread_messages():\n mark_seen = request.args.get('mark_seen', True)\n unread_msg = g.driver.get_unread()\n\n if mark_seen:\n for msg in unread_msg:\n msg.chat.send_seen()\n\n return jsonify(unread_msg)",
"def get_all_user_notifications(self, user_id):\n dao = Notific... | [
"0.7635725",
"0.72683996",
"0.7085017",
"0.703589",
"0.68658626",
"0.68634385",
"0.6820263",
"0.6811239",
"0.67490655",
"0.67361164",
"0.65947247",
"0.6419349",
"0.64029396",
"0.63255686",
"0.631757",
"0.6290393",
"0.62488854",
"0.6229212",
"0.62270206",
"0.6173307",
"0.61195... | 0.6450524 | 11 |
Takes an unsorted list, a threshold, below which insertion sort is used instead of merge sort, and a boolean reverse, which determines if the list is sorted in increasing or decreasing order. This part splits the list into progressively smaller parts then calls merge to put it all back together | def merge_sort(unsorted, threshold, reverse):
length = len(unsorted)
if length < 2:
return unsorted
elif length < threshold:
return insertion_sort(unsorted, reverse)
else:
mid = length//2
list1 = unsorted[0:mid]
list2 = unsorted[mid:length]
list1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_sort(input_list,start,end):\n if start < end:\n mid=(start+end)//2\n merge_sort(input_list,start,mid)\n merge_sort(input_list,mid+1,end)\n return merge(input_list,start,mid,end)",
"def test_list_with_unbalanced_halves():\n lst = [2, 4, 3, 8, 1, 9, 10, 13]\n assert m... | [
"0.6500331",
"0.64686525",
"0.6465554",
"0.64295685",
"0.64216506",
"0.6392987",
"0.63503456",
"0.63239914",
"0.6315092",
"0.62860906",
"0.62561256",
"0.62519425",
"0.6209382",
"0.62084955",
"0.620024",
"0.6192919",
"0.6174429",
"0.6171197",
"0.61506146",
"0.61372715",
"0.612... | 0.76275474 | 0 |
Merges two lists, first and second, in either increasing or decreasing order, depending on reverse | def merge(first, second, reverse):
final = [0]*(len(first)+len(second))
i = 0
j = 0
if reverse:
while i+j < len(final):
if (j >= len(second)) or ((i < len(first)) and (first[i] > second[j])):
final[i+j] = first[i]
i += 1
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(l1, l2):\n\n #Reverse the lists\n l1 = list(reversed(l1))\n l2 = list(reversed(l2))\n\n ret = []\n\n while True:\n # If either list is empty, reverse the other one and append it to the end\n if not l1:\n ret.extend(reversed(l2))\n return ret\n if ... | [
"0.78887236",
"0.76090616",
"0.74231946",
"0.74130917",
"0.74009126",
"0.7382625",
"0.7322549",
"0.7304537",
"0.7280156",
"0.7268654",
"0.7245732",
"0.7214211",
"0.7207699",
"0.71946347",
"0.7191366",
"0.71792436",
"0.7142443",
"0.7132886",
"0.71247315",
"0.7108219",
"0.70609... | 0.7846751 | 1 |
Takes an unsorted list and sorts it using the insertion sort method in the order specified by the value of reverse | def insertion_sort(unsorted, reverse):
length = len(unsorted)
if reverse:
i = 0
j = 0
while i < length:
j = i
while j > 0 and unsorted[j] > unsorted[j-1]:
temp = unsorted[j]
unsorted[j] = unsorted[j-1]
unso... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sort_2(l):\n l.reverse()",
"def reverse_sort(list_to_sort: List) -> List:\n if len(list_to_sort) == 1:\n return list_to_sort\n list_to_sort = [e for e in list_to_sort] # to avoid sorting in place, comment this to change original list\n for j in range(len(list_to_sort) - 2, -1, -1):\n ... | [
"0.7853301",
"0.7687661",
"0.75495464",
"0.75006354",
"0.74556357",
"0.71750027",
"0.7122347",
"0.7091604",
"0.7055314",
"0.7043185",
"0.7035889",
"0.6994239",
"0.69913334",
"0.69231874",
"0.69068694",
"0.68790865",
"0.68767464",
"0.68348974",
"0.6812114",
"0.6803969",
"0.677... | 0.7310547 | 5 |
Create a new client. | def __init__(self, url, username, password):
self.session = requests.session()
self.session.auth = (username, password)
self.session.headers.update({
'Accept': JSON_CONTENT_TYPE,
})
self.url = url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_client(self) -> None:\n pass",
"def create_client(name):\n client = Client(name=name)\n print(client.client_secret)\n db.session.add(client)\n db.session.commit()\n return client",
"def create_client(\n body: ClientmodelClientCreateRequest,\n x_additional_headers: Optional[Di... | [
"0.8414307",
"0.7898926",
"0.76239187",
"0.7560852",
"0.7491058",
"0.7406467",
"0.71997094",
"0.71953195",
"0.7139246",
"0.7005442",
"0.698633",
"0.69013715",
"0.6881409",
"0.68806535",
"0.68705076",
"0.6847955",
"0.68408066",
"0.67676437",
"0.6740156",
"0.6707498",
"0.667444... | 0.0 | -1 |
Fetch a single legislation expression, if it exists, by filtering on the FRBR URI. We do this because there is no GET endpoint for a work FRBR URI, only an expression FRBR URI. By default, only fetches the id and frbr_uri fields. Specify a list of fields to fetch otherwise. | def find_legislation(self, frbr_uri_prefix, fields=('field_frbr_uri',)):
params = {
'filter[field_frbr_uri][value]': frbr_uri_prefix,
'filter[field_frbr_uri][operator]': 'STARTS_WITH'
}
if fields:
params['fields[node--legislation]'] = ','.join(fields)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_legislation(self, expr_uri, fields=('field_frbr_uri',)):\n # the GET request requires this accept header, not the default one\n headers = {\n 'Accept': 'application/json',\n }\n params = {}\n if fields:\n params['fields[node--legislation]'] = ','.joi... | [
"0.69796807",
"0.49620867",
"0.48607516",
"0.4747582",
"0.47416613",
"0.46898153",
"0.4659622",
"0.45725793",
"0.4541741",
"0.45356673",
"0.45117137",
"0.44913068",
"0.44750413",
"0.4474428",
"0.44622138",
"0.44539246",
"0.4417351",
"0.44019884",
"0.43827352",
"0.43553713",
"... | 0.64284 | 1 |
Fetch a single legislation expression, if it exists. By default, only fetches the id and frbr_uri fields. Specify a list of fields to fetch otherwise. | def get_legislation(self, expr_uri, fields=('field_frbr_uri',)):
# the GET request requires this accept header, not the default one
headers = {
'Accept': 'application/json',
}
params = {}
if fields:
params['fields[node--legislation]'] = ','.join(fields)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_legislation(self, frbr_uri_prefix, fields=('field_frbr_uri',)):\n params = {\n 'filter[field_frbr_uri][value]': frbr_uri_prefix,\n 'filter[field_frbr_uri][operator]': 'STARTS_WITH'\n }\n\n if fields:\n params['fields[node--legislation]'] = ','.join(fie... | [
"0.61241204",
"0.51818883",
"0.49835798",
"0.49209628",
"0.49200243",
"0.48930994",
"0.47840205",
"0.4743934",
"0.45873097",
"0.4581193",
"0.45607665",
"0.45160976",
"0.44856694",
"0.4447797",
"0.44260952",
"0.4411156",
"0.4410095",
"0.4408937",
"0.440199",
"0.43945158",
"0.4... | 0.7090029 | 0 |
List all legislation expressions for a place. | def list_legislation(self, place_code):
results = []
params = {
'filter[field_frbr_uri][value]': f'/akn/{place_code}/',
'filter[field_frbr_uri][operator]': 'STARTS_WITH',
'fields[node--legislation]': 'field_frbr_uri',
}
url = self.url + '/jsonapi/node/... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def legends(self):\n return [leg for leg in self._legends]",
"def list_formulae():\n return _list_tindyb_unique_values(\"formula\", dbpath=__dbpath__)",
"def describe_locations():\n pass",
"def _derive_country_MX(place):\n lname = place.name.lower()\n derived = []\n match = _PARENTHETIC... | [
"0.5264176",
"0.49682465",
"0.49632758",
"0.49632642",
"0.49223864",
"0.49025452",
"0.4897046",
"0.48797643",
"0.48588276",
"0.48420218",
"0.47878242",
"0.4753311",
"0.47311145",
"0.4720755",
"0.4714829",
"0.4704091",
"0.47006062",
"0.47000864",
"0.46678424",
"0.46594155",
"0... | 0.610629 | 0 |
Create a new legislation work and expression and return the full description. | def create_legislation_work(self, info):
resp = self.session.post(
self.url + '/jsonapi/node/legislation',
json=info,
headers={'Content-Type': JSON_CONTENT_TYPE},
timeout=self.timeout)
self.check_for_error(resp)
info = resp.json()['data']
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_legislation(self, expr_uri, info):\n resp = self.session.post(\n self.url + expr_uri,\n json=info,\n headers={'Content-Type': JSON_CONTENT_TYPE},\n timeout=self.timeout)\n self.check_for_error(resp)\n info = resp.json()['data']\n if... | [
"0.61689997",
"0.5541025",
"0.5490086",
"0.54542214",
"0.54395074",
"0.53243685",
"0.5317579",
"0.52964807",
"0.5295471",
"0.52922416",
"0.5291361",
"0.5267162",
"0.5234458",
"0.5223556",
"0.5218605",
"0.52170676",
"0.5212621",
"0.52034056",
"0.51867324",
"0.5184041",
"0.5176... | 0.5217925 | 15 |
Create a new legislation expression and return the full description. | def create_legislation(self, expr_uri, info):
resp = self.session.post(
self.url + expr_uri,
json=info,
headers={'Content-Type': JSON_CONTENT_TYPE},
timeout=self.timeout)
self.check_for_error(resp)
info = resp.json()['data']
if not info:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_descr(self, attr_name):",
"def leg_maker(size=40, color='0x9C661F'):\n leg = GOval(size, size+30)\n leg.filled = True\n leg.fill_color = color\n leg.color = color\n return leg",
"def description(self):\n assert not self._expression_used\n self._handle_used = True\n return sel... | [
"0.57703763",
"0.5612563",
"0.5591931",
"0.5380776",
"0.53548706",
"0.5211884",
"0.512674",
"0.51117057",
"0.51014334",
"0.5098089",
"0.5097364",
"0.50892615",
"0.50838184",
"0.50791925",
"0.50747347",
"0.507339",
"0.5043403",
"0.50364876",
"0.503377",
"0.5032216",
"0.5019911... | 0.5830445 | 0 |
Delete legislation by node id. | def delete_legislation(self, expr_uri):
resp = self.session.delete(self.url + expr_uri, timeout=self.timeout)
self.check_for_error(resp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def del_node (self, id):\n raise NotImplementedError",
"def delete_node(self, _id):\n return self.make_request(\"DELETE\", \"nodes/\"+_id, {})",
"def delete_node(self, node_id, connection=None):\n\n connection = connection or self.engine.connect()\n\n # delete the paths associated with ... | [
"0.77828246",
"0.7355772",
"0.70663506",
"0.7061792",
"0.69358206",
"0.6900647",
"0.67953926",
"0.6771778",
"0.6755386",
"0.6737594",
"0.66836745",
"0.66422313",
"0.6557317",
"0.6516612",
"0.64261824",
"0.6405015",
"0.6396118",
"0.63222146",
"0.6305334",
"0.62353",
"0.6234832... | 0.60244304 | 31 |
Patch an existing legislation by node id. | def update_legislation(self, expr_uri, info):
resp = self.session.patch(
self.url + expr_uri,
json=info,
headers={'Content-Type': JSON_CONTENT_TYPE},
timeout=self.timeout)
self.check_for_error(resp)
return resp.json()['data'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch_id(self, patch_id):\n self._patch_id = patch_id",
"def change_node(self, node: dict):\n # check if it is not overriding existing node\n if node.get('id') is not None:\n if node['id'] not in self._nodes:\n raise ValueError('tried to change non-existing node... | [
"0.6265677",
"0.5985221",
"0.5901512",
"0.5749885",
"0.56735283",
"0.5509904",
"0.5506046",
"0.5481858",
"0.5442415",
"0.5403813",
"0.54012805",
"0.53729826",
"0.535759",
"0.53066707",
"0.5290731",
"0.5279866",
"0.5233747",
"0.52330667",
"0.5196351",
"0.51735353",
"0.5155912"... | 0.0 | -1 |
Upload a file to the lii and return the node id. | def upload_file(self, node, fname, data, fieldname):
resp = self.session.post(
self.url + f'/jsonapi/node/{node}/{fieldname}',
data=data,
headers={
'Content-Type': 'application/octet-stream',
'Content-Disposition': f'attachment; filename="{fnam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upload_file(self, f):\n return self._telegraph.upload_file(f)",
"def node_file_upload(ctx, file, filename):\n filepath = click.format_filename(file)\n filename = filename if filename else filepath\n\n with open(file, \"r\") as f:\n content = f.read()\n\n try:\n ctx.obj['node'... | [
"0.7023373",
"0.687328",
"0.6477241",
"0.6289029",
"0.62865573",
"0.6145262",
"0.6127179",
"0.60793984",
"0.6061025",
"0.6020251",
"0.6013384",
"0.59927136",
"0.5989776",
"0.5945167",
"0.59342283",
"0.5850324",
"0.5836321",
"0.583418",
"0.58282876",
"0.5811652",
"0.5753125",
... | 0.723194 | 0 |
List files associated with a legislation node. | def list_legislation_files(self, nid, field):
resp = self.session.get(self.url + f"/jsonapi/node/legislation/{nid}/{field}", timeout=self.timeout)
self.check_for_error(resp)
return resp.json()['data'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def listFiles(self):\n pass",
"def list_file(self, path: str) -> List[FileName]:\n current_file = self.file_exists(path)\n if current_file is None:\n raise FileNotExistException(\n \"Path doesn't exist. Can't list non-existent path\"\n )\n if curre... | [
"0.69451326",
"0.65188605",
"0.63498425",
"0.6243756",
"0.6219241",
"0.6154089",
"0.61321485",
"0.6004312",
"0.5975518",
"0.5971345",
"0.59706646",
"0.5954831",
"0.5954498",
"0.5953372",
"0.59485877",
"0.5926061",
"0.59160614",
"0.59031665",
"0.58852905",
"0.5877798",
"0.5866... | 0.7763789 | 0 |
Filters an attack event. | def filter(self, value, attackEvent):
queryDigits = sum(c.isdigit() for c in attackEvent.fields["query"])
groups = re.findall("(==|!=|<|<=|>|>=)(\d+)", value)
relationship = groups[0][0]
number = int(groups[0][1])
if relationship == "==" and queryDigits == number:
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_event(event):\n tokens = event.split()\n# if tokens[-1] in SUBJS and tokens[-2] == \"tell\":\n# return True\n# if tokens[-1] in [\"know\", \"say\", \"think\"]:\n# return True\n # filter eventualities with only 2 tokens\n if len(tokens) <= 2:\n return True\n # filter hot verbs\n if an... | [
"0.59108555",
"0.575912",
"0.55490017",
"0.5546458",
"0.55433214",
"0.55248475",
"0.5505036",
"0.5472423",
"0.5446081",
"0.5388685",
"0.5386382",
"0.5383061",
"0.52962315",
"0.5282356",
"0.5271071",
"0.5254203",
"0.5186451",
"0.51769686",
"0.5170154",
"0.5162012",
"0.5154676"... | 0.0 | -1 |
Retrieve the tcp identified by the specified identifier | def getIpTcp(self):
query = ''
conn = self.get_connection()
headers = { 'Content-type' : 'application/json', 'Authorization' : 'A10 %s' %self.sessionid}
conn.request('GET', self.get_path() + '/' + query, headers=headers)
response = conn.getresponse()
expected_status = 200
errors = {500: 'An unexpected run... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lookup_socket(self, address): # TODO: optimize me\n\n net_tuple = self.read_nodestate(0)\n for item in net_tuple:\n discovered_address = item[1]\n if address == discovered_address:\n return item[0]",
"def tcp_socket(self) -> Optional[pulumi.Input['TCPSocket... | [
"0.59464496",
"0.55471534",
"0.5472671",
"0.54111755",
"0.53893316",
"0.5299998",
"0.52808774",
"0.5254719",
"0.5224211",
"0.52072257",
"0.5200745",
"0.5184563",
"0.5152923",
"0.5148989",
"0.5146435",
"0.51278967",
"0.5104274",
"0.51016253",
"0.5075102",
"0.5066041",
"0.50655... | 0.69662493 | 0 |
Replace the object tcp | def putIpTcp(self, tcp):
query = ''
conn = self.get_connection()
headers = { 'Content-type' : 'application/json', 'Authorization' : 'A10 %s' %self.sessionid}
output=OrderedDict()
output['tcp']=serialize_Tcp_json(tcp)
payload = serialize_final_json(output)
conn.request('PUT', self.get_path() + '/' + query,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace(name, newobject):",
"def put(cls, obj):\n pass",
"def swap_socket(self, new_sock):\n del self.socket\n self.socket = new_sock\n self.conn = self.socket",
"def _update_object(self, data_dict):\r\n pass",
"def put(self, obj):\n\n if obj is None:\n ... | [
"0.58834565",
"0.5881783",
"0.56873995",
"0.5530008",
"0.5500321",
"0.54792285",
"0.5454966",
"0.5424171",
"0.5419293",
"0.5419293",
"0.5400785",
"0.53520703",
"0.53288096",
"0.5328373",
"0.5314694",
"0.5311538",
"0.52730453",
"0.52693754",
"0.5240439",
"0.52332467",
"0.52060... | 0.57627726 | 2 |
Remove the tcp identified by the specified identifier from the system | def deleteIpTcp(self):
query = ''
conn = self.get_connection()
headers = { 'Content-type' : 'application/json', 'Authorization' : 'A10 %s' %self.sessionid}
conn.request('DELETE', self.get_path() + '/' + query, headers=headers)
response = conn.getresponse()
expected_status = 200
errors = {500: 'An unexpect... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_tcp(ctx, global_ip, global_port, local_ip, local_port):\n\n # Verify the ip address format \n if is_valid_ipv4_address(local_ip) is False:\n ctx.fail(\"Given local ip address {} is invalid. Please enter a valid local ip address !!\".format(local_ip))\n\n if is_valid_ipv4_address(global_i... | [
"0.66617686",
"0.61916286",
"0.61521727",
"0.58983296",
"0.58463335",
"0.5779146",
"0.5741216",
"0.57381725",
"0.5735484",
"0.57274055",
"0.56983846",
"0.5684289",
"0.56816524",
"0.5629058",
"0.5621266",
"0.5618001",
"0.5610599",
"0.5610599",
"0.56052005",
"0.5603235",
"0.555... | 0.74882025 | 0 |
Create the object tcp | def submitIpTcp(self, tcp):
query = ''
conn = self.get_connection()
headers = { 'Content-type' : 'application/json', 'Authorization' : 'A10 %s' %self.sessionid}
output=OrderedDict()
output['tcp']=serialize_Tcp_json(tcp)
payload = serialize_final_json(output)
conn.request('POST', self.get_path() + '/' + qu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n # Create a TCP/IP socket\n self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)",
"def __init__(self):\n self.host = socket.gethostname() # 192.168.56.1\n self.port = 33000\n self.buffer_size = 1024\n self.address = (self.host, se... | [
"0.70379204",
"0.685682",
"0.6756597",
"0.6746518",
"0.6735529",
"0.66671294",
"0.66281486",
"0.66208684",
"0.6613877",
"0.6589314",
"0.658274",
"0.65486974",
"0.65486974",
"0.65458995",
"0.6543262",
"0.65430474",
"0.65310043",
"0.6520433",
"0.6496424",
"0.647834",
"0.6472835... | 0.0 | -1 |
Retrieve all tcp objects currently pending in the system | def getAllIpTcps(self):
query = ''
conn = self.get_connection()
headers = { 'Content-type' : 'application/json', 'Authorization' : 'A10 %s' %self.sessionid}
conn.request('GET', self.get_path() + '/' + query, headers=headers)
response = conn.getresponse()
expected_status = 200
errors = {500: 'An unexpected... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetListTCPObjects(self):\n rdata =[]\n total = 0\n with open(self.ServerInfo['MgmtObjects'].MGMTServerFilePathTCPPorts) as f:\n data = json.load(f)\n total = data['total']\n if total == 0:\n return None\n for i in range(total):\n # prin... | [
"0.69517106",
"0.64199525",
"0.6138711",
"0.6105612",
"0.59809905",
"0.5949874",
"0.59222156",
"0.5889137",
"0.57988304",
"0.5736065",
"0.5722521",
"0.57223004",
"0.57219213",
"0.5707166",
"0.56596583",
"0.56313956",
"0.5623342",
"0.55821925",
"0.557804",
"0.5577517",
"0.5568... | 0.69884336 | 0 |
Runs kmeans on 1 GPU. | def run_kmeans(x, nmb_clusters, verbose=False):
n_data, d = x.shape
# faiss implementation of k-means
clus = faiss.Clustering(d, nmb_clusters)
clus.niter = 10
clus.max_points_per_centroid = 10000000
res = faiss.StandardGpuResources()
flat_config = faiss.GpuIndexFlatConfig()
flat_config.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n data = Dummy(n_samples=500, n_dim=3)\n X = data.get_dummy()\n clustering = Kmeans(X, K=5, display=False)\n clustering.run()\n print(f\"Number of iterations: {clustering.num_iterations}\\n\")\n\n \"\"\" Test example of clustering_kmeans with unknown number of clusters K \"\"\"\n c... | [
"0.67367566",
"0.6471971",
"0.6289722",
"0.626697",
"0.62218416",
"0.6204235",
"0.6202007",
"0.6184911",
"0.6184055",
"0.6147832",
"0.6088372",
"0.606217",
"0.6025204",
"0.59815586",
"0.59565955",
"0.5939371",
"0.59327406",
"0.5915717",
"0.59018946",
"0.58462656",
"0.5816353"... | 0.64684594 | 2 |
Preprocess an array of features. | def preprocess_features(npdata, pca=128):
_, ndim = npdata.shape
npdata = npdata.astype('float32')
# Using PCA didn't help in our case.
# Apply PCA-whitening with Faiss
#mat = faiss.PCAMatrix (ndim, pca, eigen_power=-0.9)
#mat.train(npdata)
#assert mat.is_trained
#npdata = mat.app... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_feature(df):",
"def preprocess_features(features):\n rowsum = np.array(features.sum(1))\n r_inv = np.power(rowsum, -1).flatten()\n r_inv[np.isinf(r_inv)] = 0.\n r_mat_inv = sp.diags(r_inv)\n features = r_mat_inv.dot(features)\n return features.toarray() # densify -- these are ti... | [
"0.7355943",
"0.6872203",
"0.680106",
"0.6781985",
"0.67640245",
"0.66646343",
"0.66646343",
"0.660503",
"0.66022897",
"0.65712607",
"0.6488485",
"0.64480215",
"0.64433885",
"0.64012057",
"0.6370464",
"0.63638115",
"0.6356219",
"0.6356219",
"0.63524216",
"0.63437927",
"0.6343... | 0.672049 | 5 |
Insert a new Node at the end of linked list | def insert(self, data):
if self.head == None:
self.head = Node(data)
else:
curr = self.head
while curr.link != None:
curr = curr.link
curr.link = Node(data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert_end(self, data):\n\n if self.head is None:\n self.head = ListNode(data)\n else:\n temp = self.head\n while temp.next is not None:\n temp = temp.next\n temp.next = ListNode(data)",
"def insert_after(self,node,new_node):\n n... | [
"0.8148187",
"0.7815384",
"0.7763275",
"0.7622498",
"0.7496598",
"0.74464536",
"0.74432915",
"0.7405461",
"0.73680526",
"0.7358912",
"0.72806185",
"0.72622913",
"0.72363603",
"0.7232796",
"0.71699554",
"0.7160366",
"0.7143708",
"0.7132515",
"0.7132515",
"0.71115035",
"0.70284... | 0.70837075 | 20 |
Display all linked list elements | def display(self, end="->"):
curr = self.head
result = ''
while curr != None:
result += str(curr.data) + end
curr = curr.link
result = result.strip(end)
print(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display(self):\r\n elems = [] #create a list of elements we've seen\r\n current_node = self.head\r\n while current_node.next!=None:\r\n current_node = current_node.next\r\n elems.append(current_node.data)\r\n print(elems)",
"def list_print(self):\n nod... | [
"0.84568965",
"0.8213851",
"0.808806",
"0.80566",
"0.80476457",
"0.79047906",
"0.78577435",
"0.7706681",
"0.7697232",
"0.76910263",
"0.76873213",
"0.7658046",
"0.76558465",
"0.7618996",
"0.7616294",
"0.75307035",
"0.7484382",
"0.74367356",
"0.7413044",
"0.7277549",
"0.7274222... | 0.68089575 | 34 |
Get the length of the linked list | def get_length(self):
curr = self.head
length = 0
while curr != None:
length += 1
curr = curr.link
return length | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_length(self):\n pointer = self.head\n counter = 0\n while pointer:\n counter += 1\n pointer = pointer.next_node\n return counter",
"def length(self):\n return self.linked_list.length()",
"def length(self):\r\n current_node = self.head\r\n ... | [
"0.8839559",
"0.88344073",
"0.8750934",
"0.86144745",
"0.83789593",
"0.8362712",
"0.83407676",
"0.83168334",
"0.83009917",
"0.82192546",
"0.8112709",
"0.8077225",
"0.80621135",
"0.80393803",
"0.80384076",
"0.8028961",
"0.79636455",
"0.79584897",
"0.7937",
"0.7933721",
"0.7933... | 0.8840205 | 0 |
Get the element at specified position or returns None if position does not exist | def get_element(self, pos):
curr = self.head
count = 1
while curr != None:
if count == pos:
return curr.data
curr = curr.link
count += 1
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_position(self, pos):\n element = self.head\n count = 1\n\n if pos == 1:\n return element\n elif pos > 1 and self.head:\n while count < pos:\n element = element.next\n count += 1\n if element is None:\n ... | [
"0.7687424",
"0.7412961",
"0.6943923",
"0.68401533",
"0.67232615",
"0.67172253",
"0.66860145",
"0.66341776",
"0.6605367",
"0.6601718",
"0.6578222",
"0.6516474",
"0.6492555",
"0.6492555",
"0.64918137",
"0.64886534",
"0.647172",
"0.6471375",
"0.64704806",
"0.64075685",
"0.63981... | 0.7868817 | 0 |
carga los emojis desde la carpeta. | def _load_emoticons(emotions):
return [nparray_as_image(cv2.imread('graphics/%s.png' % emotion, -1), mode=None) for emotion in emotions] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def emojis(self, ctx):\n\n\t\tawait self.message_leaderboard(ctx, \"emojis\")",
"async def getemoji(self, ctx):\n pass",
"def de_emojify(self, tweet):\n regrex_pattern = re.compile(\n pattern=\"[\"\n \"\\U0001F600-\\U0001F64F\" # emoticons\n \"\\U0001F300-\... | [
"0.759955",
"0.6647761",
"0.6587347",
"0.6486262",
"0.6481584",
"0.64346176",
"0.636827",
"0.6305332",
"0.620564",
"0.61532205",
"0.6023843",
"0.60163885",
"0.6000087",
"0.59775937",
"0.5953988",
"0.5945015",
"0.59159696",
"0.5895401",
"0.58917266",
"0.5872658",
"0.58493346",... | 0.5666559 | 26 |
Muestra la webcam y detecta los rostros y las emociones en tiempo real para dibujar los emojis. | def show_webcam_and_run(model, emoticons, window_size=None, window_name='webcam', update_time=10):
cv2.namedWindow(window_name, WINDOW_NORMAL)
if window_size:
width, height = window_size
cv2.resizeWindow(window_name, width, height)
# 选择摄像头，0为本地
vc = cv2.VideoCapture(0) # http://192.168... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_frame(self):\r\n\r\n # Reading the Video and grasping the Frames\r\n _, frame = self.video.read()\r\n\r\n # Converting the Color image to Gray Scale\r\n gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\r\n\r\n # Image size is reduced by 30% at each image scale.\r\n ... | [
"0.6349221",
"0.61298025",
"0.60099834",
"0.5987401",
"0.5907742",
"0.58317894",
"0.5773631",
"0.57720965",
"0.5752085",
"0.57329386",
"0.5702524",
"0.56955504",
"0.5686861",
"0.5675076",
"0.56712705",
"0.5658507",
"0.5623298",
"0.5621945",
"0.558406",
"0.5580833",
"0.5568899... | 0.67097116 | 0 |
Get the stride between lines of a C matrix | def get_matrix_stride(mat):
itemsize = mat.itemsize
stride = mat.strides[0] // itemsize
assert mat.strides == (stride * itemsize, itemsize)
return stride | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def out_stride(self):\n return 4",
"def lineout(data, cencol, pxwidth = 3):\n frame_dimension = len(data)\n spectrum_intensities = np.array([ sum( [data[i][j] for j in range(cencol-pxwidth,cencol+pxwidth+1)] ) for i in range(frame_dimension) ])\n return spectrum_intensities",
"def out_stride(self):... | [
"0.6341353",
"0.6026125",
"0.6015157",
"0.5969687",
"0.5904242",
"0.58180946",
"0.5800844",
"0.57403153",
"0.5735365",
"0.57338125",
"0.5727915",
"0.5695839",
"0.5649859",
"0.56348044",
"0.5630995",
"0.55920064",
"0.5587389",
"0.55793166",
"0.5561398",
"0.5519366",
"0.5517608... | 0.6712748 | 0 |
Check that the matrix of double looks fine | def check_double_matrix(mat):
if len(mat.shape) != 2:
sys.stderr.write("Invalid matrix: dimension {} not {}\n"
.format(len(mat.shape), 2))
return False
# If the strides hasn't got the same number of elements, really weird
# things happened... Let's abort in such cas... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testMatrix(m):\n print \"Testing the spread matrix:\"\n for i in m.matrix:\n if float('%.3g' % sum(i)) != 1.000 and sum(i) != 0:\n print \"The spread is not as expected\", sum(i)\n return\n print \"Matrix is acceptable\"",
"def _check_matrix(self,... | [
"0.6854547",
"0.6790353",
"0.67284423",
"0.6678701",
"0.6612804",
"0.6561573",
"0.64683634",
"0.63938135",
"0.63869256",
"0.6364449",
"0.63438624",
"0.6276176",
"0.6272913",
"0.62640566",
"0.6256419",
"0.6254902",
"0.62461764",
"0.62152296",
"0.6209413",
"0.6194714",
"0.61872... | 0.68912345 | 0 |
Test several things around numpy and cffi | def main():
matrix = numpy.zeros((10, 10))
print("Original matrix:\n{}".format(matrix))
if not check_double_matrix(matrix):
return 1
matrix_data = ffi.cast("double *", matrix.ctypes.data)
_cffi_example.matrix_add_coords(matrix_data,
matrix.shape[0], matri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compile_cutils():\r\n\r\n types = ['npy_' + t for t in ['int8', 'int16', 'int32', 'int64', 'int128',\r\n 'int256', 'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'uint256',\r\n 'float16', 'float32', 'float64', 'float80', 'float96', 'float128',\r\n 'float256']]\r\n\r\n complex_type... | [
"0.65539813",
"0.6443295",
"0.6392358",
"0.6291215",
"0.62505853",
"0.6220695",
"0.62024707",
"0.61812323",
"0.60880494",
"0.607032",
"0.60649407",
"0.602607",
"0.59926057",
"0.59598535",
"0.5942965",
"0.5938708",
"0.5923445",
"0.59232455",
"0.59103423",
"0.5894893",
"0.58833... | 0.0 | -1 |
Converts a time string from an slog file into a string DTG string for use in TAML. Have to artificially turn (seconds) into (date), so there's some creativity in the conversion. | def convert_time(slog_time_str):
base_time = datetime.datetime(2007, 1, 1)
delta = datetime.timedelta(0, float(slog_time_str))
timestamp = base_time + delta
taml_dtg = timestamp.strftime('%Y-%m-%dT%H:%M:%S')
return taml_dtg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convertTime(string):\n try:\n d = dtparser.parse(string)\n except ValueError:\n try:\n d = datetime.fromtimestamp(float(string))\n except ValueError:\n return string\n\n d.replace(tzinfo=tz.tzlocal())\n return datetime.strftime(d, \"%Y/%m/%d %H:%M:%S\")",
... | [
"0.6709552",
"0.6487091",
"0.6420539",
"0.639823",
"0.6296272",
"0.62832755",
"0.6231348",
"0.62042576",
"0.6168536",
"0.61509234",
"0.61488825",
"0.6141358",
"0.6126549",
"0.6100859",
"0.6069301",
"0.603041",
"0.60138583",
"0.5983436",
"0.59756863",
"0.59745187",
"0.59640115... | 0.7685931 | 0 |
Fits generator on the graph | def fit(
self, graph: List[Tuple[int, int]], is_directed: bool, *args, **kwargs
):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_graph(self):",
"def __generator(self, inp):\n nodes_input = 1\n for i in range(len(self.arch_G)):\n nodes_output = self.arch_G[i]\n inp = fc_layer(inp, nodes_input, nodes_output, 'G_' + str(i + 1) + '_')\n nodes_input = self.arch_G[i]\n\n return fc_la... | [
"0.7418792",
"0.7051481",
"0.69156545",
"0.67285794",
"0.66040176",
"0.6590043",
"0.6583011",
"0.65533",
"0.6494747",
"0.6431917",
"0.6421992",
"0.6377688",
"0.6371203",
"0.6349026",
"0.6347922",
"0.63353777",
"0.6330606",
"0.6300959",
"0.62825394",
"0.62698245",
"0.6258512",... | 0.0 | -1 |
Generates graph with approximately `num_nodes` and exactly `num_edges` from generator | def generate(
self,
num_nodes: int,
num_edges: int,
is_directed: bool,
*args,
return_node_ids: bool = False,
**kwargs,
) -> np.ndarray:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate(self):\n\n g = nx.Graph()\n g.add_nodes_from(self.graph.nodes)\n\n num_nodes = g.number_of_nodes()\n\n degree_sequence = sorted([d for n, d in self.graph.degree()])\n degree_count = Counter(degree_sequence)\n deg, cnt = zip(*degree_count.items())\n\n de... | [
"0.7148452",
"0.7055047",
"0.67906475",
"0.67173404",
"0.665062",
"0.6641448",
"0.6621053",
"0.65373224",
"0.64683425",
"0.6438116",
"0.6409539",
"0.63667434",
"0.63432056",
"0.6339525",
"0.62839967",
"0.62677395",
"0.6254661",
"0.6254088",
"0.6254088",
"0.6210768",
"0.619631... | 0.6627939 | 6 |
Store fitted results into json file | def save_fit_results(self, save_path: str = "./fit_results.json"):
assert (
self._fit_results
), "There are no fit results to be saved, \
call fit method first or load the results from the file"
assert save_path.endswith(".json"), self.JSON_ASSERTION
with open(save_pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_results(results):\n json.dump(results, open(\"results.json\", \"w\"))",
"def save_fit_results(self, save_path: str = \"./fit_results.json\"):\n assert (\n self._fit_src_dst_results or self._fit_dst_src_results\n ), \"There are no fit results to be saved, \\\n call fit ... | [
"0.7465609",
"0.7382611",
"0.6806038",
"0.6790864",
"0.67722875",
"0.6744859",
"0.66805696",
"0.66547126",
"0.66245914",
"0.65919757",
"0.6576034",
"0.65640616",
"0.6540873",
"0.6520938",
"0.6481845",
"0.64712536",
"0.6405506",
"0.6401357",
"0.63735455",
"0.6363669",
"0.63511... | 0.7513786 | 0 |
load fitted results from json file | def load_fit_results(self, load_path: str = "./fit_results.json"):
assert load_path.endswith(".json"), self.JSON_ASSERTION
with open(load_path, "r") as fjson:
self._fit_results = json.load(fjson) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_fit_results(self, load_path: str = \"./fit_results.json\"):\n assert load_path.endswith(\".json\"), self.JSON_ASSERTION\n with open(load_path, \"r\") as fjson:\n wrapped_results = json.load(fjson)\n assert (\n \"fit_src_dst_results\" in wrapped_results\n ... | [
"0.73352855",
"0.6404458",
"0.63621724",
"0.6311765",
"0.62229115",
"0.6197745",
"0.6123886",
"0.60660917",
"0.60134476",
"0.59846854",
"0.5945812",
"0.592143",
"0.5854745",
"0.5849048",
"0.583823",
"0.5828923",
"0.58042717",
"0.57943183",
"0.5791443",
"0.5774277",
"0.5751769... | 0.7811587 | 0 |
Fits generator on the graph | def fit(
self,
graph: List[Tuple[int, int]],
src_set: Set[int],
dst_set: Set[int],
is_directed: bool,
transform_graph: bool,
*args,
**kwargs,
):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_graph(self):",
"def __generator(self, inp):\n nodes_input = 1\n for i in range(len(self.arch_G)):\n nodes_output = self.arch_G[i]\n inp = fc_layer(inp, nodes_input, nodes_output, 'G_' + str(i + 1) + '_')\n nodes_input = self.arch_G[i]\n\n return fc_la... | [
"0.7418792",
"0.7051481",
"0.69156545",
"0.67285794",
"0.66040176",
"0.6590043",
"0.6583011",
"0.65533",
"0.6494747",
"0.6431917",
"0.6421992",
"0.6377688",
"0.6371203",
"0.6349026",
"0.6347922",
"0.63353777",
"0.6330606",
"0.6300959",
"0.62825394",
"0.62698245",
"0.6258512",... | 0.0 | -1 |
Generates graph with approximately `num_nodes_src_set`/`num_nodes_dst_set` nodes and exactly `num_edges_src_dst`/`num_edges_dst_src` edges from generator | def generate(
self,
num_nodes_src_set: int,
num_nodes_dst_set: int,
num_edges_src_dst: int,
num_edges_dst_src: int,
is_directed: bool,
return_node_ids: bool = False,
transform_graph: bool = True,
*args,
**kwargs,
):
raise NotImp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dfs_edges_generator(graph, source, reverse=...):\n ...",
"def np_batch_generator(n_nodes, n_edges, batch_size, data_subset, epochs=1, shuffle=True):\n\n # we stop accumulating to a batch when one of these numbers is exceeded\n max_nodes = batch_size * n_nodes\n max_edges = batch_size * n_edges\n ... | [
"0.6357381",
"0.61960644",
"0.6187048",
"0.6162786",
"0.61440974",
"0.61100316",
"0.6039733",
"0.59805906",
"0.59549385",
"0.59503865",
"0.5926314",
"0.58999896",
"0.58972",
"0.57888955",
"0.576996",
"0.5767073",
"0.57605594",
"0.5741135",
"0.5737695",
"0.57273066",
"0.570914... | 0.7906923 | 0 |
Stores fitted results into json file | def save_fit_results(self, save_path: str = "./fit_results.json"):
assert (
self._fit_src_dst_results or self._fit_dst_src_results
), "There are no fit results to be saved, \
call fit method first or load the results from the file"
assert save_path.endswith(".json"), self.JSO... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_results(results):\n json.dump(results, open(\"results.json\", \"w\"))",
"def save_fit_results(self, save_path: str = \"./fit_results.json\"):\n assert (\n self._fit_results\n ), \"There are no fit results to be saved, \\\n call fit method first or load the results from... | [
"0.76523083",
"0.76427025",
"0.6963589",
"0.68375766",
"0.6818667",
"0.6774356",
"0.66953206",
"0.6687157",
"0.66694516",
"0.6658131",
"0.6654102",
"0.6638956",
"0.66346896",
"0.6613533",
"0.65783024",
"0.6571502",
"0.6545202",
"0.65309095",
"0.65279335",
"0.65145934",
"0.649... | 0.7499114 | 2 |
Loads fitted results from json file | def load_fit_results(self, load_path: str = "./fit_results.json"):
assert load_path.endswith(".json"), self.JSON_ASSERTION
with open(load_path, "r") as fjson:
wrapped_results = json.load(fjson)
assert (
"fit_src_dst_results" in wrapped_results
and "fit_dst_src... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_fit_results(self, load_path: str = \"./fit_results.json\"):\n assert load_path.endswith(\".json\"), self.JSON_ASSERTION\n with open(load_path, \"r\") as fjson:\n self._fit_results = json.load(fjson)",
"def load():\n\n #: the file passed by the user in the post request\n fi... | [
"0.79122615",
"0.65482247",
"0.64179564",
"0.6359414",
"0.6281388",
"0.6250493",
"0.61909735",
"0.61442757",
"0.61417186",
"0.60516894",
"0.59675527",
"0.5951223",
"0.5920149",
"0.5870302",
"0.5859236",
"0.5849556",
"0.5831417",
"0.5825516",
"0.5821571",
"0.5817166",
"0.58045... | 0.7303407 | 1 |
Create plugin manager and defined hooks specification. | def create_plugin_manager():
plugin_manager = PiPluginManager(hookspecs.hookspec.project_name)
plugin_manager.add_hookspecs(hookspecs)
return plugin_manager | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_register_dynamic_plugin_manager(self):\n pass",
"def test_register_dynamic_plugin_manager1(self):\n pass",
"def plugin_manager() -> pluggy.PluginManager:\n _plugin_manager = pluggy.PluginManager(\"rasa\")\n _plugin_manager.add_hookspecs(sys.modules[\"rasa.plugin\"])\n _discover_... | [
"0.7119126",
"0.70899945",
"0.70372623",
"0.69193995",
"0.6870526",
"0.665556",
"0.6444245",
"0.64034927",
"0.6372821",
"0.63320184",
"0.6328381",
"0.6325857",
"0.6302487",
"0.62694174",
"0.6228222",
"0.6221385",
"0.6182159",
"0.6134531",
"0.61034197",
"0.6096832",
"0.6066662... | 0.81805366 | 0 |
Keep the list of already called hook per plugin to know if a plugin has already been initialized in case of hotregistration. | def before(hook_name, methods, kwargs):
for hookimpl in methods:
self._plugin2calls[hookimpl.plugin].add(hook_name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_all_hooks():\n global _all_hooks_registered\n if not _all_hooks_registered:\n logger.debug(\"Searching for hooks\")\n hooks = list(get_app_submodules('site_hooks'))\n logger.debug(\"Got %s hooks\" % len(hooks))\n _all_hooks_registered = True",
"def init(self):\n ... | [
"0.68519974",
"0.65498334",
"0.6497009",
"0.6264585",
"0.6251791",
"0.623449",
"0.62343425",
"0.62343425",
"0.61572456",
"0.6060473",
"0.60595745",
"0.6048773",
"0.60333836",
"0.6011112",
"0.5968206",
"0.59615594",
"0.5940426",
"0.58936125",
"0.5871757",
"0.5865771",
"0.58567... | 0.6333181 | 3 |
Override to keep all plugins that have already been registered at least one time. | def register(self, plugin, name=None):
plugin_name = super(PiPluginManager, self).register(plugin, name)
if plugin not in self._plugin2calls:
self._plugin2calls[plugin] = set()
return plugin_name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self):\r\n with PluginStore.mutex:\r\n self._disabled = []\r\n for _, plugin in self._plugins.items():\r\n plugin.shutdown()\r\n self._plugins.clear()",
"def reset(self):\n for plugin in self.plugins:\n LOGGER.info('Resetting %s', plugin)\n... | [
"0.72106093",
"0.68358684",
"0.6480067",
"0.6460695",
"0.6422556",
"0.6353031",
"0.63316566",
"0.618075",
"0.61752623",
"0.60917026",
"0.60694945",
"0.6019211",
"0.6017463",
"0.59837437",
"0.597309",
"0.59382385",
"0.5896065",
"0.5854006",
"0.5845902",
"0.5836334",
"0.5798915... | 0.53707254 | 59 |
Register the core plugins, load plugins from setuptools entry points and the load given module/package paths. | def load_all_plugins(self, paths, disabled=None):
# Load plugins declared by setuptools entry points
self.load_setuptools_entrypoints(hookspecs.hookspec.project_name)
plugins = []
for path in paths:
plugin = load_module(path)
if plugin:
LOGGER.deb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_plugins(self):\n self.__doing('load_plugins')\n self.__do_if_not_done('bootstrap')\n if self.env.mode in ('dummy', 'unit_test'):\n return\n for package in self.packages:\n self.add_package(package)",
"def load_plugins(self) -> None:\n import impor... | [
"0.71670216",
"0.70831335",
"0.68646836",
"0.6777503",
"0.6772449",
"0.6566016",
"0.6562655",
"0.6513015",
"0.6493436",
"0.64681345",
"0.6448732",
"0.6436965",
"0.63849676",
"0.63309056",
"0.6289031",
"0.62655675",
"0.6195485",
"0.6175629",
"0.61183715",
"0.61055356",
"0.6090... | 0.6887568 | 2 |
Return the list of loaded plugins except ``pibooth`` core plugins. (external plugins can be registered or unregistered) | def list_external_plugins(self):
values = []
for plugin in self._plugin2calls:
# The core plugins are classes, we don't want to include
# them here, thus we take only the modules objects.
if inspect.ismodule(plugin):
if plugin not in values:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_plugins(self):\n return []",
"def get_non_gui_plugins():\n return [cls() for cls in get_non_gui_plugin_classes()]",
"def plugin_list(self):\r\n return get_module_list()",
"def get_disabled_plugins(self):\n return self._disabled_plugins",
"def getIgnoredPlugins(self):\n ... | [
"0.748177",
"0.7343613",
"0.715946",
"0.7155568",
"0.7129391",
"0.6981885",
"0.69517004",
"0.69423413",
"0.6925067",
"0.68775153",
"0.67109644",
"0.66824967",
"0.66654766",
"0.66553617",
"0.6642868",
"0.66312057",
"0.65977263",
"0.65490544",
"0.6548626",
"0.654292",
"0.652238... | 0.71489537 | 4 |
Return the friendly name of the given plugin and optionally its version. | def get_friendly_name(self, plugin, version=True):
# List of all setuptools registered plugins
distinfo = dict(self.list_plugin_distinfo())
if plugin in distinfo:
name = distinfo[plugin].project_name
vnumber = distinfo[plugin].version
else:
name = sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_name(self, plugin):\n return plugin.name if isinstance(plugin, BasePlugin) else plugin",
"def get_plugin_name(filename):\n m = PLUGIN_PACKAGE_RE.search(filename or '')\n if m:\n return m.group(1)\n else:\n return None",
"def get_plugin_name(self):\n return self.plu... | [
"0.7386398",
"0.7290012",
"0.7092868",
"0.69911456",
"0.67694056",
"0.67535245",
"0.67400986",
"0.6504187",
"0.6483196",
"0.6451923",
"0.6373576",
"0.63026863",
"0.62797564",
"0.625846",
"0.6180294",
"0.61733705",
"0.609387",
"0.59891397",
"0.5984237",
"0.59653777",
"0.589649... | 0.8702743 | 0 |
Return the ist of the hook names that has already been called at least one time fr the given plugins. | def get_calls_history(self, plugin):
if plugin in self._plugin2calls:
return list(self._plugin2calls[plugin])
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_custom_hook_names():\n return list(_CUSTOM_HOOKS)",
"def names() -> Tuple[str, ...]:\n return plugins.list_all(package_name=__name__)",
"def hooks(self):\n return tuple(self.__hooks.keys())",
"def plugin_names(self):\n return self.__plugin_names",
"def get_functions_seen(self):\... | [
"0.62393296",
"0.5960841",
"0.5893372",
"0.58870816",
"0.57874966",
"0.5709598",
"0.56208736",
"0.5597268",
"0.5507188",
"0.5443211",
"0.531665",
"0.5305549",
"0.52597785",
"0.52513576",
"0.5248053",
"0.5206385",
"0.5205989",
"0.5186444",
"0.51845413",
"0.51769197",
"0.514961... | 0.5334923 | 10 |
Returns a bytes_list from a string / byte. | def _bytes_feature(value):
if isinstance(value, type(tf.constant(0))):
value = value.numpy() # BytesList won't unpack a string from an EagerTensor.
return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hex_str_to_bytes_arr(bytes_str: str) -> List[int]:\n return eval(f\"[{bytes_str}]\")",
"def decode_chain_list(in_bytes):\n bstrings = numpy.frombuffer(in_bytes, numpy.dtype('S' + str(mmtf.utils.constants.CHAIN_LEN)))\n return [s.decode(\"ascii\").strip(mmtf.utils.constants.NULL_BYTE) for s in bstrin... | [
"0.72284156",
"0.7016995",
"0.6966397",
"0.6805752",
"0.6782744",
"0.6686736",
"0.66507965",
"0.6556132",
"0.65115374",
"0.6501608",
"0.6488183",
"0.64153695",
"0.6406492",
"0.63723576",
"0.63595635",
"0.6352758",
"0.6343899",
"0.6320864",
"0.630812",
"0.6248688",
"0.62459064... | 0.0 | -1 |
Yield a connection pool connected to vial server | def vial_client(
server: str, apikey: str
) -> Iterator[urllib3.connectionpool.ConnectionPool]:
if not server:
raise Exception("Must pass VIAL server to call")
if not apikey:
raise Exception("Must pass VIAL API Key to use")
http_pool = urllib3.PoolManager()
vial_http = http_pool.c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_connection(self) -> Iterator[psycopg2.connect]:\n\n conn = self._pool.getconn()\n\n if self.pre_ping:\n for n in range(self.max_reconnects):\n if not self.ping(conn):\n if n > 0:\n time.sleep(self._back_off_time(n - 1))\n ... | [
"0.68395984",
"0.6616775",
"0.6468955",
"0.6466008",
"0.62284225",
"0.6185906",
"0.6179943",
"0.61773294",
"0.6155422",
"0.6123735",
"0.6113533",
"0.61117333",
"0.6077807",
"0.602352",
"0.6014565",
"0.59833854",
"0.5972427",
"0.59647954",
"0.5947133",
"0.59159994",
"0.5907486... | 0.67863506 | 1 |
Verifies that header contains valid authorization token | def verify_token(vial_http: urllib3.connectionpool.ConnectionPool) -> bool:
verify_resp = vial_http.request("GET", "/api/verifyToken")
return verify_resp.status == 200 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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] != ... | [
"0.7470917",
"0.7445979",
"0.7394502",
"0.73606247",
"0.7258435",
"0.715719",
"0.7148856",
"0.71172875",
"0.71169674",
"0.7074974",
"0.700769",
"0.69644564",
"0.69075775",
"0.6794475",
"0.67745864",
"0.67448145",
"0.67387635",
"0.673642",
"0.66281843",
"0.66200036",
"0.661797... | 0.6473546 | 34 |
Start import run and return the id for it | def start_import_run(vial_http: urllib3.connectionpool.ConnectionPool) -> str:
import_resp = vial_http.request("POST", "/api/startImportRun")
if import_resp.status != 200:
raise Exception(f"Failed to start import run {import_resp.data}")
import_data = json.loads(import_resp.data.decode("utf-8"))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_import_task(clientRequestToken=None, name=None, importUrl=None):\n pass",
"def start_import(data_import):\n\tdata_import = frappe.get_doc(\"Data Import Beta\", data_import)\n\ti = Importer(data_import.reference_doctype, data_import=data_import)\n\treturn i.import_data()",
"def importer_process(imp... | [
"0.69069815",
"0.6695886",
"0.66000867",
"0.62952036",
"0.6082602",
"0.60786223",
"0.59738696",
"0.59381676",
"0.59378403",
"0.5874674",
"0.58106",
"0.57830364",
"0.57355547",
"0.5719899",
"0.5697861",
"0.5693284",
"0.5665559",
"0.56556344",
"0.5612762",
"0.56112766",
"0.5574... | 0.76171285 | 0 |
Verifies that header contains valid authorization token | def retrieve_existing_locations(
vial_http: urllib3.connectionpool.ConnectionPool,
) -> Iterator[dict]:
resp = vial_http.request(
"GET", "/api/searchLocations?format=nlgeojson&all=1", preload_content=False
)
for line in resp:
yield geojson.loads(line)
resp.release_conn() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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] != ... | [
"0.7473123",
"0.74481225",
"0.73952866",
"0.7360394",
"0.72580284",
"0.71565604",
"0.71481323",
"0.7116696",
"0.71163434",
"0.70735514",
"0.7007949",
"0.6964352",
"0.6907963",
"0.67945844",
"0.677438",
"0.67444694",
"0.67376435",
"0.6735434",
"0.6628119",
"0.6618508",
"0.6617... | 0.0 | -1 |
Verifies that header contains valid authorization token | def retrieve_existing_locations_as_index(
vial_http: urllib3.connectionpool.ConnectionPool,
) -> rtree.index.Index:
locations = retrieve_existing_locations(vial_http)
def generate_index_row(i: int, loc: dict) -> tuple:
loc_point = shapely.geometry.shape(loc["geometry"])
return (i, loc_point... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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] != ... | [
"0.7473123",
"0.74481225",
"0.73952866",
"0.7360394",
"0.72580284",
"0.71565604",
"0.71481323",
"0.7116696",
"0.71163434",
"0.70735514",
"0.7007949",
"0.6964352",
"0.6907963",
"0.67945844",
"0.677438",
"0.67444694",
"0.67376435",
"0.6735434",
"0.6628119",
"0.6618508",
"0.6617... | 0.0 | -1 |
Ininitialise the particle with a position and momentum vectors and a mass | def __init__(self, position, momentum, mass):
self.position = position
self.momentum = momentum
self.mass = mass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self,mass,x=None,p=None,v=None):\n self.setPosition(x)\n self.setMass(mass)\n if p is not None and v is not None:\n raise CoordinateException(\"Initializing a particle can only have momentum or velocity, not both.\")\n elif p is None:\n self.setVelocity(v)\n self.calcMomentu... | [
"0.7615262",
"0.7456344",
"0.72507364",
"0.7072128",
"0.69992965",
"0.69264543",
"0.6856271",
"0.68511766",
"0.67422575",
"0.66545683",
"0.66174793",
"0.6592208",
"0.65753937",
"0.65723133",
"0.6545215",
"0.6524425",
"0.65193844",
"0.650629",
"0.6497146",
"0.6483156",
"0.6477... | 0.7441553 | 2 |
Return the velocity vector of the particle | def get_velocity(self):
return self.momentum/self.mass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getVelocity(self):\n return self.v",
"def getVelocity(self):\n\n return self.vel",
"def velocity(self):\n return self._velocity",
"def velocity(self):\n return self._velocity",
"def velocity_at_pos(self, x, y):\n return scipy.array([float(self._interp_u(x, y)),\n ... | [
"0.7955968",
"0.7745024",
"0.77234554",
"0.77234554",
"0.7688092",
"0.76584786",
"0.76424485",
"0.75447935",
"0.75148714",
"0.7462534",
"0.7457666",
"0.73845005",
"0.72576076",
"0.7106754",
"0.70722777",
"0.7026906",
"0.7010185",
"0.69741774",
"0.6948821",
"0.6877791",
"0.686... | 0.79404175 | 1 |
Return kinetic enrgy of the particle | def get_energy(self):
return self.momentum*self.momentum/(2*self.mass) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kineticEnergy(self):\n return self.params['kinetic']",
"def kinetic_energy(self):\r\n position, velocity, escaped_particles,impact, wall_collision,mom = self.box_collision_info()\r\n for j in xrange(1,self.n):\r\n abs_velocity = np.sqrt(velocity[:,0]**2+velocity[:,1]**2\r\n ... | [
"0.7499276",
"0.74066544",
"0.7244842",
"0.7038553",
"0.673587",
"0.65941375",
"0.65808964",
"0.65267044",
"0.65236604",
"0.6151119",
"0.6151119",
"0.6103551",
"0.60998434",
"0.6088825",
"0.6062322",
"0.5941433",
"0.58287054",
"0.5811235",
"0.57866675",
"0.5780221",
"0.572142... | 0.0 | -1 |
Return quaternion from Euler angles and axis sequence. | def quaternion_from_euler(ai, aj, ak, axes='sxyz'):
try:
firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()]
except (AttributeError, KeyError):
_ = _TUPLE2AXES[axes]
firstaxis, parity, repetition, frame = axes
i = firstaxis
j = _NEXT_AXIS[i+parity]
k = _NEXT_AXI... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def euler_to_quaternion(euler: tuple) -> object:\n\n (yaw, pitch, roll) = (euler[0], euler[1], euler[2])\n qy = np.sin(roll / 2) * np.cos(pitch / 2) * np.cos(yaw / 2) - np.cos(roll / 2) * np.sin(pitch / 2) * np.sin(yaw / 2)\n qx = np.cos(roll / 2) * np.sin(pitch / 2) * np.cos(yaw / 2) + np.sin(roll / 2) *... | [
"0.7727526",
"0.7503549",
"0.74089247",
"0.73761517",
"0.73758185",
"0.7261005",
"0.72107375",
"0.7182006",
"0.71239877",
"0.71054584",
"0.70450413",
"0.70432484",
"0.69958776",
"0.69414973",
"0.6939632",
"0.69368577",
"0.69198453",
"0.68761027",
"0.68623286",
"0.68605334",
"... | 0.7246877 | 6 |
Extract filtered inrange velodyne coordinates based on azimuth & elevation angle limit | def hv_in_range(x, y, z, fov, fov_type='h'):
d = np.sqrt(x ** 2 + y ** 2 + z ** 2)
if fov_type == 'h':
return np.logical_and(np.arctan2(y, x) > (-fov[1] * np.pi/180), np.arctan2(y, x) < (-fov[0] * np.pi/180))
elif fov_type == 'v':
return np.logical_and(np.arctan2(z, d) < (fov[1] * np.pi / 180), np.arctan2(z, d) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_target_azimuths(radar_in):\n sweep_start = radar_in.sweep_start_ray_index['data'][0]\n sweep_end = radar_in.sweep_end_ray_index['data'][0]\n target_azimuths = np.sort(\n radar_in.azimuth['data'][sweep_start:sweep_end+1])\n az_tol = np.median(target_azimuths[1:]-target_azimuths[:-1])\n\n... | [
"0.6166181",
"0.5888999",
"0.58740586",
"0.58250934",
"0.5766253",
"0.57479966",
"0.5739707",
"0.5711385",
"0.5607426",
"0.55564934",
"0.5489532",
"0.54890054",
"0.5479273",
"0.5467141",
"0.54620796",
"0.5453764",
"0.5424477",
"0.5399013",
"0.53936005",
"0.5388616",
"0.537854... | 0.0 | -1 |
Get the event type | def __unicode__(self):
return "%d" % (self.type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_event_type(event):\n return event.type()",
"def _get_event_type(event):\n return event.type()",
"def get_type(self):\n return self.event_type",
"def event_type(self) -> int:\n return self.data[\"args\"][\"eventType\"]",
"def type(self) -> str:\n return self._even... | [
"0.9124082",
"0.9124082",
"0.90069985",
"0.8711404",
"0.83575463",
"0.82805854",
"0.80476016",
"0.80090797",
"0.77455413",
"0.76935184",
"0.76803297",
"0.76801234",
"0.7523564",
"0.73957133",
"0.71513206",
"0.7093203",
"0.7033223",
"0.69131833",
"0.6899823",
"0.6825652",
"0.6... | 0.0 | -1 |
Get the Billing agreement | def __unicode__(self):
return "%d (%d - %d)" % (self.agreement_id, self.payer_email, self.state) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_agreement(self):\n pass",
"def get_incorporation_agreement_json(filing):\n return filing.json['filing']['incorporationApplication'].get('incorporationAgreement', {})",
"def agreement_number(self) -> Optional[str]:\n return pulumi.get(self, \"agreement_number\")",
"def getPay... | [
"0.6833925",
"0.65939116",
"0.6525695",
"0.6019161",
"0.59166104",
"0.56271607",
"0.56155455",
"0.5562701",
"0.5470692",
"0.5386633",
"0.5386633",
"0.5386633",
"0.5381787",
"0.53544766",
"0.53544766",
"0.5314757",
"0.5287566",
"0.52750283",
"0.5269475",
"0.5251014",
"0.524676... | 0.0 | -1 |
Get the payment descriptor | def __unicode__(self):
return "%d (%d , %d, %d)" % (self.pay_id, self.intent, self.state, self.client_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPayment(self):\n pass",
"def get_payment_description(self, name):\n if self.method == 'manual':\n return \"Paid by Cash\"\n elif self.method == 'credit_card':\n return (\n \"Paid by Card \" + \"(\" + (\"xxxx \" * 3) +\n self.payment_... | [
"0.7141235",
"0.6703626",
"0.66543996",
"0.6183217",
"0.60790956",
"0.59304446",
"0.5927887",
"0.58225256",
"0.5784891",
"0.57677084",
"0.57677084",
"0.57616067",
"0.57466364",
"0.5736313",
"0.5706687",
"0.56976795",
"0.56879294",
"0.5646603",
"0.5642304",
"0.563779",
"0.5634... | 0.0 | -1 |
Get the transaction descriptor | def __unicode__(self):
return "%d (%f)" % (self.payment.pay_id, self.id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transaction_id(self):\n return self.private",
"def get_transfer(self):\n return self._transfer",
"def gettransaction(self, txid):\n return TransactionInfo(**self.proxy.gettransaction(txid))",
"def get_descriptor(self, uuid):\n return tuple(self.get_many_descriptors(uuid))[0]",
"... | [
"0.5730446",
"0.5669879",
"0.5597634",
"0.5591067",
"0.5510349",
"0.55066407",
"0.55001414",
"0.5484473",
"0.5484473",
"0.54712063",
"0.5413419",
"0.5396153",
"0.5390768",
"0.53889847",
"0.53568065",
"0.5290514",
"0.5290454",
"0.52822185",
"0.52687573",
"0.52203363",
"0.52101... | 0.0 | -1 |
Get the sale descriptor | def __unicode__(self):
if self.billing_agreement_id != None:
return "%d -%d (%d)" % (self.sale_id, self.state, self.billing_agreement_id)
return "%d -%d (%d)" % (self.sale_id, self.state, self.parent_payment) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sales_rep(self):\r\n return self._sales_rep",
"def get_single_sale(self, sale_id):\n sale_record = self.dbconn.get_single_sale(sale_id=sale_id)\n return sale_record",
"def get(self, sale_id):\n sales_record = Sales().get_all_sales()\n single_sale = [\n sale... | [
"0.6110091",
"0.59884834",
"0.5958059",
"0.5788091",
"0.56876206",
"0.559325",
"0.5526897",
"0.53787124",
"0.5336509",
"0.53172165",
"0.5274664",
"0.526286",
"0.5261349",
"0.5202559",
"0.5164068",
"0.5111815",
"0.5108286",
"0.5108286",
"0.5088821",
"0.508271",
"0.5072037",
... | 0.0 | -1 |
Get the authorization descriptor | def __unicode__(self):
return "%s -%s (%s)" % (self.sale_id, self.state, self.parent_payment) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authorization(self):\n return self._authorization",
"def get_authorization(self):\n raise NotImplemented()",
"def authorization(self) -> Optional['outputs.AuthorizationResponse']:\n return pulumi.get(self, \"authorization\")",
"def authorize(self):\n\n return self.__a",
"def... | [
"0.707867",
"0.69775796",
"0.6673104",
"0.64048684",
"0.6353344",
"0.6286655",
"0.6067879",
"0.59025586",
"0.58201575",
"0.58201575",
"0.5803035",
"0.5797658",
"0.57780045",
"0.5777812",
"0.57753474",
"0.57323074",
"0.5643588",
"0.56276643",
"0.5623638",
"0.5604519",
"0.55523... | 0.0 | -1 |
Get the refund descriptor | def __unicode__(self):
if self.sale_id != None:
return "%d -%d (%d)" % (self.refund_id, self.state, self.sale_id)
return "%d -%d (%d)" % (self.refund_id, self.state, self.capture_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retrieve(payment, refund_id):\n if isinstance(payment, resources.Payment):\n payment = payment.id\n\n http_client = HttpClient()\n response, _ = http_client.get(routes.url(routes.REFUND_RESOURCE, resource_id=refund_id, payment_id=payment))\n return resources.Refund(**resp... | [
"0.64392316",
"0.5863587",
"0.58257824",
"0.5778564",
"0.5630128",
"0.54803634",
"0.54636323",
"0.5356619",
"0.53540045",
"0.5255977",
"0.523284",
"0.51943237",
"0.51324826",
"0.510862",
"0.510862",
"0.5082535",
"0.50733966",
"0.50484294",
"0.50201195",
"0.49867564",
"0.49514... | 0.43564573 | 96 |
Check that `VMPool.__iter__` iterates over VM IDs. | def test_iter(self):
for n, pool in enumerate([self.pool0, self.pool1, self.pool2]):
assert list(iter(pool)) in (
list('ab'[:n]),
list('ba'[:n]),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_vpn_id():\n for v in vpns:\n assert len(v.id) > 0",
"def test_iter(self):\n obs = self.tester.__iter__()\n self.assertTrue(isinstance(obs, Iterable))\n self.assertEqual(set(obs), self.exp_sample_ids)",
"def test_iter(self):\n obs = self.tester.__iter__()\n ... | [
"0.5551847",
"0.5502366",
"0.5502366",
"0.499766",
"0.4989234",
"0.49801987",
"0.4952273",
"0.49347952",
"0.49295378",
"0.49100518",
"0.49041685",
"0.4864451",
"0.48494568",
"0.48422536",
"0.48142493",
"0.47784758",
"0.47465125",
"0.4716814",
"0.4716193",
"0.47150078",
"0.470... | 0.5758834 | 0 |
Apply the electron event selection using fastcalo or electron features. The pidname will be a string that can be one or more pidnames algorithms. If there is EFCalo or HLT in pidname, the selection uses fastcalo features. | def ApplyElectronSelection( self, pidname ):
doAnd=False; doOr=False
fc = self.retrieve("FastCalo"); el = self.retrieve("Electron")
# remove spaces if exist
pidname = pidname.replace(' ','')
# Check conditions strings
if '&' in pidname:
pidname = pidname.split('&')
doAnd=True; isPass... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute(module_name):\n\n global clf_re\n global filter_function\n global remap_pairs\n\n # Get the window date to process events\n (from_date, until_date) = rules_common.window_dates(module_name)\n\n # Get the files to process, lines and mark lines\n (files, total_lines, mark_lines) = \\\... | [
"0.5087484",
"0.50239825",
"0.49709415",
"0.46197402",
"0.4569843",
"0.45122904",
"0.4461218",
"0.4412482",
"0.44032472",
"0.44027945",
"0.43926793",
"0.43906233",
"0.43781617",
"0.4360104",
"0.43565696",
"0.43386114",
"0.43149012",
"0.43059707",
"0.4303484",
"0.4274708",
"0.... | 0.7302416 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.