0 else 1.\\n # clip\\n if params['clipping'] == 'transparent':\\n data[np.logical_or(data > 1, data < -1)] = np.nan\\n elif params['clipping'] == 'clamp':\\n data = np.clip(data, -1, 1, data)\\n params['data'] = data\\n params['times'] = times\",\n \"def get_spectrum(self, outwave=None, filters=None, peraa=False, **params):\\n self.params.update(**params)\\n # Pass the model parameters through to the sps object\\n ncomp = len(self.params['mass'])\\n for ic in range(ncomp):\\n s, p, x = self.one_sed(component_index=ic, filterlist=filters)\\n try:\\n spec += s\\n maggies += p\\n extra += [x]\\n except(NameError):\\n spec, maggies, extra = s, p, [x]\\n # `spec` is now in Lsun/Hz, with the wavelength array being the\\n # observed frame wavelengths. Flux array (and maggies) have not been\\n # increased by (1+z) due to cosmological redshift\\n\\n if outwave is not None:\\n w = self.csp.wavelengths\\n spec = np.interp(outwave, w, spec)\\n # Distance dimming and unit conversion\\n if (self.params['zred'] == 0) or ('lumdist' in self.params):\\n # Use 10pc for the luminosity distance (or a number provided in the\\n # lumdist key in units of Mpc). Do not apply cosmological (1+z)\\n # factor to the flux.\\n dfactor = (self.params.get('lumdist', 1e-5) * 1e5)**2\\n a = 1.0\\n else:\\n # Use the comsological luminosity distance implied by this\\n # redshift. Incorporate cosmological (1+z) factor on the flux.\\n lumdist = cosmo.luminosity_distance(self.params['zred']).value\\n dfactor = (lumdist * 1e5)**2\\n a = (1 + self.params['zred'])\\n if peraa:\\n # spectrum will be in erg/s/cm^2/AA\\n spec *= to_cgs * a / dfactor * lightspeed / outwave**2\\n else:\\n # Spectrum will be in maggies\\n spec *= to_cgs * a / dfactor / 1e3 / (3631*jansky_mks)\\n\\n # Convert from absolute maggies to apparent maggies\\n maggies *= a / dfactor\\n \\n return spec, maggies, extra\",\n \"def spMultiIndex(self):\\n # reset column levels\\n self.spfiltEEG.columns = pd.MultiIndex.from_arrays([self.channels, np.repeat(('Filtered'), len(self.channels))],names=['Channel','datatype'])\\n self.spRMS.columns = pd.MultiIndex.from_arrays([self.channels, np.repeat(('RMS'), len(self.channels))],names=['Channel','datatype'])\\n self.spRMSmavg.columns = pd.MultiIndex.from_arrays([self.channels, np.repeat(('RMSmavg'), len(self.channels))],names=['Channel','datatype'])\\n\\n # list df vars for index specs\\n dfs =[self.spfiltEEG, self.spRMS, self.spRMSmavg] # for > speed, don't store spinfilt_RMS as an attribute\\n calcs = ['Filtered', 'RMS', 'RMSmavg']\\n lvl0 = np.repeat(self.channels, len(calcs))\\n lvl1 = calcs*len(self.channels) \\n \\n # combine & custom sort\\n self.spindle_calcs = pd.concat(dfs, axis=1).reindex(columns=[lvl0, lvl1])\",\n \"def joss_ssr(ppg, accel_x, accel_y, accel_z, eng):\\n\\n freq = ppg.frequency\\n\\n N = 60 * freq # Resolution is 1 BPM\\n\\n Y = np.array((ppg.values, accel_x.values, accel_y.values, \\n accel_z.values))\\n\\n Y = np.transpose(Y)\\n\\n L = Y.shape[1]\\n\\n spectra = ssr(Y, freq, N, eng)\\n \\n for i in range(0, L):\\n spectra_i = spectra[:,i]\\n\\n spectra_i[:20] = 0\\n spectra_i[220:] = 0\\n\\n spectra_i = spectra_i / np.max(spectra_i)\\n spectra[:,i] = spectra_i\\n\\n\\n # BPM axis\\n bpm = 60 * freq / N * np.arange(N)\\n\\n aggression = 0.99\\n accel_max = np.zeros((N))\\n signal_ssr = spectra[:,0]\\n\\n # Modify the SSR signal by subtracting the maximum acceleration in each bin\\n for i in range(0, bpm.size):\\n # Max of acceleration at this frequency\\n accel_max[i] = np.max([spectra[i,1], spectra[i,2], spectra[i,3]])\\n\\n signal_ssr[i] = signal_ssr[i] - aggression * accel_max[i]\\n\\n if DEBUG:\\n plt.subplot(221)\\n plt.title(\\\"x\\\")\\n plt.plot(spectra[:,1])\\n plt.subplot(222)\\n plt.title(\\\"y\\\")\\n plt.plot(spectra[:,2])\\n plt.subplot(223)\\n plt.title(\\\"z\\\")\\n plt.plot(spectra[:,3])\\n\\n\\n # Set all SSR bins lower than the maximum divided by 5 to 0\\n max_bin = np.max(signal_ssr)\\n signal_ssr[signal_ssr < max_bin / 4] = 0\\n\\n return signal_ssr, accel_max\",\n \"def reduc(self,zarange=[20,50]):\\n \\n # First, take out a secular gain drift for each constant elevation\\n # stare. Fit P(t) to each channel in a contiguous elevation stare,\\n # normalize fit to mean=1, and normalize each chan to this.\\n #deg=10\\n #self.removedrift(deg)\\n\\n # Convert P-> T RJ\\n #self.P2T()\\n\\n # Now fit a line to P(am) in each scan and store the results.\\n self.fitam(zarange)\",\n \"def soMultiIndex(self):\\n # reset column levels\\n self.sofiltEEG.columns = pd.MultiIndex.from_arrays([self.channels, np.repeat(('Filtered'), len(self.channels))],names=['Channel','datatype'])\\n self.spsofiltEEG.columns = pd.MultiIndex.from_arrays([self.channels, np.repeat(('Filtered'), len(self.channels))],names=['Channel','datatype'])\\n\\n # list df vars for index specs\\n # dfs =[self.sofiltEEG] # for > speed, don't store spinfilt_RMS as an attribute\\n # calcs = ['Filtered']\\n # lvl0 = np.repeat(self.channels, len(calcs))\\n # lvl1 = calcs*len(self.channels) \\n \\n # # combine & custom sort --> what was this for??\\n # self.so_calcs = pd.concat(dfs, axis=1).reindex(columns=[lvl0, lvl1])\",\n \"def one_sed(self, component_index=0, filterlist=[]):\\n # Pass the model parameters through to the sps object, and keep track\\n # of the mass of this component\\n mass = 1.0\\n for k, vs in list(self.params.items()):\\n try:\\n v = vs[component_index]\\n except(IndexError, TypeError):\\n v = vs\\n if k in self.csp.params.all_params:\\n if k == 'zmet':\\n vv = np.abs(v - (np.arange(len(self.csp.zlegend)) + 1)).argmin() + 1\\n else:\\n vv = v.copy()\\n self.csp.params[k] = vv\\n if k == 'mass':\\n mass = v\\n # Now get the magnitudes and spectrum. The spectrum is in units of\\n # Lsun/Hz/per solar mass *formed*\\n w, spec = self.csp.get_spectrum(tage=self.csp.params['tage'], peraa=False)\\n mags = getSED(w, lightspeed/w**2 * spec * to_cgs, filterlist)\\n mfrac = self.csp.stellar_mass\\n if np.all(self.params.get('mass_units', 'mstar') == 'mstar'):\\n # Convert normalization units from per stellar masss to per mass formed\\n mass /= mfrac\\n # Output correct units\\n return mass * spec, mass * 10**(-0.4*(mags)), mfrac\",\n \"def combine(self,data):\\n channels = []\\n #if type(data.data) == pandas.core.frame.DataFrame:\\n # spike_train_all_trial_ = np.array(data.data.stack())\\n # spike_train_all_trial = np.reshape(spike_train_all_trial_,(spike_train_all_trial_.shape[0],1))\\n #else:\\n # spike_train_all_trial_ = np.array(data.data)\\n # spike_train_all_trial = np.reshape(spike_train_all_trial_,(spike_train_all_trial_.shape[0],1))\\n for c in range(data.nr_cells):\\n channels.append(data.cell(c).getFlattend())\\n\\n d = DesignMatrix(channels[0].shape[0], self.component_width)\\n d.setMask(self.mask)\\n for c in self.components:\\n d.add(c.getSplines(channels),c.header)\\n #if self.mask.shape[0] == d.matrix.shape[1] + 1:\\n # d.matrix = d.matrix[:,~self.mask[:-1]]\\n self._header = d.header\\n #print \\\"--\\\"\\n #print d.matrix.shapeload\\n return d.matrix\",\n \"def get_components(self, outwave, filters, **params):\\n if outwave is not None:\\n params['outwave'] = outwave\\n # This will rebuild the basis if relevant parameters changed\\n self.update(params)\\n\\n # distance dimming and conversion from Lsun/AA to cgs\\n dist10 = self.params.get('lumdist', 1e-5)/1e-5 # distance in units of 10s of pcs\\n dfactor = to_cgs / dist10**2\\n\\n nebspec = self.nebular(params, self.params['outwave']) * dfactor\\n cspec = np.empty([self.nbasis, len(outwave)])\\n cphot = np.empty([self.nbasis, np.size(filters)])\\n for i in range(self.nbasis):\\n cspec[i,:], cphot[i,:] = self.process_component(i, outwave, filters)\\n\\n return cspec * dfactor, nebspec, cphot * dfactor, self.basis_mass\",\n \"def combine_components(self):\\n\\n # ensure is array with correct shape\\n if self.separated_components_ft.shape[1] != 3:\\n raise ValueError(\\\"Expected shifted_components_ft to have shape (nangles, 3, ny, nx), where components are\\\"\\n \\\"O(f)*otf(f), O(f-fo)*otf(f), O(f+fo)*otf(f). But size of second dimension was not 3.\\\")\\n\\n # upsample image before shifting\\n f_upsample = 2\\n otf_us = tools.expand_fourier_sp(self.otf, mx=f_upsample, my=f_upsample, centered=True)\\n\\n # upsampled frequency data\\n fx_us = tools.get_fft_frqs(f_upsample * self.nx, self.dx / f_upsample)\\n dfx_us = fx_us[1] - fx_us[0]\\n fy_us = tools.get_fft_frqs(f_upsample * self.ny, self.dx / f_upsample)\\n dfy_us = fy_us[1] - fy_us[0]\\n\\n def ff_shift(f): return np.sqrt((self.fx[None, :] - f[0]) ** 2 + (self.fy[:, None] - f[1]) ** 2)\\n def ff_shift_upsample(f): return np.sqrt((fx_us[None, :] - f[0]) ** 2 + (fy_us[:, None] - f[1]) ** 2)\\n\\n # wiener filter deconvolution to divide by H(k)\\n # components_deconvolved_ft = np.zeros((self.nangles, 3, self.ny, self.nx), dtype=np.complex)\\n components_deconvolved_ft = np.zeros((self.nangles, 3, self.ny * f_upsample, self.nx * f_upsample), dtype=np.complex)\\n snr = np.zeros((self.nangles, 3, self.ny, self.nx))\\n # shift to correct place in frq space\\n components_shifted_ft = np.zeros((self.nangles, 3, self.ny * f_upsample, self.nx * f_upsample), dtype=np.complex)\\n snr_shifted = np.zeros(components_shifted_ft.shape)\\n # weight and average\\n components_weighted = np.zeros(components_shifted_ft.shape, dtype=np.complex)\\n weights = np.zeros(components_weighted.shape)\\n\\n # shift and filter components\\n for ii in range(self.nangles):\\n # loop over components, O(f)H(f), m*O(f - f_o)H(f), m*O(f + f_o)H(f)\\n for jj, eps in enumerate([0, 1, -1]):\\n params = list(self.power_spectrum_params[ii, jj, :-1]) + [0]\\n snr[ii, jj] = power_spectrum_fn(params, ff_shift(self.frqs[ii] * eps), 1) / self.noise_power[ii, jj]\\n\\n # get shifted SNR\\n otf_shifted, _, _ = tools.translate_pix(otf_us, eps*self.frqs[ii], dx=dfx_us, dy=dfy_us, mode='no-wrap')\\n snr_shifted[ii, jj] = power_spectrum_fn(params, ff_shift_upsample((0, 0)), 1) / self.noise_power[ii, jj]\\n\\n # weights\\n weights[ii, jj] = get_snr_weight(otf_shifted, snr_shifted[ii, jj])\\n\\n if True:\\n # deconvolve, then shift\\n\\n # deconvolve\\n deconv_temp, _ = \\\\\\n wiener_deconvolution(self.separated_components_ft[ii, jj] / self.mod_depths[ii, jj], self.otf,\\n snr[ii, jj])\\n\\n components_deconvolved_ft[ii, jj] = tools.expand_fourier_sp(deconv_temp, mx=f_upsample, my=f_upsample, centered=True)\\n\\n # shift and expand\\n components_shifted_ft[ii, jj] = tools.translate_ft(components_deconvolved_ft[ii, jj], eps * self.frqs[ii], self.dx / f_upsample)\\n else:\\n # shift then deconvolve\\n\\n # shift and expand\\n components_shifted_ft[ii, jj] = tools.translate_ft(\\n tools.expand_fourier_sp(self.separated_components_ft[ii, jj], mx=f_upsample, my=f_upsample, centered=True),\\n eps * self.frqs[ii], self.dc / f_upsample)\\n\\n # deconvolved\\n components_shifted_ft[ii, jj], _ = \\\\\\n wiener_deconvolution(components_shifted_ft[ii, jj] / self.mod_depths[ii, jj], otf_shifted,\\n snr_shifted[ii, jj])\\n\\n # optionally remove frequency data around modulation frequency, to avoid artifacts\\n if self.size_near_fo_to_remove != 0:\\n to_remove = np.abs(ff_shift_upsample(-self.frqs[ii])) < self.size_near_fo_to_remove * np.linalg.norm(self.frqs[ii])\\n components_shifted_ft[ii, jj][to_remove] = 0\\n\\n to_remove = np.abs(ff_shift_upsample(self.frqs[ii])) < self.size_near_fo_to_remove * np.linalg.norm(self.frqs[ii])\\n components_shifted_ft[ii, jj][to_remove] = 0\\n\\n # correct for wrong global phases (on shifted components before weighting,\\n # but then apply to weighted components)\\n if self.global_phase_correction:\\n self.phase_corrections = global_phase_correction(components_shifted_ft)\\n else:\\n self.phase_corrections = np.zeros(self.nangles)\\n\\n # combine components\\n components_weighted = components_shifted_ft * weights\\n for ii in range(self.nangles):\\n components_weighted[ii, 1] = np.exp(1j * self.phase_corrections[ii]) * components_weighted[ii, 1]\\n components_weighted[ii, 2] = np.exp(-1j * self.phase_corrections[ii]) * components_weighted[ii, 2]\\n\\n # final averaging\\n weight_norm = np.sum(weights, axis=(0, 1)) + self.wiener_parameter\\n sim_sr_ft = np.nansum(components_weighted, axis=(0, 1)) / weight_norm\\n\\n # Fourier transform back to get real-space reconstructed image\\n apod = scipy.signal.windows.tukey(sim_sr_ft.shape[1], alpha=0.1)[None, :] * \\\\\\n scipy.signal.windows.tukey(sim_sr_ft.shape[0], alpha=0.1)[:, None]\\n\\n sim_sr = fft.fftshift(fft.ifft2(fft.ifftshift(sim_sr_ft * apod))).real\\n\\n return sim_sr, sim_sr_ft, components_deconvolved_ft, components_shifted_ft,\\\\\\n weights, weight_norm, snr, snr_shifted\",\n \"def repackage_coeff(boss_pca_fil=None, sdss_pca_fil=None,\\n outfil='qso_templates_v2.0.fits'):\\n # PCA values\\n if boss_pca_fil is None:\\n boss_pca_fil = 'BOSS_DR10Lya_PCA_values_nocut.fits.gz'\\n hdu = fits.open(boss_pca_fil)\\n boss_pca_coeff = hdu[1].data\\n\\n if sdss_pca_fil is None:\\n sdss_pca_fil = 'SDSS_DR7Lya_PCA_values_nocut.fits.gz'\\n hdu2 = fits.open(sdss_pca_fil)\\n sdss_pca_coeff = hdu2[1].data\\n\\n # Redshifts\\n boss_cat_fil = os.environ.get('BOSSPATH')+'/DR10/BOSSLyaDR10_cat_v2.1.fits.gz'\\n bcat_hdu = fits.open(boss_cat_fil)\\n t_boss = bcat_hdu[1].data\\n boss_zQSO = np.array(t_boss['z_pipe'])\\n\\n # Open the SDSS catalog file\\n sdss_cat_fil = os.environ.get('SDSSPATH')+'/DR7_QSO/dr7_qso.fits.gz'\\n scat_hdu = fits.open(sdss_cat_fil)\\n t_sdss = scat_hdu[1].data\\n sdss_zQSO = t_sdss['z']\\n if len(sdss_pca_coeff) != len(sdss_zQSO):\\n print('Need to finish running the SDSS models!')\\n sdss_zQSO = sdss_zQSO[0:len(sdss_pca_coeff)]\\n\\n # Eigen vectors\\n eigen, eigen_wave = fbq.read_qso_eigen()\\n\\n # Write\\n phdu = fits.PrimaryHDU()\\n bp_hdu = fits.BinTableHDU(boss_pca_coeff)\\n bp_hdu.name = 'BOSS_PCA'\\n bz_hdu = fits.ImageHDU(boss_zQSO)\\n bz_hdu.name = 'BOSS_z'\\n sp_hdu = fits.BinTableHDU(sdss_pca_coeff)\\n sp_hdu.name = 'SDSS_PCA'\\n sz_hdu = fits.ImageHDU(sdss_zQSO)\\n sz_hdu.name = 'SDSS_z'\\n e_hdu = fits.ImageHDU(eigen)\\n e_hdu.name = 'SDSS_EIGEN'\\n ew_hdu = fits.ImageHDU(eigen_wave)\\n ew_hdu.name = 'SDSS_EIGEN_WAVE'\\n\\n hdulist = fits.HDUList([phdu, bp_hdu, bz_hdu, sp_hdu, sz_hdu,\\n e_hdu, ew_hdu])\\n hdulist.writeto(outfil, overwrite=True)\\n print('Wrote {:s}'.format(outfil))\",\n \"def createIntegratedPsf(self):\\n\\n (wavelengths, weights) = self.filter\\n for i in range(len(wavelengths)):\\n\\n wavelength = wavelengths[i]\\n weight = weights[i]\\n self.convertToOpd(wavelength) # creates self.opd\\n opd = self.embedOpd()\\n zf = numpy.fft.fft2(opd)\\n del opd\\n # Compute the amplitude squared.\\n # (psf is not really the point spread function yet)\\n psf = np.conjugate(zf)\\n # psf will now be the point spread function, but still complex\\n np.multiply(psf, zf, psf)\\n del zf\\n # normalize the PSF, and convert to single precision\\n psf = psf.real / psf.size\\n psf = psf.astype(np.float32)\\n\\n self.center(psf)\\n\\n # This describes the image scale if no resampling is done.\\n cdelt_before_resampling = (wavelength * MICRONStoMETERS) / \\\\\\n (self.D * self.oversample) * RADIANStoDEGREES\\n if self.pixel_size is None:\\n # we won't resample the output image\\n self.cdelt = cdelt_before_resampling\\n # Extract a subset.\\n if self.output_size < self.npix:\\n o_npix = self.output_size\\n n0 = (self.npix - o_npix) // 2\\n self.integrated_psf += \\\\\\n (psf[n0:n0 + o_npix, n0:n0 + o_npix] * weight)\\n else:\\n self.integrated_psf += (psf * weight)\\n else:\\n # we'll resample to this image scale\\n self.cdelt = self.pixel_size / self.oversample * ARCSECtoDEGREES\\n # These three parameters are only used by mapPsf and for\\n # normalizing the weight after resampling.\\n self.rescale = self.cdelt / cdelt_before_resampling\\n self.input_center = (self.npix + 1) // 2\\n self.output_center = (self.output_size + 1) // 2\\n sub_psf = np.zeros((self.output_size, self.output_size),\\n dtype=np.float32)\\n # Do the resampling, writing the output to sub_psf.\\n ndimage.geometric_transform(psf, self.mapPsf,\\n output_shape=(self.output_size, self.output_size),\\n output=sub_psf, prefilter=True)\\n weight = weight * self.rescale**2\\n self.integrated_psf += (sub_psf * weight)\\n del sub_psf\\n\\n if self.verbose:\\n print(\\\"PSF for wavelength %g has been computed\\\" % wavelength)\",\n \"def _ssc(pars, nu):\\n\\t(log10_gamma_max, redshift, delta, log10_R, log10_B, log10_Norm, index, log10_gamma_c) = pars\\n\\n\\t# define from the input parameters the dictionary to be feeded to the model\\n\\t# we neglect the time-dependent part for now\\n\\ttime_grid = dict(time_min=0, time_max=3, time_bins=50, time_inj=2)\\n\\t# gamma grid\\n\\tgamma_grid = dict(log10_gamma_min=2, log10_gamma_max=log10_gamma_max, gamma_bins=50)\\n\\t# emission region, again time dependent part is ignored\\n\\temission_region = dict(log10_R=log10_R, R_unit='cm', delta=delta,\\n\\t\\t\\t\\t\\t\\t log10_B=log10_B, B_unit='G', t_esc=1.5, z=redshift)\\n\\t# injected spectrum\\n\\tinjected_spectrum = dict(type='ExponentialCutoffPowerLaw',\\n\\t\\t\\t\\t\\t\\t\\t log10_Norm=log10_Norm,\\n\\t\\t\\t\\t\\t\\t\\t Norm_unit='cm-3',\\n\\t\\t\\t\\t\\t\\t\\t index=index,\\n\\t\\t\\t\\t\\t\\t\\t log10_gamma_c=log10_gamma_c)\\n\\n\\t# dump into a tmp yaml file\\n\\twith open('tmp_config.yaml', 'w') as yaml_file:\\n\\t\\tyaml.dump({'time_grid': time_grid,\\n\\t\\t\\t\\t 'gamma_grid': gamma_grid,\\n\\t\\t\\t\\t 'emission_region': emission_region,\\n\\t\\t\\t\\t 'injected_spectrum': injected_spectrum},\\n\\t\\t\\t\\t yaml_file, default_flow_style=False)\\n\\n\\n\\t# initialize the ssc model\\n\\tmodel = BaseModel('tmp_config.yaml')\\n\\n\\t# define the base electron population for now just as the injected one\\n\\tgamma = model.gamma\\n\\tN_e = model.N_e_inj(gamma)\\n\\n\\t# test synchrotron\\n\\tsyn = Synchrotron(model)\\n\\tic = InverseCompton(model)\\n\\n\\tobs_nu = nu * u.Hz\\n\\t# de - boosting, for intrinsic values\\n\\tnu = obs_nu / model.blob.delta\\n\\n\\t# transform to energy\\n\\tE = const.h * obs_nu\\n\\n\\tsyn_flux = syn.flux(nu, N_e, self_absorption=True)\\n\\tic_flux = ic.flux(nu, N_e, ebl_absorption=True)\\n\\n\\tsed = (E**2*(syn_flux + ic_flux)).to('erg cm-2 s-1')\\n\\n\\treturn sed.value\",\n \"def constructAllWRFstreamsRegridded(first=1):\\n pattern.a.load()\\n WRFstreams = pickle.load(open(summary_folder+'WRF/dbzstreamAll.pydump', 'r'))\\n for M in range(first, len(WRFstreams)+1):\\n ds = WRFstreams[M-1] # the models are labelled 1-20\\n print \\\"\\\\n.......\\\\n\\\", M, ds.name \\n #ds.outputFolder = summary_folder+ 'WRF[regridded]'\\n #debug\\n #print ds[0].outputFolder\\n #print ds[0].dataPath\\n print 'loading...'\\n ds.load()\\n # debug\\n #print ds[0].matrix.shape\\n #ds[0].show()\\n #ds[1].show()\\n #ds[4].show()\\n # END debug\\n ds.setOutputFolder(summary_folder+'WRF[regridded]/')\\n ds.setImageFolder(summary_folder+'WRF[regridded]/')\\n #print 'outputFolder:', ds.outputFolder\\n print ds[0].outputFolder\\n print 'imageFolder:', ds.imageFolder\\n print 'regridding...'\\n ds.regrid(pattern.a)\\n for D in ds:\\n print D.name,\\n if 'regridded' not in D.name:\\n D.name += '[regridded]'\\n # debug\\n #print D.matrix.shape\\n #D.show()\\n # END debug\\n print 'saving...'\\n pickle.dump(ds, open(summary_folder + 'WRF[regridded]/dbzstream' + ('0'+str(M))[-2:] + '.pydump', 'w'))\\n return WRFstreams\",\n \"def calc_spindle_psd_concat(self, psd_bandwidth):\\n \\n print('Calculating power spectra (this may take a few minutes)...')\\n self.metadata['spindle_analysis']['psd_dtype'] = 'raw_concat'\\n self.metadata['spindle_analysis']['psd_method'] = 'multitaper'\\n self.metadata['spindle_analysis']['psd_bandwidth'] = psd_bandwidth\\n sf = self.metadata['analysis_info']['s_freq']\\n \\n spindle_psd = {}\\n spindle_multitaper_calcs = pd.DataFrame(index=['data_len', 'N', 'W', 'NW', 'K'])\\n for chan in self.spindles:\\n #print(f'Calculating spectra for {chan}...')\\n if len(self.spindles[chan]) > 0:\\n # concatenate spindles\\n spindles = [self.spindles[chan][x].Raw.values for x in self.spindles[chan]]\\n data = np.concatenate(spindles)\\n \\n # record PS params [K = 2NW-1]\\n N = len(data)/sf\\n W = psd_bandwidth\\n K = int((2*N*W)-1)\\n spindle_multitaper_calcs[chan] = [len(data), N, W, N*W, K] \\n \\n # calculate power spectrum\\n pwr, freqs = psd_array_multitaper(data, sf, adaptive=True, bandwidth=psd_bandwidth, fmax=25, \\n normalization='full', verbose=0)\\n # convert to series & add to dict\\n psd = pd.Series(pwr, index=freqs)\\n spindle_psd[chan] = psd\\n \\n self.spindle_multitaper_calcs = spindle_multitaper_calcs\\n self.spindle_psd_concat = spindle_psd\\n print('Done. Spectra stored in obj.spindle_psd_concat. Calculations stored in obj.spindle_multitaper_calcs.\\\\n')\",\n \"def reconstruct(self):\\n self.print_tee(\\\"starting reconstruction\\\", self.log_file)\\n\\n # #############################################\\n # estimate SIM parameters\\n # #############################################\\n # estimate frequencies\\n tstart = time.time() # since done using joblib, process_time() is not useful...\\n\\n if self.use_fixed_frq:\\n self.frqs = self.frqs_guess\\n self.print_tee(\\\"using fixed frequencies\\\", self.log_file)\\n else:\\n if self.find_frq_first:\\n self.frqs = self.estimate_sim_frqs(self.imgs_ft, self.imgs_ft, self.frqs_guess)\\n else:\\n self.print_tee(\\\"doing phase demixing prior to frequency finding\\\", self.log_file)\\n self.separated_components_ft = separate_components(self.imgs_ft, self.phases_guess, np.ones((self.nangles, self.nphases)))\\n imgs1 = np.expand_dims(self.separated_components_ft[:, 0], axis=1)\\n imgs2 = np.expand_dims(self.separated_components_ft[:, 1], axis=1)\\n self.frqs = self.estimate_sim_frqs(imgs1, imgs2, self.frqs_guess)\\n\\n tend = time.time()\\n self.print_tee(\\\"fitting frequencies took %0.2fs\\\" % (tend - tstart), self.log_file)\\n\\n # estimate phases\\n tstart = time.process_time()\\n if self.use_fixed_phase:\\n self.phases = self.phases_guess\\n self.amps = np.ones((self.nangles, self.nphases))\\n self.print_tee(\\\"Using fixed phases\\\", self.log_file)\\n else:\\n self.phases, self.amps = self.estimate_sim_phases(self.frqs, self.phases_guess)\\n\\n tend = time.process_time()\\n self.print_tee(\\\"estimated %d phases in %0.2fs\\\" % (self.nangles * self.nphases, tend - tstart), self.log_file)\\n\\n # separate components\\n self.separated_components_ft = separate_components(self.imgs_ft, self.phases, self.amps)\\n\\n # estimate modulation depths and power spectrum fit parameters\\n tstart = time.process_time()\\n # for the moment, need to do this feet even if have fixed mod depth, because still need the\\n # power spectrum parameters\\n self.mod_depths, self.power_spectrum_params, self.pspec_masks = self.estimate_mod_depths()\\n\\n if self.use_fixed_mod_depths:\\n self.mod_depths = np.zeros((self.nangles, self.nphases))\\n self.mod_depths[:, 0] = 1\\n for jj in range(1, self.nphases):\\n self.mod_depths[:, jj] = self.mod_depths_guess\\n\\n # also correct power spectrum params\\n self.power_spectrum_params[:, jj, 2] = self.mod_depths[:, jj]\\n\\n tend = time.process_time()\\n self.print_tee('estimated %d modulation depths in %0.2fs' % (self.nangles, tend - tstart), self.log_file)\\n\\n # #############################################\\n # estimate modulation contrast to noise ratio for raw images\\n # #############################################\\n mcnr = np.zeros((self.nangles, self.nphases))\\n for ii in range(self.nangles):\\n for jj in range(self.nphases):\\n mcnr[ii, jj] = get_mcnr(self.imgs_ft[ii, jj], self.frqs[ii], self.fx, self.fy, self.fmax)\\n\\n # if mcnr is too low (typically < 1), use guess values instead\\n if self.default_to_guess_on_low_mcnr and np.min(mcnr[ii]) < self.min_mcnr and self.frqs_guess is not None:\\n self.frqs[ii] = self.frqs_guess[ii]\\n self.print_tee(\\\"Angle %d/%d, minimum mcnr = %0.2f is less than the minimum value, %0.2f,\\\"\\n \\\" so fit frequency will be replaced with guess\\\"\\n % (ii + 1, self.nangles, np.min(mcnr[ii]), self.min_mcnr), self.log_file)\\n\\n for jj in range(self.nphases):\\n mcnr[ii, jj] = get_mcnr(self.imgs_ft[ii, jj], self.frqs[ii], self.fx, self.fy, self.fmax)\\n\\n self.mcnr = mcnr\\n # for convenience, also save periods and angles\\n self.periods = 1 / np.sqrt(self.frqs[:, 0] ** 2 + self.frqs[:, 1] ** 2)\\n self.angles = np.angle(self.frqs[:, 0] + 1j * self.frqs[:, 1])\\n\\n # #############################################\\n # estimate noise in component images\\n # #############################################\\n self.noise_power = self.power_spectrum_params[:, :, -1]\\n\\n # #############################################\\n # SIM reconstruction\\n # #############################################\\n tstart = time.process_time()\\n self.img_sr, self.img_sr_ft, self.components_deconvolved_ft, self.components_shifted_ft, \\\\\\n self.weights, self.weight_norm, self.snr, self.snr_shifted = self.combine_components()\\n # self.img_sr, self.img_sr_ft, self.components_deconvolved_ft, self.components_shifted_ft, \\\\\\n # self.weights, self.weight_norm, self.snr, self.snr_shifted = self.combine_components_fairSIM()\\n tend = time.process_time()\\n\\n self.print_tee(\\\"combining components took %0.2fs\\\" % (tend - tstart), self.log_file)\\n\\n # #############################################\\n # widefield deconvolution\\n # #############################################\\n # get signal to noise ratio\\n wf_noise = get_noise_power(self.widefield_ft, self.fx, self.fy, self.fmax)\\n fit_result, self.mask_wf = fit_power_spectrum(self.widefield_ft, self.otf, self.fx, self.fy, self.fmax, self.fbounds,\\n init_params=[None, self.power_spectrum_params[0, 0, 1], 1, wf_noise],\\n fixed_params=[False, True, True, True])\\n\\n self.pspec_params_wf = fit_result['fit_params']\\n ff = np.sqrt(self.fx[None, :]**2 + self.fy[:, None]**2)\\n sig = power_spectrum_fn([self.pspec_params_wf[0], self.pspec_params_wf[1], self.pspec_params_wf[2], 0], ff, 1)\\n wf_snr = sig / wf_noise\\n # deconvolution\\n wf_decon_ft, wfilter = wiener_deconvolution(self.widefield_ft, self.otf, wf_snr, snr_includes_otf=False)\\n\\n # upsample to make fully comparable to reconstructed image\\n self.widefield_deconvolution_ft = tools.expand_fourier_sp(wf_decon_ft, 2, 2, centered=True)\\n self.widefield_deconvolution = fft.fftshift(fft.ifft2(fft.ifftshift(self.widefield_deconvolution_ft))).real\\n\\n # #############################################\\n # print parameters\\n # #############################################\\n self.print_parameters()\\n\\n try:\\n self.log_file.close()\\n except AttributeError:\\n pass\",\n \"def prepare_templates(params, outfile, redo=False):\\n if os.path.exists(outfile) and not redo:\\n return\\n emiles = EMILES()\\n wmin = params[\\\"wmin\\\"] * u.micrometer\\n wmax = params[\\\"wmax\\\"] * u.micrometer\\n # Modify wmin to compensate for the recession velocity of the system\\n zmax = (params[\\\"vsyst\\\"] + 3000) / const.c.to(\\\"km/s\\\").value\\n wrest = wmin / (1 + zmax)\\n grid = np.array(np.meshgrid(params[\\\"ages\\\"], params[\\\"metals\\\"],\\n params[\\\"bis\\\"])).T.reshape(-1, 3)\\n ssppars = Table(grid, names=[\\\"T\\\", \\\"Z\\\", \\\"imf\\\"])\\n filenames = []\\n for args in grid:\\n filenames.append(os.path.join(emiles.data_dir,\\n emiles.filename(*args)))\\n wave, spec = misc.read_spec(filenames[0])\\n wave = wave * u.angstrom\\n idx = np.where((wave > wrest) & (wave <= wmax))\\n wave = wave[idx]\\n spec = spec[idx]\\n wrange = [wave[0].to(\\\"angstrom\\\").value, wave[-1].to(\\\"angstrom\\\").value]\\n newflux, logLam, velscale = util.log_rebin(wrange, spec,\\n velscale=params[\\\"velscale\\\"])\\n ssps = np.zeros((len(filenames), len(newflux)))\\n print(\\\"Processing SSP files\\\")\\n for i, fname in tqdm(enumerate(filenames)):\\n spec = fits.getdata(fname)[idx]\\n newflux, logLam, velscale = util.log_rebin(wrange, spec,\\n velscale=params[\\\"velscale\\\"])\\n ssps[i] = newflux\\n norm = np.median(ssps)\\n ssps /= norm\\n hdu1 = fits.PrimaryHDU(ssps)\\n hdu1.header[\\\"EXTNAME\\\"] = \\\"SSPS\\\"\\n hdu1.header[\\\"BSCALE\\\"] = (norm, \\\"Scale to convert from ADU to flux.\\\")\\n hdu2 = fits.BinTableHDU(ssppars)\\n hdu2.header[\\\"EXTNAME\\\"] = \\\"PARAMS\\\"\\n hdu1.header[\\\"CRVAL1\\\"] = logLam[0]\\n hdu1.header[\\\"CD1_1\\\"] = logLam[1] - logLam[0]\\n hdu1.header[\\\"CRPIX1\\\"] = 1.\\n # Making wavelength array\\n hdu3 = fits.BinTableHDU(Table([logLam], names=[\\\"loglam\\\"]))\\n hdu3.header[\\\"EXTNAME\\\"] = \\\"LOGLAM\\\"\\n hdulist = fits.HDUList([hdu1, hdu2, hdu3])\\n hdulist.writeto(outfile, overwrite=True)\\n return\",\n \"def __update(self):\\n\\n # Make sure loads have been assigned to group\\n if type(self.appliedLoad) == Load:\\n self.appliedLoad = LoadSet(self.appliedLoad)\\n elif type(self.appliedLoad) != LoadSet:\\n raise TypeError(\\\"Applied load must be a Load or LoadSet\\\")\\n\\n # Begin Calculations\\n _cg = self.cg # calculate the cg once to save computation time\\n _appLoad = self.appliedLoad.totalForce\\n _appMoment = self.appliedLoad.totalMoment\\n\\n coef_mat = np.zeros((len(self) * 3, len(self) * 3)) # coeff matrix\\n soln_mat = np.zeros(len(self) * 3) # solution matrix\\n\\n cSet = [[i, i+1, i+2] for i in range(0, 3 * len(self), 3)]\\n rSet = [[i+6, i+7, i+8] for i in range(0, 3 * (len(self) - 2), 3)]\\n\\n for i, j in enumerate(cSet):\\n # i = column fastener ID\\n # j = column fastener set\\n # Mx = yFz - zFy\\n # My = zFx - xFz\\n # Mz = xFy - yFx\\n\\n Fx = j[0]\\n Fy = j[1]\\n Fz = j[2]\\n\\n # fill in first three rows\\n coef_mat[0][Fx] = 1 # sum of Fx\\n coef_mat[1][Fy] = 1 # sum of Fy\\n coef_mat[2][Fz] = 1 # sum of Fz\\n\\n # fill in fourth row (sum of Mx at CG)\\n coef_mat[3][Fy] = -(F[i].xyz[2] - _cg[2]) # -zFy\\n coef_mat[3][Fz] = +(F[i].xyz[1] - _cg[1]) # +yFz\\n\\n # fill in fifth row (sum of My at CG)\\n coef_mat[4][Fx] = +(F[i].xyz[2] - _cg[2]) # +zFx\\n coef_mat[4][Fz] = -(F[i].xyz[0] - _cg[0]) # -xFz\\n\\n # fill in sixth row (sum of Mz at CG)\\n coef_mat[5][Fx] = -(F[i].xyz[1] - _cg[1]) # -yFx\\n coef_mat[5][Fy] = +(F[i].xyz[0] - _cg[0]) # +xFy\\n\\n for u, w in enumerate(rSet):\\n # u = row fastener ID\\n # w = row fastener set\\n\\n rX = w[0]\\n rY = w[1]\\n rZ = w[2]\\n\\n coef_mat[rX][Fy] = -(F[i].xyz[2] - F[u].xyz[2]) # -zFy\\n coef_mat[rX][Fz] = +(F[i].xyz[1] - F[u].xyz[1]) # +yFz\\n\\n coef_mat[rY][Fx] = +(F[i].xyz[2] - F[u].xyz[2]) # +zFx\\n coef_mat[rY][Fz] = -(F[i].xyz[0] - F[u].xyz[0]) # -xFz\\n\\n coef_mat[rZ][Fx] = -(F[i].xyz[1] - F[u].xyz[1]) # -yFx\\n coef_mat[rZ][Fy] = +(F[i].xyz[0] - F[u].xyz[0]) # +xFy\\n\\n # fill in the solution matrix (soln_mat)\\n for i in range(3):\\n soln_mat[i] = -_netLoad.force[i]\\n soln_mat[i+3] = -_netLoad.moment[i]\\n\\n # fill in the remaining rows\\n for i, j in enumerate(rSet):\\n # i = fastener\\n # j = row\\n\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n # Mx = (y_cg - y_i)F_znet - (z_cg - z_i)F_ynet + M_xnet\\n soln_mat[rX] = - ((_cg[1] - F[i].xyz[1]) * _netLoad.force[2]\\n - (_cg[2] - F[i].xyz[2]) * _netLoad.force[1]\\n + _netLoad.moment[0])\\n\\n # My = (z_cg - z_i)F_xnet - (x_cg - x_i)F_znet + M_ynet\\n soln_mat[rY] = -((_cg[2] - F[i].xyz[2]) * _netLoad.force[0]\\n - (_cg[0] - F[i].xyz[0]) * _netLoad.force[2]\\n + _netLoad.moment[1])\\n\\n # Mz = (x_cg - x_i)F_ynet - (y_cg - y_i)F_xnet + M_znet\\n soln_mat[rZ] = -((_cg[0] - F[i].xyz[0]) * _netLoad.force[1]\\n - (_cg[1] - F[i].xyz[1]) * _netLoad.force[0]\\n + _netLoad.moment[2])\\n\\n # Solve system of equations\\n matSol = np.linalg.lstsq(coef_mat, soln_mat)[0]\\n\\n # Add resulting fastener loads to fastener objects\\n for i, j in enumerate(cSet):\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n F[i].force[0] = matSol[rX]\\n F[i].force[1] = matSol[rY]\\n F[i].force[2] = matSol[rZ]\",\n \"def reconstruct_pu(self, receivers, compute_uxy = True):\\n # Initialize\\n self.p_recon = np.zeros((receivers.coord.shape[0], len(self.controls.k0)), dtype=complex)\\n self.uz_recon = np.zeros((receivers.coord.shape[0], len(self.controls.k0)), dtype=complex)\\n if compute_uxy:\\n self.ux_recon = np.zeros((receivers.coord.shape[0], len(self.controls.k0)), dtype=complex)\\n self.uy_recon = np.zeros((receivers.coord.shape[0], len(self.controls.k0)), dtype=complex)\\n # Loop over frequency\\n bar = tqdm(total = len(self.controls.k0), desc = 'Reconstructing sound field...')\\n for jf, k0 in enumerate(self.controls.k0):\\n # get the scaled version of the propagating directions\\n k_p = k0 * self.dir\\n # Form the new sensing matrix\\n h_mtx = np.exp(1j*receivers.coord @ k_p.T)\\n # compute P and U\\n self.p_recon[:,jf] = h_mtx @ self.pk[:,jf]\\n self.uz_recon[:,jf] = -((np.divide(k_p[:,2], k0)) * h_mtx) @ self.pk[:,jf]\\n if compute_uxy:\\n self.ux_recon[:,jf] = -((np.divide(k_p[:,0], k0)) * h_mtx) @ self.pk[:,jf]\\n self.uy_recon[:,jf] = -((np.divide(k_p[:,1], k0)) * h_mtx) @ self.pk[:,jf]\\n bar.update(1)\\n bar.close()\",\n \"def compute_mixing_coefficients_surf(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n\\n # SET UP NEW MIXING COEFFICIENT ARRAYS\\n self.Kv_surf = np.zeros([Ly,N+1])\\n self.Kt_surf = np.zeros([Ly,N+1])\\n \\n self.ghat = np.zeros([Ly,N+1])\\n \\n\\n #################################\\n # \\tSURFACE KPP\\n ################################\\n #---> j-loop\\n \\n self.wm2 = []\\n self.ws2 = []\\n self.sigma_y = []\\n for j in range(Ly):\\n #--> k-loop (top to kbl[j])\\n # in fortran k=N-1,kbl(j),-1\\n for k in range(N-1,self.kbl[j]-1,-1):\\n k_w = k\\n k_r = k-1\\n\\n Bfsfc = self.Bfsfc_bl[j]\\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\\n \\n # CALCULATE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm2.append(wm)\\n self.ws2.append(ws)\\n # COMPUTE VERTICAL MIXING COEFFICIENTS\\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\\n self.sigma1 = sigma #for debugging\\n if j == 25: \\n self.sigma_y.append(sigma)\\n a1 = sigma - 2.\\n a2 = 3.-2.*sigma\\n a3 = sigma - 1.\\n\\n if sigma < 0.07:\\n cff = 0.5 * (sigma-0.07)**2/0.07\\n else:\\n cff = 0\\n \\n \\n if k == N-1: \\n self.wm_debug = wm\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n\\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\\n\\n if k == N-1:\\n self.ws_debug = ws\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n \\n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\\n #---> end k-loop \\n if self.LMD_NONLOCAL:\\n if Bfsfc < 0:\\n self.ghat[j,k_w] = 0\\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\\n else:\\n self.ghat[j,k_w] = 0.\\n\\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \\n if self.LMD_CONVEC and self.MLCONVEC: \\n for k in range(N-1,int(self.kbl[j]-1),-1):\\n k_w = k\\n k_r = k -1\\n\\n if self.bvf[j,k_w] < 0:\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\\n\\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\\n # IF BKPP IS SWITCHED OFF!!\\n for k in range(int(self.kbl[j]-1),-1,-1):\\n k_w = k\\n k_r = k -1\\n if self.LMD_NONLOCAL:\\n self.ghat[j,k_w] = 0\\n if self.LMD_CONVEC and self.LMD_BKPP == False:\\n if self.bvf[j,k_w] < 0:\\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\\n \\n\\n #---> end j-loop\",\n \"def get_bforce_wm_ws_Gx_surf(self):\\n\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w'] \\n \\n self.Gm1 = np.zeros([Ly])\\n self.dGm1_dS = np.zeros([Ly]) \\n self.Gt1 = np.zeros([Ly])\\n self.dGt1_dS = np.zeros([Ly]) \\n self.Bfsfc_bl = np.zeros([Ly])\\n self.Av_bl = np.zeros([Ly])\\n self.dAv_bl = np.zeros([Ly])\\n \\n #debugging\\n self.wm_surf = np.zeros([Ly])\\n self.ws_surf = np.zeros([Ly]) \\n\\n #---> j-loop\\n for j in range(Ly): \\n k_w = self.kbl[j] # KBL is \\\"new bl index after calling find_new_kbl()\\n z_bl = z_u_w[j,N] - self.hbls[j]\\n zscale = self.hbls[j] \\n \\n if self.swr_frac[j,k_w-1] > 0:\\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\\n \\n else:\\n Bfsfc = self.Bo[j] + self.Bosol[j]\\n \\n # CALCUALTE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm_surf[j] = wm\\n self.ws_surf[j] = ws \\n\\n if self.LIMIT_UNSTABLE_ONLY:\\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\\n else:\\n f1 = 0\\n\\n \\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n\\n #MOMENTUM \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl[j] = Av_bl\\n self.dAv_bl[j] = dAv_bl\\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \\n\\n #TEMPERATURE(BUOYANCY)\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \\n\\n self.Bfsfc_bl[j] = Bfsfc\",\n \"def __InitializeNorms(self, norm_SF, norm_plane):\\n # Initializes values \\n nc = self.__nc_RSoft_I\\n n_SF = self.__n_SF_rad+self.__n_SF_ang\\n mean_SF = np.zeros(n_SF)\\n std_SF = np.zeros(n_SF)\\n cov_SF = np.zeros((n_SF,n_SF))\\n n_parts = 0\\n\\n for idx_type, type_ in enumerate(self.__types_unique):\\n n_parts = 0\\n idx_type_SF = np.where(self.__types==type_)[0]\\n for f in range(self._n_f):\\n # Finds particle typtes for each particle. \\n particle_types = self.__NcIO_dyn.GetDataCol(f,'type')\\n type_ids = np.where(particle_types==type_)[0]\\n\\n # Obtains radial and angular SFs for f\\n if self.__containsRadial:\\n rSF = nc.variables['radial_structures'][f][type_ids]\\n else:\\n rSF = np.zeros((len(type_ids),0))\\n if self.__containsAngular:\\n aSF = nc.variables['angular_structures'][f][type_ids]\\n else:\\n aSF = np.zeros((len(type_ids),0))\\n SF = np.hstack((rSF,aSF))\\n SF = SF[~np.isnan(np.sum(SF,axis=1))] # SHOULD REMOVE NaNs\\n\\n # Counts number of SFs in frame and sums particles to find\\n # mean. We do not use mean function in case number of \\n # particles changes between frames\\n n_parts += len(SF)\\n mean_SF[idx_type_SF] += np.sum(SF[:,idx_type_SF],axis=0)\\n cov_SF[idx_type_SF[:,None],idx_type_SF[None,:]] += \\\\\\n np.dot(SF[:,idx_type_SF].T,SF[:,idx_type_SF])\\n\\n # Calculates mean and covariance\\n mean_SF[idx_type_SF] /= float(n_parts)\\n cov_SF[idx_type_SF[:,None],idx_type_SF[None,:]] /= \\\\\\n float(n_parts)\\n cov_SF[idx_type_SF[:,None],idx_type_SF[None,:]] -= \\\\\\n np.outer(mean_SF[idx_type_SF],mean_SF[idx_type_SF])\\n std_SF = np.sqrt(np.diagonal(cov_SF))\\n\\n # Checks if std_SF == 0 for any structure functions\\n if np.any(std_SF==0):\\n print('WARNING: stdev of following structure functions is 0')\\n idx_0s = np.where(std_SF==0)[0]\\n for idx_0 in idx_0s:\\n std_SF[idx_0] = 1\\n if idx_0 < self.__n_SF_rad:\\n mu = self.mus[idx_0]\\n L = self.Ls[idx_0]\\n X = self.radial_Xs[idx_0]\\n Y = self.radial_Ys[idx_0]\\n print(' radial structure function: mu = '+str(mu)+\\\\\\n ', L = '+str(L)+', X = '+str(X)+', Y = '+str(Y))\\n else:\\n idx_0 -= self.__n_SF_rad\\n xi = self.xis[idx_0]\\n l = self.lambdas[idx_0] \\n z = self.zetas[idx_0]\\n X = self.angular_Xs[idx_0]\\n Y = self.angular_Ys[idx_0]\\n Z = self.angular_Za[idx_0]\\n print(' angular structure function: xi = '+str(xi)+\\\\\\n ', lambda = '+str(l)+', zeta = '+str(z)+\\\\\\n ', X = '+str(X)+', Y = '+str(Y)+', Z = '+str(Z))\\n\\n self._mean_SF = mean_SF\\n self._cov_SF = cov_SF\\n self._std_SF = std_SF\",\n \"def hessian_full(self, params):\\n\\n if type(params) is not MixedLMParams:\\n params = MixedLMParams.from_packed(params, self.k_fe,\\n self.use_sqrt)\\n\\n fe_params = params.get_fe_params()\\n cov_re = params.get_cov_re()\\n try:\\n cov_re_inv = np.linalg.inv(cov_re)\\n except np.linalg.LinAlgError:\\n cov_re_inv = None\\n\\n # Blocks for the fixed and random effects parameters.\\n hess_fe = 0.\\n hess_re = np.zeros((self.k_re2, self.k_re2), dtype=np.float64)\\n hess_fere = np.zeros((self.k_re2, self.k_fe),\\n dtype=np.float64)\\n\\n fac = self.n_totobs\\n if self.reml:\\n fac -= self.exog.shape[1]\\n\\n rvir = 0.\\n xtvix = 0.\\n xtax = [0.,] * self.k_re2\\n B = np.zeros(self.k_re2, dtype=np.float64)\\n D = np.zeros((self.k_re2, self.k_re2), dtype=np.float64)\\n F = [[0.,]*self.k_re2 for k in range(self.k_re2)]\\n for k in range(self.n_groups):\\n\\n exog = self.exog_li[k]\\n ex_r = self.exog_re_li[k]\\n ex2_r = self.exog_re2_li[k]\\n\\n # The residuals\\n expval = np.dot(exog, fe_params)\\n resid = self.endog_li[k] - expval\\n\\n viexog = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n exog)\\n xtvix += np.dot(exog.T, viexog)\\n vir = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n resid)\\n rvir += np.dot(resid, vir)\\n\\n for jj1,mat1 in self._gen_dV_dPsi(ex_r):\\n\\n hess_fere[jj1,:] += np.dot(viexog.T,\\n np.dot(mat1, vir))\\n if self.reml:\\n xtax[jj1] += np.dot(viexog.T, np.dot(mat1, viexog))\\n\\n B[jj1] += np.dot(vir, np.dot(mat1, vir))\\n E = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n mat1)\\n\\n for jj2,mat2 in self._gen_dV_dPsi(ex_r, jj1):\\n Q = np.dot(mat2, E)\\n Q1 = Q + Q.T\\n vt = np.dot(vir, np.dot(Q1, vir))\\n D[jj1, jj2] += vt\\n if jj1 != jj2:\\n D[jj2, jj1] += vt\\n R = _smw_solve(1., ex_r, ex2_r, cov_re,\\n cov_re_inv, Q)\\n rt = np.trace(R) / 2\\n hess_re[jj1, jj2] += rt\\n if jj1 != jj2:\\n hess_re[jj2, jj1] += rt\\n if self.reml:\\n F[jj1][jj2] += np.dot(viexog.T,\\n np.dot(Q, viexog))\\n\\n hess_fe -= fac * xtvix / rvir\\n\\n hess_re = hess_re - 0.5 * fac * (D/rvir - np.outer(B, B) / rvir**2)\\n\\n hess_fere = -fac * hess_fere / rvir\\n\\n if self.reml:\\n for j1 in range(self.k_re2):\\n Q1 = np.linalg.solve(xtvix, xtax[j1])\\n for j2 in range(j1 + 1):\\n Q2 = np.linalg.solve(xtvix, xtax[j2])\\n a = np.trace(np.dot(Q1, Q2))\\n a -= np.trace(np.linalg.solve(xtvix, F[j1][j2]))\\n a *= 0.5\\n hess_re[j1, j2] += a\\n if j1 > j2:\\n hess_re[j2, j1] += a\\n\\n # Put the blocks together to get the Hessian.\\n m = self.k_fe + self.k_re2\\n hess = np.zeros((m, m), dtype=np.float64)\\n hess[0:self.k_fe, 0:self.k_fe] = hess_fe\\n hess[0:self.k_fe, self.k_fe:] = hess_fere.T\\n hess[self.k_fe:, 0:self.k_fe] = hess_fere\\n hess[self.k_fe:, self.k_fe:] = hess_re\\n\\n return hess\",\n \"def dstrf_snapshots(rec, model_list, D=11, out_channel=0, time_step=85, snr_threshold=5):\\n t_indexes = np.arange(time_step, rec['stim'].shape[1], time_step)\\n dlc = rec['dlc'].as_continuous().T\\n log.info(f\\\"Computing dSTRF at {len(t_indexes)} timepoints, {dlc.shape[1]} DLC channels, t_step={time_step}\\\")\\n if rec.meta['batch'] in [346, 347]:\\n dicount=didx.shape[0]\\n else:\\n dicount=4\\n\\n dstrf = {}\\n mdstrf = np.zeros((len(model_list), dicount, rec['stim'].shape[0], D))\\n pc1 = np.zeros((len(model_list), dicount, rec['stim'].shape[0], D))\\n pc2 = np.zeros((len(model_list), dicount, rec['stim'].shape[0], D))\\n pc_count=3\\n pc_mag_all = np.zeros((len(model_list), dicount, pc_count))\\n for di in range(dicount):\\n dlc1 = dlc.copy()\\n dcount=dlc1.shape[1]\\n didx_ = adjust_didx(dlc, didx)\\n\\n for t in t_indexes:\\n dlc1[(t-didx_.shape[1]+1):(t+1), :] = didx_[di,:,:dcount]\\n log.info(f\\\"DLC values: {np.round(didx[di,-1,:dcount],3)}\\\")\\n #log.info(f'di={di} Applying HRTF for frozen DLC coordinates')\\n #rec2 = rec.copy()\\n #rec2['dlc'] = rec2['dlc']._modified_copy(data=dlc1.T)\\n #rec2 = free_tools.stim_filt_hrtf(rec2, hrtf_format='az', smooth_win=2,\\n # f_min=200, f_max=20000, channels=18)['rec']\\n\\n for mi, m in enumerate(model_list):\\n stim = {'stim': rec['stim'].as_continuous().T, 'dlc': dlc1}\\n dstrf[di] = m.dstrf(stim, D=D, out_channels=[out_channel], t_indexes=t_indexes)\\n\\n d = dstrf[di]['stim'][0, :, :, :]\\n\\n if snr_threshold is not None:\\n d = np.reshape(d, (d.shape[0], d.shape[1] * d.shape[2]))\\n md = d.mean(axis=0, keepdims=True)\\n e = np.std(d - md, axis=1) / np.std(md)\\n if (e > snr_threshold).sum() > 0:\\n log.info(f\\\"Removed {(e > snr_threshold).sum()}/{len(d)} noisy dSTRFs for PCA calculation\\\")\\n\\n d = dstrf[di]['stim'][0, (e <= snr_threshold), :, :]\\n mdstrf[mi, di, :, :] = d.mean(axis=0)\\n pc, pc_mag = dtools.compute_dpcs(d[np.newaxis, :, :, :], pc_count=pc_count)\\n pc1[mi, di, :, :] = pc[0, 0, :, :] * pc_mag[0, 0]\\n pc2[mi, di, :, :] = pc[0, 1, :, :] * pc_mag[1, 0]\\n pc_mag_all[mi, di, :] = pc_mag[:, 0]\\n return mdstrf, pc1, pc2, pc_mag_all\",\n \"def coadd(self, sp, method='pixel'):\\n\\t\\tif method == 'pixel':\\n\\t\\t\\tw1 = 1/self.oriNoise**2\\n\\t\\t\\tw2 = 1/sp.oriNoise**2\\n\\t\\t\\tself.oriFlux = (self.oriFlux*w1 + sp.oriFlux*w2)/(w1 + w2)\\n\\t\\t\\tself.oriNoise = np.sqrt(1/(w1 + w2))\\n\\t\\t\\t## set up masking criteria\\n\\t\\t\\tself.avgFlux = np.mean(self.oriFlux)\\n\\t\\t\\tself.stdFlux = np.std(self.oriFlux)\\n\\t\\t\\tself.smoothFlux = self.oriFlux\\n\\t\\t\\t## set the outliers as the flux below \\n\\t\\t\\tif self.apply_sigma_mask:\\n\\t\\t\\t\\tself.smoothFlux[self.smoothFlux <= self.avgFlux-2*self.stdFlux] = 0\\n\\t\\t\\t\\tself.mask = np.where(self.smoothFlux <= 0)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.mask = []\\n\\t\\t\\tself.wave = np.delete(self.oriWave, list(self.mask))\\n\\t\\t\\tself.flux = np.delete(self.oriFlux, list(self.mask))\\n\\t\\t\\tself.noise = np.delete(self.oriNoise, list(self.mask))\\n\\n\\t\\telif method == 'wavelength':\\n\\t\\t\\tself_supers = copy.deepcopy(self)\\n\\t\\t\\tg = interpolate.interp1d(self.wave, self.flux)\\n\\t\\t\\tsp_supers = copy.deepcopy(sp)\\n\\t\\t\\tf = interpolate.interp1d(sp.wave, sp.flux)\\n\\t\\t\\t## 10x supersample the average difference of \\n\\t\\t\\t## the wavelength\\n\\t\\t\\t#step0 = np.mean(np.diff(self.wave))/10\\n\\t\\t\\t#self_supers.wave = np.arange(self.wave[0],\\n\\t\\t\\t#\\tself.wave[-1],step0)\\n\\t\\t\\tself_supers.flux = g(self_supers.wave)\\n\\t\\t\\tself_supers.oriWave = np.arange(self.oriWave[0],\\n\\t\\t\\t\\tself.oriWave[-1],(self.oriWave[-1]-self.oriWave[0])/10240)\\n\\t\\t\\tg1 = interpolate.interp1d(self.oriWave, self.oriFlux)\\n\\t\\t\\tself_supers.oriFlux = g1(self_supers.oriWave)\\n\\n\\t\\t\\t#step = np.mean(np.diff(sp.wave))/10\\n\\t\\t\\t#sp_supers.wave = np.arange(sp.wave[0],sp.wave[-1],step)\\n\\t\\t\\t#sp_supers.flux = f(sp_supers.wave)\\n\\t\\t\\tsp_supers.oriWave = np.arange(sp.oriWave[0],\\n\\t\\t\\t\\tsp.oriWave[-1],(sp.oriWave[-1]-sp.oriWave[0])/10240)\\n\\t\\t\\tf1 = interpolate.interp1d(sp.oriWave, sp.oriFlux)\\n\\t\\t\\tsp_supers.oriFlux = f1(sp_supers.oriWave)\\n\\n\\t\\t\\t## calculate the max cross correlation value\\n\\t\\t\\tdef xcorr(a0,b0,shift):\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tShift is the index number after supersampling \\n\\t\\t\\t\\tboth of the spectra.\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\ta = copy.deepcopy(a0)\\n\\t\\t\\t\\tb = copy.deepcopy(b0)\\n\\n\\t\\t\\t\\t## shift the wavelength of b\\n\\t\\t\\t\\tlength = b.oriFlux.shape[0]\\n\\t\\t\\t\\tif shift >= 0:\\n\\t\\t\\t\\t\\tmask_a = np.arange(0,shift,1)\\n\\t\\t\\t\\t\\ta.oriFlux = np.delete(a.oriFlux,mask_a)\\n\\t\\t\\t\\t\\tmask_b = np.arange(length-1,length-shift-1,-1)\\n\\t\\t\\t\\t\\tb.oriFlux = np.delete(b.oriFlux,mask_b)\\n\\n\\t\\t\\t\\telif shift < 0:\\n\\t\\t\\t\\t\\tmask_a = np.arange(length-1,length+shift-1,-1)\\n\\t\\t\\t\\t\\ta.oriFlux = np.delete(a.oriFlux,mask_a)\\n\\t\\t\\t\\t\\tmask_b = np.arange(0,-shift,1)\\n\\t\\t\\t\\t\\tb.oriFlux = np.delete(b.oriFlux,mask_b)\\n\\n\\t\\t\\t\\t## shift the wavelength of b\\n\\t\\t\\t\\t#b.wave += shift * step\\n\\t\\t\\t\\t## discard the points where the wavelength values\\n\\t\\t\\t\\t## are larger\\n\\t\\t\\t\\t#condition = (a.wave > b.wave[0]) & (a.wave < b.wave[-1])\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t#a.flux = a.flux[np.where(condition)]\\n\\t\\t\\t\\t#a.wave = a.wave[np.where(condition)]\\n\\t\\t\\t\\t## resampling the telluric model\\n\\t\\t\\t\\t#b.flux = np.array(smart.integralResample(xh=b.wave, \\n\\t\\t\\t\\t#\\tyh=b.flux, xl=a.wave))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\treturn np.inner(a.oriFlux, b.oriFlux)/\\\\\\n\\t\\t\\t\\t(np.average(a.oriFlux)*np.average(b.oriFlux))/a.oriFlux.shape[0]\\n\\n\\t\\t\\txcorr_list = []\\n\\t\\t\\t## mask the ending pixels\\n\\t\\t\\tself_supers2 = copy.deepcopy(self_supers)\\n\\t\\t\\tsp_supers2 = copy.deepcopy(sp_supers)\\n\\t\\t\\tself_supers2.wave = self_supers2.wave[1000:-1000]\\n\\t\\t\\tself_supers2.flux = self_supers2.flux[1000:-1000]\\n\\t\\t\\tsp_supers2.wave = sp_supers2.wave[1000:-1000]\\n\\t\\t\\tsp_supers2.flux = sp_supers2.flux[1000:-1000]\\n\\t\\t\\tfor shift in np.arange(-10,10,1):\\n\\t\\t\\t\\txcorr_list.append(xcorr(self_supers2,sp_supers2,shift))\\n\\n\\t\\t\\t## dignostic plot for cc result\\n\\t\\t\\tfig, ax = plt.subplots()\\n\\t\\t\\tax.plot(np.arange(-10,10,1),np.array(xcorr_list),'k-')\\n\\t\\t\\tplt.show()\\n\\t\\t\\tplt.close()\\n\\n\\t\\t\\tstep = np.absolute(np.mean(np.diff(sp_supers.wave)))\\n\\t\\t\\tbestshift = np.arange(-10*step,10*step,step)[np.argmax(xcorr_list)]\\n\\t\\t\\tsp_supers.oriWave += bestshift\\n\\t\\t\\t## discard the points where the wavelength values\\n\\t\\t\\t## are larger\\n\\t\\t\\tcondition = (self.oriWave > sp_supers.oriWave[0])\\\\\\n\\t\\t\\t& (self.oriWave < sp_supers.oriWave[-1])\\n\\n\\t\\t\\tself.oriFlux = self.oriFlux[np.where(condition)]\\n\\t\\t\\tself.oriWave = self.oriWave[np.where(condition)]\\n\\t\\t\\tself.oriNoise = self.oriNoise[np.where(condition)]\\n\\t\\t\\tsp_supers.oriNoise = sp_supers.oriNoise[np.where(condition)]\\n\\t\\t\\tsp_supers.oriFlux = np.array(smart.integralResample(xh=sp_supers.oriWave, \\n\\t\\t\\t\\tyh=sp_supers.oriFlux, xl=self.oriWave))\\n\\n\\t\\t\\tw1 = 1/self.oriNoise**2\\n\\t\\t\\tw2 = 1/sp_supers.oriNoise**2\\n\\t\\t\\tself.oriFlux = (self.oriFlux*w1 + sp_supers.oriFlux*w2)/(w1 + w2)\\n\\t\\t\\tself.oriNoise = np.sqrt(1/(w1 + w2))\\n\\t\\t\\t## set up masking criteria\\n\\t\\t\\tself.avgFlux = np.mean(self.oriFlux)\\n\\t\\t\\tself.stdFlux = np.std(self.oriFlux)\\n\\t\\t\\tself.smoothFlux = self.oriFlux\\n\\t\\t\\t## set the outliers as the flux below \\n\\t\\t\\tself.smoothFlux[self.smoothFlux <= self.avgFlux-2*self.stdFlux] = 0\\n\\t\\t\\tself.mask = np.where(self.smoothFlux <= 0)\\n\\t\\t\\tself.wave = np.delete(self.oriWave, list(self.mask))\\n\\t\\t\\tself.flux = np.delete(self.oriFlux, list(self.mask))\\n\\t\\t\\tself.noise = np.delete(self.oriNoise, list(self.mask))\\n\\n\\t\\treturn self\",\n \"def update(self, newparams):\\n for k, v in list(newparams.items()):\\n if k in self.basis_params:\\n # Make sure parameter is in dict, and check if it changed\\n if k not in self.params:\\n self.basis_dirty = True\\n self.params[k] = v\\n if np.any(v != self.params.get(k)):\\n self.basis_dirty = True\\n else:\\n try:\\n # here the sps.params.dirtiness should increase to 2 if\\n # there was a change\\n self.ssp.params[k] = v[0]\\n except KeyError:\\n pass\\n # now update params\\n self.params[k] = np.copy(np.atleast_1d(v))\\n # if we changed only csp_params but are relying on COMPSP, make\\n # sure we remake the basis\\n if self.safe and (self.ssp.params.dirtiness == 1):\\n self.basis_dirty = True\\n # if we changed only csp_params propagate them through but don't\\n # force basis remake (unless basis_dirty)\\n if self.ssp.params.dirtiness == 1:\\n self.ssp._update_params()\\n\\n if self.basis_dirty | (self.ssp.params.dirtiness == 2):\\n self.build_basis()\",\n \"def loadData(fname='Unstra.out2.00008.athdf'):\\n #data=ath.athdf(fname,quantities=['B1','B2','B3'])\\n time,data=ath.athdf(fname,quantities=['Bcc1'])\\n bx = data['Bcc1']\\n time,data=ath.athdf(fname,quantities=['Bcc2'])\\n by = data['Bcc2']\\n time,data=ath.athdf(fname,quantities=['Bcc3'])\\n bz = data['Bcc3']\\n x = data['x1f']\\n y = data['x2f']\\n z = data['x3f']\\n # refinement\\n rfac = 1.0\\n ##if bx.shape[0] < 512:\\n ## nz,ny,nx = bx.shape\\n ## rfac = int(512/bx.shape[0])\\n ## bx = np.repeat(bx,rfac,axis=0)\\n ## bx = np.repeat(bx,rfac,axis=1)\\n ## bx = np.repeat(bx,rfac,axis=2)\\n ## by = np.repeat(by,rfac,axis=0)\\n ## by = np.repeat(by,rfac,axis=1)\\n ## by = np.repeat(by,rfac,axis=2)\\n ## bz = np.repeat(bz,rfac,axis=0)\\n ## bz = np.repeat(bz,rfac,axis=1)\\n ## bz = np.repeat(bz,rfac,axis=2)\\n # ---\\n def curl(vx,vy,vz,dx,dy,dz):\\n [dzvx,dyvx,dxvx] = np.gradient(vx)\\n [dzvy,dyvy,dxvy] = np.gradient(vy)\\n [dzvz,dyvz,dxvz] = np.gradient(vz)\\n cx = dyvz/dy-dzvy/dz\\n cy = dzvx/dz-dxvz/dx\\n cz = dxvy/dx-dyvx/dy\\n # No need to del the reference by one manually\\n # allow python to perform its own garbage collection\\n # after the function return cxyz\\n #del dzvx\\n #del dzvy\\n #del dzvz\\n return cx,cy,cz\\n # ---\\n dx = dz = (x[1]-x[0])/rfac\\n dy = (y[1]-y[0])/rfac\\n jx,jy,jz = curl(bx,by,bz,dx,dy,dz)\\n j2 = jx**2+jy**2+jz**2\\n return j2\",\n \"def reconstruct(self, my_data, my_suff_stat, model_params):\\n\\n my_x = my_data[\\\"x\\\"]\\n my_x_infr = my_data[\\\"x_infr\\\"]\\n lpj = my_suff_stat[\\\"lpj\\\"]\\n ss = my_suff_stat[\\\"ss\\\"] # is (my_N x S x H)\\n S_perm = my_suff_stat[\\\"S_perm\\\"]\\n\\n my_N, D = my_x.shape\\n B = np.minimum(self.B_max - lpj.max(axis=1), self.B_max_shft) # is: (my_N,)\\n pjc = np.exp(lpj + B[:, None]) # is: (my_N, S+H+1)\\n\\n modelmean = self.modelmean\\n\\n this_suff_stat = {}\\n if \\\"storage\\\" in my_suff_stat.keys():\\n this_suff_stat[\\\"storage\\\"] = my_suff_stat[\\\"storage\\\"]\\n\\n my_data[\\\"y_reconstructed\\\"] = my_data[\\\"y\\\"].copy()\\n my_y = my_data[\\\"y_reconstructed\\\"]\\n\\n for n in range(my_N):\\n this_x_infr = my_x_infr[n, :] # is (D,)\\n if np.logical_not(this_x_infr).all():\\n continue\\n\\n this_y = my_y[n, :] # is (D,)\\n this_x = my_x[n, :] # is (D,)\\n this_pjc = pjc[n, :] # is (S,)\\n this_ss = ss[n, :, :] # is (S, H)\\n\\n this_data = {\\\"y\\\": this_y, \\\"x\\\": this_x, \\\"x_infr\\\": this_x_infr}\\n this_suff_stat[\\\"ss\\\"] = this_ss\\n this_mu = modelmean(model_params, this_data, this_suff_stat) # is (D_miss, S)\\n\\n this_pjc_sum = this_pjc.sum()\\n\\n this_estimate = (this_mu * this_pjc[None, S_perm:]).sum(\\n axis=1\\n ) / this_pjc_sum # is (D_miss,)\\n this_y[np.logical_not(this_x)] = this_estimate\",\n \"def undulations(**kwargs):\\n\\n\\t#---parameters\\n\\tsn = kwargs['sn']\\n\\twork = kwargs['workspace']\\n\\tcalc = kwargs['calc']\\n\\tupname = 'lipid_abstractor'\\n\\tgrid_spacing = calc['specs']['grid_spacing']\\n\\tvecs = datmerge(kwargs,upname,'vecs')\\n\\tnframes = int(np.sum(datmerge(kwargs,upname,'nframes')))\\n\\ttrajectory = datmerge(kwargs,upname,'points')\\n\\tattrs,result = {},{}\\n\\t#---! hacking through error with monolayer separation\\n\\ttry: monolayer_indices = kwargs['upstream'][upname+'0']['monolayer_indices']\\n\\texcept: monolayer_indices = kwargs['upstream'][upname]['monolayer_indices']\\n\\t#---choose grid dimensions\\n\\tgrid = np.array([round(i) for i in np.mean(vecs,axis=0)/grid_spacing])[:2]\\n\\t#---! removed timeseries from result for new version of omnicalc\\n\\t#---parallel\\n\\tmesh = [[],[]]\\n\\tfor mn in range(2):\\n\\t\\tstart = time.time()\\n\\t\\tmesh[mn] = Parallel(n_jobs=work.nprocs,verbose=0,require='sharedmem')(\\n\\t\\t\\tdelayed(makemesh_regular)(\\n\\t\\t\\t\\ttrajectory[fr][np.where(monolayer_indices==mn)],vecs[fr],grid)\\n\\t\\t\\tfor fr in framelooper(nframes,start=start,text='monolayer %d, frame'%mn))\\n\\tchecktime()\\n\\n\\t#---pack\\n\\tresult['mesh'] = np.array(mesh)\\n\\tresult['grid'] = np.array(grid)\\n\\tresult['nframes'] = np.array(nframes)\\n\\tresult['vecs'] = vecs\\n\\tattrs['grid_spacing'] = grid_spacing\\n\\treturn result,attrs\",\n \"def getBarySamples(self):\\n self.XC1Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.XC2Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c1Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c2Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c3Fields = np.zeros([self.nSample, self.nCell_cfd])\\n\\n for isamp in np.arange(self.nSample):\\n TauNew = self.TauSample[isamp, :, :]\\n k,V1,V2,V3,C,NP = self.mapTau._tau2PhysParams(TauNew)\\n X = self.mapTau._C2X(C)\\n \\n self.c1Fields[isamp, :] = C[:, 0]\\n self.c2Fields[isamp, :] = C[:, 1]\\n self.c3Fields[isamp, :] = C[:, 2]\\n \\n \\n self.XC1Fields[isamp, :] = X[:, 0]\\n self.XC2Fields[isamp, :] = X[:, 1]\\n \\n # Get base C1 and C2 field\\n k,V1,V2,V3,C,NP = self.mapTau._tau2PhysParams(self.Taubar)\\n X = self.mapTau._C2X(C)\\n \\n self.c1Field_base = C[:, 0]\\n self.c2Field_base = C[:, 1]\\n self.c3Field_base = C[:, 2]\\n\\n self.XC1Field_base = X[:, 0]\\n self.XC2Field_base = X[:, 1] \\n\\n np.savetxt(self.resultDir+'RComponent_samples/XC1_s', self.XC1Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/XC2_s', self.XC2Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/XC1_base', self.XC1Field_base)\\n np.savetxt(self.resultDir+'RComponent_samples/XC2_base', self.XC2Field_base)\\n\\n np.savetxt(self.resultDir+'RComponent_samples/c1_s', self.c1Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/c2_s', self.c2Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/c3_s', self.c3Fields) \\n np.savetxt(self.resultDir+'RComponent_samples/c1_base', self.c1Field_base)\\n np.savetxt(self.resultDir+'RComponent_samples/c2_base', self.c2Field_base) \\n np.savetxt(self.resultDir+'RComponent_samples/c3_base', self.c3Field_base)\",\n \"def initialize_system(self):\\n self.mfd.set_mesh(self.mesh)\\n [[div_data, div_row, div_col], \\n [div_t_data, div_t_row, div_t_col]] = self.mfd.build_div()\\n [self.m_x_coo_data, \\n m_x_coo_row, \\n m_x_coo_col] = self.mfd.build_m(save_update_info=True)\\n\\n self.m_x_coo_length = len(self.m_x_coo_data)\\n \\n # The data for the bottom right should be zeros. \\n [c_data, c_row, c_col] = self.mfd.build_bottom_right()\\n \\n [coupling_data, coupling_row, coupling_col] = self.mfd.build_coupling_terms()\\n\\n self.div = sparse.coo_matrix((np.array(div_data), \\n (np.add(np.array(div_row), \\n -self.mesh.get_number_of_faces()), \\n np.array(div_col))))\\n self.div = self.div.tocsr()\\n\\n lhs_data = self.m_x_coo_data\\n lhs_row = m_x_coo_row\\n lhs_col = m_x_coo_col\\n \\n lhs_data += div_data\\n lhs_row += div_row\\n lhs_col += div_col\\n\\n lhs_data += div_t_data\\n lhs_row += div_t_row\\n lhs_col += div_t_col \\n \\n self.c_start = len(lhs_data)\\n \\n lhs_data += c_data\\n lhs_row += c_row\\n lhs_col += c_col \\n\\n self.c_end = len(c_data)\\n\\n lhs_data += coupling_data\\n lhs_row += coupling_row\\n lhs_col += coupling_col\\n\\n # Convert m_x_coo_data to numpy array. \\n self.m_x_coo_data = np.array(self.m_x_coo_data)\\n\\n self.lhs_coo = sparse.coo_matrix((np.array(lhs_data), \\n (np.array(lhs_row), \\n np.array(lhs_col))))\\n\\n # RHS construction is for Neumann and Dirichlet \\n # boundaries specified by the mesh. \\n self.rhs_mfd = self.mfd.build_rhs()\",\n \"def __init__(self, downsampling=False, wl_range = False, spectra_path = '/Users/kyleturner/Dropbox/My_Box/Code/M_Files/process_svc_v2p1/rrs_model_3C-master/spectra/'):\\n\\n\\t\\t\\ta_ph = pd.read_csv(spectra_path + 'phyto.A', skiprows=11, sep='\\\\t', index_col=0).iloc[:,0]\\n\\t\\t\\n\\t\\t\\ta_w = pd.read_csv(spectra_path + 'water.A', skiprows=10, sep='\\\\t', index_col=0).iloc[:,0]\\n\\t\\t\\tdaw_dT = pd.read_csv(spectra_path + 'daWdT.txt', skiprows=10, sep='\\\\t', index_col=0).iloc[:,0]\\n\\t\\t\\tastar_y = pd.read_csv(spectra_path + 'Y.A', skiprows=11, delimiter=' ', index_col=0).loc[350:].iloc[:,0]\\n\\n\\t\\t\\td = pd.DataFrame(index = a_ph.index)\\n\\t\\t\\td.index.name = 'Wavelength, [nm]'\\n\\t\\t\\td['astar_ph'] = a_ph\\n\\t\\t\\td['astar_y'] = astar_y \\n\\t\\t\\td['a_w'] = a_w \\n\\t\\t\\td['daw_dT'] = daw_dT\\n\\n\\t\\t\\tif downsampling == False:\\n\\t\\t\\t\\tself.spectra = d\\n\\t\\t\\telse: \\n\\t\\t\\t\\tself.spectra = d.apply(lambda x: pd.rolling_mean(x, downsampling, center=True))\\n\\n\\t\\t\\tif wl_range != False:\\n\\t\\t\\t\\tself.spectra = self.spectra.loc[wl_range[0]:wl_range[1]].dropna()\\n\\n\\t\\t\\tself.wl = np.array(self.spectra.index)\\n\\t\\t\\t\\t\\n\\t\\t\\tself.model = self._compile_model()\",\n \"def returnMSSFR(self, metallicity=None, agesBirth=None, redshiftBirth=None):\\n # find the bin number\\n lowerBinNr = np.where(self.metallicityGrid == metallicity)[0][0]\\n\\n #we will only calculate the systems of which ages\\n # and redshifts are not -1 (flagged as born too soon)\\n mask = agesBirth != -1\\n #independent of metallicity so we can do all at once\\n SFR = np.zeros(len(agesBirth))\\n SFR[mask] = self.returnSFR(redshiftBirth[mask], agesBirth[mask])\\n #The calculation of the fraction is done such that it does \\n #a single metallicity bin at the time\\n fractions = np.zeros(len(agesBirth))\\n\\n Zlower = self.metallicityBinEdges[lowerBinNr]\\n Zupper = self.metallicityBinEdges[lowerBinNr+1]\\n if self.Zprescription == 'MZ_GSMF':\\n fractions[mask] = self.returnFractionMZ_GSMF(Zlower, Zupper, redshiftBirth[mask])\\n elif self.Zprescription == 'logNormal':\\n fractions[mask] = self.returnFractionLogNormal(Zlower, Zupper, redshiftBirth[mask])\\n else:\\n raise ValueError(\\\"self.Zprescription not recognized, MZ_GSMF or logNormal?\\\")\\n #Always raise an error if the fraction is unphysical\\n if ((fractions>1).any()) or ((fractions<0).any()):\\n raise ValueError(\\\"unphysical SFR fraction check metallicity binning limits\\\")\\n #i.e. if system is born before first star formation (z=-1)\\n #we set the rate to zero\\n MSSFR = np.multiply(SFR, fractions)\\n return MSSFR\",\n \"def ofdm_demodulate(sys_parameters, waveform_info, tx_wave):\\n # Get dimensionality information derived from the system parameters\\n waveform_info.set_info(sys_parameters)\\n # Cache the main dims\\n nsc = waveform_info.nsubcarriers\\n nfft = waveform_info.nfft\\n cp_lengths = waveform_info.cyclic_prefix_lengths\\n symbols_per_slot = waveform_info.symbols_per_slot\\n # Use numpy.array to express the rxWaveform\\n rxwave = np.array(tx_wave)\\n rxant = np.shape(rxwave)[1]\\n rx_grid = np.zeros((nsc, symbols_per_slot, rxant), dtype=complex)\\n # Calculate position of the first active subcarrier in the FFT output,\\n # according to the FFT size and the number of active subcarriers\\n first_activesc = int((nfft - nsc) / 2)\\n # Demodulate all symbols within the input data\\n cpres = cp_lengths[0] - cp_lengths[1]\\n # The same as the MATLAB operation : rxwave[0:cpres, :] = []\\n rxwave = np.delete(rxwave, range(cpres), 0)\\n rxwave = np.reshape(rxwave, (-1, symbols_per_slot, rxant), order=\\\"F\\\")\\n # The same as the MATLAB operation : rxwave[0:cp_lengths[1], :, :] = []\\n rxwave = np.delete(rxwave, range(cp_lengths[1]), 0)\\n for symbol in range(symbols_per_slot):\\n for rr in range(rxant):\\n in_list = rxwave[:, symbol, rr]\\n # rxwave is the numpy.array, just div the value\\n fft_output = spy.fftpack.fftshift(spy.fft.fft(in_list)) / math.sqrt(nfft)\\n rx_grid[:, symbol, rr] = fft_output[first_activesc : (first_activesc + nsc)]\\n return rx_grid\",\n \"def joss(sync, freq = 20, window_size = 8, shift = 4, errors=False):\\n\\n freq = 20\\n\\n ppg = sync.getSyncedPPG().resample(freq)\\n accel_x = sync.getSyncedAcceleration('x').resample(freq)[:ppg.size]\\n accel_y = sync.getSyncedAcceleration('y').resample(freq)[:ppg.size]\\n accel_z = sync.getSyncedAcceleration('z').resample(freq)[:ppg.size]\\n ecg = sync.getSyncedECG()\\n\\n \\n ppg = filtering.butter_bandpass_filter(ppg, 0.4, 4, 4)\\n accel_x = filtering.butter_bandpass_filter(accel_x, 0.4, 4, 4)\\n accel_y = filtering.butter_bandpass_filter(accel_y, 0.4, 4, 4)\\n accel_z = filtering.butter_bandpass_filter(accel_z, 0.4, 4, 4)\\n\\n hr = []\\n\\n eng = matlab.engine.start_matlab()\\n\\n loc = 121\\n bpm = 121\\n trap_count = 0\\n\\n if errors:\\n error_list = []\\n\\n\\n # Iterate through windows\\n start = 0\\n while (start + window_size) * freq < ppg.size:\\n window = np.arange(start * freq, (start+window_size) * freq, 1)\\n\\n spectrum, accel_max = joss_ssr(ppg[window].normalize(), accel_x[window].normalize(), \\n accel_y[window].normalize(), accel_z[window].normalize(), eng)\\n\\n if DEBUG:\\n print(\\\"At start={}, loc={} bpm={} trap_count={} spectrum_shape={}\\\".format(start, \\n loc, bpm, trap_count, spectrum.shape))\\n ecg_bpm = get_ecg_bpm(ecg, start, window_size)\\n print(\\\"ECG bpm = {}\\\".format(ecg_bpm))\\n plt.subplot(224)\\n plt.plot(spectrum)\\n plt.title(\\\"PPG\\\")\\n plt.gca().axvline(x=ecg_bpm, color='r')\\n plt.show()\\n\\n loc, bpm, trap_count = joss_spt(spectrum, freq, loc, bpm, trap_count)\\n\\n\\n if errors:\\n try:\\n ecg_bpm = get_ecg_bpm(ecg, start, window_size)\\n error = bpm - ecg_bpm\\n error_list.append(error)\\n except:\\n print(\\\"Error with HR calculation\\\")\\n \\n\\n \\n\\n\\n hr.append(bpm)\\n\\n start += shift \\n\\n eng.quit()\\n\\n if errors:\\n return error_list\\n\\n return np.array(hr)\",\n \"def SC_generation(hourly_radiation, prop_observers, number_groups, weather_data, g, Sz, Az, ha, Tin_C, height,\\n panel_properties, latitude):\\n\\n\\n n0 = panel_properties['n0']\\n c1 = panel_properties['c1']\\n c2 = panel_properties['c2']\\n mB0_r = panel_properties['mB0_r']\\n mB_max_r = panel_properties['mB_max_r']\\n mB_min_r = panel_properties['mB_min_r']\\n C_eff = panel_properties['C_eff']\\n t_max = panel_properties['t_max']\\n IAM_d = panel_properties['IAM_d']\\n Aratio = panel_properties['aperture_area_ratio']\\n Apanel = panel_properties['module_area']\\n dP1 = panel_properties['dP1']\\n dP2 = panel_properties['dP2']\\n dP3 = panel_properties['dP3']\\n dP4 = panel_properties['dP4']\\n Cp_fluid_JperkgK = panel_properties['Cp_fluid'] # J/kgK\\n\\n # create lists to store results\\n list_results = [None] * number_groups\\n list_areas_groups = [None] * number_groups\\n Sum_mcp_kWperC = np.zeros(8760)\\n Sum_qout_kWh = np.zeros(8760)\\n Sum_Eaux_kWh = np.zeros(8760)\\n Sum_qloss = np.zeros(8760)\\n Sum_radiation_kWh = np.zeros(8760)\\n\\n Tin_array_C = np.zeros(8760) + Tin_C\\n aperature_area_per_module = Aratio * Apanel\\n total_area_module = prop_observers['total_area_module'].sum() # total area for panel installation\\n\\n # calculate equivalent length of pipes\\n lv = panel_properties['module_length'] # module length\\n number_modules = round(total_area_module/Apanel) # this is an estimation\\n l_ext_mperm2 = (2 * lv * number_modules/ (total_area_module * Aratio)) # pipe length within the collectors\\n l_int_mperm2 = 2 * height / (total_area_module * Aratio) # pipe length from building substation to roof top collectors\\n Leq_mperm2 = l_int_mperm2 + l_ext_mperm2 # in m/m2 aperture\\n\\n if panel_properties['type'] == 'ET': # for evacuated tubes\\n Nseg = 100 # default number of subsdivisions for the calculation\\n else:\\n Nseg = 10 # default number of subsdivisions for the calculation\\n\\n for group in range(number_groups):\\n # load panel angles from group\\n teta_z = prop_observers.loc[group, 'surface_azimuth'] # azimuth of panels of group\\n area_per_group = prop_observers.loc[group, 'total_area_module']\\n tilt_angle_deg = prop_observers.loc[group, 'tilt'] # tilt angle of panels\\n\\n # create dataframe with irradiation from group\\n\\n radiation_Wh = pd.DataFrame({'I_sol': hourly_radiation[group]})\\n radiation_Wh['I_diffuse'] = weather_data.ratio_diffhout * radiation_Wh.I_sol # calculate diffuse radiation\\n radiation_Wh['I_direct'] = radiation_Wh['I_sol'] - radiation_Wh['I_diffuse'] # calculate direct radiation\\n radiation_Wh.fillna(0, inplace=True) # set nan to zero\\n\\n # calculate incidence angle modifier for beam radiation\\n IAM_b = calc_IAM_beam_SC(Az, g, ha, teta_z, tilt_angle_deg, panel_properties['type'], Sz, latitude)\\n\\n # calculate heat production from a solar collector of each group\\n list_results[group] = calc_SC_module(tilt_angle_deg, IAM_b, IAM_d, radiation_Wh.I_direct,\\n radiation_Wh.I_diffuse, weather_data.drybulb_C, n0,\\n c1, c2, mB0_r, mB_max_r, mB_min_r, C_eff, t_max,\\n aperature_area_per_module, dP1, dP2, dP3, dP4,\\n Cp_fluid_JperkgK, Tin_C, Leq_mperm2, l_ext_mperm2,\\n l_int_mperm2, Nseg)\\n\\n\\n # multiplying the results with the number of panels in each group and write to list\\n number_modules_per_group = area_per_group / Apanel\\n list_areas_groups[group] = area_per_group\\n radiation_array = hourly_radiation[group] * list_areas_groups[group] / 1000 # kWh\\n Sum_qout_kWh = Sum_qout_kWh + list_results[group][1] * number_modules_per_group\\n Sum_Eaux_kWh = Sum_Eaux_kWh + list_results[group][2] * number_modules_per_group\\n Sum_qloss = Sum_qloss + list_results[group][0] * number_modules_per_group\\n Sum_mcp_kWperC = Sum_mcp_kWperC + list_results[group][5] * number_modules_per_group\\n Sum_radiation_kWh = Sum_radiation_kWh + radiation_Wh['I_sol']*area_per_group/1000\\n\\n Tout_group_C = (Sum_qout_kWh / Sum_mcp_kWperC) + Tin_C # in C assuming all collectors are connected in parallel\\n\\n Final = pd.DataFrame(\\n {'Q_SC_gen_kWh': Sum_qout_kWh, 'T_SC_sup_C': Tin_array_C, 'T_SC_re_C': Tout_group_C, 'mcp_SC_kWperC': Sum_mcp_kWperC, 'Eaux_SC_kWh': Sum_Eaux_kWh,\\n 'Q_SC_l_kWh': Sum_qloss, 'Area_SC_m2': sum(list_areas_groups), 'radiation_kWh': Sum_radiation_kWh}, index=range(8760))\\n\\n return list_results, Final\",\n \"def prepare_fg(\\n self, times, wavelength, spectra, stellar, intensities, telluric, area=None\\n ):\\n\\n if area is None:\\n orb = Orbit(self.star, self.planet)\\n area = orb.stellar_surface_covered_by_planet(times)\\n\\n model = stellar * telluric\\n\\n # Normalize the profile of the observations\\n profile = np.nanmean(spectra, axis=1)\\n model_profile = np.nanmean(model, axis=1)\\n norm = profile / model_profile\\n\\n # Normalize the spectrum\\n # model = stellar * telluric * norm[:, None]\\n # profile = np.median(spectra, axis=0)\\n # model_profile = np.median(model, axis=0)\\n\\n # nm = np.nanmedian(profile / model_profile)\\n # norm *= nm\\n\\n # model = stellar * telluric * norm[:, None]\\n # diff = spectra - model\\n\\n # model = np.nanmedian(spectra, axis=0)\\n\\n # f = -(\\n # # np.nan_to_num(intensities) *\\n # self.area_atmosphere\\n # / self.area_planet\\n # * area[:, None]\\n # # * np.nan_to_num(telluric, nan=1)\\n # * norm[:, None]\\n # )\\n # f = np.nan_to_num(intensities) * np.nan_to_num(telluric, nan=1) * norm[:, None]\\n area *= self.area_atmosphere / self.area_planet\\n f = -np.nan_to_num(intensities, nan=1) * area[:, None]\\n if hasattr(f, \\\"to_value\\\"):\\n f = f.to_value(1)\\n\\n # g = spectra - stellar * telluric * norm[:, None]\\n # if self.n_sysrem is not None:\\n # g = sysrem(g, self.n_sysrem)\\n\\n g = spectra\\n if self.n_sysrem is not None:\\n # Use SVD directly instead of Sysrem\\n g = sysrem(spectra, self.n_sysrem)\\n # u, s, vh = np.linalg.svd(spectra, full_matrices=False)\\n # s[: self.n_sysrem] = 0\\n # s[80:] = 0\\n # ic = (u * s) @ vh\\n # g = ic\\n else:\\n # g = spectra - stellar * telluric * norm[:, None]\\n gen = np.random.default_rng()\\n tmp = sysrem(spectra, 5)\\n g = gen.normal(\\n loc=np.nanmean(tmp), scale=np.nanstd(tmp), size=spectra.shape\\n )\\n # g *= np.nanstd() # std of random is 1 (in theory)\\n\\n # norm = np.nanstd(g, axis=0)\\n # f /= norm\\n # g /= norm\\n\\n # plt.imshow(g, aspect=\\\"auto\\\", origin=\\\"lower\\\")\\n # plt.xlabel(\\\"Wavelength\\\")\\n # plt.ylabel(\\\"Time\\\")\\n # plt.title(f\\\"N_Sysrem: {self.n_sysrem}\\\")\\n # plt.savefig(f\\\"spectra_sysrem_{self.n_sysrem}.png\\\")\\n\\n return wavelength, f, g\",\n \"def filterSTRF(specgram, rates=[1, 2, 4, 8, 16, 32], scales=[0.5, 1, 2, 4, 8], fl=8, tc=8, fac=-2, shift=0, full_T=0, full_X=0, BP=0):\\n\\n K1 = len(rates)\\n K2 = len(scales)\\n (N, M) = specgram.shape\\n global lastN, lastM\\n lastN, lastM = N, M\\n N1 = int(2**np.ceil(np.log2(N)))\\n N2 = 2*N1\\n M1 = int(2**np.ceil(np.log2(M)))\\n M2 = 2*M1\\n # 2D FT of specgram to perform rate/scale filter in secgram-freq domain\\n Y = np.fft.fft2(specgram,s=(N2,M2))[:,0:M1]\\n STF = 1000.0 / fl # frame per second\\n SRF = 24 # channel per octave (fixed)\\n\\n # freq. index\\n dM = int(float(M)/2*full_X)\\n mdx1 = np.hstack((np.arange(dM)+M2-dM, np.arange(M)+dM))\\n # temp. index\\n dN = int(float(N)/2*full_T)\\n ndx = np.arange(N)+2*dN\\n ndx1 = ndx\\n z = np.zeros((N+2*dN, M+2*dM), dtype='complex128')\\n cr = np.zeros((K2, K1*2, N+2*dN, M+2*dM), dtype='complex128')\\n for rdx in range(K1):\\n # rate filtering\\n fc_rt = rates[rdx]\\n HR = temporal_filter(fc_rt, N1, STF, [1+rdx+BP, K1+BP*2])\\n for sgn in (1, -1):\\n # rate filtering modification\\n if sgn > 0:\\n HR = np.hstack((HR, np.zeros(N1)))\\n else:\\n HR = np.hstack( (HR[0], np.conj(HR[N2:0:-1])) )\\n if N2 > 2:\\n \\tHR[N1] = np.abs(HR[N1+1]) \\n # first inverse fft (w.r.t. time axis)\\n z1 = HR[:,None] * Y\\n z1 = np.fft.ifft(z1,axis=0)\\n z1 = z1[ndx1,:]\\n for sdx in range(K2):\\n # scale filtering\\n fc_sc = scales[sdx]\\n HS = frequency_filter(fc_sc, M1, SRF, [1+sdx+BP, K2+BP*2])\\n \\n # second inverse fft (w.r.t frequency axis)\\n z[ndx,:] = np.fft.ifft(z1*HS,axis=1,n=M2)[ndx[:,None],mdx1]\\n cr[sdx, rdx+(sgn==1)*K1, :, :] = z\\n return cr\",\n \"def plot_sed(self, sax, rax, nufnu=True, microns=True):\\n wc = 10**(4 * microns)\\n\\n # --- Data ---\\n pmask = self.obs[\\\"phot_mask\\\"]\\n ophot, ounc = self.obs[\\\"maggies\\\"][pmask], self.obs[\\\"maggies_unc\\\"][pmask]\\n owave = np.array([f.wave_effective for f in self.obs[\\\"filters\\\"]])[pmask]\\n phot_width = np.array([f.effective_width for f in self.obs[\\\"filters\\\"]])[pmask]\\n maxw, minw = np.max(owave + phot_width) * 1.02, np.min(owave - phot_width) / 1.02\\n phot_width /= wc\\n if nufnu:\\n _, ophot = to_nufnu(owave, ophot, microns=microns)\\n owave, ounc = to_nufnu(owave, ounc, microns=microns)\\n renorm = 1 / np.mean(ophot)\\n\\n # --- posterior samples ---\\n if self.n_seds > 0:\\n self.spec_wave = self.sps.wavelengths * (1 + self.model.params[\\\"zred\\\"])\\n ckw = dict(minw=minw, maxw=maxw, R=500*2.35, nufnu=nufnu, microns=microns)\\n if nufnu:\\n swave, spec_best = convolve_spec(self.spec_wave, [self.spec_best], **ckw)\\n twave, spec_true = convolve_spec(self.spec_wave, [self.obs[\\\"true_spectrum\\\"]], **ckw)\\n pwave, phot_best = to_nufnu(self.obs[\\\"phot_wave\\\"], self.phot_best)\\n pwave, phot = to_nufnu(self.obs[\\\"phot_wave\\\"], self.phot_samples)\\n else:\\n twave, spec_true = self.spec_wave, self.obs[\\\"true_spectrum\\\"]\\n phot, phot_best = self.phot_samples, self.phot_best\\n\\n # --- plot spec & phot samples ---\\n self.bkwargs = dict(alpha=0.8, facecolor=self.pkwargs[\\\"color\\\"], edgecolor=\\\"k\\\")\\n self.art[\\\"sed_post\\\"] = Patch(**self.bkwargs)\\n widths = 0.1 * owave # phot_width\\n boxplot((phot * renorm).T, owave, widths, ax=sax, **self.bkwargs)\\n sax.plot(twave, spec_true * renorm, **self.lkwargs, label=r\\\"True spectrum\\\")\\n\\n # --- plot residuals ---\\n if rax is not None:\\n chi = (ophot - phot_best) / ounc\\n rax.plot(owave, chi, **self.dkwargs)\\n rax.axhline(0, linestyle=\\\":\\\", color=\\\"black\\\")\\n\\n # --- plot data ---\\n sax.errorbar(owave, ophot * renorm, ounc * renorm, color=\\\"k\\\", linestyle=\\\"\\\", linewidth=2)\\n sax.plot(owave, ophot * renorm, **self.dkwargs)\\n\\n # --- prettify ---\\n if self.nufnu:\\n sax.set_ylim(1.3e-13 * renorm, 0.7e-12 * renorm)\\n else:\\n sax.set_ylim(3e-9 * renorm, 1e-7 * renorm)\\n sax.set_xlim(minw / wc, maxw / wc)\\n sax.set_xscale(\\\"log\\\")\\n sax.set_yscale(\\\"log\\\")\\n sax.set_ylabel(r\\\"$\\\\nu f_\\\\nu \\\\times {\\\\rm Constant}$\\\", fontsize=20)\\n sax.set_xticklabels([])\\n sax.set_yticks([0.4, 0.6, 1.0, 1.5])\\n sax.yaxis.set_major_formatter(ticker.StrMethodFormatter(\\\"{x:0.1f}\\\"))\\n\\n rax.set_ylim(-2.8, 2.8)\\n rax.set_ylabel(r\\\"$\\\\chi_{\\\\rm best}$\\\", fontsize=20)\\n rax.set_xlabel(r\\\"$\\\\lambda_{\\\\rm obs}$ ($\\\\mu$m)\\\", fontsize=20)\\n wpos = [0.2, 0.5, 1.0, 1.5]\\n rax.set_xticks(wpos)\\n rax.xaxis.set_major_formatter(ticker.StrMethodFormatter(\\\"{x:0.1f}\\\"))\",\n \"def SOSS_psf_cube(filt='CLEAR', order=1, subarray='SUBSTRIP256', generate=False):\\n if generate:\\n\\n print('Coffee time! This takes about 5 minutes.')\\n\\n # Get the wavelengths\\n wavelengths = np.mean(utils.wave_solutions(subarray), axis=1)[:2 if filt == 'CLEAR' else 1]\\n coeffs = trace_polynomials(subarray)\\n\\n # Get the file\\n psf_path = 'files/SOSS_{}_PSF.fits'.format(filt)\\n psf_file = resource_filename('awesimsoss', psf_path)\\n\\n # Load the SOSS psf cube\\n cube = fits.getdata(psf_file).swapaxes(-1, -2)\\n wave = fits.getdata(psf_file, ext=1)\\n\\n # Initilize interpolator\\n psfs = interp1d(wave, cube, axis=0, kind=3)\\n trace_cols = np.arange(2048)\\n\\n # Run datacube\\n for n, wavelength in enumerate(wavelengths):\\n\\n # Evaluate the trace polynomial in each column to get the y-position of the trace center\\n trace_centers = np.polyval(coeffs[n], trace_cols)\\n\\n # Don't calculate order2 for F277W or order 3 for either\\n if (n == 1 and filt.lower() == 'f277w') or n == 2:\\n pass\\n\\n else:\\n\\n # Get the psf for each column\\n print('Calculating order {} SOSS psfs for {} filter...'.format(n+1, filt))\\n start = time.time()\\n pool = multiprocessing.Pool(8)\\n func = partial(get_SOSS_psf, filt=filt, psfs=psfs)\\n raw_psfs = np.array(pool.map(func, wavelength))\\n pool.close()\\n pool.join()\\n del pool\\n print('Finished in {} seconds.'.format(time.time()-start))\\n\\n # Get the PSF tilt at each column\\n angles = psf_tilts(order)\\n\\n # Rotate the psfs\\n print('Rotating order {} SOSS psfs for {} filter...'.format(n+1, filt))\\n start = time.time()\\n pool = multiprocessing.Pool(8)\\n func = partial(rotate, reshape=False)\\n rotated_psfs = np.array(pool.starmap(func, zip(raw_psfs, angles)))\\n pool.close()\\n pool.join()\\n del pool\\n print('Finished in {} seconds.'.format(time.time()-start))\\n\\n # Scale psfs to 1\\n rotated_psfs = np.abs(rotated_psfs)\\n scale = np.nansum(rotated_psfs, axis=(1, 2))[:, None, None]\\n rotated_psfs = rotated_psfs/scale\\n\\n # Split it into 4 chunks to be below Github file size limit\\n chunks = rotated_psfs.reshape(4, 512, 76, 76)\\n for N, chunk in enumerate(chunks):\\n\\n idx0 = N*512\\n idx1 = idx0+512\\n centers = trace_centers[idx0:idx1]\\n\\n # Interpolate the psfs onto the subarray\\n print('Interpolating chunk {}/4 for order {} SOSS psfs for {} filter onto subarray...'.format(N+1, n+1, filt))\\n start = time.time()\\n pool = multiprocessing.Pool(8)\\n data = zip(chunk, centers)\\n subarray_psfs = pool.starmap(put_psf_on_subarray, data)\\n pool.close()\\n pool.join()\\n del pool\\n print('Finished in {} seconds.'.format(time.time()-start))\\n\\n # Get the filepath\\n filename = 'files/SOSS_{}_PSF_order{}_{}.npy'.format(filt, n+1, N+1)\\n file = resource_filename('awesimsoss', filename)\\n\\n # Delete the file if it exists\\n if os.path.isfile(file):\\n os.system('rm {}'.format(file))\\n\\n # Write the data\\n np.save(file, np.array(subarray_psfs))\\n\\n print('Data saved to', file)\\n\\n else:\\n\\n # Get the chunked data and concatenate\\n full_data = []\\n for chunk in [1, 2, 3, 4]:\\n path = 'files/SOSS_{}_PSF_order{}_{}.npy'.format(filt, order, chunk)\\n file = resource_filename('awesimsoss', path)\\n full_data.append(np.load(file))\\n\\n return np.concatenate(full_data, axis=0)\",\n \"def combine_data(self):\\n\\t\\tself.Full_E = None\\n\\t\\tself.Imaginary_Spectrum = None\\n\\t\\tif self.raw_file is not None:\\n\\t\\t\\tlogger.info(\\\"Convert to scattering factors\\\")\\n\\t\\t\\tself.NearEdgeData = data.convert_data(self.raw_file,self.DataTypeCombo.GetValue(),'ASF')\\n#\\t\\t\\tif self.InvertDataCheckBox.GetValue():\\n#\\t\\t\\t\\tself.NearEdgeData[:,1] = numpy.abs(self.NearEdgeData[:,1] - 2*numpy.mean(self.NearEdgeData[:,1]))\\n\\t\\tlogger.info(\\\"Combine Data\\\")\\n\\t\\t# Get splice points\\n\\t\\tsplice_eV = numpy.array([10.0, 30000.0]) # Henke limits\\n\\t\\tif self.SpliceText1.GetValue() == \\\"Start\\\":\\n\\t\\t\\tif self.raw_file is not None:\\n\\t\\t\\t\\tsplice_eV[0] = self.NearEdgeData[0, 0]\\n\\t\\telse:\\n\\t\\t\\tsplice_eV[0] = float(self.SpliceText1.GetValue())\\n\\t\\tif self.SpliceText2.GetValue() == \\\"End\\\":\\n\\t\\t\\tif self.raw_file is not None:\\n\\t\\t\\t\\tsplice_eV[1] = self.NearEdgeData[-1, 0]\\n\\t\\telse:\\n\\t\\t\\tsplice_eV[1] = float(self.SpliceText2.GetValue())\\n\\t\\tif self.raw_file is not None and self.ASF_Data is None:\\n\\t\\t\\tself.Full_E, self.Imaginary_Spectrum, self.NearEdgeData, self.splice_ind = data.merge_spectra(self.NearEdgeData, self.ASF_E, self.ASF_Data, merge_points=splice_eV, add_background=self.AddBackgroundCheckBox.GetValue(), plotting_extras=True)\\n\\n\\t\\telif self.raw_file is None and self.ASF_Data is not None:\\n\\t\\t\\tself.Full_E = self.ASF_E\\n\\t\\t\\tself.Imaginary_Spectrum = self.ASF_Data\\n\\n\\t\\telif self.raw_file is not None and self.ASF_Data is not None:\\n\\t\\t\\t\\n\\t\\t\\tself.Full_E, self.Imaginary_Spectrum, self.NearEdgeData, self.splice_ind = data.merge_spectra(self.NearEdgeData, self.ASF_E, self.ASF_Data, merge_points=splice_eV, add_background=self.AddBackgroundCheckBox.GetValue(), fix_distortions=self.FixDistortionsCheckBox.GetValue(), plotting_extras=True)\\n\\n\\t\\t\\t### get start and end Y values from nexafs and asf data\\n\\t\\t\\t##splice_nexafs_Im = numpy.interp(splice_eV, raw_Im[:, 0], raw_Im[:, 1])\\n\\t\\t\\t###splice_asf_Im = numpy.interp(splice_eV, self.total_asf[:, 0], self.total_asf[:, 2])\\n\\t\\t\\t##splice_asf_Im = (data.coeffs_to_ASF(splice_eV[0],self.total_Im_coeffs[numpy.where(self.total_E<splice_eV[0])[0][-1]]),data.coeffs_to_ASF(splice_eV[1],self.total_Im_coeffs[numpy.where(self.total_E<splice_eV[1])[0][-1]]))\\n\\t\\t\\t##cut_boolean = (splice_eV[0]<raw_Im[:, 0]) == (raw_Im[:, 0]<splice_eV[1])\\n\\t\\t\\t### Merge Y values\\n\\t\\t\\t##if not self.AddBackgroundCheckBox.GetValue():\\n\\t\\t\\t\\t##logger.info(\\\"Merge data sets\\\")\\n\\t\\t\\t\\t##scale = (splice_asf_Im[1]-splice_asf_Im[0])/(splice_nexafs_Im[1]-splice_nexafs_Im[0])\\n\\t\\t\\t\\t##scaled_nexafs_Im = ((raw_Im[:, 1]-splice_nexafs_Im[0])*scale)+splice_asf_Im[0]\\n\\t\\t\\t\\t##self.asf_bg = None # We won't be using this variable this time\\n\\t\\t\\t##else:\\n\\t\\t\\t\\t##logger.info(\\\"Add data sets (this will currently only work at energies below 30 keV)\\\")\\n\\t\\t\\t\\t### Set up background function\\n\\t\\t\\t\\t### We trust this point to be just before the absorption edge\\n\\t\\t\\t\\t##trusted_ind = max(0, numpy.where(self.total_asf[:, 0]>splice_eV[0])[0][0]-1)\\n\\t\\t\\t\\t##Log_total_asf = numpy.log(self.total_asf[:, 2])\\n\\t\\t\\t\\t### Lets trust the 5 points before our trusted point and make an initial guess at the background function\\n\\t\\t\\t\\t##p = numpy.polyfit(self.total_asf[(trusted_ind-5):trusted_ind, 0], Log_total_asf[(trusted_ind-5):trusted_ind], 1)\\n\\t\\t\\t\\t### Now lets look for the points up util the absorption edge\\n\\t\\t\\t\\t##p_vals = numpy.exp(numpy.polyval(p, self.total_asf[(trusted_ind-5):-1, 0]))\\n\\t\\t\\t\\t##p_err = max(p_vals[0:5]-self.total_asf[(trusted_ind-5):trusted_ind, 2])\\n\\t\\t\\t\\t##edge_ind = numpy.where(self.total_asf[trusted_ind:-1, 2]-p_vals[4:-1]>p_err*10)\\n\\t\\t\\t\\t##if len(edge_ind[0])!=0:\\n\\t\\t\\t\\t\\t##edge_ind = edge_ind[0][0]\\n\\t\\t\\t\\t##else:\\n\\t\\t\\t\\t\\t##edge_ind = trusted_ind\\n\\t\\t\\t\\t### Redo background using the 5 points before the background point\\n\\t\\t\\t\\t##p = numpy.polyfit(self.total_asf[(trusted_ind+edge_ind-5):trusted_ind+edge_ind, 0], Log_total_asf[(trusted_ind+edge_ind-5):trusted_ind+edge_ind], 1)\\n\\t\\t\\t\\t##asf_bg = numpy.exp(numpy.polyval(p, raw_Im[:, 0]))\\n\\t\\t\\t\\t##logger.info(\\\"Background defined as: y=exp(%(p1)ex %(p0)+e)\\\" % {\\\"p1\\\":p[1], \\\"p0\\\":p[0]})\\n\\t\\t\\t\\t### Apply background function\\n\\t\\t\\t\\t##scale = (splice_asf_Im[1]-numpy.exp(numpy.polyval(p, splice_eV[1])))/splice_nexafs_Im[1]\\n\\t\\t\\t\\t##scaled_nexafs_Im = raw_Im[:, 1]*scale+asf_bg\\n\\t\\t\\t\\t### store background data for plotting\\n\\t\\t\\t\\t##cut_boolean_wide = numpy.roll(cut_boolean, -1) + numpy.roll(cut_boolean, 1)\\n\\t\\t\\t\\t##self.asf_bg = [[trusted_ind+edge_ind-5, trusted_ind+edge_ind], numpy.vstack((raw_Im[cut_boolean_wide, 0], asf_bg[cut_boolean_wide])).T]\\n\\t\\t\\t\\n\\t\\t\\t##nexafs_cut = numpy.vstack((raw_Im[cut_boolean, 0], scaled_nexafs_Im[cut_boolean])).T\\n\\t\\t\\t####Merge point-wise data sets together\\n\\t\\t\\t##asf_cut_high = self.total_asf[self.total_asf[:, 0]>splice_eV[1], :]\\n\\t\\t\\t##asf_cut_low = self.total_asf[self.total_asf[:, 0]<splice_eV[0], :]\\n\\t\\t\\t##self.merged_Im = numpy.vstack((asf_cut_low[:, [0, 2]], (splice_eV[0], splice_asf_Im[0]), nexafs_cut, (splice_eV[1], splice_asf_Im[1]), asf_cut_high[:, [0, 2]]))\\n\\t\\t\\t\\n\\t\\t\\t####Merge coeff data together\\n\\t\\t\\t##coeffs_cut_high = self.total_Im_coeffs[self.total_E[:-1]>splice_eV[1],:]\\n\\t\\t\\t##coeffs_cut_low = self.total_Im_coeffs[self.total_E[:-1]<splice_eV[0],:]\\n\\t\\t\\t###convert points to coeffs\\n\\t\\t\\t##nexafs_coeffs_cut = numpy.zeros((len(nexafs_cut)+1,5))\\n\\t\\t\\t##Y = numpy.append(numpy.insert(nexafs_cut[:,1],0,splice_asf_Im[0]),splice_asf_Im[1])\\n\\t\\t\\t##nexafs_E = numpy.append(numpy.insert(nexafs_cut[:,0],0,splice_eV[0]),splice_eV[1])\\n\\t\\t\\t##M = (Y[1:]-Y[:-1])/(nexafs_E[1:]-nexafs_E[:-1])\\n\\t\\t\\t##nexafs_coeffs_cut[:,0] = M\\n\\t\\t\\t##nexafs_coeffs_cut[:,1] = Y[:-1]-M*nexafs_E[:-1]\\n\\t\\t\\t###assemble merged coeffs and energy values\\n\\t\\t\\t##self.merged_Im_coeffs = numpy.vstack((coeffs_cut_low, nexafs_coeffs_cut, self.total_Im_coeffs[-coeffs_cut_high.shape[0]-2,:], coeffs_cut_high))\\n\\t\\t\\t##self.merged_E = numpy.concatenate((self.total_E[self.total_E<splice_eV[0]], nexafs_E, self.total_E[self.total_E>splice_eV[1]]))\\n\\t\\t\\t### Extras for plotting\\n\\t\\t\\t##self.splice_ind = (len(asf_cut_low[:, 0]), -len(asf_cut_high[:, 0]))\\n\\t\\t\\t##cut_boolean = (splice_eV[0]<=raw_Im[:, 0]) != (raw_Im[:, 0]<=splice_eV[1])\\n\\t\\t\\t##self.nexafs_CutOut = numpy.vstack((raw_Im[cut_boolean, 0], scaled_nexafs_Im[cut_boolean])).T\\n\\t\\t### Previous calculation of f_1 is no longer matching displayed f_2 data\\n\\t\\t##self.KK_Real_Spectrum = None\",\n \"def cspline_params(self):\\n b = np.zeros(self.n)\\n c = np.zeros(self.n-1)\\n d = np.zeros(self.n-1)\\n B = np.zeros(self.n)\\n Q = np.ones(self.n-1)\\n D = 2 * np.ones(self.n)\\n dx = np.zeros(self.n-1)\\n p = np.zeros(self.n-1)\\n\\n # Calculate x-interval and slope\\n for j in range(self.n-1):\\n dx[j] = self.x[j+1] - self.x[j]\\n p[j] = (self.y[j+1] - self.y[j]) / dx[j]\\n\\n # Fill B\\n B[0] = 3 * p[0]\\n for i in range(self.n-2):\\n B[i+1] = 3 * (p[i] + p[i+1] * dx[i] / dx[i+1])\\n B[-1] = 3 * p[-2]\\n \\n # Fill D\\n for i in range(self.n-2):\\n D[i+1] = 2 * dx[i] / dx[i+1] + 2\\n\\n # Fill Q\\n for i in range(self.n-2):\\n Q[i+1] = dx[i] / dx[i+1]\\n\\n # Gauss elimination\\n for i in range(1, self.n):\\n D[i] = D[i] - Q[i-1] / D[i-1]\\n B[i] = B[i] - B[i-1] / D[i-1]\\n\\n # Back-substitution\\n b[-1] = B[-1] / D[-1]\\n list = range(self.n-1)\\n for i in list[::-1]:\\n b[i] = (B[i] - Q[i] * b[i+1]) / D[i]\\n\\n # Calculate c and d\\n for i in range(self.n-1):\\n c[i] = (3 * p[i] - 2 * b[i] - b[i+1]) / dx[i]\\n d[i] = (b[i] + b[i+1] - 2 * p[i]) / dx[i]\\n c[-1] = -3 * d[-1] * dx[-1]\\n\\n return b, c, d\",\n \"def _get_spectrum(parlist, catdir):\\n name = parlist[3]\\n\\n filename = name.split('[')[0]\\n column = name.split('[')[1][:-1]\\n\\n filename = os.path.join(catdir, filename)\\n sp = SourceSpectrum.from_file(filename, flux_col=column)\\n\\n totflux = sp.integrate()\\n try:\\n validate_totalflux(totflux)\\n except synexceptions.SynphotError:\\n raise exceptions.ParameterOutOfBounds(\\n \\\"Parameter '{0}' has no valid data.\\\".format(parlist))\\n\\n result = [member for member in parlist]\\n result.pop()\\n result.append(sp)\\n\\n return result\",\n \"def _convert(self):\\n logger.info(\\\"Converting conformers to density\\\")\\n logger.debug(\\\"Masking\\\")\\n self._transformer.reset(full=True)\\n for n, coor in enumerate(self._coor_set):\\n self.conformer.coor = coor\\n self._transformer.mask(self._rmask)\\n mask = self._transformer.xmap.array > 0\\n self._transformer.reset(full=True)\\n\\n nvalues = mask.sum()\\n self._target = self.xmap.array[mask]\\n logger.debug(\\\"Density\\\")\\n nmodels = len(self._coor_set)\\n self._models = np.zeros((nmodels, nvalues), float)\\n for n, coor in enumerate(self._coor_set):\\n self.conformer.coor = coor\\n self.conformer.b = self._bs[n]\\n self._transformer.density()\\n model = self._models[n]\\n model[:] = self._transformer.xmap.array[mask]\\n np.maximum(model, self.options.bulk_solvent_level, out=model)\\n self._transformer.reset(full=True)\",\n \"def doDrizSeparate(self, pars):\\n \\n # Start by applying input parameters to redefine\\n # the output frame as necessary\\n for p in self.assoc.parlist:\\n\\n # First do some cleaning up, in case you are restarting...\\n fileutil.removeFile(p['outsingle'])\\n if (p['outsweight'] != ''):\\n fileutil.removeFile(p['outsweight'])\\n\\n # NB DO NOT USE \\\"tophat\\\" unless pixfrac is sufficiently\\n # large (> sqrt(2))\\n \\n p['fillval'] = pars['fillval']\\n \\n # Pass in the new wt_scale value\\n p['wt_scl'] = pars['wt_scl']\\n\\n if (p['single_driz_mask'] == None and self.static_mask != None):\\n p['single_driz_mask'] = self.static_mask.getMask(p['image'].signature())\\n \\n # 'in_units' will always be counts given that the input is converted to 'electrons' in call cases\\n p['in_units'] = 'counts'\\n \\n print(\\\"\\\\ndrizzle data='\\\"+p['data']+\\\"' outdata='\\\"+p['outsingle']+\\\"' outweig='\\\"+p['outsweight']+\\n \\\"' in_mask='static_mask\\\"+\\\"' kernel='\\\"+p['kernel']+\\n \\\"' outnx=\\\"+str(p['outnx'])+\\\" outny=\\\"+str(p['outny'])+\\\" xsh=\\\"+str(p['xsh'])+\\\" ysh=\\\"+str(p['ysh'])+\\n \\\" scale=\\\"+str(p['scale'])+\\\" pixfrac=\\\"+str(p['pixfrac'])+\\\" rot=\\\"+str(p['rot'])+\\n \\\" coeffs='\\\"+p['coeffs']+\\\"' wt_scl='\\\"+str(p['wt_scl'])+\\\"' align='center' shft_fr='output' shft_un='output'\\\"+\\n \\\" out_un='\\\"+p['units']+\\\"' expkey='\\\"+\\\"EXPTIME\\\"+\\\"' fillval='\\\"+str(p['fillval'])+\\\"'\\\"+\\n \\\" xgeoim='\\\"+p['xgeoim']+\\\"' ygeoim='\\\"+p['ygeoim']+\\\"'\\\\n\\\")\\n\\n # Perform separate drizzling now that all parameters have been setup...\\n self.assoc.run(single=True,save=True,build=False)\\n\\n # Now that we are done with the static mask, delete it...\\n del self.static_mask\",\n \"def generate_modelSED_photo_fit(sp=None,sfh_form=4,filters=None,add_igm_absorption=0,igm_type=0,params_fsps=None,DL_Gpc=0.0,cosmo='flat_LCDM',\\n\\tH0=70.0,Om0=0.3,params_val=None,interp_filters_waves=[],interp_filters_trans=[]):\\n\\n\\tdef_params_fsps, params_assoc_fsps, status_log = list_params_fsps()\\n\\n\\tformed_mass = pow(10.0,params_val['log_mass'])\\n\\n\\t# input model parameters to FSPS:\\n\\tfor pp in range(len(params_fsps)):\\n\\t\\tstr_temp = params_assoc_fsps[params_fsps[pp]]\\n\\t\\tif status_log[params_fsps[pp]] == 0:\\n\\t\\t\\tsp.params[str_temp] = params_val[params_fsps[pp]]\\n\\t\\telif status_log[params_fsps[pp]] == 1:\\n\\t\\t\\tsp.params[str_temp] = pow(10.0,params_val[params_fsps[pp]])\\n\\n\\t# generate the SED:\\n\\tif sfh_form==0 or sfh_form==1:\\n\\t\\tage = pow(10.0,params_val['log_age'])\\n\\t\\twave, extnc_spec = sp.get_spectrum(peraa=True,tage=age) ## spectrum in L_sun/AA\\n\\t\\tmass = sp.stellar_mass\\n\\t\\tdust_mass0 = sp.dust_mass ## in solar mass/norm\\n\\telif sfh_form==2 or sfh_form==3 or sfh_form==4:\\n\\t\\tt0 = pow(10.0,params_val['log_t0'])\\n\\t\\ttau = pow(10.0,params_val['log_tau'])\\n\\t\\tage = pow(10.0,params_val['log_age'])\\n\\t\\talpha = pow(10.0,params_val['log_alpha'])\\n\\t\\tbeta = pow(10.0,params_val['log_beta'])\\n\\t\\tSFR_fSM,mass,wave,extnc_spec,dust_mass0 = csp_spec_restframe_fit(sp=sp,sfh_form=sfh_form,formed_mass=formed_mass,age=age,tau=tau,t0=t0,alpha=alpha,beta=beta)\\n\\n\\t# redshifting\\n\\tredsh_wave,redsh_spec0 = cosmo_redshifting(DL_Gpc=DL_Gpc,cosmo=cosmo,H0=H0,Om0=Om0,z=params_val['z'],wave=wave,spec=extnc_spec)\\n\\n\\t# IGM absorption:\\n\\tif add_igm_absorption == 1:\\n\\t\\tif igm_type == 0:\\n\\t\\t\\ttrans = igm_att_madau(redsh_wave,params_val['z'])\\n\\t\\t\\ttemp = redsh_spec0\\n\\t\\t\\tredsh_spec0 = temp*trans\\n\\t\\telif igm_type == 1:\\n\\t\\t\\ttrans = igm_att_inoue(redsh_wave,params_val['z'])\\n\\t\\t\\ttemp = redsh_spec0\\n\\t\\t\\tredsh_spec0 = temp*trans\\n\\n\\t# normalize:\\n\\tnorm0 = formed_mass/mass\\n\\tredsh_spec = redsh_spec0*norm0\\n\\tdust_mass = dust_mass0*norm0\\n\\n\\t# filtering:\\n\\tphoto_SED_flux = filtering_interp_filters(redsh_wave,redsh_spec,interp_filters_waves,interp_filters_trans)\\n\\n\\treturn photo_SED_flux\",\n \"def setup(self):\\n super().setup()\\n\\n # prepare scratch directory\\n unix.mkdir(PATH.ORTHO)\\n\\n # get data file names from solver\\n solver = sys.modules['seisflows_solver']\\n\\n nevt = PAR.NEVT # number of encoded sources\\n ntpss = PAR.NTPSS # number of timesteps after steady state\\n dt = PAR.DT # total number of timesteps\\n nrec = PAR.NREC # number of stations\\n # ntrace = len(solver.data_filenames)\\n freq_min = float(PAR.FREQ_MIN) # minimium frequency of interest\\n freq_max = float(PAR.FREQ_MAX) # maximium frequency of interest\\n \\n #create a mask on relevant frequencies\\n freq_full = fftfreq(ntpss, dt) # full frequency compunent\\n freq_thresh = 1 / (ntpss * dt) / 200 # threshold for frequency alignment\\n freq_idx = np.squeeze(np.where((freq_min <= (freq_full)) & ((freq_full) < freq_max - freq_thresh))) # frequency band of interest\\n freq = freq_full[freq_idx] # index of frequencies within the frequency band\\n nfreq = len(freq_idx) # number of frequency within the frequency band\\n print('Number of frequencies considered: ' +str(nfreq)+' / '+str(len(freq_full)))\\n\\n # converts time data to Fourier domain\\n sff_obs = np.zeros((nfreq, nevt), dtype=complex) # fourier transform of observed source time function\\n ft_obs = np.zeros((nfreq, nevt, nrec), dtype=complex) # TODO ntrace fourier transform of observed seismogram\\n\\n for isrc in range(nevt):\\n source_name = solver.source_names_all[isrc] # name of source\\n stf_file = solver.stf_files_all[isrc] # name of source file\\n with open(stf_file) as f:\\n lines = f.readlines()\\n stf_obs = []\\n for line in lines:\\n stf_obs.append(float(line.split()[1]))\\n\\n sff_obs[:, isrc] = fft(stf_obs, n=ntpss)[freq_idx]\\n # for itrace in range(ntrace):\\n # trace = self.reader(PATH.DATA + '/' + source_name, solver.data_filenames[itrace])\\n # for irec in range(nrec):\\n # ft_obs[:, isrc, irec, itrace] = fft(trace[irec].data, n=ntpss)[freq_idx]\\n for irec in range(nrec):\\n trace = self.reader(PATH.DATA + '/' + source_name, solver.data_filenames[0])\\n ft_obs[:, isrc, irec] = fft(trace[irec].data, n=ntpss)[freq_idx]\\n \\n self.save('freq_idx', freq_idx)\\n self.save('freq', freq)\\n self.save('sff_obs', sff_obs)\\n self.save('ft_obs', ft_obs)\",\n \"def __get_s_params_from_cache(self, component, freqs: \\\"np.array\\\", s_parameters_method: str = \\\"s_parameters\\\"):\\n if s_parameters_method == \\\"s_parameters\\\":\\n # each frequency has a different s-matrix, so we need to cache\\n # the s-matrices by frequency as well as component\\n s_params = []\\n for freq in freqs:\\n try:\\n # use the cached s-matrix if available\\n s_matrix = self.__class__.scache[component][freq]\\n except KeyError:\\n # make sure the frequency dict is created\\n if component not in self.__class__.scache:\\n self.__class__.scache[component] = {}\\n\\n # store the s-matrix for the frequency and component\\n s_matrix = getattr(component, s_parameters_method)(\\n np.array([freq])\\n )[0]\\n self.__class__.scache[component][freq] = s_matrix\\n\\n # add the s-matrix to our list of s-matrices\\n s_params.append(s_matrix)\\n\\n # convert to numpy array for the rest of the function\\n return np.array(s_params)\\n elif (\\n s_parameters_method == \\\"monte_carlo_s_parameters\\\"\\n or \\\"layout_aware_monte_carlo_s_parameters\\\"\\n ):\\n # don't cache Monte Carlo scattering parameters\\n return getattr(component, s_parameters_method)(freqs)\",\n \"def _redef_sp1_vars(self):\\r\\n\\r\\n if len(self.fq_list) == 0:\\r\\n no_rad = True\\r\\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \\r\\n (self.lst_tmp.size, 1)))\\r\\n else: no_rad = False\\r\\n # The practically constants...\\r\\n # Big Epsilon:\\r\\n if self.cond == True:\\r\\n self.Epsilon = self.d_T * self.thermal_conductivity\\r\\n else:\\r\\n self.Epsilon = (self.diff_scale ** 2) / \\\\\\r\\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\\r\\n # Beta:\\r\\n if self.cond == True:\\r\\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\\\\r\\n (self.convect_coeff)\\r\\n else:\\r\\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\\\\r\\n ((1.0 - 2.0 * self.r1) * (\\r\\n 3.0 * self.absorb_coeffs[self.rad]))\\r\\n\\r\\n # The feild solutions at the last timestep.\\r\\n # The integral vF:\\r\\n if self.cond == True:\\r\\n # The horrifically complicated F:\\r\\n def F_func_cond(elem, eta):\\r\\n F = 0.0\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n F += Tn\\r\\n for k in range(0, len(self.fq_list)):\\r\\n vk = self.fq_list[k]\\r\\n try:\\r\\n vk_m = self.fq_list[k - 1]\\r\\n except:\\r\\n vk_m = self.v0_frequency\\r\\n absorbtion = self.absorb_coeffs[k]\\r\\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\\r\\n [eta])[0]\\r\\n inter1 = phi - 4.0 * sconst.pi * \\\\\\r\\n self.B_int_function(Tn, self.refr_idx_vol,\\r\\n vk, vk_m)\\r\\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\\r\\n F += inter2 * inter1\\r\\n return elem.funcs(eta) * F\\r\\n if not no_rad:\\r\\n # We're integrating something non-linear for SP1\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n # Or something easier if we're only looking at heat.\\r\\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\\r\\n else:\\r\\n def F_func_radiative(elem, eta):\\r\\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * F\\r\\n\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_radiative,\\r\\n self.node_map)\\r\\n # The path integral vf:\\r\\n if self.cond == True:\\r\\n def f_func_cond(elem, eta):\\r\\n Tb = self.background_temperature\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n n = self.refr_idx_background\\r\\n vk = self.v0_frequency\\r\\n vk_minus = 0\\r\\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\\r\\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\\r\\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\\r\\n f = Tb + B_coeff * (Bb0 - Bn0)\\r\\n return elem.funcs(eta) * f\\r\\n if not no_rad:\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n try:\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n except AttributeError:\\r\\n def elem_functor(elem, eta): return elem.funcs(eta)\\r\\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n elem_functor,\\r\\n self.node_map)\\r\\n self.cache_tb_integral_array *= self.background_temperature\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n \\r\\n else:\\r\\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\\r\\n def f_func_radiative(elem, eta):\\r\\n T = self.background_temperature\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * f\\r\\n\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_radiative,\\r\\n self.node_map)\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vf_vect_bound.shape[0] == \\\\\\r\\n self.vF_vect_vol.shape[0])\",\n \"def test_power_spectral_density_from_spatially_resolved_magnetisation_confined_to_mesh_region(tmpdir, debug=False):\\n os.chdir(str(tmpdir))\\n RTOL = 1e-10\\n\\n H1 = 1e6 # external field in A/m\\n alpha1 = 0.5 # some sort of damping constant\\n omega1 = gamma * H1 # precession frequency\\n\\n H2 = 2.8e4 # external field in A/m\\n alpha2 = 0.3 # some sort of damping constant\\n omega2 = gamma * H2 # precession frequency\\n\\n ##\\n # Step 1: Construct a time series of artificial magnetisation\\n # data and save it to a bunch of .npy files.\\n ##\\n t_step = 1e-11\\n t_ini = 0\\n t_end = 10e-9\\n\\n N1 = 42 # in a real application this would be the number of mesh vertices\\n N2 = 23 # in a real application this would be the number of mesh vertices\\n fft_test_helpers.create_test_npy_files_with_two_regions(\\n str(tmpdir), t_step, t_ini, t_end, omega1, alpha1, N1, omega2, alpha2, N2)\\n\\n ##\\n # Step 2: compute the FFT of a resampled time series, both by\\n # hand and using FFT_m.\\n ##\\n # XXX TODO: Resampling timesteps is not supported when using .npy\\n # files. Either simplify the code below, or implement saving to\\n # .h5 files so that it's easier to implement resampling for\\n # spatially resolved data, too.\\n ##\\n t_step_res = t_step\\n t_ini_res = t_ini\\n t_end_res = t_end\\n ts_resampled = np.arange(t_ini_res, t_end_res, t_step_res)\\n\\n # Compute time series based on resampled timesteps\\n mx_res = exp(-ts_resampled * 1e8 / alpha1) * sin(omega1 * ts_resampled)\\n my_res = exp(-ts_resampled * 1e8 / alpha1) * cos(omega1 * ts_resampled)\\n mz_res = 1 - sqrt(mx_res ** 2 + my_res ** 2)\\n\\n # Compute 'analytical' Fourier transform of resampled time series and\\n # determine the power of the spectrum for each component. We also need\\n # to multiply by the number of mesh nodes because the numerical algorithm\\n # sums up all contributions at the individual nodes (but we can just\\n # multiply because they are all identical by construction).\\n psd_mx_expected = N1 * np.absolute(np.fft.rfft(mx_res)) ** 2\\n psd_my_expected = N1 * np.absolute(np.fft.rfft(my_res)) ** 2\\n psd_mz_expected = N1 * np.absolute(np.fft.rfft(mz_res)) ** 2\\n\\n # Compute Fourier transform of resampled time series using FFT_m\\n freqs_computed, psd_mx_computed, psd_my_computed, psd_mz_computed = \\\\\\n compute_power_spectral_density('m_ringdown*.npy', t_step_res, t_ini=t_ini_res,\\n t_end=t_end_res, subtract_values=None, restrict_to_vertices=xrange(N1))\\n\\n # Check that the analytically determined power spectra are the same as the\\n # computed ones.\\n assert(np.allclose(psd_mx_expected, psd_mx_computed, atol=0, rtol=RTOL))\\n assert(np.allclose(psd_my_expected, psd_my_computed, atol=0, rtol=RTOL))\\n assert(np.allclose(psd_mz_expected, psd_mz_computed, atol=0, rtol=RTOL))\\n\\n if debug:\\n # Plot the spectra for debugging\\n fig = plt.figure(figsize=(20, 5))\\n ax = fig.gca()\\n ax.plot(freqs_computed, psd_mx_expected, label='psd_mx_expected')\\n ax.plot(freqs_computed, psd_my_expected, label='psd_my_expected')\\n ax.plot(freqs_computed, psd_mz_expected, label='psd_mz_expected')\\n ax.plot(freqs_computed, psd_mx_computed, label='psd_mx_computed')\\n ax.plot(freqs_computed, psd_my_computed, label='psd_my_computed')\\n ax.plot(freqs_computed, psd_mz_computed, label='psd_mz_computed')\\n ax.legend(loc='best')\\n fig.savefig('psd_m_McMichaelStiles.png')\",\n \"def get_grad(self, params: Sequence[float] = []) -> np.ndarray:\\n self.check_parameters(params)\\n\\n ct = np.cos(params[0] / 2)\\n st = np.sin(params[0] / 2)\\n cp = np.cos(params[1])\\n sp = np.sin(params[1])\\n cl = np.cos(params[2])\\n sl = np.sin(params[2])\\n el = cl + 1j * sl\\n ep = cp + 1j * sp\\n del_ = -sl + 1j * cl\\n dep_ = -sp + 1j * cp\\n\\n return np.array(\\n [\\n [ # wrt params[0]\\n [-0.5 * st, -0.5 * ct * el],\\n [0.5 * ct * ep, -0.5 * st * el * ep],\\n ],\\n\\n [ # wrt params[1]\\n [0, 0],\\n [st * dep_, ct * el * dep_],\\n ],\\n\\n [ # wrt params[2]\\n [0, -st * del_],\\n [0, ct * ep * del_],\\n ],\\n ], dtype=np.complex128,\\n )\",\n \"def calc_spindle_psd_i(self, psd_bandwidth, zpad=False, zpad_len=3):\\n \\n print('Calculating power spectra (this may take a few minutes)...')\\n self.metadata['spindle_analysis']['psd_dtype'] = 'raw_individual'\\n self.metadata['spindle_analysis']['psd_method'] = 'multitaper'\\n self.metadata['spindle_analysis']['psd_bandwidth'] = psd_bandwidth\\n self.metadata['spindle_analysis']['zeropad'] = zpad\\n self.metadata['spindle_analysis']['zeropad_len_sec'] = zpad_len\\n sf = self.metadata['analysis_info']['s_freq']\\n \\n spindles_zpad = {}\\n spindle_psd = {}\\n spindle_multitaper_calcs = {}\\n for chan in self.spindles:\\n spindles_zpad[chan] = {}\\n spindle_psd[chan] = {}\\n # waveform resolution is dependent on length of signal, regardless of zero-padding\\n spindle_multitaper_calcs[chan] = pd.DataFrame(columns=['spin_samples', 'spin_seconds', 'zpad_samples', 'zpad_seconds', 'waveform_resoultion_Hz', \\n 'psd_resolution_Hz', 'N_taper_len', 'W_bandwidth', 'K_tapers'])\\n spindle_multitaper_calcs[chan].index.name = 'spindle_num'\\n \\n if len(self.spindles[chan]) > 0:\\n for x in self.spindles[chan]:\\n # subtract mean to zero-center spindle for zero-padding\\n data = self.spindles[chan][x].Raw.values - np.mean(self.spindles[chan][x].Raw.values)\\n zpad_samples=0\\n zpad_seconds=0\\n tx=0\\n \\n # option to zero-pad the spindle\\n if zpad:\\n total_len = zpad_len*sf\\n zpad_samples = total_len - len(data)\\n zpad_seconds = zpad_samples/sf\\n if zpad_samples > 0:\\n padding = np.repeat(0, zpad_samples)\\n data_pad = np.append(data, padding)\\n else:\\n spin_len = len(data)/sf\\n print(f'Spindle {chan}:{x} length {spin_len} seconds longer than pad length {zpad_len}')\\n data_pad = data\\n \\n # or leave as-is\\n else:\\n data_pad = data\\n \\n # record PS params [K = 2NW-1]\\n spin_samples = len(data)\\n spin_seconds = len(data)/sf\\n waveform_res = 1/spin_seconds\\n psd_res = 1/(len(data_pad)/sf)\\n N_taper_len = len(data_pad)/sf\\n W_bandwidth = psd_bandwidth\\n K_tapers = int((2*N_taper_len*W_bandwidth)-1)\\n spindle_multitaper_calcs[chan].loc[x] = [spin_samples, spin_seconds, zpad_samples, zpad_seconds, waveform_res, psd_res, N_taper_len, W_bandwidth, K_tapers]\\n\\n # calculate power spectrum\\n try:\\n pwr, freqs = psd_array_multitaper(data_pad, sf, adaptive=True, bandwidth=psd_bandwidth, fmax=25, \\n normalization='full', verbose=0)\\n except ValueError:\\n print(f'Specified bandwidth too small for data length. Skipping spindle {chan}:{x}.')\\n continue\\n \\n # convert to series & add to dict\\n psd = pd.Series(pwr, index=freqs)\\n spindle_psd[chan][x] = psd\\n spindles_zpad[chan][x] = data_pad\\n \\n self.spindles_zpad = spindles_zpad\\n self.spindle_multitaper_calcs = spindle_multitaper_calcs\\n self.spindle_psd_i = spindle_psd\\n print('Done. \\\\nSpectra stored in obj.spindle_psd_i. Calculations stored in obj.spindle_multitaper_calcs. Zero-padded spindle data in obj.spindles_zpad.\\\\n')\",\n \"def _set_regressors(self) :\\n\\t\\tlogging.debug(\\\"Setting regressors\\\")\\n\\t\\n\\t\\tnvars = len(self.ss.variables)\\t\\t\\n\\n\\t\\tself.regressors_true = []\\n\\t\\tfor eqn in self.ss.equations : \\n\\t\\t\\tprod= self._find_regressors(eqn,'g')\\n\\t\\t\\tdegrad = self._find_regressors(eqn,'h')\\n\\t\\t\\tself.regressors_true.append({\\n\\t\\t\\t\\t'prod':prod,\\n\\t\\t\\t\\t'degrad':degrad\\n\\t\\t\\t})\\n\\n\\t\\tif self.ss.exptype in ('noinfo','structure') : \\n\\t\\t\\tprod = range(1,nvars+1)\\n\\t\\t\\tdegrad = prod\\n\\t\\t\\tself.regressors = [{\\n\\t\\t\\t\\t'prod' : prod,\\n\\t\\t\\t\\t'degrad' : degrad\\n\\t\\t\\t}]*len(self.ss.equations) \\n\\n\\t\\telif self.ss.exptype == 'fullinfo' :\\n\\t\\t\\tself.regressors = []\\n\\t\\t\\tfor eqn in self.ss.equations : \\n\\t\\t\\t\\tprod= self._find_regressors(eqn,'g')\\n\\t\\t\\t\\tdegrad = self._find_regressors(eqn,'h')\\n\\t\\t\\t\\tself.regressors.append({\\n\\t\\t\\t\\t\\t'prod':prod,\\n\\t\\t\\t\\t\\t'degrad':degrad\\n\\t\\t\\t\\t})\\n\\n\\t\\telif self.ss.exptype == 'partialinfo' : \\n\\t\\t\\tself.regressors = []\\n\\t\\t\\tfor eqn in self.ss.equations : \\n\\t\\t\\t\\tprod= self._find_regressors(eqn,'g')\\n\\t\\t\\t\\tdegrad = self._find_regressors(eqn,'h')\\n\\t\\t\\t\\tprod = list(set(prod).union(degrad))\\n\\t\\t\\t\\tdegrad = prod\\n\\t\\t\\t\\tself.regressors.append({\\n\\t\\t\\t\\t\\t'prod':prod,\\n\\t\\t\\t\\t\\t'degrad':degrad\\n\\t\\t\\t\\t})\\n\\n\\t\\telse :\\n\\t\\t\\tlogging.error('Did not recognize exptype %s'% \\\\\\n\\t\\t\\t(self.ss.exptype))\\n\\t\\t\\tsys.exit(1)\\n\\n\\t\\t# The regressors that are to be artificially fixed at every \\n\\t\\t# iteration\\n\\t\\t# This is only necessary for the noinfo and partial info case\\n\\t\\tself._regressors_fix = []\\n\\t\\tfor eqn in self.ss.equations : \\n\\t\\t\\tprod= self._find_regressors(eqn,'g')\\n\\t\\t\\tdegrad = self._find_regressors(eqn,'h')\\n\\t\\t\\tprod_all = degrad_all = range(1,nvars+1)\\n\\t\\t\\tprod = list(set(prod_all).difference(prod))\\n\\t\\t\\tdegrad = list(set(degrad_all).difference(degrad))\\n\\t\\t\\tself._regressors_fix.append({\\n\\t\\t\\t\\t'prod':prod,\\n\\t\\t\\t\\t'degrad':degrad\\n\\t\\t\\t})\",\n \"def rebuild_models(self):\\n\\n zmin = self._domain.z.lbound\\n zmax = self._domain.z.rbound\\n\\n xmin = self._domain.x.lbound\\n xmax = self._domain.x.rbound\\n\\n grid = self.mesh.mesh_coords()\\n\\n # the small number is added to prevent undesireable numerical effects\\n air_depth = (1e-8 + 2.0/15.0) * (zmax - zmin) + zmin\\n rock_bottom = 13.0/15.0 * (zmax - zmin) + zmin\\n\\n coast_left = 3.0/25.0 * (xmax - xmin) + xmin\\n coast_right = 13.0/25.0 * (xmax - xmin) + xmin\\n\\n max_depth = zmax\\n\\n # Set up air layer\\n if self._domain.dim == 2:\\n n = (0., 1.)\\n p = (coast_right, air_depth)\\n else: # domain.dim == 3\\n n = (0.0, 0.0, 1.0)\\n p = (coast_right, coast_right, air_depth)\\n\\n air_plane = ImplicitPlane(p,n)\\n air = air_plane\\n\\n # Set up rock layer\\n if self._domain.dim == 2:\\n n = (coast_right - coast_left, -(1.0 - air_depth))\\n p = (coast_right, max_depth)\\n n2 = (0., -1.)\\n p2 = (0., rock_bottom)\\n else: # domain.dim == 3\\n n = (coast_right - coast_left, 0.0, -(1.0 - air_depth))\\n p = (coast_right, 0.0, max_depth)\\n n2 = (0., 0., -1.)\\n p2 = (0., 0., rock_bottom)\\n\\n rock_plane = ImplicitPlane(p,n)\\n rock_plane2 = ImplicitPlane(p2,n2)\\n\\n rock = ImplicitDifference(ImplicitUnion(rock_plane, rock_plane2), air_plane)\\n\\n C0 = air.interior(grid, True) * self.air_velocity + \\\\\\n rock.interior(grid, True) * self.rock_velocity\\n\\n C0[np.where(C0 == 0.0)] = self.water_velocity\\n\\n submarine = self.submarine\\n\\n if submarine is not None:\\n sub = submarine.implicit_surface\\n\\n C = air.interior(grid, True) * self.air_velocity + \\\\\\n rock.interior(grid, True) * self.rock_velocity + \\\\\\n sub.interior(grid, True) * submarine.velocity\\n\\n C[np.where(C == 0.0)] = self.water_velocity\\n\\n else:\\n C = C0.copy()\\n\\n C.shape = self._mesh.shape()\\n C0.shape = self._mesh.shape()\\n\\n self._true_model = C\\n self._initial_model = C0\",\n \"def sr(self, params, r_s, sz_s, energy_s):\\n\\n self.itr += 1\\n\\n r_av = jnp.reshape(r_s[:,:,0:self.nav,:,:], (self.n_devices, self.nwalk // self.n_devices * self.nav, self.npart, self.ndim))\\n sz_av = jnp.reshape(sz_s[:,:,0:self.nav,:,:], (self.n_devices, self.nwalk // self.n_devices * self.nav, self.npart, 2))\\n energy_av = jnp.reshape(energy_s[:,:,0:self.nav], (self.n_devices, self.nwalk // self.n_devices * self.nav))\\n\\n r_val = jnp.reshape(r_s[:,:,0:self.nac,:,:], (self.n_devices, self.nwalk // self.n_devices * self.nac, self.npart, self.ndim))\\n sz_val = jnp.reshape(sz_s[:,:,0:self.nac,:,:], (self.n_devices, self.nwalk // self.n_devices * self.nac, self.npart, 2))\\n energy_val = jnp.reshape(energy_s[:,:,0:self.nac], (self.n_devices, self.nwalk // self.n_devices * self.nac))\\n r_avg, r_max = self.observables.radius_pmap(r_val, sz_val)\\n logger.info(f\\\"Maximum Radius validation=, {jnp.sqrt(r_max):.3f} \\\")\\n logger.info(f\\\"Average Radius validation=, {jnp.sqrt(r_avg):.3f} \\\")\\n psi_val = self.wavefunction.psi_pmap(params, r_val, sz_val)\\n logger.info(f\\\"Maximum Psi validation= ,{jnp.max(jnp.abs(psi_val)):.4e} \\\")\\n logger.info(f\\\"Average Psi validation= ,{jnp.mean(jnp.abs(psi_val)):.4e} \\\")\\n logger.info(f\\\"Minimum Psi validation= ,{jnp.min(jnp.abs(psi_val)):.4e} \\\")\\n\\n r_tst = jnp.reshape(r_s[:,:,self.nav:self.nav+self.nac,:,:], (self.n_devices, self.nwalk // self.n_devices * self.nac, self.npart, self.ndim))\\n sz_tst = jnp.reshape(sz_s[:,:,self.nav:self.nav+self.nac,:,:], (self.n_devices, self.nwalk // self.n_devices * self.nac, self.npart, 2))\\n energy_tst = jnp.reshape(energy_s[:,:,self.nav:self.nav+self.nac], (self.n_devices, self.nwalk // self.n_devices * self.nac))\\n r_avg, r_max = self.observables.radius_pmap(r_tst, sz_tst)\\n logger.info(f\\\"Maximum Radius test=, {jnp.sqrt(r_max):.3f} \\\")\\n logger.info(f\\\"Average Radius test=, {jnp.sqrt(r_avg):.3f} \\\")\\n psi_tst = self.wavefunction.psi_pmap(params, r_tst, sz_tst)\\n logger.info(f\\\"Maximum Psi test= ,{jnp.max(jnp.abs(psi_tst)):.4e} \\\")\\n logger.info(f\\\"Average Psi test= ,{jnp.mean(jnp.abs(psi_tst)):.4e} \\\")\\n logger.info(f\\\"Minimum Psi test= ,{jnp.min(jnp.abs(psi_tst)):.4e} \\\")\\n\\n if (self.solver == 'Adam'):\\n dp_i, self.g2_i, self.m_i = self.adam(params, r_av, sz_av, energy_av, g2_i = self.g2_i, m_i = self.m_i, itr = self.itr)\\n elif (self.solver == 'Cholesky'):\\n dp_i, self.g2_i = self.sr_cholesky(params, r_av, sz_av, energy_av, g2_i = self.g2_i, itr = self.itr) \\n elif (self.solver == 'Pseudo'):\\n dp_i = self.sr_pseudo(params, r_av, sz_av, energy_av) \\n elif (self.solver == 'CG'):\\n dp_i, self.g2_i = self.sr_cg(params, r_av, sz_av, energy_av, dp0_i=self.dp_i, g2_i = self.g2_i, itr = self.itr) \\n\\n self.dp_i = dp_i\\n energy_d_min= 1.\\n converged = False\\n dp_range = jnp.linspace(0.1, 0.8, self.nstep)\\n for n in range (self.nstep):\\n# dt = dt_range[n]\\n dp_n = self.delta * dp_i#[n] #+ dp_range[n] * self.dp_o\\n dp_max = jnp.max(jnp.abs(dp_n)) \\n delta_p = self.wavefunction.unflatten_params(dp_n) \\n# delta_p = self.wavefunction.unflatten_params( self.delta * dp_i ) \\n\\n psi_d_tst, psi_d_err_tst, energy_d_tst, energy_d_err_tst, overlap_tst = self.pmap_dist(delta_p, params, r_tst, sz_tst, psi_tst, energy_tst)\\n dist_tst = jnp.arccos(jnp.sqrt(psi_d_tst))**2\\n logger.debug(f\\\"dist acos tst = {dist_tst:.8f}\\\")\\n logger.debug(f\\\"energy diff tst = {energy_d_tst:.6f}, err = {energy_d_err_tst:.6f}\\\")\\n logger.debug(f\\\"overlap tst= { jnp.arccos(jnp.sqrt(overlap_tst))**2:.8f}\\\")\\n \\n psi_d_val, psi_d_err_val, energy_d_val, energy_d_err_val, overlap_val = self.pmap_dist(delta_p, params, r_val, sz_val, psi_val, energy_val)\\n dist_val = jnp.arccos(jnp.sqrt(psi_d_val))**2\\n logger.debug(f\\\"dist acos val = {dist_val:.8f}\\\")\\n logger.debug(f\\\"energy diff val= {energy_d_val:.6f}, err = {energy_d_err_val:.6f}\\\")\\n logger.debug(f\\\"overlap val = { jnp.arccos(jnp.sqrt(overlap_val))**2:.8f}\\\")\\n\\n logger.debug(f\\\"delta param max = {dp_max:.6f}\\\")\\n logger.debug(f\\\"delta param avg = {jnp.linalg.norm(dp_n):.6f}\\\")\\n\\n if ( dist_tst < 0.1 and dist_val < 0.1 and energy_d_val < energy_d_min and dp_max < 0.5):\\n energy_d_min = energy_d_val\\n energy_d_err_min = energy_d_err_val\\n delta_p_min = delta_p\\n dp_n_min = dp_n\\n converged = True\\n if converged: \\n logger.debug(f\\\"Converged, energy diff min = {energy_d_min:.6f}, err = {energy_d_err_min:.6f}\\\")\\n else:\\n logger.debug(f\\\"Not converged\\\")\\n delta_p_min = self.wavefunction.unflatten_params(jnp.zeros(self.nparams))\\n dp_n_min = jnp.zeros(self.nparams)\\n return delta_p_min\",\n \"def __init__(self, parameters, mesh_name, facet_name,\\n bc_dict={\\\"obstacle\\\": 2, \\\"channel_walls\\\": 1, \\\"inlet\\\": 3,\\n \\\"outlet\\\": 4}):\\n self.bc_dict = bc_dict\\n self.mesh = df.Mesh()\\n with df.XDMFFile(mesh_name) as infile:\\n infile.read(self.mesh)\\n\\n mvc = df.MeshValueCollection(\\\"size_t\\\", self.mesh,\\n self.mesh.topology().dim() - 1)\\n with df.XDMFFile(facet_name) as infile:\\n infile.read(mvc, \\\"name_to_read\\\")\\n self.mf = mf = df.cpp.mesh.MeshFunctionSizet(self.mesh, mvc)\\n\\n self.V = V = df.VectorFunctionSpace(self.mesh, 'P',\\n parameters[\\\"degree velocity\\\"])\\n self.Q = Q = df.FunctionSpace(self.mesh, 'P',\\n parameters[\\\"degree pressure\\\"])\\n self.rho = df.Constant(parameters[\\\"density [kg/m3]\\\"])\\n self.mu = df.Constant(parameters[\\\"viscosity [Pa*s]\\\"])\\n self.dt = df.Constant(parameters[\\\"dt [s]\\\"])\\n self.g = df.Constant((0, 0))\\n self.vu, self.vp = df.TestFunction(V), df.TestFunction(Q)\\n self.u_, self.p_ = df.Function(V), df.Function(Q)\\n self.u_1, self.p_1 = df.Function(V), df.Function(Q)\\n self.u_k, self.p_k = df.Function(V), df.Function(Q)\\n self.u, self.p = df.TrialFunction(V), df.TrialFunction(Q) # unknown!\\n\\n self.U_m = U_m = parameters[\\\"velocity [m/s]\\\"]\\n x = [0, .41 / 2] # center of the channel\\n Ucenter = 4.*U_m*x[1]*(.41-x[1])/(.41*.41)\\n U0_str = \\\"4.*U_m*x[1]*(.41-x[1])/(.41*.41)\\\"\\n self.U_mean = np.mean(2 / 3 * Ucenter)\\n\\n U0 = df.Expression((U0_str, \\\"0\\\"), U_m=U_m, degree=2)\\n bc0 = df.DirichletBC(V, df.Constant((0, 0)), mf, bc_dict[\\\"obstacle\\\"])\\n bc1 = df.DirichletBC(V, df.Constant((0, 0)), mf, bc_dict[\\\"channel_walls\\\"])\\n bc2 = df.DirichletBC(V, U0, mf, bc_dict[\\\"inlet\\\"])\\n bc3 = df.DirichletBC(Q, df.Constant(0), mf, bc_dict[\\\"outlet\\\"])\\n self.bcu = [bc0, bc1, bc2]\\n self.bcp = [bc3]\\n self.ds_ = df.Measure(\\\"ds\\\", domain=self.mesh, subdomain_data=mf)\\n return\",\n \"def __calculateDDIstart(self, partedscans, partedspws):\\n \\n # Example of partedspws:\\n # create 2 subMss with spw=0,1,2 and spw=3\\n # partedSPWs = {0:['0','1','2'],1:['3']}\\n #\\n # create 3 subMSs with spw=0,1,2 spw=3 and spw=4,5\\n # partedSPWs = {0:['0','1','2'],1:['3'],2:['4','5']}\\n \\n hasscans = True\\n if len(partedscans) == 0:\\n scans = ''\\n hasscans = False\\n\\n # It needs to take the correlation selection into account\\n corr_sel = self._arg['correlation']\\n ddistartList = []\\n \\n # scan+spw separation axis \\n if hasscans:\\n count = 0\\n for k,spws in partedspws.iteritems():\\n for ks,scans in partedscans.iteritems():\\n if self._msTool is None:\\n self._msTool = mstool()\\n self._msTool.open(self._arg['vis'],nomodify=False)\\n else:\\n self._msTool.reset()\\n \\n try:\\n # The dictionary with selected indices\\n seldict = self._msTool.msseltoindex(vis=self._arg['vis'],scan=scans,spw=spws,polarization=corr_sel)\\n except:\\n self._msTool.close()\\n continue\\n \\n # Get the selected DD IDs\\n ddis = seldict['dd'].tolist()\\n ddsize = ddis.__len__()\\n if count == 0:\\n ddistart = 0\\n \\n # Create a ddistart list\\n ddistartList.append(ddistart)\\n ddistart = ddistart + ddsize\\n count = count + 1\\n \\n # spw separation axis \\n else:\\n count = 0\\n for k,spws in partedspws.iteritems():\\n if self._msTool is None:\\n self._msTool = mstool()\\n self._msTool.open(self._arg['vis'],nomodify=False)\\n else:\\n self._msTool.reset()\\n \\n try:\\n # The dictionary with selected indices\\n seldict = self._msTool.msseltoindex(vis=self._arg['vis'],scan=scans,spw=spws, polarization=corr_sel)\\n except:\\n self._msTool.reset()\\n continue\\n \\n # Get the selected DD IDs\\n ddis = seldict['dd'].tolist()\\n ddsize = ddis.__len__()\\n if count == 0:\\n ddistart = 0\\n \\n # Create a ddistart list\\n ddistartList.append(ddistart)\\n ddistart = ddistart + ddsize\\n count = count + 1\\n \\n return ddistartList\",\n \"def test_power_spectral_density_from_spatially_resolved_magnetisation(tmpdir, debug=False):\\n os.chdir(str(tmpdir))\\n RTOL = 1e-10\\n\\n H = 1e6 # external field in A/m\\n alpha = 0.5 # some sort of damping constant\\n omega = gamma * H # precession frequency\\n\\n ##\\n # Step 1: Construct a time series of artificial magnetisation\\n # data and save it to a bunch of .npy files.\\n ##\\n t_step = 1e-11\\n t_ini = 0\\n t_end = 10e-9\\n\\n # in a real application this would be the number of mesh vertices\\n num_vertices = 42\\n fft_test_helpers.create_test_npy_files(\\n str(tmpdir), t_step, t_ini, t_end, omega, alpha, num_vertices)\\n\\n ##\\n # Step 2: compute the FFT of a resampled time series, both by\\n # hand and using FFT_m.\\n ##\\n # XXX TODO: Resampling timesteps is not supported when using .npy\\n # files. Either simplify the code below, or implement saving to\\n # .h5 files so that it's easier to implement resampling for\\n # spatially resolved data, too.\\n ##\\n t_step_res = t_step\\n t_ini_res = t_ini\\n t_end_res = t_end\\n ts_resampled = np.arange(t_ini_res, t_end_res, t_step_res)\\n\\n # Compute time series based on resampled timesteps\\n mx_res = exp(-ts_resampled * 1e8 / alpha) * sin(omega * ts_resampled)\\n my_res = exp(-ts_resampled * 1e8 / alpha) * cos(omega * ts_resampled)\\n mz_res = 1 - sqrt(mx_res ** 2 + my_res ** 2)\\n\\n # Compute 'analytical' Fourier transform of resampled time series and\\n # determine the power of the spectrum for each component. We also need\\n # to multiply by the number of mesh nodes because the numerical algorithm\\n # sums up all contributions at the individual nodes (but we can just\\n # multiply because they are all identical by construction).\\n psd_mx_expected = num_vertices * np.absolute(np.fft.rfft(mx_res)) ** 2\\n psd_my_expected = num_vertices * np.absolute(np.fft.rfft(my_res)) ** 2\\n psd_mz_expected = num_vertices * np.absolute(np.fft.rfft(mz_res)) ** 2\\n\\n # Compute Fourier transform of resampled time series using\\n # compute_power_spectral_density.\\n freqs_computed, psd_mx_computed, psd_my_computed, psd_mz_computed = \\\\\\n compute_power_spectral_density(\\n 'm_ringdown*.npy', t_step_res, t_ini=t_ini_res, t_end=t_end_res, subtract_values=None)\\n\\n # Check that the analytically determined power spectra are the same as the\\n # computed ones.\\n assert(np.allclose(psd_mx_expected, psd_mx_computed, atol=0, rtol=RTOL))\\n assert(np.allclose(psd_my_expected, psd_my_computed, atol=0, rtol=RTOL))\\n assert(np.allclose(psd_mz_expected, psd_mz_computed, atol=0, rtol=RTOL))\\n\\n if debug:\\n # Plot the spectra for debugging\\n fig = plt.figure(figsize=(20, 5))\\n ax = fig.gca()\\n ax.plot(freqs_computed, psd_mx_expected, label='psd_mx_expected')\\n ax.plot(freqs_computed, psd_my_expected, label='psd_my_expected')\\n ax.plot(freqs_computed, psd_mz_expected, label='psd_mz_expected')\\n ax.plot(freqs_computed, psd_mx_computed, label='psd_mx_computed')\\n ax.plot(freqs_computed, psd_my_computed, label='psd_my_computed')\\n ax.plot(freqs_computed, psd_mz_computed, label='psd_mz_computed')\\n ax.legend(loc='best')\\n fig.savefig('psd_m_McMichaelStiles.png')\",\n \"def reassignedSmethod(fx,nh=2**7-1,tstep=2**4,nfbins=2**9,df=1.0,alpha=4,\\r\\n thresh=.01,L=5): \\r\\n \\r\\n# if type(fx) is list:\\r\\n# fx=np.array(fx)\\r\\n# try:\\r\\n# fn,fm=fx.shape\\r\\n# if fm>fn:\\r\\n# fm,fn=fx.shape\\r\\n# except ValueError:\\r\\n# fn=len(fx)\\r\\n# fm=1\\r\\n# if fm>1:\\r\\n# print 'computing cross spectra'\\r\\n# #compute the analytic signal of function f and dctrend\\r\\n# #fa=sps.hilbert(dctrend(fx[0]))\\r\\n# #fb=sps.hilbert(dctrend(fx[1]))\\r\\n# fa=fx[0]\\r\\n# fb=fx[1]\\r\\n# fa=fa.reshape(fn)\\r\\n# fb=fb.reshape(fn)\\r\\n# else:\\r\\n# fa=fx\\r\\n# fa=fa.reshape(fn)\\r\\n# fb=fa.copy()\\r\\n\\r\\n \\r\\n nx=len(fx) \\r\\n \\r\\n #compute gaussian window\\r\\n h=gausswin(nh,alpha=alpha)\\r\\n #h=np.hanning(nh)\\r\\n lh=(nh-1)/2\\r\\n \\r\\n #compute ramp window\\r\\n th=h*np.arange(start=-lh,stop=lh+1,step=1)\\r\\n \\r\\n #compute derivative of window\\r\\n dh=dwindow(h)\\r\\n \\r\\n #make a time list of indexes\\r\\n tlst=np.arange(start=0,stop=nx,step=tstep)\\r\\n nt=len(tlst)\\r\\n \\r\\n #make frequency list for plotting\\r\\n flst=np.fft.fftfreq(nfbins,1./df)[:nfbins/2]\\r\\n \\r\\n #initialize some time-frequency arrays\\r\\n tfh=np.zeros((nfbins,nt),dtype='complex128')\\r\\n tfth=np.zeros((nfbins,nt),dtype='complex128')\\r\\n tfdh=np.zeros((nfbins,nt),dtype='complex128')\\r\\n \\r\\n #compute components for reassignment\\r\\n for ii,tt in enumerate(tlst):\\r\\n #create a time shift list\\r\\n tau=np.arange(start=-min([np.round(nx/2.),lh,tt-1]),\\r\\n stop=min([np.round(nx/2.),lh,nx-tt-1])+1)\\r\\n #compute the frequency spots to be calculated\\r\\n ff=np.remainder(nfbins+tau,nfbins)\\r\\n #make lists of data points for each window calculation\\r\\n xlst=tt+tau\\r\\n hlst=lh+tau\\r\\n normh=np.sqrt(np.sum(abs(h[hlst])**2))\\r\\n tfh[ff,ii]=fx[xlst]*h[hlst].conj()/normh\\r\\n tfth[ff,ii]=fx[xlst]*th[hlst].conj()/normh\\r\\n tfdh[ff,ii]=fx[xlst]*dh[hlst].conj()/normh\\r\\n \\r\\n #compute Fourier Transform\\r\\n spech=np.fft.fft(tfh,axis=0)\\r\\n specth=np.fft.fft(tfth,axis=0)\\r\\n specdh=np.fft.fft(tfdh,axis=0)\\r\\n \\r\\n #get only positive frequencies\\r\\n spech=spech[nfbins/2:,:]\\r\\n specth=specth[nfbins/2:,:]\\r\\n specdh=specdh[nfbins/2:,:]\\r\\n \\r\\n #check to make sure no spurious zeros floating around\\r\\n szf=np.where(abs(spech)<1.E-6)\\r\\n spech[szf]=0.0+0.0j\\r\\n zerofind=np.nonzero(abs(spech))\\r\\n twspec=np.zeros((nfbins/2,nt),dtype='float')\\r\\n dwspec=np.zeros((nfbins/2,nt),dtype='float')\\r\\n twspec[zerofind]=np.round(np.real(specth[zerofind]/spech[zerofind]))\\r\\n dwspec[zerofind]=np.round(np.imag((nfbins/2.)*specdh[zerofind]/\\r\\n spech[zerofind])/(np.pi))\\r\\n \\r\\n #get shape of spectrogram\\r\\n nf,nt=spech.shape\\r\\n \\r\\n #-----calculate s-method-----\\r\\n Llst=np.arange(start=-L/2+1,stop=L/2+1,step=1,dtype='int')\\r\\n\\r\\n #make and empty array of zeros\\r\\n sm=np.zeros_like(spech)\\r\\n \\r\\n #put values where L cannot be value of L, near top and bottom\\r\\n sm[0:L/2,:]=abs(spech[0:L/2,:])**2\\r\\n sm[-L/2:,:]=abs(spech[-L/2:,:])**2\\r\\n\\r\\n #calculate s-method\\r\\n for ff in range(L/2,nf-L/2-1):\\r\\n sm[ff,:]=2*np.real(np.sum(spech[ff+Llst,:]*spech[ff-Llst,:].conj(),\\r\\n axis=0))/L\\r\\n \\r\\n #------compute reassignment----- \\r\\n\\r\\n \\r\\n rtfarray=np.zeros((nfbins/2,nt))\\r\\n \\r\\n threshold=thresh*np.max(abs(sm))\\r\\n \\r\\n for nn in range(nt):\\r\\n for kk in range(nf):\\r\\n if abs(spech[kk,nn])>threshold:\\r\\n #get center of gravity index in time direction from spectrogram \\r\\n nhat=int(nn+twspec[kk,nn])\\r\\n nhat=int(min([max([nhat,1]),nt-1]))\\r\\n #get center of gravity index in frequency direction from spec\\r\\n khat=int(kk-dwspec[kk,nn])\\r\\n khat=int(np.remainder(np.remainder(khat-1,nfbins/2)+nfbins/2,\\r\\n nfbins/2))\\r\\n rtfarray[khat,nhat]=rtfarray[khat,nhat]+abs(sm[kk,nn])\\r\\n else:\\r\\n rtfarray[kk,nn]=rtfarray[kk,nn]+sm[kk,nn]\\r\\n\\r\\n #place values where L cannot be L \\r\\n rtfarray[:L/2,:]=abs(sm[:L/2,:])\\r\\n rtfarray[-L/2:,:]=abs(sm[-L/2:,:])\\r\\n \\r\\n tz=np.where(rtfarray==0)\\r\\n rtfarray[tz]=1.0\\r\\n \\r\\n tz=np.where(sm==0.0)\\r\\n sm[tz]=1.0 \\r\\n \\r\\n #scale\\r\\n rtfarray=abs(rtfarray)\\r\\n \\r\\n return rtfarray,tlst,flst,sm\",\n \"def prep_base(self):\\n\\n self.config.logger.info(\\\"Preparing base layer land use data...\\\")\\n\\n # set start time\\n t0 = time.time()\\n\\n # extract and process base layer land cover data\\n base_data = rdr.read_base(self.config, self.observed_landclasses, self.sequence_metric_dict,\\n metric_seq=self.metric_sequence_list, region_seq=self.region_sequence_list)\\n\\n # unpack variables\\n self.spat_ludata, self.spat_water, self.spat_coords, self.spat_aez_region, self.spat_grid_id, self.spat_aez, \\\\\\n self.spat_region, self.ngrids, self.cellarea, self.celltrunk, self.sequence_metric_dict = base_data\\n\\n self.config.logger.info('PERFORMANCE: Base spatial landuse data prepared in {0} seconds'.format(time.time() - t0))\",\n \"def _bs_forecasts(self, dfsamples, dfldfs, scale_param):\\n dfcombined = self._get_dfcombined(dfsamples, dfldfs)\\n min_origin_year = dfcombined[\\\"origin\\\"].min()\\n dfcombined[\\\"_l_init_indx\\\"] = np.where(\\n dfcombined[\\\"dev\\\"].values >= dfcombined[\\\"l_act_dev\\\"].values,\\n dfcombined.index.values, -1\\n )\\n dfacts = dfcombined[(dfcombined[\\\"origin\\\"].values == min_origin_year) |\\n (dfcombined[\\\"_l_init_indx\\\"].values == -1)]\\n\\n dffcst = dfcombined[~dfcombined.index.isin(dfacts.index)].sort_values(\\n by=[\\\"sim\\\", \\\"origin\\\", \\\"dev\\\"])\\n dffcst[\\\"_l_act_indx\\\"] = dffcst.groupby([\\\"sim\\\", \\\"origin\\\"])[\\\"_l_init_indx\\\"].transform(\\\"min\\\")\\n l_act_cum = dffcst.loc[dffcst[\\\"_l_act_indx\\\"], \\\"samp_cum\\\"].values\\n dffcst[\\\"l_act_cum\\\"] = l_act_cum\\n dffcst[\\\"_cum_ldf\\\"] = dffcst.groupby([\\\"sim\\\", \\\"origin\\\"])[\\\"ldf\\\"].transform(\\n \\\"cumprod\\\").shift(periods=1)\\n dffcst[\\\"_samp_cum2\\\"] = dffcst[\\\"l_act_cum\\\"].values * dffcst[\\\"_cum_ldf\\\"].values\\n dffcst[\\\"_samp_cum2\\\"] = np.where(\\n np.isnan(dffcst[\\\"_samp_cum2\\\"].values), 0, dffcst[\\\"_samp_cum2\\\"].values\\n )\\n dffcst[\\\"cum_final\\\"] = np.where(\\n np.isnan(dffcst[\\\"samp_cum\\\"].values), 0,\\n dffcst[\\\"samp_cum\\\"].values) + dffcst[\\\"_samp_cum2\\\"].values\\n\\n # Combine forecasts with actuals then compute incremental losses by sim and origin.\\n dffcst = dffcst.drop(labels=[\\\"samp_cum\\\", \\\"samp_incr\\\"], axis=1).rename(\\n columns={\\\"cum_final\\\": \\\"samp_cum\\\"})\\n dfsqrd = pd.concat([dffcst, dfacts], sort=True).sort_values(\\n by=[\\\"sim\\\", \\\"origin\\\", \\\"dev\\\"])\\n dfsqrd[\\\"_dev1_ind\\\"] = (dfsqrd[\\\"dev\\\"].values == 1) * 1\\n dfsqrd[\\\"_incr_dev1\\\"] = dfsqrd[\\\"_dev1_ind\\\"].values * dfsqrd[\\\"samp_cum\\\"].values\\n dfsqrd[\\\"_incr_dev2\\\"] = dfsqrd.groupby([\\\"sim\\\", \\\"origin\\\"])[\\\"samp_cum\\\"].diff(periods=1)\\n dfsqrd[\\\"_incr_dev2\\\"] = np.where(\\n np.isnan(dfsqrd[\\\"_incr_dev2\\\"].values), 0, dfsqrd[\\\"_incr_dev2\\\"].values\\n )\\n dfsqrd[\\\"samp_incr\\\"] = dfsqrd[\\\"_incr_dev1\\\"].values + dfsqrd[\\\"_incr_dev2\\\"].values\\n dfsqrd[\\\"var\\\"] = np.abs(dfsqrd[\\\"samp_incr\\\"].values * scale_param)\\n dfsqrd[\\\"sign\\\"] = np.where(dfsqrd[\\\"samp_incr\\\"].values > 0, 1, -1)\\n dfsqrd = dfsqrd.drop(\\n labels=[ii for ii in dfsqrd.columns if ii.startswith(\\\"_\\\")], axis=1)\\n return(dfsqrd.sort_values(by=[\\\"sim\\\", \\\"origin\\\", \\\"dev\\\"]).reset_index(drop=True))\",\n \"def spectral_model(self):\\n spec_type = self.data['SpectrumType'].strip()\\n pars, errs = {}, {}\\n pars['amplitude'] = self.data['Flux_Density']\\n errs['amplitude'] = self.data['Unc_Flux_Density']\\n pars['reference'] = self.data['Pivot_Energy']\\n\\n if spec_type == 'PowerLaw':\\n pars['index'] = self.data['Spectral_Index'] * u.dimensionless_unscaled\\n errs['index'] = self.data['Unc_Spectral_Index'] * u.dimensionless_unscaled\\n model = PowerLaw(**pars)\\n elif spec_type == 'PLExpCutoff':\\n pars['index'] = self.data['Spectral_Index'] * u.dimensionless_unscaled\\n pars['ecut'] = self.data['Cutoff']\\n errs['index'] = self.data['Unc_Spectral_Index'] * u.dimensionless_unscaled\\n errs['ecut'] = self.data['Unc_Cutoff']\\n model = ExponentialCutoffPowerLaw3FGL(**pars)\\n elif spec_type == 'LogParabola':\\n pars['alpha'] = self.data['Spectral_Index'] * u.dimensionless_unscaled\\n pars['beta'] = self.data['beta'] * u.dimensionless_unscaled\\n errs['alpha'] = self.data['Unc_Spectral_Index'] * u.dimensionless_unscaled\\n errs['beta'] = self.data['Unc_beta'] * u.dimensionless_unscaled\\n model = LogParabola(**pars)\\n elif spec_type == \\\"PLSuperExpCutoff\\\":\\n # TODO: why convert to GeV here? Remove?\\n pars['reference'] = pars['reference'].to('GeV')\\n pars['index_1'] = self.data['Spectral_Index'] * u.dimensionless_unscaled\\n pars['index_2'] = self.data['Exp_Index'] * u.dimensionless_unscaled\\n pars['ecut'] = self.data['Cutoff'].to('GeV')\\n errs['index_1'] = self.data['Unc_Spectral_Index'] * u.dimensionless_unscaled\\n errs['index_2'] = self.data['Unc_Exp_Index'] * u.dimensionless_unscaled\\n errs['ecut'] = self.data['Unc_Cutoff'].to('GeV')\\n model = PLSuperExpCutoff3FGL(**pars)\\n else:\\n raise ValueError('Spectral model {} not available'.format(spec_type))\\n\\n model.parameters.set_parameter_errors(errs)\\n return model\",\n \"def _project_sensors_onto_inflated(\\n info,\\n trans,\\n subject,\\n subjects_dir=None,\\n picks=None,\\n max_dist=0.004,\\n flat=False,\\n verbose=None,\\n):\\n subjects_dir = get_subjects_dir(subjects_dir, raise_error=True)\\n surf_data = dict(lh=dict(), rh=dict())\\n x_dir = np.array([1.0, 0.0, 0.0])\\n surfs = (\\\"pial\\\", \\\"inflated\\\")\\n if flat:\\n surfs += (\\\"cortex.patch.flat\\\",)\\n for hemi in (\\\"lh\\\", \\\"rh\\\"):\\n for surf in surfs:\\n for img in (\\\"\\\", \\\".T1\\\", \\\".T2\\\", \\\"\\\"):\\n surf_fname = subjects_dir / subject / \\\"surf\\\" / f\\\"{hemi}.{surf}\\\"\\n if surf_fname.is_file():\\n break\\n if surf.split(\\\".\\\")[-1] == \\\"flat\\\":\\n surf = \\\"flat\\\"\\n coords, faces, orig_faces = _read_patch(surf_fname)\\n # rotate 90 degrees to get to a more standard orientation\\n # where X determines the distance between the hemis\\n coords = coords[:, [1, 0, 2]]\\n coords[:, 1] *= -1\\n else:\\n coords, faces = read_surface(surf_fname)\\n if surf in (\\\"inflated\\\", \\\"flat\\\"):\\n x_ = coords @ x_dir\\n coords -= np.max(x_) * x_dir if hemi == \\\"lh\\\" else np.min(x_) * x_dir\\n surf_data[hemi][surf] = (coords / 1000, faces) # mm -> m\\n # get channel locations\\n picks_idx = _picks_to_idx(info, \\\"seeg\\\" if picks is None else picks)\\n locs = np.array([info[\\\"chs\\\"][idx][\\\"loc\\\"][:3] for idx in picks_idx])\\n trans = _ensure_trans(trans, \\\"head\\\", \\\"mri\\\")\\n locs = apply_trans(trans, locs)\\n # initialize projected locs\\n proj_locs = np.zeros(locs.shape) * np.nan\\n surf = \\\"flat\\\" if flat else \\\"inflated\\\"\\n for hemi in (\\\"lh\\\", \\\"rh\\\"):\\n hemi_picks = np.where(locs[:, 0] <= 0 if hemi == \\\"lh\\\" else locs[:, 0] > 0)[0]\\n # compute distances to pial vertices\\n nearest, dists = _compute_nearest(\\n surf_data[hemi][\\\"pial\\\"][0], locs[hemi_picks], return_dists=True\\n )\\n mask = dists / 1000 < max_dist\\n proj_locs[hemi_picks[mask]] = surf_data[hemi][surf][0][nearest[mask]]\\n # back to the \\\"head\\\" coordinate frame for storing in ``raw``\\n proj_locs = apply_trans(invert_transform(trans), proj_locs)\\n montage = info.get_montage()\\n montage_kwargs = (\\n montage.get_positions() if montage else dict(ch_pos=dict(), coord_frame=\\\"head\\\")\\n )\\n for idx, loc in zip(picks_idx, proj_locs):\\n montage_kwargs[\\\"ch_pos\\\"][info.ch_names[idx]] = loc\\n info.set_montage(make_dig_montage(**montage_kwargs))\\n return info\",\n \"def plot_combined_spectrum(SSC, band):\\n\\n def get_spectrum(SSC, band):\\n spectrum = spectra[str(SSC['no'])][band]\\n frequency = spectrum['frequency'].to(u.GHz)\\n intensity = spectrum['spectrum'].to(u.K)\\n # shift spectrum to rest frequency\\n velshift = SSC['velshift']\\n frequency = [(-vsys-velshift).to(u.GHz, equivalencies=u.doppler_optical(f)).value for f in frequency]*u.GHz\\n # remove NaNs\\n frequency, intensity = crossmatch(frequency.to(u.GHz).value, intensity.to(u.K).value)\\n return frequency, intensity\\n\\n def get_model(SSC, band):\\n with open(escape_fname(os.path.join(XCLASSdir,'SSC_'+str(SSC['no']),'combined_model.spectrum.pickle')), 'rb') as f:\\n m = pickle.load(f, encoding=\\\"latin1\\\")\\n frequency = (m[:,0]*u.MHz).to(u.GHz)\\n model = m[:,1]*u.K\\n return frequency.value,model.value\\n\\n def set_up_figure(SSC, band):\\n fig,ax = plt.subplots(nrows=1, ncols=1, squeeze=True, sharex='col', sharey='row', figsize=(10,8))\\n ax.text(0.05, 0.9, 'SSC '+str(SSC['no'])+': '+band, color='k', transform=ax.transAxes, ha='left', va='top', weight='bold', fontsize=16, bbox=props)\\n return fig,ax\\n\\n def plot_spectrum(ax, frequency, spectrum):\\n ax.plot(frequency, spectrum, lw=1, ls='-', color='k', zorder=3)\\n ax.fill_between(frequency, spectrum, [0. for f in frequency], color='grey', alpha=0.5, zorder=2)\\n\\n def plot_fitted_spectrum(ax, frequency, model):\\n ax.plot(frequency, model, lw=1, ls='-', color='r', zorder=5)\\n # ax.fill_between(frequency, model, [0. for f in frequency], color='r', alpha=0.5, zorder=4)\\n\\n def get_detected_lines(band=None):\\n # get detected species\\n all_species = []\\n for SSC in SSCs:\\n for specie in detected_species[str(SSC['no'])]:\\n if not specie in all_species:\\n all_species.append(specie)\\n # get all lines of the detected species\\n all_lines = []\\n for specie in all_species:\\n slines = [l for l in lines if l['XCLASS']==specie]\\n for sl in slines:\\n all_lines.append(sl)\\n # keep only lines of given band\\n if not band==None:\\n bandlines = []\\n for line in all_lines:\\n if band=='LSB':\\n if line['restfreq']<350*u.GHz:\\n bandlines.append(line)\\n elif band=='USB':\\n if line['restfreq']>350*u.GHz:\\n bandlines.append(line)\\n return sorted(bandlines, key=lambda k: k['restfreq'])\\n else:\\n return sorted(all_lines, key=lambda k: k['restfreq'])\\n\\n def label_lines(ax, spectrum, band):\\n detected_lines = get_detected_lines(band=band)\\n for idx,line in enumerate(detected_lines):\\n restfreq = line['restfreq'].to(u.GHz).value\\n if (restfreq>frequency[0] and restfreq<frequency[-1]):\\n if band=='LSB':\\n xlim = [342.4, 346.2]\\n elif band=='USB':\\n xlim = [354.3, 358.1]\\n xloc = xlim[0] +((idx+0.5)/len(detected_lines))*(xlim[1]-xlim[0])\\n ax.axvline(x=restfreq, ymin=0, ymax=1, color='dimgrey', ls='--', lw=0.5, zorder=1)\\n ax.plot([restfreq,xloc], [1.05*np.nanmax(spectrum), 1.05*1.05*np.nanmax(spectrum)], color='dimgrey', ls='--', lw=0.5, zorder=1, clip_on=False)\\n ax.text(xloc, 1.06*1.05*np.nanmax(spectrum), line_tex(line), color='dimgrey', fontsize=10, rotation=90, ha='center', va='bottom')\\n\\n def format_figure(ax, frequency, spectrum, band):\\n if band=='LSB':\\n ax.set_xlim([342.4, 346.2])\\n elif band=='USB':\\n ax.set_xlim([354.3, 358.1])\\n ax.set_ylim(-0.05*np.nanmax(spectrum), 1.05*np.nanmax(spectrum))\\n ax.xaxis.set_major_locator(MultipleLocator(0.5))\\n ax.xaxis.set_minor_locator(MultipleLocator(0.1))\\n ax.yaxis.set_major_locator(MultipleLocator(10))\\n ax.yaxis.set_minor_locator(MultipleLocator(2))\\n ax.tick_params(axis='both', which='major', labelsize=12)\\n ax.set_axisbelow(True)\\n ax.grid(axis='y', ls=':', c='grey')\\n ax.set_xlabel(r'$\\\\nu_\\\\mathrm{rest}$ [GHz]', fontsize=12)\\n ax.set_ylabel(r'T$_\\\\mathrm{b}$ [K]', fontsize=12)\\n fig.set_tight_layout(True)\\n\\n def save_figure(fig, band):\\n savepath = escape_fname(os.path.join(plotdir, '03.XCLASS_fit', 'combined_spectra', 'SSC_'+str(SSC['no'])+'.'+band+'.combined_spectrum.pdf'))\\n os.system('mkdir -p '+os.path.dirname(savepath))\\n fig.savefig(savepath, dpi=300, bbox_inches='tight')\\n\\n\\n frequency, spectrum = get_spectrum(SSC, band)\\n mfrequency, model = get_model(SSC, band)\\n fig,ax = set_up_figure(SSC, band)\\n plot_spectrum(ax, frequency, spectrum)\\n plot_fitted_spectrum(ax, mfrequency, model)\\n label_lines(ax, spectrum, band)\\n format_figure(ax, frequency, spectrum, band)\\n save_figure(fig, band)\",\n \"def sosfiltfilt(pro, sos, axis, **kwargs):\\n\\n # get initial value from producer\\n subarr = next(iter(pro))\\n x0 = slice_along_axis(subarr, 0, 1, axis=axis) \\n\\n # build steady state initial condition\\n zi = sps.sosfilt_zi(sos) #nsections x 2\\n # reshape zi so zi * x0 broadcast to correct shape for zi param\\n s = [1] * len(pro.shape)\\n s[axis] = 2\\n zi = np.reshape(zi, (sos.shape[0], *s)) #nsections,1,2\\n\\n # build a generators of forward filtered with one advanced\\n a_gen = iter(sosfilt(pro, sos, axis, zi=zi*x0)) \\n b_gen = iter(sosfilt(pro, sos, axis, zi=zi*x0))\\n next(b_gen)\\n\\n n = int(np.ceil(pro.shape[axis] / pro.chunksize))\\n for idx, a in enumerate(a_gen, 1):\\n\\n if idx < n:\\n\\n b = next(b_gen)\\n # for reverse filter, use final delay values from flipped\\n # advanced 'b' arr as initial values for current flipped arr. \\n bflipped = np.flip(b, axis=axis)\\n b_0 = slice_along_axis(bflipped, 0, 1, axis=axis)\\n _, zf = sps.sosfilt(sos, bflipped, axis=axis, zi=zi*b_0)\\n\\n aflipped = np.flip(a, axis=axis)\\n rfilt, _ = sps.sosfilt(sos, aflipped, axis=axis, zi=zf)\\n yield np.flip(rfilt, axis=axis)\\n\\n else:\\n \\n # for last segment the initial condition is last sample ss\\n aflipped = np.flip(a, axis=axis)\\n a0 = slice_along_axis(aflipped, 0, 1, axis=axis)\\n rfilt, _ = sps.sosfilt(sos, aflipped, axis=axis, zi=zi*a0)\\n yield np.flip(rfilt, axis=axis)\",\n \"def from_basisgrid(cls, bg):\\n \\n cspad = cls(type_name='CSPAD:V1')\\n \\n if not isinstance(bg, basisgrid.BasisGrid):\\n raise TypeError('`bg` argument must be instance of BasisGrid,'\\n ' got: %s' % type(bg))\\n \\n \\n # if the grids are asics, we can strip out every other one and then\\n # treat them like 2x1s \\n if bg.num_pixels / bg.num_grids == 185 * 388: # two-by-one grids\\n stride = 1\\n \\n elif bg.num_pixels / bg.num_grids == 185 * 194: # asic grids\\n stride = 2\\n \\n else:\\n raise RuntimeError('Could not tell if BasisGrid grid elements are '\\n 'CSPAD 2x1s or ASICs. Pixels per element:'\\n '%d' % (bg.num_pixels / bg.num_grids,))\\n \\n for g in range(0, bg.num_grids, stride):\\n \\n asic_id = (g/stride) # index from 0 to 7\\n \\n # find the quad geometry\\n quad_index = asic_id / 8\\n \\n # we just put the quads in a zero'd frame, no knowledge of absolute\\n # orientations\\n quad_rot = np.array([0.0, 0.0, 0.0])\\n quad_trs = np.array([0.0, 0.0, 0.0])\\n \\n \\n # add a new quad if necessary\\n if asic_id % 8 == 0:\\n quad = CompoundCamera(type_name='QUAD:V1',\\n id_num=quad_index,\\n parent=cspad,\\n rotation_angles=quad_rot, \\n translation=quad_trs)\\n \\n p, s, f, shape = bg.get_grid(g)\\n \\n pixel_shape = (np.linalg.norm(s),\\n np.linalg.norm(f))\\n \\n \\n # compute the rotation based on s/f vectors\\n us = s / pixel_shape[0] # unit vector\\n uf = f / pixel_shape[1] # unit vector\\n \\n # BIG WARNING: There is a minus sign on `us` below, which is needed\\n # to account for the fact that the slow scan is swapped in the\\n # sensors.Cspad2x1 class\\n \\n n = np.cross(uf, -us) # tested for orthog. in next fxn\\n ra = moveable._angles_from_rotated_frame(uf, -us, n)\\n \\n \\n # translation is center of 2x1, less the quad center\\n # dont forget the big pixels!\\n # dont forget p/s/f here is only an ASIC!\\n # dont forget p points to the middle of a pixel!\\n\\n tr = p + 184.0/2.0 * 109.92 * us + (192.5 * 109.92 + 274.8) * uf\\n\\n \\n # construct the 2x1\\n pas = sensors.Cspad2x1(type_name='SENS2X1:V1', \\n id_num=int(asic_id % 8), \\n parent=quad,\\n rotation_angles=ra, \\n translation=tr)\\n \\n \\n # if we skipped a grid (ASIC), we'll check to make sure that\\n # the p-vector from that grid points to the correct pixel on\\n # our newly oriented 2x1 -- allow 10 um error in x/y, 200 um in z\\n \\n if stride == 2:\\n \\n p_skipped, _, _, _ = bg.get_grid(g + 1)\\n \\n # be more lenient in z, since some programs are not general\\n # enough to handle it\\n \\n if (np.linalg.norm(p_skipped[:2] - pas.xyz[0,194,:2]) > 10.0) or \\\\\\n (np.abs(p_skipped[2] - pas.xyz[0,194,2]) > 200.0):\\n \\n print 'quad %d / 2x1 %d' % (quad_index, asic_id % 8)\\n print 'grid p-vector: ', p_skipped\\n print 'pixel (0, 194): ', pas.xyz[0,194,:]\\n print ''\\n \\n warnings.warn('The two ASICs making up the %d-th 2x1 on '\\n 'the %d-th quad (grids %d, %d) do not conform'\\n ' to the geometric requirements of a 2x1 '\\n 'unit. Check your geometry! Do not ignore this'\\n ' warning unless you were expecting it!!'\\n '' % (asic_id % 8, quad_index, g, g+1))\\n \\n if _STRICT:\\n raise RuntimeError('_STRICT set, no warnings allowed')\\n \\n \\n return cspad\",\n \"def buildSasGrid(self):\\n\\n self.q = np.linspace(-self.qmax, self.qmax, self.nq)\\n self.sasGrid = sasmodels.data.empty_data2D(self.q)\\n\\n return\",\n \"def HD_input_snfit_data(self):\\n\\n dico = cPickle.load(open(SUGAR_parameter_pkl))\\n self.read_snfit_results()\\n self.read_meta()\\n Filtre = np.array([True]*len(self.sn_name))\\n self.zcmb = []\\n self.z_err = []\\n for j in range(len(self.sn_name)):\\n if self.sn_name[j] in dico.keys() and self.sn_name[j] :\\n\\n for i in range (len(self.meta_sn_name_list)):\\n if self.sn_name[j] == self.meta_sn_name_list[i]:\\n \\n self.z_err.append(self.meta_zhl_err[i])\\n self.zcmb.append(self.meta_zcmb[i])\\n if np.abs(self.x1[j] - self.meta_x1[i]) > 0.001:\\n print 'problem with %s include in sample but difference between snfit and meta'%(self.sn_name[j])\\n else:\\n Filtre[j] = False\\n\\n for p in dico.keys():\\n if p not in self.sn_name:\\n print p\\n \\n self.x1 = self.x1[Filtre]\\n self.x1_err = self.x1_err[Filtre] \\n self.c = self.c[Filtre]\\n self.c_err = self.c_err[Filtre]\\n self.mb = self.mb[Filtre]\\n self.mb_err = self.mb_err[Filtre]\\n self.cov_x0_x1 = self.cov_x0_x1[Filtre]\\n self.cov_x0_c = self.cov_x0_c[Filtre]\\n self.cov_x1_c = self.cov_x1_c[Filtre]\\n self.cov_mb_x1 = self.cov_mb_x1[Filtre]\\n self.cov_mb_c = self.cov_mb_c[Filtre]\\n self.z = self.z[Filtre]\\n self.zcmb = np.array(self.zcmb)\\n self.z_err = np.array(self.z_err)\\n\\n self.cov_y = np.zeros((len(self.mb)*3,len(self.mb)*3))\\n\\n for i in range (len(self.mb)):\\n self.cov_y[i*3,i*3] = self.mb_err[i]**2\\n self.cov_y[i*3+ 1,i*3+ 1] = self.x1_err[i]**2\\n \\n self.cov_y[i*3+ 2,i*3+ 2] = self.c_err[i]**2\\n self.cov_y[i*3+ 0,i*3+ 1] = self.cov_mb_x1[i]\\n self.cov_y[i*3+ 1,i*3+ 0] = self.cov_mb_x1[i]\\n self.cov_y[i*3+ 0,i*3+ 2] = self.cov_mb_c[i]\\n self.cov_y[i*3+ 2,i*3+ 0] = self.cov_mb_c[i]\\n self.cov_y[i*3+ 1,i*3+ 2] = self.cov_x1_c[i] \\n self.cov_y[i*3+ 2,i*3+ 1] = self.cov_x1_c[i] \\n \\n self.salt_parm = np.array([self.mb,self.x1,self.c]).T\\n# print len(self.salt_parm), len(self.cov_y), len(self.z), len(self.zcmb)\\n# return self.salt_parm, self.cov_y, self.z, self.meta_zcmb, self.meta_zhl_err, self.sn_name, self.meta_idr\\n return self.salt_parm, self.cov_y, self.z, self.zcmb, self.z_err\",\n \"def update_pressure(self):\\n m_multipliers = np.ones(self.mesh.get_number_of_cells())\\n\\n\\n rhs_current = np.zeros(self.mfd.get_number_of_dof()) \\n rhs_current += self.rhs_mfd\\n\\n\\n for cell_index in range(self.mesh.get_number_of_cells()):\\n density = -self.ref_pressure\\n density += self.current_pressure[cell_index]\\n density *= self.compressibility\\n density += 1.\\n density *= self.ref_density\\n\\n # We multiply by the inverse of \\\\frac{\\\\rho}{\\\\mu}\\n m_multipliers[cell_index] = self.viscosity/density\\n\\n c_entry = self.compressibility\\n c_entry *= self.porosities[cell_index]\\n c_entry /= self.delta_t\\n c_entry *= self.mesh.get_cell_volume(cell_index)\\n\\n rhs_current[self.mesh.get_number_of_faces()+\\n cell_index] += c_entry*self.current_pressure[cell_index]\\n\\n self.lhs_coo.data[self.c_start+cell_index] = c_entry\\n\\n for [index, cell_index] in enumerate(self.rate_wells):\\n rhs_current[self.mesh.get_number_of_faces()+cell_index] += \\\\\\n self.rate_wells_rate[index]\\n\\n self.mfd.update_m(self.lhs_coo.data[:self.m_x_coo_length], m_multipliers)\\n\\n solution = dsolve.spsolve(self.lhs_coo.tocsr(), rhs_current)\\n self.prev_pressure = self.current_pressure\\n self.current_pressure = solution[self.mesh.get_number_of_faces():]\\n self.current_velocity = solution[:self.mesh.get_number_of_faces()]\",\n \"def spsofilt(self, i):\\n\\n # separate NaN and non-NaN values to avoid NaN filter output on cleaned data\\n data_nan = self.data[i][self.data[i]['Raw'].isna()]\\n data_notnan = self.data[i][self.data[i]['Raw'].isna() == False]\\n\\n # filter notNaN data & add column to notNaN df\\n ## bandpass\\n data_notnan_bandpassed = sosfiltfilt(self.spso_sos_bandpass, data_notnan.to_numpy(), axis=0)\\n ## now bandstop\\n data_notnan_filt = sosfiltfilt(self.spso_sos_bandstop, data_notnan_bandpassed, axis=0)\\n data_notnan['Filt'] = data_notnan_filt\\n\\n # merge NaN & filtered notNaN values, sort on index\\n filt_chan = data_nan['Raw'].append(data_notnan['Filt']).sort_index()\\n\\n # add channel to main dataframe\\n self.spsofiltEEG[i] = filt_chan\",\n \"def _build_datasets_sis3302(self):\\n bc_arr = np.where(self._active_brdch[\\\"SIS 3302\\\"])\\n\\n for board, channel in zip(bc_arr[0], bc_arr[1]):\\n brd = board + 1\\n ch = channel + 1\\n slot = self.get_slot(brd, \\\"SIS 3302\\\")\\n\\n for cname in self._active_config:\\n # create main dataset\\n dset_name = f\\\"{cname} [Slot {slot}: SIS 3302 ch {ch}]\\\"\\n shape = (self._sn_size, self._nt)\\n data = np.empty(shape=shape, dtype=np.int16)\\n self.create_dataset(dset_name, data=data)\\n\\n # create header dataset\\n hdset_name = f\\\"{dset_name} headers\\\"\\n shape = (self._sn_size,)\\n dtype = np.dtype(\\n [\\n (\\\"Shot number\\\", np.int32),\\n (\\\"Scale\\\", np.float32),\\n (\\\"Offset\\\", np.float32),\\n (\\\"Min\\\", np.uint16),\\n (\\\"Max\\\", np.uint16),\\n (\\\"Clipped\\\", np.int8),\\n ]\\n )\\n dheader = np.empty(shape=shape, dtype=dtype)\\n dheader[\\\"Shot number\\\"] = np.arange(\\n 1, shape[0] + 1, 1, dtype=dheader[\\\"Shot number\\\"].dtype\\n )\\n dheader[\\\"Scale\\\"] = 7.7241166e-5\\n dheader[\\\"Offset\\\"] = -2.531\\n dheader[\\\"Min\\\"] = data.min(axis=1)\\n dheader[\\\"Max\\\"] = data.max(axis=1)\\n dheader[\\\"Clipped\\\"] = 0\\n self.create_dataset(hdset_name, data=dheader)\",\n \"def setup_flux_contours(self):\\n e = self.e\\n \\n self.npsi = len(e.getRmidPsi()[self.tind])\\n self.psigrid = np.linspace(0, 1, self.npsi)\\n \\n refineFactor = 4\\n \\n # This is the default psigrid to evaluate on\\n psigridRefine = np.linspace(0, 1, self.npsi * refineFactor)\\n self.psigridEv = (psigridRefine[1:] + psigridRefine[:-1])/2.0\\n self.dpsigridEv = np.diff(psigridRefine)\\n \\n # This is an array of numpy arrays of (R,Z) coordinates which poloidally\\n # parameterize the flux surface. Note that the last point is not equal\\n # to the first point, so if a closed contour is desired, the last point\\n # must be repeated\\n self.psicontours = [None]*(len(self.psigridEv))\\n \\n # The following two are the length element (ds) and the flux surface\\n # area element (ds/Bp) for each flux surface element given in psicontours.\\n # Note that these are calculated as centered on the given R,Z coordinates.\\n self.psicontours_ds = [None]*(len(self.psigridEv))\\n # Note an additional very important fact; Bp has been normalized such\\n # that psi_axis = 0 and psi_LCFS = 1!!!\\n self.psicontours_dsbp = [None]*(len(self.psigridEv))\\n \\n rgrid = e.getRGrid()\\n zgrid = e.getZGrid()\\n \\n # Begin by loading up basic magnetic geometry information\\n self.magR = e.getMagR()[self.tind]\\n self.magZ = e.getMagZ()[self.tind]\\n self.magRZ = np.array([self.magR, self.magZ])\\n \\n self.fluxRZ = e.getFluxGrid()[self.tind,:,:]\\n \\n psiMin = e.getFluxAxis()[self.tind]\\n psiMax = e.getFluxLCFS()[self.tind]\\n self.psiRange = psiMax-psiMin\\n \\n self.psinormRZ = (self.fluxRZ-psiMin)/self.psiRange\\n \\n # Set up interpolation functions for the poloidal flux\\n self.psifunc = scipy.interpolate.RectBivariateSpline(rgrid, zgrid, self.fluxRZ.T, kx=2, ky=2)\\n self.psinormfunc = scipy.interpolate.RectBivariateSpline(rgrid, zgrid, self.psinormRZ.T, kx=2, ky=2)\\n \\n # Set up an upscaled version of the poloidal flux, since the conour finder\\n # performs better on the upscaled version\\n rgrid_upscaled = np.linspace(rgrid[0], rgrid[-1], len(rgrid)*4)\\n zgrid_upscaled = np.linspace(zgrid[0], zgrid[-1], len(zgrid)*8)\\n rmesh, zmesh = np.meshgrid(rgrid_upscaled, zgrid_upscaled)\\n \\n rfunc = scipy.interpolate.interp1d(range(len(rgrid_upscaled)), rgrid_upscaled)\\n zfunc = scipy.interpolate.interp1d(range(len(zgrid_upscaled)), zgrid_upscaled)\\n psinormRZ_upscaled = self.psinormfunc.ev(rmesh, zmesh)\\n \\n \\n # Use skimage to get contours easily for us\\n for i in range(len(self.psigridEv)):\\n contours = measure.find_contours(psinormRZ_upscaled, self.psigridEv[i])\\n if len(contours) == 1:\\n self.psicontours[i] = np.array([rfunc(contours[0][:,1]), zfunc(contours[0][:,0])])\\n elif len(contours) > 1:\\n minDist = np.inf\\n for c in contours:\\n rz = np.array([rfunc(c[:,1]), zfunc(c[:,0])])\\n \\n if np.linalg.norm(np.mean(rz, axis=1) - self.magRZ) < minDist:\\n self.psicontours[i] = rz\\n minDist = np.linalg.norm(np.mean(rz, axis=1) - self.magRZ)\\n else:\\n self.psicontours[i] = np.array([self.magRZ]).T\\n \\n if self.plotting:\\n plt.figure()\\n \\n # Resample the contours such that the point spacings are of approximately equal arclength\\n for i in range(len(self.psigridEv)):\\n cRZ = self.psicontours[i]\\n \\n ctheta = np.unwrap(np.arctan2(cRZ[1] - self.magZ, cRZ[0] - self.magR))\\n cr = np.linalg.norm(cRZ - self.magRZ[:,np.newaxis], axis=0)\\n \\n dtheta = np.unwrap(np.diff(ctheta))\\n dr = np.diff(cr)\\n r = (cr[1:] + cr[:-1])/2.0\\n \\n # Calculate total contour arclength using ds**2 = dr**2 + (r*dtheta)**2\\n ds = np.sqrt(dr**2 + (r*dtheta)**2)\\n cs = np.concatenate(([0], np.cumsum(ds)))\\n \\n cthetaFunc = scipy.interpolate.interp1d(cs, ctheta)\\n crFunc = scipy.interpolate.interp1d(cs, cr, kind='quadratic')\\n \\n # Resample to an odd number of points\\n resamp_theta = cthetaFunc(np.linspace(0, cs[-1], (len(cr)/2)*2+1))\\n resamp_r = crFunc(np.linspace(0, cs[-1], (len(cr)/2)*2+1))\\n \\n dtheta2 = np.diff(resamp_theta[::2])\\n dr2 = np.diff(resamp_r[::2])\\n \\n cr2 = resamp_r[1::2]\\n ctheta2 = resamp_theta[1::2]\\n \\n ds2 = np.sqrt(dr2**2 + (cr2*dtheta2)**2)\\n \\n resampled_cRZ = np.array([np.cos(ctheta2), np.sin(ctheta2)]*cr2[np.newaxis,:]) + self.magRZ[:,np.newaxis]\\n \\n if self.plotting:\\n plt.plot(resampled_cRZ[0,:], resampled_cRZ[1,:], marker='.')\\n \\n self.psicontours[i] = resampled_cRZ\\n self.psicontours_ds[i] = ds2\\n \\n # This equation is abs(del(psi) cross del(toroidal angle))\\n br_norm = -self.psinormfunc.ev(resampled_cRZ[0,:], resampled_cRZ[1,:], dy=1)\\n bz_norm = self.psinormfunc.ev(resampled_cRZ[0,:], resampled_cRZ[1,:], dx=1)\\n bp_norm = np.sqrt(br_norm**2 + bz_norm**2)/resampled_cRZ[0,:]\\n self.psicontours_dsbp[i] = ds2/bp_norm\",\n \"def da(y, X, nb_runs_x, ctl, reg, cons_test, formule_ic_tls, sample_extr):\\n #%% Options\\n # Spherical harmonics truncation\\n trunc = 0\\n # -> for extracting large sample Z into two samples Z1 and Z2\\n sampling_name = sample_extr \\n # fraction of data used in Z2 (the remaining is used in Z1)\\n frac_z2 = .5\\n #%% Input parameters\\n y = np.matrix(y).T\\n X = np.matrix(X).T\\n Z = np.transpose(np.matrix(ctl))\\n nb_runs_x = np.matrix(nb_runs_x)\\n # Number of Time steps\\n nbts = y.shape[0]\\n # Spatial dimension\\n n_spa = (trunc+1)**2\\n # Spatio_temporal dimension (ie dimension of y)\\n n_st = n_spa * nbts\\n # number of different forcings\\n I = X.shape[1]\\n if Z.shape[1] == 1:\\n nle = len(Z)\\n NZ = nle / n_st\\n fl = int(np.floor(Z.shape[0] / y.shape[0]))\\n Z = np.transpose(np.reshape(Z[:int(y.shape[0])*fl,], (fl, int(y.shape[0]))))\\n else:\\n NZ = Z.shape[1]\\n \\n ## Z1 and Z2 are taken from Z\\n ind_z = pda.extract_Z2(NZ, frac_z2, sampling_name)\\n ind_z1 = np.argwhere(ind_z == 0)[:, 0]\\n ind_z2 = np.argwhere(ind_z == 1)[:, 0]\\n Z1 = Z[:, ind_z1]\\n Z2 = Z[:, ind_z2]\\n\\n #%% Pre-processing\\n #%% Weighting of spherical harmonics (cf Stott & Tett, 1998)\\n l = pda.total_wave_number(trunc)\\n p = 1. / np.sqrt(2*l-1)\\n p.shape = (p.shape[0], 1)\\n pml = np.matrix(np.diag(np.reshape(np.transpose(p*np.ones((1, nbts))), (n_st, 1)).squeeze()))\\n y = np.dot(pml, y)\\n Z1 = np.dot(pml, Z1)\\n Z2 = np.dot(pml, Z2)\\n X = pml*X\\n\\n # Removing of useless dimensions (equivalent to remove one time step;\\n # see scientific documentation, Section 2)\\n # Spatio-temporal dimension after reduction\\n n_red = n_st - n_spa\\n U = pda.projfullrank(nbts, n_spa)\\n\\n ## Project all input data\\n yc = np.dot(U, y)\\n Z1c = np.dot(U, Z1)\\n Z2c = np.dot(U, Z2)\\n Xc = np.dot(U, X)\\n proj = np.identity(X.shape[1])\\n\\n #%% Statistical estimation\\n ## Regularised covariance matrix\\n Cf = pda.regC(Z1c.T)\\n Cf1 = np.real(spla.inv(Cf))\\n #Matrix is singular and may not have a square root. can be ignored\\n Cf12 = np.real(spla.inv(spla.sqrtm(Cf)))\\n #Matrix is singular and may not have a square root. can be ignored\\n Cfp12 = np.real(spla.sqrtm(Cf))\\n\\n if reg == 'OLS':\\n ## OLS algorithm\\n pv_consist = np.nan\\n Ft = np.transpose(np.dot(np.dot(spla.inv(np.dot(np.dot(Xc.T, Cf1), Xc)), Xc.T), Cf1))\\n beta_hat = np.dot(np.dot(yc.T, Ft), proj.T)\\n ## 1-D confidence intervals\\n NZ2 = Z2c.shape[1]\\n var_valid = np.dot(Z2c, Z2c.T) / NZ2\\n var_beta_hat = np.dot(np.dot(np.dot(np.dot(proj, Ft.T), var_valid), Ft), proj.T)\\n beta_hat_inf = beta_hat - sps.t.ppf(0.95, NZ2) * np.sqrt(np.diag(var_beta_hat))\\n beta_hat_sup = beta_hat + sps.t.ppf(0.95, NZ2) * np.sqrt(np.diag(var_beta_hat))\\n ## Consistency check\\n # print('Residual Consistency Check')\\n epsilon = yc - np.dot(np.dot(Xc, proj.T), beta_hat.T)\\n if cons_test == \\\"OLS_AT99\\\":\\n # Formula provided by Allen & Tett (1999)\\n d_cons = np.dot(np.dot(epsilon.T, np.linalg.pinv(var_valid)), epsilon) / (n_red - I)\\n pv_cons = 1 - sps.f.cdf(d_cons, n_red - I, NZ2)\\n elif cons_test == \\\"OLS_Corr\\\":\\n # Hotelling Formula\\n d_cons = np.dot(np.dot(epsilon.T, np.linalg.pinv(var_valid)), epsilon)/(NZ2*(n_red-I))*(NZ2-n_red+1)\\n if NZ2-n_red + 1 > 0:\\n pv_cons = 1 - sps.f.cdf(d_cons, n_red - I, NZ2 - n_red + 1)\\n else:\\n pv_cons = np.nan\\n else:\\n print('Unknown Cons_test : ', cons_test)\\n\\n elif reg == 'TLS':\\n ## TLS algorithm\\n c0, c1, c2, d_cons, x_tilde_white, y_tilde_white = pda.tls(np.dot(Xc.T, Cf12), np.dot(yc.T, Cf12), np.dot(Z2c.T, Cf12), nb_runs_x, proj, formule_ic_tls)\\n x_tilde = np.dot(Cfp12, x_tilde_white.T)\\n y_tilde = np.dot(Cfp12, y_tilde_white.T)\\n beta_hat = c0.T\\n beta_hat_inf = c1.T\\n beta_hat_sup = c2.T\\n\\n # Consistency check\\n print(\\\"Residual Consistency Check\\\")\\n NZ1 = Z1c.shape[1]\\n NZ2 = Z2c.shape[1]\\n\\n if cons_test == 'MC':\\n ## Null-distribution sampled via Monte-Carlo simulations\\n ## Note: input data here need to be pre-processed, centered, etc.\\n ## First, simulate random variables following the null-distribution\\n N_cons_mc = 1000\\n d_H0_cons = pda.consist_mc_tls(Cf, Xc, nb_runs_x, NZ1, NZ2, N_cons_mc, formule_ic_tls)\\n ## Evaluate the p-value from the H0 sample (this uses gke = gaussian kernel estimate)\\n pv_cons = pda.gke(d_H0_cons, d_cons)\\n elif cons_test == \\\"AS03\\\":\\n ## Formula provided by Allen & Stott (2003)\\n pv_cons = 1 - sps.f.cdf(d_cons / (n_red-I), n_red-I, NZ2)\\n else:\\n pv_cons = np.nan\\n\\n beta = np.zeros((4, I))\\n beta[:-1, :] = np.concatenate((beta_hat_inf, beta_hat, beta_hat_sup))\\n beta[-1, 0] = pv_cons\\n \\n return beta\",\n \"def preprocess(self, fs, signal):\\n # NUMERO TOTAL DE MUESTRAS\\n Y, frq, ceps = self.calculate_spectrum_cepstrum(signal, fs)\\n # Hacemos lista de (decibeles(Y), frecuencia(x)) tuples\\n esp_frecuencia_pairs = [(Y[i], frq[i]) for i in range(len(Y))]\\n # APLICAMOS FILTRO DE FRECUENCIAS\\n esp_frecuencia_pairs = [(Y[i], frq[i]) for i in range(\\n len(Y)) if frq[i] > self.min_frq and frq[i] < self.max_frq]\\n # FRECUENCIAS FILTRADAS\\n esp_aux = np.array(esp_frecuencia_pairs)\\n frq = esp_aux[:, 1]\\n # ESPECTRO DE POTENCIA\\n Y = esp_aux[:, 0]\\n # ORDENAMOS\\n esp_frecuencia_pairs.sort()\\n esp_frecuencia_pairs.reverse()\\n # OBTENEMOS TODAS LAS CARACTERISTICAS RELEVANTES\\n result = self.calculate_all_spec_props(\\n frq, Y, ceps, esp_frecuencia_pairs)\\n return result\",\n \"def _get_data(self, gas, loc, voltage, speed, trial):\\n cols = []\\n for g in gas:\\n for l in loc:\\n try:\\n (sub, files) = self._get_sensor_col_files(g, l)\\n except OSError as e:\\n print('{}\\\\n Keeping calm and carrying on.'.format(e))\\n continue\\n for v in voltage:\\n for s in speed:\\n end = \\\"_board_setPoint_%s_fan_setPoint_%s_mfc_setPoint_%sppm_p%s\\\" % (\\n self.SensorVoltages[v],\\n self.FanSpeeds[s],\\n self.GasNames[g],\\n self.AltLocs[l])\\n filtered = [f.split('/')[-1] for f in files if f.endswith(end)]\\n if not filtered:\\n if self._args['verbose']:\\n print('No valid files found for \\\"%s\\\", skipping!' % sub)\\n continue\\n timeStamp = [filt.split('_', 1)[0] for filt in filtered]\\n date = [time.strptime(ts, '%Y%m%d%H%M') for ts in timeStamp]\\n date = [time.strftime('%Y-%m-%d %H:%M', d) for d in date]\\n filtered = [os.path.join(sub, f) for f in filtered]\\n for i, filt in enumerate(filtered):\\n j = i + 1\\n if j in trial:\\n p = os.path.sep.join([self.dataloc_prefix,\\n self.data_location,\\n filt])\\n\\n cols.append(SensorColumn(data_location=p,\\n gas=self.GasNames[g],\\n loc=self.Locs[l],\\n voltage=self.SensorVoltages[v],\\n speed=self.AltFanSpeeds[s],\\n trial=j,\\n _args=self._args))\\n\\n if self._args['verbose']:\\n print('\\\\nSelected %i single trial SensorColumns!' % len(cols))\\n return cols\",\n \"def runCalFlat(lst, hband=False, darkLst=None, rootFolder='', nlCoef=None, satCounts=None, BPM=None, distMapLimitsFile='', plot=True, nChannel=32, nRowsAvg=0,rowSplit=1,nlSplit=32, combSplit=32,bpmCorRng=100, crReject=False, skipObsinfo=False,winRng=51, polyFitDegree=3, imgSmth=5,nlFile='',bpmFile='', satFile='',darkFile='',flatCutOff=0.1,flatSmooth=0, logfile=None, gain=1., ron=None, dispAxis=0,limSmth=20, ask=True, obsCoords=None,satSplit=32, centGuess=None, flatCor=False, flatCorFile=''):\\n\\n colorama.init()\\n \\n plt.ioff()\\n\\n t0 = time.time()\\n \\n #create processed directory, in case it doesn't exist\\n wifisIO.createDir('processed')\\n wifisIO.createDir('quality_control')\\n\\n if hband:\\n print('*** WORKING ON H-BAND DATA ***')\\n \\n #create processed directory, in case it doesn't exist\\n wifisIO.createDir('processed')\\n\\n if (plot):\\n wifisIO.createDir('quality_control')\\n\\n procFlux = []\\n procSigma = []\\n procSatFrame = []\\n\\n #go through list and process each file individually\\n #************\\n #eventually need to add capability to create master flat from groups\\n #************\\n\\n for lstNum in range(len(lst)):\\n if (lst.ndim>1):\\n folder = lst[lstNum,0]\\n else:\\n folder = lst[lstNum]\\n\\n t1 = time.time()\\n\\n savename = 'processed/'+folder\\n\\n #first check master flat and limits exists\\n \\n if(os.path.exists(savename+'_flat.fits') and os.path.exists(savename+'_flat_limits.fits') and os.path.exists(savename+'_flat_slices.fits') and os.path.exists(savename+'_flat_slices_norm.fits')):\\n cont = 'n'\\n if ask:\\n cont = wifisIO.userInput('All processed flat field files already exists for ' +folder+', do you want to continue processing (y/n)?')\\n else:\\n cont = 'y'\\n \\n if (cont.lower() == 'y'):\\n print('*** Working on folder ' + folder + ' ***')\\n\\n if (os.path.exists(savename+'_flat.fits')):\\n cont = 'n'\\n cont = wifisIO.userInput('Processed flat field file already exists for ' +folder+', do you want to continue processing (y/n)?')\\n \\n if (not cont.lower() == 'y'):\\n print('Reading image '+savename+'_flat.fits instead')\\n flatImgs, hdr= wifisIO.readImgsFromFile(savename+'_flat.fits')\\n flatImg, sigmaImg, satFrame = flatImgs\\n if (type(hdr) is list):\\n hdr = hdr[0]\\n contProc2=False\\n else:\\n contProc2=True\\n else:\\n contProc2=True\\n \\n if contProc2:\\n flatImg, sigmaImg, satFrame, hdr = processRamp.auto(folder, rootFolder,savename+'_flat.fits', satCounts, nlCoef, BPM, nChannel=nChannel, rowSplit=rowSplit, nlSplit=nlSplit, combSplit=combSplit, crReject=crReject, bpmCorRng=bpmCorRng, skipObsinfo=skipObsinfo, nRows=nRowsAvg, rampNum=None, nlFile=nlFile, satFile=satFile, bpmFile=bpmFile, gain=gain, ron=ron, logfile=logfile, obsCoords=obsCoords, avgAll=True, satSplit=satSplit)\\n \\n #carry out dark subtraction\\n if darkLst is not None and darkLst[0] is not None:\\n print('Subtracting dark ramp')\\n if len(darkLst)>1:\\n dark, darkSig = darkLst[:2]\\n sigmaImg = np.sqrt(sigmaImg**2 + darkSig**2)\\n else:\\n dark = darkLst[0]\\n logfile.write('*** Warning: No uncertainty associated with dark image ***\\\\n')\\n print(colorama.Fore.RED+'*** WARNING: No uncertainty associated with dark image ***'+colorama.Style.RESET_ALL)\\n\\n flatImg -= dark\\n hdr.add_history('Dark image subtracted using file:')\\n hdr.add_history(darkFile)\\n if logfile is not None:\\n logfile.write('Subtracted dark image using file:\\\\n')\\n logfile.write(darkFile+'\\\\n')\\n else:\\n print(colorama.Fore.RED+'*** WARNING: No dark image provided, or file does not exist ***'+colorama.Style.RESET_ALL)\\n if logfile is not None:\\n logfile.write('*** WARNING: No dark image provided, or file ' + str(darkFile)+' does not exist ***')\\n\\n if os.path.exists(savename+'_flat_limits.fits'):\\n cont = wifisIO.userInput('Limits file already exists for ' +folder+ ', do you want to continue processing (y/n)?')\\n \\n if (not cont.lower() == 'y'):\\n print('Reading limits '+savename+'_flat_limits.fits instead')\\n finalLimits, limitsHdr= wifisIO.readImgsFromFile(savename+'_flat_limits.fits')\\n shft = limitsHdr['LIMSHIFT']\\n contProc2 = False\\n else:\\n contProc2 = True\\n else:\\n contProc2= True\\n \\n if (contProc2):\\n print('Finding slice limits and extracting slices')\\n\\n #remove comment about contents of file\\n hdrTmp = hdr[::-1]\\n hdrTmp.remove('COMMENT')\\n hdr = hdrTmp[::-1]\\n \\n #find limits of each slice with the reference pixels, but the returned limits exclude them\\n limits = slices.findLimits(flatImg, dispAxis=dispAxis, winRng=winRng, imgSmth=imgSmth, limSmth=limSmth, rmRef=True,centGuess=centGuess)\\n\\n if logfile is not None:\\n logfile.write('Identified slice limits using the following parameters:\\\\n')\\n logfile.write('dispAxis: '+str(dispAxis)+'\\\\n')\\n logfile.write('winRng: ' + str(winRng)+'\\\\n')\\n logfile.write('imgSmth: ' + str(imgSmth)+'\\\\n')\\n logfile.write('limSmth: ' + str(limSmth)+'\\\\n')\\n \\n if hband:\\n print('Using suitable region of detector to determine flat limits')\\n if logfile is not None:\\n logfile.write('Using suitable region of detector to determine flat limits:\\\\n')\\n\\n #only use region with suitable flux\\n if dispAxis == 0:\\n flatImgMed = np.nanmedian(flatImg[4:-4,4:-4], axis=1)\\n else:\\n flatImgMed = np.nanmedian(flatImg[4:-4,4:-4], axis=0)\\n \\n flatImgMedGrad = np.gradient(flatImgMed)\\n medMax = np.nanargmax(flatImgMed)\\n lim1 = np.nanargmax(flatImgMedGrad[:medMax])\\n lim2 = np.nanargmin(flatImgMedGrad[medMax:])+medMax\\n\\n if logfile is not None:\\n logfile.write('Using following detector limits to set slice limits:\\\\n')\\n logfile.write(str(lim1)+ ' ' + str(lim2)+'\\\\n')\\n \\n polyLimits = slices.polyFitLimits(limits, degree=2, sigmaClipRounds=2, constRegion=[lim1,lim2])\\n else:\\n #get smoother limits, if desired, using polynomial fitting\\n polyLimits = slices.polyFitLimits(limits, degree=polyFitDegree, sigmaClipRounds=2)\\n\\n if logfile is not None:\\n logfile.write('Fit polynomial to slice edge traces using:\\\\n')\\n logfile.write('Polynomial degree: ' + str(polyFitDegree)+'\\\\n')\\n logfile.write('sigmaClipRounds: ' + str(2)+'\\\\n')\\n\\n if hband:\\n logfile.write('Only used pixels between ' + str(lim1) +' and ' + str(lim2)+'\\\\n')\\n \\n if os.path.exists(distMapLimitsFile):\\n print('Finding slice limits relative to distortion map file')\\n hdr.add_history('Slice limits are relative to the following file:')\\n hdr.add_history(distMapLimitsFile)\\n distMapLimits = wifisIO.readImgsFromFile(distMapLimitsFile)[0]\\n if logfile is not None:\\n logfile.write('Finding slice limits relative to distortion map file:\\\\n')\\n logfile.write(distMapLimitsFile+'\\\\n')\\n\\n if hband:\\n shft = int(np.nanmedian(polyLimits[1:-1,lim1:lim2+1] - distMapLimits[1:-1,lim1:lim2+1]))\\n else:\\n shft = int(np.nanmedian(polyLimits[1:-1,:] - distMapLimits[1:-1,:]))\\n \\n if logfile is not None:\\n logfile.write('Median pixel shift using all inner edge limits is ' + str(shft)+'\\\\n')\\n finalLimits = distMapLimits\\n else:\\n finalLimits = polyLimits\\n shft = 0\\n\\n if logfile is not None:\\n logfile.write('*** WARNING:No slice limits provided for distortion map. Finding independent slice limits ***\\\\n')\\n logfile.write(distMapLimitsFile+'\\\\n')\\n \\n \\n #write distMapLimits + shft to file\\n hdr.set('LIMSHIFT',shft, 'Limits shift relative to Ronchi slices')\\n hdr.add_comment('File contains the edge limits for each slice')\\n\\n wifisIO.writeFits(finalLimits.astype('float32'),savename+'_flat_limits.fits', hdr=hdr, ask=False)\\n\\n #remove comment about contents of file\\n hdrTmp = hdr[::-1]\\n hdrTmp.remove('COMMENT')\\n hdr = hdrTmp[::-1]\\n \\n #save figures of tracing results for quality control purposes\\n if (plot):\\n print('Plotting results')\\n plt.ioff()\\n wifisIO.createDir('quality_control')\\n \\n pdfName = 'quality_control/'+folder+'_flat_slices_traces.pdf'\\n with PdfPages(pdfName) as pdf:\\n fig = plt.figure()\\n #med1= np.nanmedian(flatImg)\\n interval = ZScaleInterval()\\n lims = interval.get_limits(flatImg[4:-4,4:-4])\\n #plt.imshow(flatImg[4:-4,4:-4], aspect='auto', cmap='jet', clim=[0,2.*med1], origin='lower')\\n plt.imshow(flatImg[4:-4,4:-4], aspect='auto', cmap='jet', clim=lims, origin='lower')\\n \\n plt.xlim=(0,2040)\\n plt.colorbar()\\n for l in range(limits.shape[0]):\\n if dispAxis==0:\\n plt.plot(limits[l], np.arange(limits.shape[1]),'k', linewidth=1) #drawn limits\\n plt.plot(np.clip(finalLimits[l]+shft,0, flatImg[4:-4,4:-4].shape[0]-1), np.arange(limits.shape[1]),'r--', linewidth=1) #shifted ronchi limits, if provided, or polynomial fit\\n else:\\n plt.plot(np.arange(limits.shape[1]),limits[l],'k', linewidth=1) #drawn limits\\n plt.plot(np.arange(limits.shape[1]),np.clip(finalLimits[l]+shft,0, flatImg[4:-4,4:-4].shape[0]-1),'r--', linewidth=1) #shifted ronchi limits\\n\\n if hband:\\n if dispAxis==0:\\n plt.plot([0,flatImg[4:-4,4:-4].shape[1]-1],[lim1,lim1],'b:',linewidth=1)\\n plt.plot([0,flatImg[4:-4,4:-4].shape[1]-1],[lim2,lim2],'b:',linewidth=1)\\n else:\\n plt.plot([lim1,lim1],[0,flatImg[4:-4,4:-4].shape[1]-1],'b:',linewidth=1)\\n plt.plot([lim2,lim2],[0,flatImg[4:-4,4:-4].shape[1]-1],'b:',linewidth=1)\\n\\n plt.tight_layout()\\n pdf.savefig()\\n plt.close(fig)\\n\\n #get rid of reference pixels\\n flatImg = flatImg[4:-4, 4:-4]\\n sigmaImg = sigmaImg[4:-4, 4:-4]\\n satFrame = satFrame[4:-4,4:-4]\\n\\n if logfile is not None:\\n logfile.write('Removing reference pixels\\\\n')\\n \\n if os.path.exists(savename+'_flat_slices.fits'):\\n cont='n'\\n cont = wifisIO.userInput('Flat slices file already exists for ' +folder+ ', do you want to continue processing (y/n)?')\\n\\n if (not cont.lower() == 'y'):\\n print('Reading slices file '+savename+'_flat_slices.fits instead')\\n flatSlices = wifisIO.readImgsFromFile(savename+'_flat_slices.fits')[0]\\n contProc2 = False\\n else:\\n contProc2 = True\\n else:\\n contProc2= True\\n \\n if (contProc2):\\n print('Extracting slices') \\n #now extract the individual slices\\n flatSlices = slices.extSlices(flatImg, finalLimits, dispAxis=dispAxis, shft=shft)\\n for slc in flatSlices:\\n slc = slc.astype('float32')\\n \\n if logfile is not None:\\n logfile.write('Extracted flat slices\\\\n')\\n \\n #extract uncertainty slices\\n sigmaSlices = slices.extSlices(sigmaImg, finalLimits, dispAxis=dispAxis, shft=shft)\\n for slc in sigmaSlices:\\n slc = slc.astype('float32')\\n \\n if logfile is not None:\\n logfile.write('Extracted uncertainty slices\\\\n')\\n \\n #extract saturation slices\\n satSlices = slices.extSlices(satFrame, finalLimits, dispAxis=dispAxis, shft=shft)\\n for slc in satSlices:\\n slc = slc.astype('float32')\\n \\n if logfile is not None:\\n logfile.write('Extracted saturation info slices\\\\n')\\n \\n #write slices to file\\n hdr.add_comment('File contains each slice image as separate extension')\\n wifisIO.writeFits(flatSlices+sigmaSlices+satSlices,savename+'_flat_slices.fits',hdr=hdr, ask=False)\\n \\n #remove comment about contents of file\\n hdrTmp = hdr[::-1]\\n hdrTmp.remove('COMMENT')\\n hdr = hdrTmp[::-1]\\n \\n if os.path.exists(savename+'_flat_slices_norm.fits'):\\n cont = 'n'\\n cont = wifisIO.userInput('Normalized flat slices file already exists for ' +folder+', do you want to continue processing (y/n)?')\\n \\n if (not cont.lower() == 'y'):\\n contProc2 = False\\n else:\\n contProc2 = True\\n else:\\n contProc2= True\\n \\n if (contProc2):\\n print('Getting normalized flat field')\\n #now get smoothed and normalized response function\\n flatNorm = slices.getResponseAll(flatSlices, flatSmooth, flatCutOff)\\n for slc in flatNorm:\\n slc = slc.astype('float32')\\n \\n hdr.add_comment('File contains the normalized flat-field response function')\\n hdr.add_history('Smoothed using Gaussian with 1-sigma width of ' + str(flatSmooth) + ' pixels')\\n hdr.add_history('Normalized cutoff threshold is ' + str(flatCutOff))\\n\\n if logfile is not None:\\n logfile.write('Computed normalized response function from flat slices using the following parameters:\\\\n')\\n logfile.write('flatSmooth: ' + str(flatSmooth)+'\\\\n')\\n logfile.write('flatCutoff: ' + str(flatCutOff)+'\\\\n')\\n \\n sigmaNorm = slices.ffCorrectAll(sigmaSlices, flatNorm)\\n for slc in sigmaNorm:\\n slc = slc.astype('float32')\\n \\n if logfile is not None:\\n logfile.write('Computed uncertainties for normalized response function for each slice\\\\n')\\n\\n if flatCor:\\n print('Correcting flat field response function')\\n logfile.write('Correcting flat field response function using file:\\\\n')\\n logfile.write(flatCorFile+'\\\\n')\\n \\n flatCorSlices = wifisIO.readImgsFromFile(flatCorFile)[0]\\n flatNorm = slices.ffCorrectAll(flatNorm, flatCorSlices)\\n hdr.add_history('Corrected flat field response function using file:')\\n hdr.add_history(flatCorFile)\\n\\n if len(flatCorSlices)>nSlices:\\n hdr.add_history('Uncertainties include correction')\\n sigmaNorm = wifisUncertainties.multiplySlices(flatNorm,sigmaNorm,flatCorSlices[:nSlices],flatCorSlices[nSlices:2*nSlices])\\n\\n else:\\n hdr.add_history('Uncertainties do not include correction')\\n logfile.write('*** WARNING: Response correction does not include uncertainties***\\\\n')\\n\\n else:\\n #print(colorama.Fore.RED+'*** WARNING: Flat field correction file does not exist, skipping ***'+colorama.Style.RESET_ALL)\\n \\n #logfile.write('*** WARNING: Flat field correction file does not exist, skipping ***\\\\n')\\n print('Flat field correction file off...skipping')\\n \\n logfile.write('Flat field correction file off...skipping\\\\n')\\n \\n #write normalized images to file\\n wifisIO.writeFits(flatNorm + sigmaNorm + satSlices,savename+'_flat_slices_norm.fits',hdr=hdr, ask=False)\\n print('*** Finished processing ' + folder + ' in ' + str(time.time()-t1) + ' seconds ***')\\n \\n return\",\n \"def _get_data(\\n self,\\n vis_hdu,\\n antenna_nums,\\n antenna_names,\\n ant_str,\\n bls,\\n frequencies,\\n freq_chans,\\n times,\\n time_range,\\n lsts,\\n lst_range,\\n polarizations,\\n blt_inds,\\n phase_center_ids,\\n catalog_names,\\n keep_all_metadata,\\n fix_old_proj,\\n fix_use_ant_pos,\\n ):\\n # figure out what data to read in\\n blt_inds, freq_inds, pol_inds, history_update_string = self._select_preprocess(\\n antenna_nums,\\n antenna_names,\\n ant_str,\\n bls,\\n frequencies,\\n freq_chans,\\n times,\\n time_range,\\n lsts,\\n lst_range,\\n polarizations,\\n blt_inds,\\n phase_center_ids,\\n catalog_names,\\n )\\n\\n if blt_inds is not None:\\n blt_frac = len(blt_inds) / float(self.Nblts)\\n else:\\n blt_frac = 1\\n\\n if freq_inds is not None:\\n freq_frac = len(freq_inds) * float(self.Nspws) / float(self.Nfreqs)\\n else:\\n freq_frac = 1\\n\\n if pol_inds is not None:\\n pol_frac = len(pol_inds) / float(self.Npols)\\n else:\\n pol_frac = 1\\n\\n min_frac = np.min([blt_frac, freq_frac, pol_frac])\\n\\n if min_frac == 1:\\n # no select, read in all the data\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :]\\n else:\\n # do select operations on everything except data_array, flag_array\\n # and nsample_array\\n self._select_by_index(\\n blt_inds, freq_inds, pol_inds, history_update_string, keep_all_metadata\\n )\\n\\n # just read in the right portions of the data and flag arrays\\n if blt_frac == min_frac:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n if freq_frac < 1:\\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\\n if pol_frac < 1:\\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\\n elif freq_frac == min_frac:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, :, :, :, freq_inds, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, :, :, freq_inds, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n\\n if blt_frac < 1:\\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\\n if pol_frac < 1:\\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\\n else:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, :, :, :, :, pol_inds, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, :, :, :, pol_inds, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n\\n if blt_frac < 1:\\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\\n if freq_frac < 1:\\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\\n\\n assert len(raw_data_array.shape) == 5\\n\\n # Reshape the data array to be the right size if we are working w/ multiple\\n # spectral windows to be 'flex_spw' compliant\\n if self.Nspws > 1:\\n raw_data_array = np.reshape(\\n raw_data_array,\\n (self.Nblts, 1, self.Nfreqs, self.Npols, raw_data_array.shape[4]),\\n )\\n\\n # FITS uvw direction convention is opposite ours and Miriad's.\\n # So conjugate the visibilities and flip the uvws:\\n self.data_array = (\\n raw_data_array[:, :, :, :, 0] - 1j * raw_data_array[:, :, :, :, 1]\\n )\\n self.flag_array = raw_data_array[:, :, :, :, 2] <= 0\\n self.nsample_array = np.abs(raw_data_array[:, :, :, :, 2])\\n\\n if fix_old_proj:\\n self.fix_phase(use_ant_pos=fix_use_ant_pos)\",\n \"def fit_redshift_grid(file='jw02767005001-02-clear-prism-nrs2-2767_11027.spec.fits', zgrid=None, vel_width=100, bkg=None, scale_disp=1.3, nspline=27, line_complexes=True, Rline=1000, eazy_templates=None, use_full_dispersion=True, sys_err=0.02, use_aper_columns=False, **kwargs):\\n import time\\n import os\\n from tqdm import tqdm\\n \\n import astropy.io.fits as pyfits\\n \\n import numpy as np\\n from grizli import utils\\n import grizli.utils_c\\n import astropy.units as u\\n \\n import eazy.igm\\n \\n import matplotlib.pyplot as plt\\n \\n #spec = read_spectrum(file, sys_err=sys_err)\\n sampler = SpectrumSampler(file, **kwargs)\\n spec = sampler.spec\\n \\n if (use_aper_columns > 0) & ('aper_flux' in spec.colnames):\\n if ('aper_corr' in spec.colnames) & (use_aper_columns > 1):\\n ap_corr = spec['aper_corr']*1\\n else:\\n ap_corr = 1\\n \\n flam = spec['aper_flux']*spec['to_flam']*ap_corr\\n eflam = spec['aper_full_err']*spec['to_flam']*ap_corr\\n else:\\n flam = spec['flux']*spec['to_flam']\\n eflam = spec['full_err']*spec['to_flam']\\n \\n wobs = spec['wave']\\n mask = spec['valid']\\n \\n flam[~mask] = np.nan\\n eflam[~mask] = np.nan\\n \\n #spline = utils.bspline_templates(wave=spec['wave']*1.e4, degree=3, df=nspline)\\n bspl = sampler.bspline_array(nspline=nspline, get_matrix=True)\\n \\n chi2 = zgrid*0.\\n \\n #bspl = utils.bspline_templates(wave=spec['wave']*1.e4, degree=3, df=nspline) #, log=True)\\n # w0 = utils.log_zgrid([spec['wave'].min()*1.e4,\\n # spec['wave'].max()*1.e4], 1./Rline)\\n \\n for iz, z in tqdm(enumerate(zgrid)):\\n \\n templates, tline, _A = make_templates(sampler, z,\\n bspl=bspl,\\n eazy_templates=eazy_templates,\\n vel_width=vel_width,\\n scale_disp=scale_disp,\\n use_full_dispersion=use_full_dispersion,\\n disp=spec.disp,\\n grating=spec.grating,\\n **kwargs,\\n )\\n \\n okt = _A[:,mask].sum(axis=1) > 0\\n \\n _Ax = _A[okt,:]/eflam\\n _yx = flam/eflam\\n \\n if eazy_templates is None:\\n _x = np.linalg.lstsq(_Ax[:,mask].T, \\n _yx[mask], rcond=None)\\n else:\\n _x = nnls(_Ax[:,mask].T, _yx[mask])\\n \\n coeffs = np.zeros(_A.shape[0])\\n coeffs[okt] = _x[0]\\n _model = _A.T.dot(coeffs)\\n \\n chi = (flam - _model) / eflam\\n \\n chi2_i = (chi[mask]**2).sum()\\n # print(z, chi2_i)\\n chi2[iz] = chi2_i\\n \\n return zgrid, chi2\",\n \"def _calculate(self,*args,**kwargs):\\n\\n like = self.like\\n name = self.name\\n\\n init_energes = like.energies[[0,-1]]\\n\\n # Freeze all sources except one to make sed of.\\n all_sources = like.sourceNames()\\n\\n if name not in all_sources:\\n raise Exception(\\\"Cannot find source %s in list of sources\\\" % name)\\n\\n # make copy of parameter values + free parameters\\n \\n saved_state = SuperState(like)\\n\\n if self.verbosity: print 'Freezing background sources'\\n for other_name in get_background(like):\\n if self.freeze_bg_diffuse:\\n if self.verbosity: print ' * Freezing diffuse source %s' % other_name\\n modify(like, other_name, free=False)\\n else:\\n if self.verbosity: print ' * Freezing spectral shape for diffuse source %s' % other_name\\n modify(like, other_name, freeze_spectral_shape=True)\\n for other_name in get_sources(like):\\n if self.freeze_bg_sources:\\n if self.verbosity: print ' * Freezing bg source %s' % other_name\\n modify(like, other_name, free=False)\\n else:\\n if self.verbosity: print ' * Freezing spectral shape for bg source %s' % other_name\\n modify(like, other_name, freeze_spectral_shape=True)\\n\\n self.raw_results = []\\n for i,(lower,upper) in enumerate(zip(self.lower,self.upper)):\\n\\n like.setEnergyRange(float(lower)+1, float(upper)-1)\\n\\n e = np.sqrt(lower*upper)\\n\\n if self.verbosity: print 'Calculating SED from %.0dMeV to %.0dMeV' % (lower,upper)\\n\\n \\\"\\\"\\\" Note, the most robust method I have found for computing SEDs in gtlike is:\\n (a) Create a generic spectral model with a fixed spectral index.\\n (b) Set the 'Scale' to sqrt(emin*emax) so the prefactor is dNdE in the middle\\n of the sed bin.\\n (b) Set the limits to go from norm/fit_range to norm*fit_range and set the scale to 'norm'\\n \\\"\\\"\\\" \\n old_flux = self.init_model.i_flux(emin=lower,emax=upper)\\n model = PowerLaw(index=self.powerlaw_index, e0=e)\\n model.set_flux(old_flux, emin=lower, emax=upper)\\n norm = model['norm']\\n model.set_limits('norm',norm/float(self.fit_range),norm*self.fit_range, scale=norm)\\n model.set_limits('index',-5,5)\\n model.freeze('index')\\n spectrum = build_gtlike_spectrum(model)\\n\\n like.setSpectrum(name,spectrum)\\n like.syncSrcParams(name)\\n\\n if self.verbosity:\\n print 'Before fitting SED from %.0dMeV to %.0dMeV' % (lower,upper)\\n print summary(like)\\n\\n paranoid_gtlike_fit(like, verbosity=self.verbosity)\\n\\n if self.verbosity:\\n print 'After fitting SED from %.0dMeV to %.0dMeV' % (lower,upper)\\n print summary(like)\\n\\n d = dict()\\n self.raw_results.append(d)\\n\\n d['energy'] = energy_dict(emin=lower, emax=upper, energy_units=self.energy_units)\\n d['flux'] = flux_dict(like, name, emin=lower,emax=upper, flux_units=self.flux_units, \\n errors=True, include_prefactor=True, prefactor_energy=e)\\n d['prefactor'] = powerlaw_prefactor_dict(like, name, errors=self.save_hesse_errors, minos_errors=True,\\n flux_units=self.flux_units)\\n d['TS'] = ts_dict(like, name, verbosity=self.verbosity)\\n\\n if self.verbosity: print 'Calculating SED upper limit from %.0dMeV to %.0dMeV' % (lower,upper)\\n\\n if self.always_upper_limit or d['TS']['reoptimize'] < self.min_ts:\\n ul = GtlikePowerLawUpperLimit(like, name,\\n cl=self.ul_confidence,\\n emin=lower,emax=upper,\\n flux_units=self.flux_units,\\n energy_units=self.energy_units,\\n upper_limit_kwargs=self.upper_limit_kwargs,\\n include_prefactor=True,\\n prefactor_energy=e,\\n verbosity=self.verbosity,\\n )\\n d['upper_limit'] = ul.todict()\\n\\n # revert to old model\\n like.setEnergyRange(*init_energes)\\n saved_state.restore()\\n\\n self._condense_results()\",\n \"def get_scale_factor(self, jets, passing_cut):\\n # First of all flatten everything to make it easier to handle\\n pt = ak.to_numpy(ak.flatten(jets.pt))\\n eta = ak.to_numpy(ak.flatten(jets.eta))\\n flav = ak.to_numpy(ak.flatten(jets.hadronFlavour))\\n pass_wp = ak.to_numpy(ak.flatten(jets[passing_cut]))\\n\\n # Get the MC efficiency\\n eff = self.efficiency_(pt, eta, flav)\\n # for each systematic/central value compute the proper SF\\n # cache the SF values as sometimes they are repeated, there \\n # might also be systematic combinations that are never accessed\\n # but pruning them at the beginning can be hard\\n # use schema to define combinations, lcb is a tuple with the sf keys\\n # for light, charm, bottom for each systematic\\n flavour_sf_cache = {}\\n scale_factors = {} # our final product\\n for key, lcb in self.schema_.items(): \\n # populate cache if needed\\n for i in range(3):\\n # protect against using prelim csv files that don't have UDSG wps\\n flavour_sf_cache[lcb[i]] = np.ones(eta.size) if lcb[i] not in self.sf_.keys() else flavour_sf_cache.get(lcb[i], self.sf_[lcb[i]](eta, pt, pass_wp))\\n \\n scale_factors[key] = eff * self.match_flav_(\\n flavour_sf_cache[lcb[0]],\\n flavour_sf_cache[lcb[1]],\\n flavour_sf_cache[lcb[2]],\\n flav\\n )\\n\\n # use SF and eff to compute p(data) and p(MC)\\n p_data = {key : np.where(pass_wp, val, 1 - val) \\n for key, val in scale_factors.items()}\\n p_mc = np.where(pass_wp, eff, 1 - eff)\\n\\n # return the unflattened version of the ratio\\n return {key : ak.unflatten(i/p_mc, ak.num(jets.pt))\\n for key, i in p_data.items()}\",\n \"def _s_parameters(\\n self,\\n freqs: \\\"np.array\\\",\\n s_parameters_method: str = \\\"s_parameters\\\",\\n ) -> \\\"np.ndarray\\\":\\n from simphony.simulation import SimulationModel\\n from simphony.simulators import Simulator\\n\\n all_pins = []\\n available_pins = []\\n s_block = None\\n\\n # merge all of the s_params into one giant block diagonal matrix\\n for component in self._wrapped_circuit:\\n # simulators don't have scattering parameters\\n if isinstance(component, (Simulator, SimulationModel)):\\n continue\\n\\n # get the s_params from the cache if possible\\n s_params = self.__get_s_params_from_cache(component, freqs, s_parameters_method)\\n\\n # merge the s_params into the block diagonal matrix\\n if s_block is None:\\n if s_params.ndim == 3:\\n s_block = np.stack((np.abs(s_params), np.angle(s_params)), axis=-1)\\n else:\\n s_block = s_params\\n else:\\n s_block = create_block_diagonal(s_block, s_params)\\n\\n # keep track of all of the pins (in order) in the circuit\\n all_pins += component.pins\\n available_pins += component.pins\\n\\n # use the subnetwork growth algorithm for each connection\\n return self.__compute_s_block(s_block, available_pins, all_pins)\",\n \"def get_spectrum(self, shcoeffs, nwins):\\n for itaper in range(nwins):\\n tapercoeffs = self._coeffs(itaper)\\n modelcoeffs = shcoeffs.get_coeffs(normalization='4pi',kind='real')\\n coeffs = SHMultiply(tapercoeffs,modelcoeffs)\",\n \"def _get_single_PSF(SCA, bandpass, SCA_pos, pupil_bin,\\n n_waves, extra_aberrations, wavelength,\\n pupil_plane_type, gsparams):\\n from .. import OpticalPSF, ChromaticOpticalPSF\\n from . import diameter\\n from ..bandpass import Bandpass\\n from .roman_bandpass import getBandpasses\\n\\n if wavelength is None:\\n wave = zemax_wavelength\\n elif isinstance(wavelength, Bandpass):\\n wave = wavelength = wavelength.effective_wavelength\\n else:\\n wave = wavelength\\n\\n # All parameters relevant to the aperture. We may be able to use a cached version.\\n aper = _make_aperture(SCA, pupil_plane_type, pupil_bin, wave, gsparams)\\n\\n # Start reading in the aberrations for that SCA\\n aberrations, x_pos, y_pos = _read_aberrations(SCA)\\n # Do bilinear interpolation, unless we're exactly at the center (default).\\n use_aberrations = _interp_aberrations_bilinear(aberrations, x_pos, y_pos, SCA_pos)\\n\\n if extra_aberrations is not None:\\n use_aberrations[:len(extra_aberrations)] += extra_aberrations\\n # We don't want to use piston, tip, or tilt aberrations. The former doesn't affect the\\n # appearance of the PSF, and the latter cause centroid shifts. So, we set the first 4\\n # numbers (corresponding to a place-holder, piston, tip, and tilt) to zero.\\n use_aberrations[0:4] = 0.\\n\\n # Now set up the PSF, including the option to interpolate over waves\\n if wavelength is None:\\n PSF = ChromaticOpticalPSF(lam=zemax_wavelength,\\n diam=diameter, aberrations=use_aberrations,\\n aper=aper, gsparams=gsparams)\\n if n_waves is not None:\\n # To decide the range of wavelengths to use, check the bandpass.\\n bp_dict = getBandpasses()\\n bp = bp_dict[bandpass]\\n PSF = PSF.interpolate(waves=np.linspace(bp.blue_limit, bp.red_limit, n_waves),\\n oversample_fac=1.5)\\n else:\\n tmp_aberrations = use_aberrations * zemax_wavelength / wavelength\\n PSF = OpticalPSF(lam=wavelength, diam=diameter,\\n aberrations=tmp_aberrations,\\n aper=aper, gsparams=gsparams)\\n\\n return PSF\",\n \"def CD95_to_SecondaryComplex():\\n\\n Parameter('Fas_0' , 6000) # 6000 corresponds to 100ng/ml Fas (J Immunol 2005)\\n Parameter('CD95_0' , 4817) # 4817receptors per cell (J Immunol 2005)\\n Parameter('FADD_0' , 8030) # 8300 molecules per cell (J Immunol 2005)\\n Parameter('flip_L_0', 390220) # 39022 molecules per cell (J Immunol 2005)\\n Parameter('flip_S_0', 390220) # molecules per cell assummed both isoforms w/conc.\\n Parameter('proC8_0' , 16057) # procaspase 8 molecules per cell 16057 (J Immunol 2005)\\n Parameter('C8_0' , 0) # active caspase 8 dimers per cell.\\n Parameter('Bar_0' , 1.0e3) # Bar molecules per cell. (Hela Cells)\\n alias_model_components()\\n \\n Initial(Fas(blig=None), Fas_0) #Fas Ligand\\n Initial(CD95(blig=None, bDD=None), CD95_0) #Fas Receptor (CD95)\\n Initial(FADD(bDD=None, bDED1=None, bDED2=None), FADD_0) #FADD\\n Initial(flip_L(bDED=None), flip_L_0) #c-Flip[L]\\n Initial(flip_S(bDED=None), flip_S_0) #c-Flip[S]\\n Initial(proC8(bDED=None), proC8_0) #procaspase 8\\n Initial(C8(bf=None, state = 'A'), C8_0) #caspase 8\\n Initial(Bar(bC8=None), Bar_0) #bifunctional apoptosis regulator\\n \\n # =========================================\\n # CD95 ligation and formation of Secondary Complex rules\\n # -----------------------------------------\\n # Fas + CD95 <-> Fas:CD95\\n # Fas:CD95 + FADD <-> Fas:CD95:FADD\\n # Fas:CD95:FADD + proC8 <-> Fas:CD95:FADD:proC8\\n \\n # Fas:CD95:FADD:proC8 + proC8 <-> Fas:CD95:FADD:proC8:proC8 -> Fas:CD95:FADD + C8\\n # Fas:CD95:FADD:proC8 + flip_L <-> Fas:CD95:FADD:proC8:flip_L\\n # Fas:CD95:FADD:proC8 + flip_S <-> Fas:CD95:FADD:proC8:flip_S\\n \\n # Fas:CD95:FADD:proC8:flip_L <-> Fas:CD95 + FADD:proC8:flip_L\\n # Fas:CD95:FADD:proC8:flip_S <-> Fas:CD95 + FADD:proC8:flip_S\\n # ------------------------------------------\\n \\n # ==========================================\\n # Regulation (downstream of CD95) of Caspase 8 activity\\n # ------------------------------------------\\n # C8 + BAR <-> C8:BAR\\n # C8 + TRAF2 >> TRAF2\\n \\n # -------------DISC assembly----------------\\n alias_model_components()\\n bind(Fas(blig=None), 'blig', CD95(blig = None, bDD = None), 'blig', [1.89e-7, 1e-4])\\n bind(CD95(blig = ANY, bDD = None), 'bDD', FADD(bDD = None, bDED1 =None, bDED2 = None), 'bDD', [1.04e-6, 0.2]) # (J Immunol 2005)\\n bind(FADD(bDD = ANY, bDED1 = None, bDED2 = None),'bDED1', proC8(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\\n \\n # For simplicity allow proC8 to bind FADD before any c-Flip do.\\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', flip_L(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', flip_S(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\\n \\n \\n # procaspase 8 dimerization and activation\\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', proC8(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\\n \\n Rule('C8_activation', FADD(bDED1 = ANY, bDED2 = ANY)%proC8(bDED=ANY)%proC8(bDED = ANY) >> FADD(bDED1 = None, bDED2 = None) + C8(bf = None, state = 'A'), Parameter('k1', 0.3)) # (J Immunol 2005)\\n\\n # caspase 8 inhibition by BAR\\n bind(Bar(bC8 = None), 'bC8', C8(bf = None, state = 'A'), 'bf', [1e-6, 1e-3])\\n \\n # release of secondary complex from the DISC\\n bind(FADD(bDD = None, bDED2 = ANY, bDED1 = ANY), 'bDD', CD95(blig = ANY, bDD=None), 'bDD', [1e-10, 1e-3])\",\n \"def analyze_spindles(self, zmethod='trough', trough_dtype='spfilt', buff=False, buffer_len=3, psd_type='i', psd_bandwidth=1.0, \\n zpad=True, zpad_len=3.0, norm_range=[(4,6), (18, 25)], spin_range=[9, 16]):\\n \\n # create individual datframes for each spindle\\n self.create_spindfs(zmethod, trough_dtype, buff, buffer_len)\\n\\n # calculate spindle & spindle buffer means\\n self.calc_spindle_means()\\n if buff:\\n self.calc_spindle_buffer_means()\\n\\n # run time-domain spindle statistics by channel\\n self.calc_spin_tstats(spin_range)\\n\\n # calculate power spectra\\n if psd_type == 'concat':\\n # calc psd on concated spindles\\n self.calc_spindle_psd_concat(psd_bandwidth)\\n # normalize power spectra for quantification\\n self.calc_gottselig_norm(norm_range)\\n elif psd_type == 'i':\\n # calc psd on individual spindles\\n self.calc_spindle_psd_i(psd_bandwidth, zpad, zpad_len)\",\n \"def eval_grads(self, data):\\n drho = np.zeros_like(self.rhos)\\n dW = np.zeros_like(self.W)\\n da = np.zeros_like(self.a)\\n dc = np.zeros_like(self.c)\\n dba = np.zeros_like(self.bs['alpha'])\\n dVa = np.zeros_like(self.Vs['alpha'])\\n dbm = np.zeros_like(self.bs['mu'])\\n dVm = np.zeros_like(self.Vs['mu'])\\n dbs = np.zeros_like(self.bs['sigma'])\\n dVs = np.zeros_like(self.Vs['sigma'])\\n\\n const = 0.5 * np.log(2. * np.pi)\\n for i in range(self.Ndim - 1, -1, -1):\\n a = self.rhos[i] * self.a[i]\\n h = 0.5 * (a + np.abs(a)) # ReLU\\n dlt = (data[:, i][:, None] - self.mus[i][None, :])\\n dlt /= self.sigmas[i][None, :]\\n dlt = np.mean(dlt, axis=0)\\n phi = 0.5 * dlt ** 2. - np.log(self.sigmas[i]) - const\\n pi = self.alphas[i] * phi\\n pi /= np.mean(pi)\\n dza = pi - self.alphas[i]\\n dba[i] = dza\\n dVa[i] = dza[None, :] * h[:, None]\\n dzm = pi * dlt\\n dzm *= self.slow_factor # apparently this is a `tight' component\\n dbm[i] = dzm\\n dVm[i] = dzm[None, :] * h[:, None]\\n dzs = pi * (dlt ** 2. - 1)\\n dbs[i] = dzs\\n dVs[i] = dzs[None, :] * h[:, None]\\n\\n # dh has shape Nhidden x Ncomponents (?)\\n dh = dza * dVa[i] + dzm * dVm[i] + dzs * dVs[i]\\n dpsi = 1. * (dh > 0)\\n\\n # collapse to a scalar or vector of Nhidden?\\n drho[i] = np.mean(dpsi)\\n\\n if i == 0:\\n dc = da[i]\\n else:\\n da[i - 1] = da[i] + np.mean(dpsi * self.rhos[i], axis=1)\\n dW[:, i] = np.mean(da[i - 1][:, None] * data[:, i][None, :],\\n axis=1)\\n self.a[i - 1] = self.a[i] - np.mean(data[:, i][None, :] *\\n self.W[:, i][:, None],\\n axis=1)\\n\\n return -drho, -dc, -dW, -dba, -dVa, -dbm, -dVm, -dbs, -dVs\",\n \"def prep_standard(st, segment, data):\\n\\n from rfpipe import calibration, flagging, util\\n\\n if not np.any(data):\\n return data\\n\\n # read and apply flags for given ant/time range. 0=bad, 1=good\\n if st.prefs.applyonlineflags and st.metadata.datasource in ['vys', 'sdm']:\\n flags = flagging.getonlineflags(st, segment)\\n data = np.where(flags[None, :, None, None], data, 0j)\\n else:\\n logger.info('Not applying online flags.')\\n\\n if not np.any(data):\\n return data\\n\\n if st.prefs.simulated_transient is not None or st.otfcorrections is not None:\\n uvw = util.get_uvw_segment(st, segment)\\n\\n # optionally integrate (downsample)\\n if ((st.prefs.read_tdownsample > 1) or (st.prefs.read_fdownsample > 1)):\\n data2 = np.zeros(st.datashape, dtype='complex64')\\n if st.prefs.read_tdownsample > 1:\\n logger.info('Downsampling in time by {0}'\\n .format(st.prefs.read_tdownsample))\\n for i in range(st.datashape[0]):\\n data2[i] = data[\\n i*st.prefs.read_tdownsample:(i+1)*st.prefs.read_tdownsample].mean(axis=0)\\n if st.prefs.read_fdownsample > 1:\\n logger.info('Downsampling in frequency by {0}'\\n .format(st.prefs.read_fdownsample))\\n for i in range(st.datashape[2]):\\n data2[:, :, i, :] = data[:, :, i*st.prefs.read_fdownsample:(i+1)*st.prefs.read_fdownsample].mean(axis=2)\\n data = data2\\n\\n # optionally add transients\\n if st.prefs.simulated_transient is not None:\\n # for an int type, overload prefs.simulated_transient random mocks\\n if isinstance(st.prefs.simulated_transient, int):\\n logger.info(\\\"Filling simulated_transient with {0} random transients\\\"\\n .format(st.prefs.simulated_transient))\\n st.prefs.simulated_transient = util.make_transient_params(st, segment=segment,\\n ntr=st.prefs.simulated_transient,\\n data=data)\\n\\n assert isinstance(st.prefs.simulated_transient, list), \\\"Simulated transient must be list of tuples.\\\"\\n\\n for params in st.prefs.simulated_transient:\\n assert len(params) == 7 or len(params) == 8, (\\\"Transient requires 7 or 8 parameters: \\\"\\n \\\"(segment, i0/int, dm/pc/cm3, dt/s, \\\"\\n \\\"amp/sys, dl/rad, dm/rad) and optionally \\\"\\n \\\"ampslope/sys\\\")\\n if segment == params[0]:\\n if len(params) == 7:\\n (mock_segment, i0, dm, dt, amp, l, m) = params\\n ampslope = 0\\n\\n logger.info(\\\"Adding transient to segment {0} at int {1}, \\\"\\n \\\"DM {2}, dt {3} with amp {4} and l,m={5},{6}\\\"\\n .format(mock_segment, i0, dm, dt, amp, l, m))\\n elif len(params) == 8:\\n (mock_segment, i0, dm, dt, amp, l, m, ampslope) = params\\n logger.info(\\\"Adding transient to segment {0} at int {1}, \\\"\\n \\\" DM {2}, dt {3} with amp {4}-{5} and \\\"\\n \\\"l,m={6},{7}\\\"\\n .format(mock_segment, i0, dm, dt, amp,\\n amp+ampslope, l, m))\\n try:\\n model = np.require(np.broadcast_to(util.make_transient_data(st, amp, i0, dm, dt, ampslope=ampslope)\\n .transpose()[:, None, :, None],\\n st.datashape),\\n requirements='W')\\n except IndexError:\\n logger.warning(\\\"IndexError while adding transient. Skipping...\\\")\\n continue\\n\\n if st.gainfile is not None:\\n model = calibration.apply_telcal(st, model, sign=-1)\\n util.phase_shift(model, uvw, -l, -m)\\n data += model\\n\\n if st.otfcorrections is not None:\\n # shift phasecenters to first phasecenter in segment\\n if len(st.otfcorrections[segment]) > 1:\\n ints, ra0, dec0 = st.otfcorrections[segment][0] # new phase center for segment\\n logger.info(\\\"Correcting {0} phasecenters to first at RA,Dec = {1},{2}\\\"\\n .format(len(st.otfcorrections[segment])-1, ra0, dec0))\\n for ints, ra_deg, dec_deg in st.otfcorrections[segment][1:]:\\n l0 = np.radians(ra_deg-ra0)\\n m0 = np.radians(dec_deg-dec0)\\n util.phase_shift(data, uvw, l0, m0, ints=ints)\\n\\n return data\",\n \"def filterfit(self, sf, x_pha, x_amp=None, method='circular', smooth=None,\\n n_perm=None, p=.05, mcp='fdr', edges=None, n_jobs=-1,\\n verbose=None):\\n x_amp = x_pha if not isinstance(x_amp, np.ndarray) else x_amp\\n # extract phases and amplitudes\\n logger.info(f\\\" Extract phases (n_pha={len(self.xvec)}) and \\\"\\n f\\\"amplitudes (n_amps={len(self.yvec)})\\\")\\n kw = dict(keepfilt=False, edges=edges, n_jobs=1)\\n pha = self.filter(sf, x_pha, ftype='phase', **kw)\\n amp = self.filter(sf, x_amp, ftype='amplitude', **kw)\\n # compute erpac\\n return self.fit(pha, amp, method=method, smooth=smooth, n_jobs=n_jobs,\\n n_perm=n_perm, p=p, mcp=mcp, verbose=verbose)\",\n \"def _parse_directional_spectrum(self, offset, rules):\\n # Unpack the unpacking rules\\n (num_freq_name, num_dir_name, good_name, dat_name),\\\\\\n (num_freq_fmt, num_dir_fmt, good_fmt, dat_fmt) = zip(*rules)\\n\\n # First unpack the array lengths and single length values\\n (num_freq_data, num_dir_data, dspec_good_data) = struct.unpack_from(\\n '<%s%s%s' % (num_freq_fmt, num_dir_fmt, good_fmt), self.raw_data, offset)\\n\\n # Then unpack the array using the retrieved lengths values\\n next_offset = offset + struct.calcsize(num_freq_fmt) + struct.calcsize(num_dir_fmt) + \\\\\\n struct.calcsize(good_fmt)\\n dspec_dat_list_data = struct.unpack_from(\\n '<%s%s' % (num_freq_data * num_dir_data, dat_fmt), self.raw_data, next_offset)\\n\\n # convert to numpy array and reshape the data per IDD spec\\n transformed_dat_data = numpy.array(dspec_dat_list_data).reshape(\\n (num_freq_data, num_dir_data)).tolist()\\n\\n # Add to the collected parameter data\\n self.final_result.extend(\\n ({DataParticleKey.VALUE_ID: num_freq_name, DataParticleKey.VALUE: num_freq_data},\\n {DataParticleKey.VALUE_ID: num_dir_name, DataParticleKey.VALUE: num_dir_data},\\n {DataParticleKey.VALUE_ID: good_name, DataParticleKey.VALUE: dspec_good_data},\\n {DataParticleKey.VALUE_ID: dat_name, DataParticleKey.VALUE: transformed_dat_data}))\",\n \"def construct_linear_system(self):\\n N=self.grid.Ncells()\\n Nbc = len(self.dirichlet_bcs)\\n self.Ncalc=Ncalc = N - Nbc\\n\\n # map cells to forced values\\n dirichlet = dict( [ (c,v) for c,v,xy in self.dirichlet_bcs])\\n\\n self.is_calc_c = is_calc_c = np.ones(N,np.bool8)\\n for c,v,xy in self.dirichlet_bcs:\\n is_calc_c[c] = False\\n\\n # is_calc_c[self.c_mask] = False\\n\\n # c_map is indexed by real cell indices, and returns the matrix index\\n c_map = self.c_map = np.zeros(N,np.int32)\\n self.c_map[is_calc_c] = np.arange(Ncalc)\\n\\n dzc=self.dzc\\n dzf=self.dzf\\n area_c=self.area_c\\n\\n meth='coo' # 'dok'\\n if meth == 'dok':\\n A=sparse.dok_matrix((Ncalc,Ncalc),np.float64)\\n else:\\n # construct the matrix from a sequence of indices and values\\n ij=[]\\n values=[] # successive value for the same i.j will be summed\\n \\n b = np.zeros(Ncalc,np.float64)\\n flux_per_gradient_j = -self.K_j * self.l_j * dzf / self.d_j * self.dt\\n\\n self.grid.edge_to_cells() # makes sure that edges['cells'] exists.\\n \\n for j in range(self.grid.Nedges()):\\n e = self.grid.edges[j]\\n ic1,ic2 = e['cells']\\n \\n if ic1<0 or ic2<0 or e['deleted']:\\n continue # boundary edge, or deleted edge\\n \\n flux_per_gradient=flux_per_gradient_j[j]\\n \\n # this is the desired operation:\\n # Cdiff[ic1] -= flux_per_gradient / (An[ic1]*dzc) * (C[ic2] - C[ic1])\\n # Cdiff[ic2] += flux_per_gradient / (An[ic2]*dzc) * (C[ic2] - C[ic1])\\n # Where Cdiff is row, C is col\\n\\n if is_calc_c[ic1] and is_calc_c[ic2]:\\n mic2 = c_map[ic2]\\n mic1 = c_map[ic1]\\n v1=flux_per_gradient / (area_c[ic1]*dzc[ic1])\\n v2=flux_per_gradient / (area_c[ic2]*dzc[ic2])\\n \\n if meth == 'dok':\\n A[mic1,mic2] -= v1\\n A[mic1,mic1] += v1\\n A[mic2,mic2] += v2\\n A[mic2,mic1] -= v2\\n else:\\n ij.append( (mic1,mic2) ) ; values.append(-v1)\\n ij.append( (mic1,mic1) ) ; values.append(v1)\\n ij.append( (mic2,mic2) ) ; values.append(v1)\\n ij.append( (mic2,mic1) ) ; values.append(-v1)\\n \\n elif not ( is_calc_c[ic1] or is_calc_c[ic2] ):\\n # both are dirichlet, so nothing to do\\n pass\\n elif not is_calc_c[ic2]:\\n mic1 = c_map[ic1]\\n v=flux_per_gradient / (self.area_c[ic1]*dzc[ic1])\\n if meth == 'dok':\\n A[mic1,mic1] += v\\n else:\\n ij.append( (mic1,mic1) )\\n values.append(v)\\n\\n # roughly\\n # A[1,1]*x[1] + A[1,2]*x[2] + ... = b[1]\\n # but we already know x[2],\\n # A[1,1]*x[1] + ... = b[1] - A[1,2]*x[2]\\n # so flip the sign, multiply by known dirichlet value, and\\n # add to the RHS\\n b[mic1] += flux_per_gradient / (area_c[ic1]*dzc[ic1]) * dirichlet[ic2]\\n else: # not is_calc_c[c1]\\n mic2 = c_map[ic2]\\n # A[mic2,mic2] += flux_per_gradient / (area_c[ic2]*dzc[ic2])\\n # A[mic2,mic1] -= flux_per_gradient / (area_c[ic2]*dzc[ic2])\\n\\n # A[mic2,mic2]*x[2] + A[mic2,mic1]*x[1] = b[2]\\n # ...\\n # A[mic2,mic2]*x[2] - flux_per_gradient / (area_c[ic2]*dzc[ic2])*x[1] = b[2]\\n # ...\\n # A[mic2,mic2]*x[2] = b[2] + flux_per_gradient / (area_c[ic2]*dzc[ic2])*x[1]\\n v=flux_per_gradient / (area_c[ic2]*dzc[ic2])\\n if meth == 'dok':\\n A[mic2,mic2] += v\\n else:\\n ij.append( (mic2,mic2) )\\n values.append(v)\\n b[mic2] += flux_per_gradient / (area_c[ic2]*dzc[ic2]) * dirichlet[ic1]\\n\\n # Used to test 'is not 0:' but modern python complains\\n if isinstance(self.alpha,np.ndarray): \\n for c in range(N):\\n if self.is_calc_c[c]:\\n mic=self.c_map[c]\\n v=self.alpha[c]*self.dt\\n if meth == 'dok':\\n A[mic,mic] -= v\\n else:\\n ij.append( (mic,mic) )\\n values.append(-v)\\n\\n # Flux boundary conditions:\\n for ic,value,xy in self.neumann_bcs:\\n mic=c_map[ic]\\n # make mass/time into concentration/step\\n # arrived at minus sign by trial and error.\\n # 2023-08-04: there was a bug here that used ic2 instead of ic.\\n b[mic] -= value/(area_c[ic]*dzc[ic]) * self.dt\\n\\n if meth == 'dok':\\n self.A = sparse.coo_matrix(A)\\n else:\\n ijs=np.array(ij,dtype=np.int32)\\n data=np.array(values,dtype=np.float64)\\n A=sparse.coo_matrix( (data, (ijs[:,0],ijs[:,1]) ), shape=(Ncalc,Ncalc) )\\n self.A=A\\n \\n # report scale to get a sense of whether dt is too large\\n Ascale = A.diagonal().min()\\n log.debug(\\\"Ascale is %s\\\"%Ascale)\\n\\n self.b = b\",\n \"def __init__(self, x=0, y=0, flux=None, time=None, wcs=None, quality=None, mask=None, exposure=1800, sector=0,\\n size=150,\\n camera=1, ccd=1, cadence=None):\\n super(Source, self).__init__()\\n if cadence is None:\\n cadence = []\\n if quality is None:\\n quality = []\\n if wcs is None:\\n wcs = []\\n if time is None:\\n time = []\\n if flux is None:\\n flux = []\\n\\n self.size = size\\n self.sector = sector\\n self.camera = camera\\n self.ccd = ccd\\n self.cadence = cadence\\n self.quality = quality\\n self.exposure = exposure\\n self.wcs = wcs\\n co1 = 38.5\\n co2 = 116.5\\n catalog_1 = self.search_gaia(x, y, co1, co1)\\n catalog_2 = self.search_gaia(x, y, co1, co2)\\n catalog_3 = self.search_gaia(x, y, co2, co1)\\n catalog_4 = self.search_gaia(x, y, co2, co2)\\n catalogdata = vstack([catalog_1, catalog_2, catalog_3, catalog_4], join_type='exact')\\n catalogdata = unique(catalogdata, keys='DESIGNATION')\\n coord = wcs.pixel_to_world([x + (size - 1) / 2 + 44], [y + (size - 1) / 2])[0].to_string()\\n ra = float(coord.split()[0])\\n dec = float(coord.split()[1])\\n catalogdata_tic = tic_advanced_search_position_rows(ra=ra, dec=dec, radius=(self.size + 2) * 21 * 0.707 / 3600)\\n # print(f'no_of_stars={len(catalogdata_tic)}, camera={camera}, ccd={ccd}: ra={ra}, dec={dec}, radius={(self.size + 2) * 21 * 0.707 / 3600}')\\n self.tic = convert_gaia_id(catalogdata_tic)\\n self.flux = flux[:, y:y + size, x:x + size]\\n self.mask = mask[y:y + size, x:x + size]\\n self.time = np.array(time)\\n median_time = np.median(self.time)\\n interval = (median_time - 388.5) / 365.25\\n\\n num_gaia = len(catalogdata)\\n tic_id = np.zeros(num_gaia)\\n x_gaia = np.zeros(num_gaia)\\n y_gaia = np.zeros(num_gaia)\\n tess_mag = np.zeros(num_gaia)\\n in_frame = [True] * num_gaia\\n for i, designation in enumerate(catalogdata['DESIGNATION']):\\n ra = catalogdata['ra'][i]\\n dec = catalogdata['dec'][i]\\n if not np.isnan(catalogdata['pmra'].mask[i]): # masked?\\n ra += catalogdata['pmra'][i] * np.cos(np.deg2rad(dec)) * interval / 1000 / 3600\\n if not np.isnan(catalogdata['pmdec'].mask[i]):\\n dec += catalogdata['pmdec'][i] * interval / 1000 / 3600\\n pixel = self.wcs.all_world2pix(\\n np.array([catalogdata['ra'][i], catalogdata['dec'][i]]).reshape((1, 2)), 0, quiet=True)\\n x_gaia[i] = pixel[0][0] - x - 44\\n y_gaia[i] = pixel[0][1] - y\\n try:\\n tic_id[i] = catalogdata_tic['ID'][np.where(catalogdata_tic['GAIA'] == designation.split()[2])[0][0]]\\n except:\\n tic_id[i] = np.nan\\n if np.isnan(catalogdata['phot_g_mean_mag'][i]):\\n in_frame[i] = False\\n elif catalogdata['phot_g_mean_mag'][i] >= 25:\\n in_frame[i] = False\\n elif -4 < x_gaia[i] < self.size + 3 and -4 < y_gaia[i] < self.size + 3:\\n dif = catalogdata['phot_bp_mean_mag'][i] - catalogdata['phot_rp_mean_mag'][i]\\n tess_mag[i] = catalogdata['phot_g_mean_mag'][\\n i] - 0.00522555 * dif ** 3 + 0.0891337 * dif ** 2 - 0.633923 * dif + 0.0324473\\n if np.isnan(tess_mag[i]):\\n tess_mag[i] = catalogdata['phot_g_mean_mag'][i] - 0.430\\n if np.isnan(tess_mag[i]):\\n in_frame[i] = False\\n else:\\n in_frame[i] = False\\n\\n tess_flux = 10 ** (- tess_mag / 2.5)\\n t = Table()\\n t[f'tess_mag'] = tess_mag[in_frame]\\n t[f'tess_flux'] = tess_flux[in_frame]\\n t[f'tess_flux_ratio'] = tess_flux[in_frame] / np.nanmax(tess_flux[in_frame])\\n t[f'sector_{self.sector}_x'] = x_gaia[in_frame]\\n t[f'sector_{self.sector}_y'] = y_gaia[in_frame]\\n catalogdata = hstack([catalogdata[in_frame], t]) # TODO: sorting not sorting all columns\\n catalogdata.sort('tess_mag')\\n self.gaia = catalogdata\",\n \"def fit(self):\\n\\t\\tstart = time.time()\\n\\n\\t\\t# sqrt of weights\\n\\t\\tsqrtW = np.sqrt(self._weights)\\n\\n\\t\\t# separation between adjacent blocks\\n\\t\\tdn = self._n_DFT - self._n_overlap\\n\\n\\t\\t# number of blocks being updated in parallel if segments overlap\\n\\t\\tn_blocks_parallel = int(np.ceil(self._n_DFT/dn))\\n\\n\\t\\t# sliding, relative time index for each block\\n\\t\\tt_idx = np.zeros([n_blocks_parallel,1],dtype=int)\\n\\t\\tfor block_i in range(0,n_blocks_parallel):\\n\\t\\t\\tt_idx[block_i] = t_idx[block_i] - (block_i) * dn\\n\\n\\t\\tprint(' ')\\n\\t\\tprint('Calculating temporal DFT (streaming)')\\n\\t\\tprint('------------------------------------')\\n\\n\\t\\t# obtain first snapshot to determine data size\\n\\t\\t# x_new = self._X[0]\\n\\t\\tx_new = self._data_handler(self._data, t_0=0, t_end=0, variables=self._variables)\\n\\t\\tx_new = np.reshape(x_new,(self._nx*self._nv,1))\\n\\n\\t\\t# allocate data arrays\\n\\t\\tX_hat = np.zeros([self._nv*self._nx,self._n_freq], dtype='complex_')\\n\\t\\tX_sum = np.zeros([self._nv*self._nx,self._n_freq,n_blocks_parallel], dtype='complex_')\\n\\t\\tX_SPOD = np.zeros([self._nv*self._nx,self._n_freq,self._n_modes_save], dtype='complex_')\\n\\t\\tU_hat = np.zeros([self._nv*self._nx,self._n_freq,self._n_modes_save], dtype='complex_')\\n\\t\\tmu = np.zeros([self._nv*self._nx,1], dtype='complex_')\\n\\t\\tself._eigs = np.zeros([self._n_modes_save,self._n_freq], dtype='complex_')\\n\\t\\tself._modes = dict()\\n\\n\\t\\t# DFT matrix\\n\\t\\tFourier = np.fft.fft(np.identity(self._n_DFT))\\n\\n\\t\\t# correct Fourier coefficients for one-sided spectrum\\n\\t\\tif self._isrealx:\\n\\t\\t\\tFourier[:,1:self._n_freq-1] = 2 * Fourier[:,1:self._n_freq-1]\\n\\t\\t\\tfreq_idx = np.arange(0,int(self._n_DFT/2+1))\\n\\t\\t\\tFourier = Fourier[:,freq_idx]\\n\\n\\t\\t# convergence tests\\n\\t\\tmse_prev = np.empty([int(1e3),self._n_modes_save,self._n_freq], dtype='complex_') * np.nan\\n\\t\\tproj_prev = np.empty([self._n_freq,int(1e3),self._n_modes_save], dtype='complex_') * np.nan\\n\\t\\tS_hat_prev = np.zeros([self._n_modes_save,self._n_freq], dtype='complex_')\\n\\n\\t\\t# initialize counters\\n\\t\\tblock_i = 0\\n\\t\\tti = -1\\n\\t\\tz = np.zeros([1,self._n_modes_save])\\n\\t\\twhile True:\\n\\t\\t\\tti = ti + 1\\n\\n\\t\\t\\t# Get new snapshot and abort if data stream runs dry\\n\\t\\t\\tif ti > 0:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tx_new = self._data_handler(self._data, t_0=ti, t_end=ti, variables=self._variables)\\n\\t\\t\\t\\t\\t# x_new = self._X[ti]\\n\\t\\t\\t\\t\\tx_new = np.reshape(x_new,(self._nx*self._nv,1))\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\tprint('--> Data stream ended.')\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t# Update sample mean\\n\\t\\t\\tmu_old = mu\\n\\t\\t\\tmu = (ti * mu_old + x_new) / (ti + 1)\\n\\n\\t\\t\\t# Update incomplete Fourier sums, eqn (17)\\n\\t\\t\\tupdate = False\\n\\t\\t\\tfor block_j in range(0,n_blocks_parallel):\\n\\t\\t\\t\\tif t_idx[block_j] > -1:\\n\\t\\t\\t\\t\\tX_sum[:,:,block_j] = X_sum[:,:,block_j] + self._window[t_idx[block_j]] \\\\\\n\\t\\t\\t\\t\\t\\t* Fourier[t_idx[block_j],:] * x_new\\n\\n\\t\\t\\t\\t# check if sum is completed, and if so, initiate update\\n\\t\\t\\t\\tif t_idx[block_j] == self._n_DFT-1:\\n\\t\\t\\t\\t\\tupdate = True\\n\\t\\t\\t\\t\\tX_hat = X_sum[:,:,block_j].copy()\\n\\t\\t\\t\\t\\tX_sum[:,:,block_j] = 0\\n\\t\\t\\t\\t\\tt_idx[block_j] = min(t_idx) - dn\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tt_idx[block_j] = t_idx[block_j] + 1\\n\\n\\t\\t\\t# Update basis if a Fourier sum is completed\\n\\t\\t\\tif update:\\n\\t\\t\\t\\tblock_i = block_i + 1\\n\\n\\t\\t\\t\\t# subtract mean contribution to Fourier sum\\n\\t\\t\\t\\tfor row_idx in range(0,self._n_DFT):\\n\\t\\t\\t\\t\\tX_hat = X_hat - (self._window[row_idx] * Fourier[row_idx,:]) * mu\\n\\n\\t\\t\\t\\t# correct for windowing function and apply 1/self._n_DFT factor\\n\\t\\t\\t\\tX_hat = self._winWeight / self._n_DFT * X_hat\\n\\n\\t\\t\\t\\tif block_i == 0:\\n\\t\\t\\t\\t\\t# initialize basis with first vector\\n\\t\\t\\t\\t\\tprint('--> Initializing left singular vectors', 'Time ', str(ti), ' / block ', str(block_i))\\n\\t\\t\\t\\t\\tU_hat[:,:,0] = X_hat * sqrtW\\n\\t\\t\\t\\t\\tself._eigs[0,:] = np.sum(abs(U_hat[:,:,0]**2))\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# update basis\\n\\t\\t\\t\\t\\tprint('--> Updating left singular vectors', 'Time ', str(ti), ' / block ', str(block_i))\\n\\t\\t\\t\\t\\tS_hat_prev = self._eigs.copy()\\n\\t\\t\\t\\t\\tfor iFreq in range(0,self._n_freq):\\n\\n\\t\\t\\t\\t\\t\\t# new data (weighted)\\n\\t\\t\\t\\t\\t\\tx = X_hat[:,[iFreq]] * sqrtW[:]\\n\\t\\t\\t\\t\\t\\t# old basis\\n\\t\\t\\t\\t\\t\\tU = np.squeeze(U_hat[:,iFreq,:])\\n\\t\\t\\t\\t\\t\\t# old singular values\\n\\t\\t\\t\\t\\t\\tS = np.diag(np.squeeze(self._eigs[:,iFreq]))\\n\\t\\t\\t\\t\\t\\t# product U^H*x needed in eqns. (27,32)\\n\\t\\t\\t\\t\\t\\tUx = np.matmul(U.conj().T, x)\\n\\t\\t\\t\\t\\t\\t# orthogonal complement to U, eqn. (27)\\n\\t\\t\\t\\t\\t\\tu_p = x - np.matmul(U, Ux)\\n\\t\\t\\t\\t\\t\\t# norm of orthogonal complement\\n\\t\\t\\t\\t\\t\\tabs_up = np.sqrt(np.matmul(u_p.conj().T, u_p))\\n\\t\\t\\t\\t\\t\\t# normalized orthogonal complement\\n\\t\\t\\t\\t\\t\\tu_new = u_p / abs_up\\n\\n\\t\\t\\t\\t\\t\\t# build K matrix and compute its SVD, eqn. (32)\\n\\t\\t\\t\\t\\t\\tK_1 = np.hstack((np.sqrt(block_i+2) * S, Ux))\\n\\t\\t\\t\\t\\t\\tK_2 = np.hstack((z, abs_up))\\n\\t\\t\\t\\t\\t\\tK = np.vstack((K_1, K_2))\\n\\t\\t\\t\\t\\t\\tK = np.sqrt((block_i+1)/ (block_i+2)**2) * K\\n\\n\\t\\t\\t\\t\\t\\t# calculate partial svd\\n\\t\\t\\t\\t\\t\\tUp, Sp, _ = la.svd(K, full_matrices=False)\\n\\n\\t\\t\\t\\t\\t\\t# update U as in eqn. (33)\\n\\t\\t\\t\\t\\t\\t# for simplicity, we could not rotate here and instead\\n\\t\\t\\t\\t\\t\\t# update U<-[U p] and Up<-[Up 0;0 1]*Up and rotate later;\\n\\t\\t\\t\\t\\t\\t# see Brand (LAA ,2006, section 4.1)\\n\\t\\t\\t\\t\\t\\tU_tmp = np.hstack((U, u_new))\\n\\t\\t\\t\\t\\t\\tU = np.dot(U_tmp, Up)\\n\\n\\t\\t\\t\\t\\t\\t# best rank-k approximation, eqn. (37)\\n\\t\\t\\t\\t\\t\\tU_hat[:,iFreq,:] = U[:,0:self._n_modes_save]\\n\\t\\t\\t\\t\\t\\tself._eigs[:,iFreq] = Sp[0:self._n_modes_save]\\n\\n\\t\\t\\t\\t\\t# reset Fourier sum\\n\\t\\t\\t\\t\\tX_hat[:,:] = 0\\n\\n\\t\\t\\t\\tX_SPOD_prev = X_SPOD\\n\\t\\t\\t\\tX_SPOD = U_hat * (1 / sqrtW[:,:,np.newaxis])\\n\\n\\t\\t\\t\\t# Convergence\\n\\t\\t\\t\\tfor iFreq in range(0,self._n_freq):\\n\\t\\t\\t\\t\\tproj_iFreq = np.matmul((np.squeeze(X_SPOD_prev[:,iFreq,:]) * self._weights).conj().T, \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t np.squeeze(X_SPOD[:,iFreq,:]))\\n\\t\\t\\t\\t\\tproj_prev[iFreq,block_i,:] = np.amax(np.abs(proj_iFreq), axis=0)\\n\\t\\t\\t\\tmse_prev[block_i,:,:] = (np.abs(S_hat_prev**2 - self._eigs**2)**2) / (S_hat_prev**2)\\n\\n\\t\\t# rescale such that <U_i,U_j>_E = U_i^H*W*U_j = delta_ij\\n\\t\\tX_SPOD = U_hat[:,:,0:self._n_modes_save] * (1 / sqrtW[:,:,np.newaxis])\\n\\n\\t\\t# shuffle and reshape\\n\\t\\tX_SPOD = np.einsum('ijk->jik', X_SPOD)\\n\\t\\tX_SPOD = np.reshape(X_SPOD, (self._n_freq,)+self._xshape+(self._nv,)+(self._n_modes_save,))\\n\\n\\t\\t# save eigenvalues\\n\\t\\tself._eigs = self._eigs.T\\n\\n\\t\\t# save results into files\\n\\t\\tfile = os.path.join(self._save_dir,'spod_energy')\\n\\t\\tnp.savez(file, eigs=self._eigs, f=self._freq)\\n\\t\\tfor iFreq in range(0,self._n_freq):\\n\\t\\t\\tPsi = X_SPOD[iFreq,...]\\n\\t\\t\\tfile_psi = os.path.join(self._save_dir,'modes1to{:04d}_freq{:04d}.npy'.format(self._n_modes_save,iFreq))\\n\\t\\t\\tnp.save(file_psi, Psi)\\n\\t\\t\\tself._modes[iFreq] = file_psi\\n\\n\\t\\tprint('Elapsed time: ', time.time() - start, 's.')\\n\\t\\treturn self\",\n \"def _dipole_forwards(fwd_data, whitener, rr, n_jobs=1):\\n B = _compute_forwards_meeg(rr, fwd_data, n_jobs, verbose=False)\\n B = np.concatenate(B, axis=1)\\n B_orig = B.copy()\\n\\n # Apply projection and whiten (cov has projections already)\\n B = np.dot(B, whitener.T)\\n\\n # column normalization doesn't affect our fitting, so skip for now\\n # S = np.sum(B * B, axis=1) # across channels\\n # scales = np.repeat(3. / np.sqrt(np.sum(np.reshape(S, (len(rr), 3)),\\n # axis=1)), 3)\\n # B *= scales[:, np.newaxis]\\n scales = np.ones(3)\\n return B, B_orig, scales\",\n \"def _ps_update(self, i):\\n\\n for d in range(self.plant.dof):\\n self.ps_plots[d].set_data(\\n np.asarray(self.x_values).T[d],\\n np.asarray(self.x_values).T[self.plant.dof+d])\\n return self.ps_plots\",\n \"def setup(self):\\n\\n module = [m for m in Rt.modules if m.name == self.module_name][0]\\n\\n # Take CPACS file from the optimisation\\n cpacs_path = module.cpacs_in\\n tixi = open_tixi(cpacs_path)\\n self.Model = load_surrogate(tixi)\\n tixi.save(cpacs_path)\\n\\n df = self.Model.df\\n df.set_index(\\\"Name\\\", inplace=True)\\n for name in df.index:\\n if df.loc[name, \\\"type\\\"] == \\\"obj\\\":\\n self.add_output(name)\\n elif df.loc[name, \\\"type\\\"] == \\\"des\\\":\\n self.add_input(name)\\n\\n self.xd = df.loc[[name for name in df.index if df.loc[name, \\\"type\\\"] == \\\"des\\\"]]\\n self.yd = df.loc[[name for name in df.index if df.loc[name, \\\"type\\\"] == \\\"obj\\\"]]\",\n \"def __updateMatC(self):\\n\\t\\tif self.regScheme == 2:\\n\\t\\t\\tfor id1 in range(self.nTemplates):\\n\\t\\t\\t\\tself.C[id1,id1] = 1.0 / self.w0[id1]**2\",\n \"def smethod(fx,L=11,nh=2**8,tstep=2**7,ng=1,df=1.0,nfbins=2**10,sigmaL=None):\\r\\n \\t\\r\\n df=float(df)\\r\\n \\r\\n if type(fx) is list:\\r\\n fx=np.array(fx)\\r\\n try:\\r\\n fn,fm=fx.shape\\r\\n if fm>fn:\\r\\n fm,fn=fx.shape\\r\\n except ValueError:\\r\\n fn=len(fx)\\r\\n fm=1\\r\\n if fm>1:\\r\\n print 'computing cross spectra'\\r\\n #compute the analytic signal of function f and dctrend\\r\\n #fa=sps.hilbert(dctrend(fx[0]))\\r\\n #fb=sps.hilbert(dctrend(fx[1]))\\r\\n fa=fx[0]\\r\\n fb=fx[1]\\r\\n fa=fa.reshape(fn)\\r\\n fb=fb.reshape(fn)\\r\\n pxa,tlst,flst=stft(fa,nh=nh,tstep=tstep,ng=ng,df=df,nfbins=nfbins)\\r\\n pxb,tlst,flst=stft(fb,nh=nh,tstep=tstep,ng=ng,df=df,nfbins=nfbins)\\r\\n pxx=pxa*pxb.conj()\\r\\n else:\\r\\n #compute the analytic signal of function f and dctrend\\r\\n #fa=sps.hilbert(dctrend(fx))\\r\\n fa=fx\\r\\n fa=fa.reshape(fn)\\r\\n fb=fa\\r\\n pxx,tlst,flst=stft(fa,nh=nh,tstep=tstep,ng=ng,df=df,nfbins=nfbins)\\r\\n# pxb=pxa\\r\\n\\r\\n #make an new array to put the new tfd in\\r\\n tfarray=abs(pxx)**2\\r\\n #get shape of spectrogram\\r\\n nf,nt=tfarray.shape\\r\\n #create a list of frequency shifts\\r\\n Llst=np.arange(start=-L/2+1,stop=L/2+1,step=1,dtype='int')\\r\\n #create a frequency gaussian window\\r\\n if sigmaL==None:\\r\\n sigmaL=L/(1*np.sqrt(2*np.log(2)))\\r\\n p=sps.gaussian(L,sigmaL)\\r\\n #make a matrix of windows\\r\\n pm=np.zeros((L,nt))\\r\\n for kk in range(nt):\\r\\n pm[:,kk]=p\\r\\n \\r\\n #loop over frequency and calculate the s-method \\r\\n for ff in range(L/2,nf-L/2):\\r\\n tfarray[ff,:]=tfarray[ff,:]+2*np.real(np.sum(pm*pxx[ff+Llst,:]*\\r\\n pxx[ff-Llst,:].conj(),axis=0))\\r\\n tfarray=tfarray/L\\r\\n \\r\\n return tfarray,tlst,flst,pxx\",\n \"def spindle_attributes(self):\\n try:\\n self.channels\\n except AttributeError:\\n # create if doesn't exist\\n self.channels = [x[0] for x in self.data.columns]\\n\\n dfs =['spfiltEEG', 'spRMS', 'spRMSmavg'] # for > speed, don't store spRMS as an attribute\\n [setattr(self, df, pd.DataFrame(index=self.data.index)) for df in dfs]\\n self.spThresholds = pd.DataFrame(index=['Mean RMS', 'Low Threshold', 'High Threshold'])\\n self.spindle_events = {}\\n self.spindle_rejects = {}\",\n \"def cpsd(self):\\r\\n self.welch_method = self.method\\r\\n self.welch_method['this_method'] = 'welch'\\r\\n self.welch_method['Fs'] = self.input.sampling_rate\\r\\n f, spectrum_welch = tsa.get_spectra(self.input.data,\\r\\n method=self.welch_method)\\r\\n\\r\\n return f, spectrum_welch\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5937564","0.5780565","0.5741519","0.56655246","0.563537","0.5506949","0.5402162","0.5372675","0.5352444","0.5346785","0.532719","0.531849","0.5266165","0.5228784","0.5225048","0.51991665","0.51623684","0.5162299","0.51584435","0.5140857","0.5140395","0.5132746","0.5084031","0.5079144","0.50787956","0.507082","0.50343704","0.5027339","0.5013533","0.50035834","0.499128","0.49839756","0.4975396","0.49678218","0.49677503","0.49435437","0.49371222","0.49355578","0.49348998","0.4933212","0.49270692","0.49183702","0.49174982","0.49035478","0.48973233","0.48880547","0.48636556","0.48630422","0.48461765","0.48457614","0.484451","0.48336995","0.48247948","0.48214266","0.48187652","0.48086017","0.48067263","0.48015642","0.47986594","0.47979054","0.4790621","0.4782569","0.4777784","0.47678038","0.4767192","0.47600776","0.4752929","0.47426516","0.47329006","0.47325394","0.47289535","0.47247326","0.47203216","0.4710456","0.47090116","0.47083068","0.47051728","0.46985102","0.4698206","0.4697747","0.46962902","0.46960768","0.46936315","0.46932706","0.4692846","0.46874538","0.46804577","0.46747026","0.46746463","0.46710312","0.4669624","0.46595192","0.46590635","0.46534342","0.4652106","0.46379003","0.4636843","0.46353194","0.463308","0.46323735"],"string":"[\n \"0.5937564\",\n \"0.5780565\",\n \"0.5741519\",\n \"0.56655246\",\n \"0.563537\",\n \"0.5506949\",\n \"0.5402162\",\n \"0.5372675\",\n \"0.5352444\",\n \"0.5346785\",\n \"0.532719\",\n \"0.531849\",\n \"0.5266165\",\n \"0.5228784\",\n \"0.5225048\",\n \"0.51991665\",\n \"0.51623684\",\n \"0.5162299\",\n \"0.51584435\",\n \"0.5140857\",\n \"0.5140395\",\n \"0.5132746\",\n \"0.5084031\",\n \"0.5079144\",\n \"0.50787956\",\n \"0.507082\",\n \"0.50343704\",\n \"0.5027339\",\n \"0.5013533\",\n \"0.50035834\",\n \"0.499128\",\n \"0.49839756\",\n \"0.4975396\",\n \"0.49678218\",\n \"0.49677503\",\n \"0.49435437\",\n \"0.49371222\",\n \"0.49355578\",\n \"0.49348998\",\n \"0.4933212\",\n \"0.49270692\",\n \"0.49183702\",\n \"0.49174982\",\n \"0.49035478\",\n \"0.48973233\",\n \"0.48880547\",\n \"0.48636556\",\n \"0.48630422\",\n \"0.48461765\",\n \"0.48457614\",\n \"0.484451\",\n \"0.48336995\",\n \"0.48247948\",\n \"0.48214266\",\n \"0.48187652\",\n \"0.48086017\",\n \"0.48067263\",\n \"0.48015642\",\n \"0.47986594\",\n \"0.47979054\",\n \"0.4790621\",\n \"0.4782569\",\n \"0.4777784\",\n \"0.47678038\",\n \"0.4767192\",\n \"0.47600776\",\n \"0.4752929\",\n \"0.47426516\",\n \"0.47329006\",\n \"0.47325394\",\n \"0.47289535\",\n \"0.47247326\",\n \"0.47203216\",\n \"0.4710456\",\n \"0.47090116\",\n \"0.47083068\",\n \"0.47051728\",\n \"0.46985102\",\n \"0.4698206\",\n \"0.4697747\",\n \"0.46962902\",\n \"0.46960768\",\n \"0.46936315\",\n \"0.46932706\",\n \"0.4692846\",\n \"0.46874538\",\n \"0.46804577\",\n \"0.46747026\",\n \"0.46746463\",\n \"0.46710312\",\n \"0.4669624\",\n \"0.46595192\",\n \"0.46590635\",\n \"0.46534342\",\n \"0.4652106\",\n \"0.46379003\",\n \"0.4636843\",\n \"0.46353194\",\n \"0.463308\",\n \"0.46323735\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60962576"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":25590,"cells":{"query":{"kind":"string","value":"Given a theta vector, generate spectroscopy, photometry and any extras (e.g. stellar mass)."},"document":{"kind":"string","value":"def get_spectrum(self, outwave=None, filters=None, peraa=False, **params):\n self.params.update(**params)\n # Pass the model parameters through to the sps object\n ncomp = len(self.params['mass'])\n for ic in range(ncomp):\n s, p, x = self.one_sed(component_index=ic, filterlist=filters)\n try:\n spec += s\n maggies += p\n extra += [x]\n except(NameError):\n spec, maggies, extra = s, p, [x]\n # `spec` is now in Lsun/Hz, with the wavelength array being the\n # observed frame wavelengths. Flux array (and maggies) have not been\n # increased by (1+z) due to cosmological redshift\n\n if outwave is not None:\n w = self.csp.wavelengths\n spec = np.interp(outwave, w, spec)\n # Distance dimming and unit conversion\n if (self.params['zred'] == 0) or ('lumdist' in self.params):\n # Use 10pc for the luminosity distance (or a number provided in the\n # lumdist key in units of Mpc). Do not apply cosmological (1+z)\n # factor to the flux.\n dfactor = (self.params.get('lumdist', 1e-5) * 1e5)**2\n a = 1.0\n else:\n # Use the comsological luminosity distance implied by this\n # redshift. Incorporate cosmological (1+z) factor on the flux.\n lumdist = cosmo.luminosity_distance(self.params['zred']).value\n dfactor = (lumdist * 1e5)**2\n a = (1 + self.params['zred'])\n if peraa:\n # spectrum will be in erg/s/cm^2/AA\n spec *= to_cgs * a / dfactor * lightspeed / outwave**2\n else:\n # Spectrum will be in maggies\n spec *= to_cgs * a / dfactor / 1e3 / (3631*jansky_mks)\n\n # Convert from absolute maggies to apparent maggies\n maggies *= a / dfactor\n \n return spec, maggies, extra"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def scattering_direction(v, theta):\r\n # Sample cos_phi and sin_phi, phi is the azimuthal angle of the scattering event\r\n continue_loop = True\r\n while continue_loop:\r\n eta1 = 1-2*random.random()\r\n eta2 = 1-2*random.random()\r\n alpha = eta1**2 + eta2**2\r\n if alpha <= 1:\r\n continue_loop = False\r\n cos_phi = eta1/np.sqrt(alpha)\r\n sin_phi = eta2/np.sqrt(alpha)\r\n \r\n new_x = v[0]*np.cos(theta) - np.sin(theta)/np.sqrt(1-v[2]**2) * (v[0]*v[2]*cos_phi + v[1]*sin_phi)\r\n new_y = v[1]*np.cos(theta) - np.sin(theta)/np.sqrt(1-v[2]**2) * (v[1]*v[2]*cos_phi - v[0]*sin_phi)\r\n new_z = v[2]*np.cos(theta) + np.sqrt(1-v[2]**2)*np.sin(theta)*cos_phi\r\n \r\n return [new_x, new_y, new_z]","def sph2car(r, theta, phi):\n x = r * np.sin(theta) * np.cos(phi)\n y = r * np.sin(theta) * np.sin(phi)\n z = r * np.cos(theta)\n\n return x, y, z","def MSPBE_tar(self, theta):\n V = np.array((theta * self.mu_phi_tar).sum(axis=1))\n V2 = self.gamma * np.array((theta * self.mu_phi_next_tar).sum(axis=1))\n return np.mean(np.array((V - np.dot(self.projection_operator(), V2 + self.mu_r_tar))) ** 2)","def generate_theta_sv(ar):\n theta_out = []\n\n mu_y = 0\n while abs(mu_y) < 0.5:\n mu_y = np.random.uniform(-6, 6)\n\n theta_out.append(mu_y) # Expected return.\n theta_out.append(np.random.uniform(0, 3)) # Mu_s.\n theta_out.append(np.random.uniform(0, 0.7)) # Phi_1\n theta_out.append(np.random.uniform(0, 0.7)) # Phi_2\n\n # Initialize autoregressive coefficients in lag polynomial.\n #p = [-1, -1, 1]\n\n #while sum(abs(np.roots(p)) < 1.2) != 0:\n #p = [np.random.randn() for i in range(ar)]\n #p = [np.random.uniform(0, 1)*-1 for i in range(ar)]\n #p.append(1)\n\n #theta_out.append(-1*p[1]) # Phi_1\n #theta_out.append(-1*p[0]) # Phi_2\n #theta_out.append(-1*p[1])\n #theta_out.append(-1*p[0])\n #theta_out.append(np.random.rand()*2) # Sigma_eta.\n\n return theta_out","def theta():\n pass","def gpower_integrand(self,theta,phi):\n\n wavelength = 299.9/self.frequency\n if(phi == 0): phi = .00001\n if(phi == np.pi): phi = np.pi - .00001\n\n self.aa.alt = np.pi/2.0 - theta\n self.aa.az = np.pi/2.0 - phi\n\n coords = self.aa.raDec(self.__lst_current,self.location)\n\n coords = self.Rotator(np.pi/2 - coords.dec,coords.ra)\n\n Tsky = hp.get_interp_val(self.hpmap,coords[0],coords[1])*(self.frequency/408.0)**(-2.55)\n\n ans = self.lofasm.beam_pattern(theta,phi,[0,0,1])\n ans += self.lofasm.beam_pattern(theta,phi,[0,1,0]) \n ans *= (Tsky*(1.3804e-23)/wavelength**2)/(1e-26)/2.0\n\n return ans","def generate_variations(seed=425, th=150):\n \n # impact parameters\n M = 1e8*u.Msun\n B0 = 19.85*u.kpc\n\n V = 220*u.km/u.s\n phi = coord.Angle(0*u.deg)\n theta = coord.Angle(th*u.deg)\n Tenc = 0.01*u.Gyr\n T = 0.5*u.Gyr\n dt = 0.05*u.Myr\n rs = 0*u.pc\n potential_perturb = 1\n \n # potential parameters (log halo)\n potential = 3\n Vh = 220*u.km/u.s\n q = 1*u.Unit(1)\n rhalo = 20*u.pc\n par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])\n \n # setup tube\n Nstar = 1400\n wx = 30*u.kpc\n wy = 0*u.pc\n wz = 0*u.pc\n sx = 0*u.km/u.s\n \n np.random.seed(seed)\n observer = {'z_sun': 27.*u.pc, 'galcen_distance': 8.3*u.kpc, 'roll': 60*u.deg, 'galcen_coord': coord.SkyCoord(ra=300*u.deg, dec=-90*u.deg, frame='icrs')}\n vobs = {'vcirc': 220*u.km/u.s, 'vlsr': [0, 0, 0]*u.km/u.s}\n wangle = 180*u.deg\n \n xphi = np.linspace(-0.3*np.pi,0.3*np.pi, Nstar)\n xphi0 = np.linspace(-0.1*np.pi, 0.1*np.pi, 1000)\n xphi1 = np.linspace(-0.28*np.pi, -0.1*np.pi, 200)\n xphi2 = np.linspace(0.1*np.pi, 0.32*np.pi, 200)\n xphi = np.concatenate([xphi1, xphi0, xphi2])\n \n Bs = 20*u.kpc\n xr = Bs + np.random.randn(Nstar)*0.0*u.kpc\n x = np.sin(xphi) * xr\n y = np.cos(xphi) * xr\n z = x * 0\n vx = -np.cos(xphi) * Vh\n vy = np.sin(xphi) * Vh\n vz = vx * 0\n ienc = np.argmin(np.abs(x))\n \n farray = np.array([0.1, 0.3, 0.5, 1, 2, 3, 10])\n farray = np.array([0.3,0.5,0.8,0.9,1,1.1,1.2,2,3])\n \n for e, f in enumerate(farray):\n # unperturbed stream\n par_perturb = np.array([0*M.si.value, 0., 0., 0.])\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B0.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, (T*f).si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream0 = {}\n stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal0 = coord.Galactocentric(stream0['x'], **observer)\n xeq0 = xgal0.transform_to(coord.ICRS)\n veq0_ = gc.vgal_to_hel(xeq0, stream0['v'], **vobs)\n veq0 = [None] * 3\n veq0[0] = veq0_[0].to(u.mas/u.yr)\n veq0[1] = veq0_[1].to(u.mas/u.yr)\n veq0[2] = veq0_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n R = find_greatcircle(xeq0.ra.deg[::10], xeq0.dec.deg[::10])\n xi0, eta0 = myutils.rotate_angles(xeq0.ra, xeq0.dec, R)\n xi0 = coord.Angle(xi0*u.deg)\n \n # place gap at xi~0\n xioff = xi0[ienc]\n xi0 -= xioff\n \n par_perturb = np.array([M.si.value, 0., 0., 0.])\n dB = (B0 - Bs)\n B = dB + Bs\n \n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, (T*f).si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream = {}\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal = coord.Galactocentric(stream['x'], **observer)\n xeq = xgal.transform_to(coord.ICRS)\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\n veq = [None] * 3\n veq[0] = veq_[0].to(u.mas/u.yr)\n veq[1] = veq_[1].to(u.mas/u.yr)\n veq[2] = veq_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\n xi = coord.Angle(xi*u.deg)\n xi -= xioff\n \n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'observer': observer, 'vobs': vobs, 'R': R, 'xi0': xioff, 'x0': stream0['x'], 'v0': stream0['v']}\n pickle.dump(outdict, open('../data/variations/vary_th{:03d}_T_{:.1f}.pkl'.format(th, f), 'wb'))\n \n # unperturbed stream\n par_perturb = np.array([0*M.si.value, 0., 0., 0.])\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B0.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream0 = {}\n stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal0 = coord.Galactocentric(stream0['x'], **observer)\n xeq0 = xgal0.transform_to(coord.ICRS)\n veq0_ = gc.vgal_to_hel(xeq0, stream0['v'], **vobs)\n veq0 = [None] * 3\n veq0[0] = veq0_[0].to(u.mas/u.yr)\n veq0[1] = veq0_[1].to(u.mas/u.yr)\n veq0[2] = veq0_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n R = find_greatcircle(xeq0.ra.deg[::10], xeq0.dec.deg[::10])\n xi0, eta0 = myutils.rotate_angles(xeq0.ra, xeq0.dec, R)\n xi0 = coord.Angle(xi0*u.deg)\n \n # place gap at xi~0\n xioff = xi0[ienc]\n xi0 -= xioff\n \n for e, f in enumerate(farray):\n par_perturb = np.array([f*M.si.value, 0., 0., 0.])\n dB = (B0 - Bs)\n B = dB + Bs\n \n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, (T).si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream = {}\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal = coord.Galactocentric(stream['x'], **observer)\n xeq = xgal.transform_to(coord.ICRS)\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\n veq = [None] * 3\n veq[0] = veq_[0].to(u.mas/u.yr)\n veq[1] = veq_[1].to(u.mas/u.yr)\n veq[2] = veq_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\n xi = coord.Angle(xi*u.deg)\n xi -= xioff\n \n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'observer': observer, 'vobs': vobs, 'R': R, 'xi0': xioff, 'x0': stream0['x'], 'v0': stream0['v']}\n pickle.dump(outdict, open('../data/variations/vary_th{:03d}_M_{:.1f}.pkl'.format(th, f), 'wb'))\n \n for e, f in enumerate(farray):\n par_perturb = np.array([M.si.value, 0., 0., 0.])\n dB = (B0 - Bs)\n B = dB*f + Bs\n \n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream = {}\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal = coord.Galactocentric(stream['x'], **observer)\n xeq = xgal.transform_to(coord.ICRS)\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\n veq = [None] * 3\n veq[0] = veq_[0].to(u.mas/u.yr)\n veq[1] = veq_[1].to(u.mas/u.yr)\n veq[2] = veq_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\n xi = coord.Angle(xi*u.deg)\n xi -= xioff\n \n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'observer': observer, 'vobs': vobs, 'R': R, 'xi0': xioff, 'x0': stream0['x'], 'v0': stream0['v']}\n pickle.dump(outdict, open('../data/variations/vary_th{:03d}_B_{:.1f}.pkl'.format(th, f), 'wb'))\n \n theta0 = theta\n V0 = V\n \n for e, f in enumerate(farray):\n par_perturb = np.array([M.si.value, 0., 0., 0.])\n dB = (B0 - Bs)\n B = dB + Bs\n \n vpar = Vh + np.cos(theta0.rad)*V0\n vperp = np.sin(theta0.rad)*V0\n vpar_scaled = vpar*f\n vperp_scaled = vperp*f\n \n V = np.sqrt((vpar_scaled-Vh)**2 + vperp_scaled**2)\n theta = coord.Angle(np.arctan2(vperp_scaled, vpar_scaled-Vh))\n \n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream = {}\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal = coord.Galactocentric(stream['x'], **observer)\n xeq = xgal.transform_to(coord.ICRS)\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\n veq = [None] * 3\n veq[0] = veq_[0].to(u.mas/u.yr)\n veq[1] = veq_[1].to(u.mas/u.yr)\n veq[2] = veq_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\n xi = coord.Angle(xi*u.deg)\n xi -= xioff\n \n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'observer': observer, 'vobs': vobs, 'R': R, 'xi0': xioff, 'x0': stream0['x'], 'v0': stream0['v']}\n pickle.dump(outdict, open('../data/variations/vary_th{:03d}_V_{:.1f}.pkl'.format(th, f), 'wb'))","def _theta(num_vars):\n theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)\n # rotate theta such that the first axis is at the top\n theta += np.pi/2\n return theta","def Psi(l,m,theta,phi):\n if numpy.isscalar(theta): \n theta=numpy.array([[theta]])\n phi=numpy.array([[phi]])\n Psilm_th=numpy.zeros(theta.shape,dtype=complex)\n Psilm_ph=numpy.zeros(theta.shape,dtype=complex)\n x=numpy.cos(theta)\n thetaNonZerosIdx=numpy.where(theta!=0.0)\n if len(thetaNonZerosIdx[0]) != 0:\n Ylm=scipy.special.sph_harm(m,l,phi[thetaNonZerosIdx],theta[thetaNonZerosIdx])\n #Compute derivative of sphrHarm function w.r.t. theta:\n if l>=numpy.abs(m):\n Plmpo=legendreLM(l,m+1,x[thetaNonZerosIdx])\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/float(math.factorial(l+m)))*Plmpo*numpy.exp(1j*m*phi[thetaNonZerosIdx])\n #YlmPmpo=sqrt((l-m)*(l+m+1))*spharm(l,m+1,theta,phi)*exp(-i*phi) %Should be equivalent to above formula.\n dtYlm=+YlmPmpo+m*x[thetaNonZerosIdx]*Ylm/numpy.sin(theta[thetaNonZerosIdx])\n # thetZerInd=[find(theta==0); find(theta==pi)]\n # dtYlm(thetZerInd)=0; %This is a fudge to remove NaNs\n else:\n dtYlm=numpy.zeros(theta[thetaNonZerosIdx].shape,dtype=complex)\n\n #dtYlm=spharmDtheta(l,m,theta,phi)\n\n Psilm_ph[thetaNonZerosIdx]=+1j*m/numpy.sin(theta[thetaNonZerosIdx])*Ylm\n Psilm_th[thetaNonZerosIdx]=+dtYlm\n #Ref: http://mathworld.wolfram.com/VectorSphericalHarmonic.html\n\n thetaZerosIdx=numpy.where(theta==0.0)\n if len(thetaZerosIdx[0]) != 0:\n if numpy.abs(m)==1:\n Yl1B=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*PBl1(l,m)*numpy.exp(1j*m*phi[thetaZerosIdx])\n Plmpo=legendreLM(l,m+1,x[thetaZerosIdx])\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*Plmpo*numpy.exp(1j*m*phi[thetaZerosIdx])\n dtYlm=+YlmPmpo+m*Yl1B\n Psilm_ph[thetaZerosIdx]=+1j*m*Yl1B\n Psilm_th[thetaZerosIdx]=+dtYlm\n else:\n Plmpo=legendreLM(l,m+1,x[thetaZerosIdx])\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*Plmpo*numpy.exp(1j*m*phi[thetaZerosIdx])\n dtYlm=+YlmPmpo+0\n Psilm_ph[thetaZerosIdx]=0\n Psilm_th[thetaZerosIdx]=+dtYlm\n return Psilm_th,Psilm_ph","def twist(self, theta):\n self.G_indv = li.expm(self.xi_hat * theta)","def batch_rodrigues(theta):\n l2norm = torch.norm(theta + 1e-08, p=2, dim=1)\n angle = torch.unsqueeze(l2norm, -1)\n normalized = torch.div(theta, angle)\n angle = angle * 0.5\n v_cos = torch.cos(angle)\n v_sin = torch.sin(angle)\n quat = torch.cat([v_cos, v_sin * normalized], dim=1)\n return quat_to_rotmat(quat)","def theta(conc, S, educts):\n\n educts_per_reaction = educts.T\n\n # in every reaction j row, element at pos (column, species) i equals conc_i^educt_{ij}\n # educt_{ij} - how many units of i are educts in reaction j\n multiplicative_term_rows = np.power(conc, educts_per_reaction)\n\n # concentrations to educt product ----> product_{i=1}^{n_s}(conc_i^{educt_{ij}}\n concentration_product = np.prod(multiplicative_term_rows, axis=1)\n\n # returns one row with #reactions elements -> fluxes\n return concentration_product * S","def grad_chi(self, theta):\n theta = np.asarray(theta)\n assert theta.size == 12 + self.nspots * 8 + self.mmax * 2, \"Parameter vector with wrong size\"\n theta_star = theta[:12]\n theta_spot = theta[12:12 + self.nspots * 8]\n theta_inst = theta[12 + self.nspots * 8:]\n\n result = macula(self.t, theta_star, theta_spot, theta_inst, tstart=self.tstart, tend=self.tend,\n full_output=True, derivatives=True)\n yf = result[0]\n dy_star = result[1]\n dy_spot = result[2]\n dy_inst = result[3]\n # TODO: review this whole function!\n dic_star = {}\n for i, key in enumerate(self.star_pars.keys()):\n dic_star[key] = dy_star[:, i]\n dic_spot = {}\n for i, key in enumerate(self.spot_pars.keys()):\n dic_spot[key] = dy_spot[:, i]\n dic_inst = {}\n for i, key in enumerate(self.inst_pars.keys()):\n dic_inst[key] = dy_inst[:, i]\n dic_full = {**dic_star, **dic_spot, **dic_inst}\n dy = []\n for key in self.fit_names:\n if key in self.spot_pars.keys():\n for j in range(self.nspots):\n dy.append(np.sum(2 * (yf - self.y) * dic_full[key][:, j]) / np.std(self.y))\n elif key in self.inst_pars.keys():\n for j in range(self.mmax):\n dy.append(np.sum(2 * (yf - self.y) * dic_full[key][:, j]) / np.std(self.y))\n else:\n dy.append(np.sum(2 * (yf - self.y) * dic_full[key]) / np.std(self.y))\n return np.array(dy)","def theta(a, b):\n \n \n def norm_vec(x):\n norm_out = sqrt(dot(x, x))\n return norm_out\n \n theta = acos(dot(a, b) / (norm_vec(a) * norm_vec(b))) * 180 / pi\n \n print theta","def inject(energy, theta_x, theta_y, flux=1, noise=0):\n respfile_f = calc_resp(energy, theta_x, theta_y)\n image = f2image(respfile_f) * flux + np.random.poisson(noise, (128, 128))\n return image","def _gen_rxx(theta):\n return np.array([[np.cos(theta / 2), 0, 0, -1j * np.sin(theta / 2)],\n [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0],\n [0, -1j * np.sin(theta / 2), np.cos(theta / 2), 0],\n [-1j * np.sin(theta / 2), 0, 0, np.cos(theta / 2)]])","def theta_rot(od, theta):\n rot_mat = np.array([[np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]])\n return rot_mat.dot(od)","def set_phi_theta_r(phi, theta, r=1):\n return np.array([sin(theta) * cos(phi),\n sin(theta) * sin(phi),\n cos(theta)]) * r","def piston( f, # frequency\n a_h, a_v,\n theta, phi,\n c=343 ): # speed of sound, in m/s.\n k = 2*np.pi*f/c # wave number\n \n if type(theta) is types.IntType or type(theta) is types.FloatType or type(theta) is np.float64:\n theta = np.array([theta], dtype=np.float64)\n else:\n theta = np.array(theta, dtype=np.float64)\n if type(phi) is types.IntType or type(phi) is types.FloatType or type(phi) is np.float64:\n phi = np.array([phi], dtype=np.float64)\n else:\n phi = np.array(phi, dtype=np.float64)\n h_term = k*a_h*np.sin(theta)\n v_term = k*a_v*np.sin(phi)\n\n h_factor = .5*np.ones(shape=h_term.shape)\n for k in range(len(h_factor)):\n if np.abs(h_term[k]) > 4*np.finfo(np.float64).eps:\n h_factor[k] = sp_special.jn(1, h_term[k])/h_term[k]\n \n v_factor = .5*np.ones(shape=v_term.shape)\n for k in range(len(v_factor)):\n if np.abs(v_term[k]) > 4*np.finfo(np.float64).eps:\n v_factor[k] = sp_special.jn(1, v_term[k])/v_term[k]\n \n if v_factor.shape[0] > 1 and h_factor.shape[0] > 1:\n return 4*np.outer(np.abs(v_factor), np.abs(h_factor)) # make P from outer product.\n else:\n return 4*np.abs(v_factor*h_factor)","def _single_term_cos(power, rho, theta):\n\n return np.power(rho, power) * np.cos(power * theta)","def theta(lam, gam, p):\n #lam = lam - 1e-15\n return np.pi - np.arccos(np.divide(-1 + lam*np.cos(2*np.pi*p ), w(lam, gam, p) ) )","def _gen_rzz(theta):\n return np.diag([1, np.exp(1j * theta), np.exp(1j * theta), 1])","def restrict_theta(theta):\n tnew = theta + np.pi\n tnew += -2.0*np.pi*np.floor(tnew/(2.0*np.pi))\n tnew -= np.pi\n return tnew","def theta(flag, S, K, t, r, sigma, q): \n\n b = r-q\n\n return numerical_theta(flag, S, K, t, r, sigma, b, f)","def op_half_wave_plate(theta):\n C2 = np.cos(2 * theta)\n S2 = np.sin(2 * theta)\n qwp = np.array([[1, 0, 0, 0],\n [0, C2**2 - S2**2, 2 * C2 * S2, 0],\n [0, 2 * C2 * S2, S2 * S2 - C2**2, 0],\n [0, 0, 0, -1]])\n return qwp","def syntheticSeismogram(d, rho, v, wavf, wavA=1., usingT=True, wavtyp = 'RICKER', dt=0.0001, dmax=200):\n\n v, rho, d = np.array(v, dtype=float), np.array(rho, dtype=float), np.array(d, dtype=float)\n usingT = np.array(usingT, dtype=bool)\n\n _, t = getTimeDepth(d,v,dmax)\n rseries,R = getReflectivity(d,rho,v)\n\n # time for reflectivity series\n tref = t[1:-1]\n\n # create time vector\n t = np.arange(t.min(),t.max(),dt)\n\n # make wavelet\n twav = np.arange(-2.0/np.min(wavf), 2.0/np.min(wavf), dt)\n\n # Get source wavelet\n wav = {'RICKER':getRicker, 'ORMSBY':getOrmsby, 'KLAUDER':getKlauder}[wavtyp](wavf,twav)\n wav = wavA*wav\n\n rseriesconv = np.zeros(len(t))\n for i in range(len(tref)):\n index = np.abs(t - tref[i]).argmin()\n rseriesconv[index] = rseries[i]\n\n # Do the convolution\n seis = np.convolve(wav,rseriesconv)\n tseis = np.min(twav)+dt*np.arange(len(seis))\n index = np.logical_and(tseis >= 0, tseis <= np.max(t))\n tseis = tseis[index]\n seis = seis[index]\n\n return tseis, seis, twav, wav, tref, rseries","def model(theta, x):\n\tw, b = theta\n\treturn w * x + b","def compute_theta(tx, index_theta, mean=[],std=[]):\n tx_new = np.cos(tx[:,index_theta])\n return standardize(tx_new,mean,std)","def _single_term_sin(power, rho, theta):\n\n return np.power(rho, power) * np.sin(power * theta)","def transform_scan(self, particle, distance, theta):\n return (particle.x + distance * math.cos(math.radians(particle.theta + theta)),\n particle.y + distance * math.sin(math.radians(particle.theta + theta)))","def theta_v_time():\n pass","def dir_vect(theta):\n return np.array([np.cos(theta),np.sin(theta)])","def op_quarter_wave_plate(theta):\n C2 = np.cos(2 * theta)\n S2 = np.sin(2 * theta)\n qwp = np.array([[1, 0, 0, 0],\n [0, C2**2, C2 * S2, -S2],\n [0, C2 * S2, S2 * S2, C2],\n [0, S2, -C2, 0]])\n return qwp","def get_theta_from_cov(self, Sigma, theta):\n sigma_values = np.triu(Sigma)\n ind_u = np.triu_indices(self.dim)\n sigma_values= sigma_values[ind_u]\n return np.append(self.get_mu(theta), sigma_values)","def morphology(seed=425, th=120):\n \n # impact parameters\n M = 1e8*u.Msun\n B = 19.85*u.kpc\n V = 220*u.km/u.s\n phi = coord.Angle(0*u.deg)\n theta = coord.Angle(th*u.deg)\n Tenc = 0.01*u.Gyr\n T = 0.5*u.Gyr\n dt = 0.1*u.Myr\n rs = 0*u.pc\n \n # potential parameters\n potential = 3\n Vh = 220*u.km/u.s\n q = 1*u.Unit(1)\n rhalo = 20*u.pc\n par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])\n \n # setup tube\n Nstar = 3000\n wx = 30*u.kpc\n wy = 0*u.pc\n wz = 0*u.pc\n sx = 0*u.km/u.s\n \n np.random.seed(seed)\n \n xphi = np.linspace(-0.3*np.pi,0.3*np.pi, Nstar)\n xr = 20*u.kpc + np.random.randn(Nstar)*0.02*u.kpc\n x = np.sin(xphi) * xr\n y = np.cos(xphi) * xr\n z = x * 0\n vx = -np.cos(xphi) * Vh\n vy = np.sin(xphi) * Vh\n vz = vx * 0\n \n potential_perturb = 1\n par_perturb = np.array([M.si.value, 0., 0., 0.])\n \n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream = {}\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n\n plt.close()\n fig, ax = plt.subplots(3,1,figsize=(12,8), sharex=True)\n \n c_init = mpl.cm.Blues_r(1)\n c_fin0 = mpl.cm.Blues_r(0.5)\n c_fin = mpl.cm.Blues_r(0.2)\n \n eta = coord.Angle(np.arctan2(np.sqrt(stream['x'][0].to(u.kpc).value**2 + stream['x'][1].to(u.kpc).value**2),xr.to(u.kpc).value)*u.rad)\n xi = np.arctan2(stream['x'][1].to(u.kpc).value, stream['x'][0].to(u.kpc).value)\n xi = coord.Angle((xi - np.median(xi))*u.rad)\n \n vlabel = ['x', 'y', 'z']\n \n for i in range(3):\n plt.sca(ax[i])\n im = plt.scatter(xi.deg, eta.deg, c=stream['v'][i].value, s=20)\n \n plt.xlim(-60, 50)\n plt.ylim(55, 35)\n plt.gca().set_aspect('equal')\n \n if i==2:\n plt.xlabel('$\\phi_1$ [deg]')\n plt.ylabel('$\\phi_2$ [deg]')\n \n divider = make_axes_locatable(plt.gca())\n cax = divider.append_axes(\"right\", size=\"3%\", pad=0.1)\n plt.colorbar(im, cax=cax)\n plt.ylabel('$V_{{{}}}$ [km s$^{{-1}}$]'.format(vlabel[i]))\n \n plt.tight_layout()","def _gen_u(theta, phi, lamda):\n m11 = (np.e ** (1j * (phi + lamda) / 2)) * np.cos(theta / 2)\n m12 = (-1) * (np.e ** (1j * (phi - lamda) / 2)) * np.sin(theta / 2)\n m21 = (np.e ** (1j * (phi - lamda) / 2)) * np.sin(theta / 2)\n m22 = (np.e ** (1j * (phi + lamda) / 2)) * np.cos(theta / 2)\n return np.array([[m11, m12], [m21, m22]], dtype=np.complex128)","def y(theta):\n return ((theta[1] + theta[2]) / theta[0]) - ((theta[2] * 0.01) + random.gauss(0, 0.1))","def mieScatteringCrossSections(refractiveIndex,\r\n particleDiameters,\r\n wavelength, \r\n theta):\r\n cos_theta = np.cos(theta)\r\n # Calculation of Mie parameters\r\n (a,b) = mie_abcd(refractiveIndex, \r\n np.pi*particleDiameters/wavelength)\r\n nmax = np.size(a,0)\r\n nangles = len(cos_theta)\r\n nd = len(particleDiameters)\r\n \r\n pi = np.empty((nangles,nmax,nd))\r\n tau = np.empty((nangles,nmax,nd))\r\n header = np.tile(Header(nmax), (nd,1)).T\r\n for (i, ctheta) in enumerate(cos_theta):\r\n pigen = Pi(nmax, ctheta)\r\n pitemp = np.fromiter(pigen, np.float)\r\n tautemp = Tau(pitemp, ctheta)\r\n pi[i,:,:] = np.tile(pitemp[:-1],(nd,1)).T\r\n tau[i,:,:] = np.tile(tautemp[:-1], (nd,1)).T\r\n \r\n i1 = header * (a * pi + b * tau)\r\n i2 = header * (b * pi + a * tau)\r\n\r\n \"\"\"\r\n The following sum puts the coefficients in the following form:\r\n < ndiameters >\r\n i1,i2 = [[i1, i1, ... i1], ^\r\n [i1, i1, ... i1], nangles\r\n ...\r\n [i1, i1, ... i1]] v\r\n so, each particle diameter is represented by a column\r\n \"\"\"\r\n i1 = np.sum(i1,1)\r\n i2 = np.sum(i2,1)\r\n\r\n i1 = (np.abs(i1)**2) * (1/4) * (wavelength/np.pi)**2\r\n i2 = (np.abs(i2)**2) * (1/4) * (wavelength/np.pi)**2\r\n \r\n return (i1, i2)","def extendpt(p, theta, length):\n\treturn [ p[0]+cos(theta)*length, p[1]+sin(theta)*length]","def samplePatchOnSphere(phi, theta, delta, size, rng, degrees=True):\n u = rng.uniform(size=size)\n v = rng.uniform(size=size)\n phi = np.radians(phi)\n theta = np.radians(theta)\n delta = np.radians(delta)\n\n phivals = 2. * delta * u + (phi - delta)\n phivals = np.where(phivals >= 0., phivals, phivals + 2. * np.pi)\n\n # use conventions in spherical coordinates\n # theta = np.pi/2.0 - theta\n thetamax = theta + delta\n thetamin = theta - delta\n\n # if thetamax > np.pi or thetamin < 0. :\n # raise ValueError('Function not implemented to cover wrap around poles')\n\n # Cumulative Density Function is cos(thetamin) - cos(theta) / cos(thetamin) - cos(thetamax)\n a = np.cos(thetamin) - np.cos(thetamax)\n thetavals = np.arccos(-v * a + np.cos(thetamin))\n\n if degrees:\n return np.degrees(phivals), np.degrees(thetavals)\n else:\n return phivals, thetavals","def spherical2cartesian(phi, theta, depth):\n x = depth * np.sin(theta) * np.cos(phi)\n y = depth * np.cos(theta)\n z = depth * np.sin(theta) * np.sin(phi)\n\n return x, y, z","def generate_image(self, theta, context):\n raise NotImplementedError()","def generate_image(self, theta, context):\n raise NotImplementedError()","def make_spectra(directory,frame):\n oober = st.short_oober(directory, frame=frame)\n #st.MakeVelocitySpectra(oober,frame)\n #st.MakeAccelSpectra(oober,frame)\n #st.MakeMagneticSpectra(oober,frame)\n st.MakeDensitySpectra(oober,frame)","def Spin(phi,theta):\n return 1/2*(cos(phi)*sin(theta)*xhat + sin(phi)*sin(theta)*yhat + cos(theta)*zhat)","def vector_compute_spherical_harmonics(theta, phi, selected_modes=None):\n # Only copies if input is scalar, else returns original array\n theta = np.array(theta, copy=False, ndmin=1)\n theta = np.array(phi, copy=False, ndmin=1)\n\n Ylms = {}\n one_m_theta = 1.0 - np.cos(theta)\n one_p_theta = 1.0 + np.cos(theta)\n snTheta = np.sin(theta)\n for m in range(-2, 3):\n if selected_modes is not None and (2,m) not in selected_modes:\n continue\n if m == -2:\n Ylms[(2,m)] = _a2m2 * one_m_theta * one_m_theta * np.exp(1j*m*phi)\n elif m == -1:\n Ylms[(2,m)] = _a2m1 * snTheta * one_m_theta * np.exp(1j*m*phi)\n elif m == 0:\n Ylms[(2,m)] = _a20 * snTheta * snTheta\n elif m == 1:\n Ylms[(2,m)] = _a21 * snTheta * one_p_theta * np.exp(1j*m*phi)\n elif m == 2:\n Ylms[(2,m)] = _a22 * one_p_theta * one_p_theta * np.exp(1j*m*phi)\n\n return Ylms","def gen_omega(costheta0, phi0, costheta1, phi1):\n global pgamma\n pgamma = [TLorentzVector(), TLorentzVector(), TLorentzVector()]\n q_omega = (m_omega**2 - m_pi0**2) / (2 * m_omega)\n sintheta1 = sqrt(1 - costheta1*costheta1)\n pgamma[0].SetXYZT(q_omega * sintheta1 * math.cos(phi1),\n q_omega * sintheta1 * math.sin(phi1),\n q_omega * costheta1, q_omega)\n q_pi0 = m_pi0 / 2\n sintheta0 = sqrt(1 - costheta0**2)\n pgamma[1].SetXYZT(q_pi0 * sintheta0 * math.cos(phi0),\n q_pi0 * sintheta0 * math.sin(phi0),\n q_pi0 * costheta0, q_pi0)\n pgamma[2].SetXYZT(-q_pi0 * sintheta0 * math.cos(phi0),\n -q_pi0 * sintheta0 * math.sin(phi0),\n -q_pi0 * costheta0, q_pi0)\n beta = pgamma[0].Vect() * (1 / math.sqrt(q_omega**2 + m_pi0**2))\n pgamma[1].Boost(-beta)\n pgamma[2].Boost(-beta)\n global pomega\n pomega = pgamma[0] + pgamma[1] + pgamma[2]\n return pomega","def generate_image(self, theta, context):\n\n raise NotImplementedError()","def _unpolarized_simulation(self, frequency, theta_0=0):\n s_data = self.simulate(frequency, 's', theta_0)\n p_data = self.simulate(frequency, 'p', theta_0)\n T = (s_data + p_data)/2\n return T","def scattering_amplitude(self, theta, pol=1):\r\n c = np.atleast_1d(np.cos(theta)) # vectorize\r\n s = np.expand_dims(np.sin(theta), -1)\r\n p = np.moveaxis([lpmn(1, self.n, c) for c in c], 0, 2)\r\n pi = p[0,1,:,1:]/s\r\n tau = -p[1,1,:,1:]*s\r\n n = np.arange(1, self.n + 1)\r\n k = (2*n+1)/n/(n+1) # Bohren and Huffman, eq(4.74)\r\n if pol==1: S = np.dot(self.a * pi + self.b * tau, k)\r\n elif pol==2: S = np.dot(self.a * tau + self.b * pi, k)\r\n else: raise RuntimeError(\"pol==1 or pol==2\")\r\n return np.squeeze(S)/self.x","def music(csi_corr, csi_target, Ntx, Nrx, d_tx, d_rx, t):\n\n In = 0\n s = phase_correction(csi_corr, csi_target)\n s_lin = (s[:, :, 0, t:t + 2].reshape(6, 2, order='F'))\n\n '''Compute the covariance matrix and the eigendecompositon'''\n R_hat = np.cov(s_lin)\n D, Q = ln.eig(R_hat)\n\n '''Sort the eigenvalues in D'''\n Do = np.abs(D)\n D = np.sort(Do)[::-1]\n I = np.argsort(Do)[::-1]\n Q = Q[:, I]\n\n ''' Compute the Number of signal that are significative'''\n T = np.cumsum(np.real(D))\n for i in range(1, 1, np.size(T)):\n if T(i) >= 0.99 * T(np.size(T)):\n In = i\n break\n\n ''' Get the signal eigenvectors'''\n In = 0 # take the first signal\n Qs = Q[:, :In]\n\n ''' Get the noise eigenvectors'''\n Qn = Q[:, In + 1:]\n\n ''' Angles at which MUSIC Pseudospectrum will be computed '''\n angles1 = np.arange(-90, 90, 1)\n angles2 = np.arange(-90, 90, 1)\n\n '''Compute steering vectors corresponding values in angles'''\n a1 = np.exp(-1.j * 2 * np.pi * d_rx * np.tensordot(arange(Nrx), sin(angles1 * np.pi / 180), 0))\n a2 = np.exp(-1.j * 2 * np.pi * d_tx * np.tensordot(arange(Ntx), sin(angles1 * np.pi / 180), 0))\n\n '''Compute MUSIC \"spectrum\" '''\n music_spectrum = np.zeros((np.size(angles1), np.size(angles2)), dtype=complex)\n for k in range(1, np.size(angles2)):\n for j in range(1, np.size(angles1)):\n K = np.kron(a1[:, j], a2[:, k])\n s = dot(K.T, Qn)\n music_spectrum[j, k] = 1 / dot(abs(s), abs(s).T)\n\n ''' compute the mesh and plot the surf of the pseudospectrum '''\n\n fig = plt.figure()\n ax = fig.gca(projection='3d')\n x = angles2\n y = angles1\n X, Y = np.meshgrid(x, y)\n Z = np.abs(np.squeeze(music_spectrum))\n ax = fig.add_subplot(111, projection='3d')\n ax.set_ylabel('AoA')\n ax.set_xlabel('AoD')\n ax.set_xlim3d(-90, 90)\n ax.set_ylim3d(-90, 90)\n ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=cm.jet, alpha=0.7, linewidth=0.25)\n\n ''' detect the peaks corresponding to DoD and DoA '''\n detect = detect_peaks(Z)\n index_max = np.column_stack(np.where(detect))\n x_ind = index_max[:, 0]\n y_ind = index_max[:, 1]\n tab = (np.transpose(np.array((Z[x_ind, y_ind], x[x_ind], y[y_ind])))).tolist()\n tab.sort(key=lambda e: e[0], reverse=True)\n myarray = np.asarray(tab[0])\n angles = myarray[1:]\n plt.show()\n\n return angles","def getPhi(mass,resonance):\n return numpy.arctan((resonance.r0*resonance.w0)/(mass**2-resonance.w0**2)) #need to make this arccotan? invert args","def x_rotmat(theta):\n cos_t = np.cos(theta)\n sin_t = np.sin(theta)\n return np.array([[1, 0, 0],\n [0, cos_t, -sin_t],\n [0, sin_t, cos_t]])","def sample_torsion(phi, psi, kappa_scalar=8, random_state=1):\n \n phi_sample = torch.tensor(np.round([randvonmises(phi, i, kappa_scalar, random_state) for i in range(phi.shape[3])], 4))\n psi_sample = torch.tensor(np.round([randvonmises(psi, i, kappa_scalar, random_state) for i in range(psi.shape[3])], 4))\n return phi_sample, psi_sample","def lsf_multimodal_function(theta):\n y_out = -((theta[:, 0] ** 2 + 4) * (theta[:, 1] - 1) / 20 - np.sin(5 * theta[:, 0] / 2) - 2)\n return y_out.reshape(y_out.shape[0], -1)","def getSpectrumNextGen(teff=None, logg=None, mstar=None, lstar=None, rstar=None, modeldir=None, wav=None):\n\n #\n # Sanity check\n #\n if teff is None:\n raise ValueError('Unknown teff. NextGen spectrum cannot be calculated without the stellar effective'\n + 'temperature.')\n if logg is None:\n if mstar is None:\n raise ValueError('Unknown logg and mstar. For NextGen atmosphere models either logg or mstar and '\n + ' rstar/lstar should be specified')\n else:\n if rstar is None:\n if lstar is None:\n raise ValueError('Unknown logg, rstar, lstar thus logg cannot be calculated. For NextGen '\n + 'atmosphere models either logg should be given or a combination of mstar, lstar, rstar '\n + 'should be specified from which logg can be calculated for a given effective temperature. ')\n else:\n rstar = np.sqrt(lstar / (4. * np.pi * nc.ss * teff**4.))\n else:\n lstar = 4. * np.pi * rstar**2 * nc.ss * teff**4\n\n logg = np.log10(nc.gg * mstar / rstar**2)\n else:\n if rstar is None:\n if lstar is None:\n raise ValueError('Unknown rstar and lstar thus luminosity cannot be calculated. For NextGen '\n + 'atmosphere models either lstar or rstar should be given')\n else:\n rstar = np.sqrt(lstar / (4. * np.pi * nc.ss * teff**4.))\n else:\n lstar = 4. * np.pi * rstar**2 * nc.ss * teff**4\n\n mstar = 10.**logg * rstar**2 / nc.gg\n\n assert (teff >= 0.), 'Negative effective temperature!'\n assert (mstar >= 0.), 'Negative stellar mass!'\n assert (lstar >= 0.), 'Negative stellar luminosity!'\n assert (rstar >= 0.), 'Negative stellar radius!'\n\n print('-------------------------------------------')\n print('Interpolating in NextGen model atmospheres')\n print('Stellar parameters: ')\n print('-------------------------------------------')\n print('Teff [K] : ', teff)\n print('Radius [Rsun] : ', rstar / nc.rs)\n print('Luminosity [Lsun] : ', lstar / nc.ls)\n print('Mass [Msun] : ', mstar / nc.ms)\n print('logg : ', logg)\n print('-------------------------------------------')\n\n teff_grid = np.append((np.arange(31.) + 9.), (np.arange(30.) * 2. + 40.))\n logg_grid = np.arange(6.) * 0.5 + 3.5\n\n # Bracket the input teff and logg values\n ii = abs(teff_grid - teff / 100.).argmin()\n idt1 = ii\n if teff_grid[ii] > teff / 100.:\n idt1 = ii - 1\n else:\n idt1 = ii\n idt2 = idt1 + 1\n\n ii = abs(logg_grid - logg).argmin()\n if logg < logg_grid[0]:\n idg1 = 0\n idg2 = 0\n elif logg > logg_grid[-1]:\n idg1 = logg_grid.shape[0] - 1\n idg2 = logg_grid.shape[0] - 1\n else:\n idg1 = ii\n if logg_grid[ii] > logg:\n idg1 = ii - 1\n else:\n idg1 = ii\n idg2 = idg1 + 1\n\n print('Bracketing spectrum : ', teff, logg)\n print('Teff : ', teff_grid[idt1], teff_grid[idt2])\n print('log(g): ', logg_grid[idg1], logg_grid[idg2])\n\n # Generate the spectral file names\n mph = '0.0'\n fname_11 = 'lte' + (\"%d\" % teff_grid[idt1]) + '-' + (\"%.1f\" % logg_grid[idg1]) + '-' + mph + '.NextGen.spec.gz'\n fname_12 = 'lte' + (\"%d\" % teff_grid[idt1]) + '-' + (\"%.1f\" % logg_grid[idg2]) + '-' + mph + '.NextGen.spec.gz'\n fname_22 = 'lte' + (\"%d\" % teff_grid[idt2]) + '-' + (\"%.1f\" % logg_grid[idg2]) + '-' + mph + '.NextGen.spec.gz'\n fname_21 = 'lte' + (\"%d\" % teff_grid[idt2]) + '-' + (\"%.1f\" % logg_grid[idg1]) + '-' + mph + '.NextGen.spec.gz'\n\n # Create a directory\n if os.path.exists(\"./tmp\"):\n shutil.rmtree(\"./tmp\")\n\n os.system('mkdir tmp')\n os.system('cp -v ' + modeldir + '/' + fname_11 + ' ./tmp')\n os.system('cp -v ' + modeldir + '/' + fname_12 + ' ./tmp')\n os.system('cp -v ' + modeldir + '/' + fname_22 + ' ./tmp')\n os.system('cp -v ' + modeldir + '/' + fname_21 + ' ./tmp')\n\n # Unzip the files\n os.chdir('./tmp')\n os.system('gunzip ' + fname_11)\n os.system('gunzip ' + fname_12)\n os.system('gunzip ' + fname_22)\n os.system('gunzip ' + fname_21)\n os.chdir('../')\n\n # Read the spectra\n sp11 = readNextGenSpectrum(fname='./tmp/' + fname_11[:-3])\n sp12 = readNextGenSpectrum(fname='./tmp/' + fname_12[:-3])\n sp22 = readNextGenSpectrum(fname='./tmp/' + fname_22[:-3])\n sp21 = readNextGenSpectrum(fname='./tmp/' + fname_21[:-3])\n\n # Do the interpolation\n c11 = (teff_grid[idt2] - teff / 100.) * (logg_grid[idg2] - logg)\n c12 = (teff_grid[idt2] - teff / 100.) * (logg - logg_grid[idg1])\n c22 = (teff / 100. - teff_grid[idt1]) * (logg - logg_grid[idg1])\n c21 = (teff / 100. - teff_grid[idt1]) * (logg_grid[idg2] - logg)\n c00 = 1. / ((teff_grid[idt2] - teff_grid[idt1]) * (logg_grid[idg2] - logg_grid[idg1]))\n\n lnu = c00 * (c11 * sp11['inu'] + c12 * sp12['inu'] + c22 * sp22['inu'] + c21 * sp21['inu'])\n bnu = c00 * (c11 * sp11['bnu'] + c12 * sp12['bnu'] + c22 * sp22['bnu'] + c21 * sp21['bnu'])\n\n shutil.rmtree('./tmp')\n\n #\n # Scale the spectrum to give the same luminosity as required\n #\n nu = nc.cc / sp11['wav'] * 1e4\n lum = (0.5 * abs(nu[1:] - nu[:-1]) * (lnu[1:] + lnu[:-1])).sum()\n lnu *= lstar / lum\n\n lum = (0.5 * abs(nu[1:] - nu[:-1]) * (bnu[1:] + bnu[:-1])).sum()\n bnu *= lstar / lum\n\n return {'wav': sp11['wav'], 'lnu': lnu, 'bnu': bnu}","def photoangular_distribution(Dmo, Amo, LMs, energy):\n # number of continuum orbitals\n nmo = Amo.shape[-1]\n # photon energy\n omega = energy # + IE ???????\n\n tdipvecs = Dmo.transpose()\n \n # convert transition dipoles from cartesian to spherical coordinates\n # <i|x|n> sin(tdip_th) cos(tdip_ph)\n # <i|y|n> = tdip_r * sin(tdip_th) cos(tdip_ph)\n # <i|z|n> cos(tdip_th)\n #\n tdip_r, tdip_th, tdip_ph = cartesian2spherical(tdipvecs)\n \n # spherical harmonics Y_(1,m1)(tdip_th, tdip_ph)\n Y1 = np.zeros((3,nmo), dtype=complex)\n for Y1m1,l1,m1 in spherical_harmonics_it(tdip_th, tdip_ph):\n if l1 > 1:\n break\n if l1 == 1:\n Y1[m1,:] = Y1m1\n\n print \"angular distributions for pairs of orbitals ...\"\n # coefficients of Legendre polynomials of degrees L=0,1,2\n # for pairs of molecular orbitals with indices a,b\n # coefsPmo[L,a,b]\n coefsPmo = np.zeros((3,nmo,nmo), dtype=complex)\n for LM,(L,M) in enumerate(LMs):\n cL = np.sqrt((2*L+1.)/(4.0*np.pi)) * Wigner3J(1,0, 1,0, L,0) * 4.0*np.pi/3.0 \\\n * np.outer(tdip_r[:], tdip_r[:]) \\\n * Amo[LM,:,:]\n yyLM = np.zeros((nmo,nmo), dtype=complex)\n for m1 in [-1,0,1]:\n for m2 in [-1,0,1]:\n if not (-m1 + m2 + M == 0):\n continue\n \n yyLM += (-1)**m1 * Wigner3J(1,-m1, 1,m2, L,M) \\\n * np.outer( Y1[m1,:], Y1[m2,:].conjugate() )\n cL *= yyLM\n cL *= 2*omega\n \n coefsPmo[L,:,:] += cL\n \n coefsP = np.sum(coefsPmo, axis=(1,2))\n\n # anisotropy parameter in\n # sigma(th) = sigma / (4 pi) [ 1 + beta P2(cos(th)) ]\n # = c0 c2 P2(cos(th))\n sigma = coefsP[0] * 4.0*np.pi\n beta = coefsP[2]/coefsP[0]\n assert -1.0-0.01 <= beta <= 2.0+0.01\n\n # sigma should be equal to sum of oscillator strengths from bound to continuum\n sigma_oscsum = 2.0/3.0 * omega * np.sum(Dmo**2)\n assert abs(sigma - sigma_oscsum) < 1.0e-4\n \n return sigma.real, beta.real","def gen_phantom_parts(signal = (1.0, 1.0), s_res = .7, oversamp = 8, diam = (4, 6, 8, 10), n_frames = 20):\n all_ves = []\n for d in diam:\n ves = gen_vessel(d, s_res/oversamp, oversamp, n_frames)\n all_ves.append(ves)\n\n total_width = 0\n max_height = 0\n for ves in all_ves:\n total_width += ves.shape[1]\n max_height = max(max_height, ves.shape[2])\n\n velv = np.zeros((n_frames, total_width, max_height))\n mask_crop = np.zeros((total_width, max_height))\n\n x_loc = 0\n ves_count = 1\n for ves in all_ves:\n velv[:, x_loc:x_loc+ves.shape[1], int(max_height/2 - ves.shape[2]/2):int(max_height/2 + ves.shape[2]/2)] = ves\n ves_mask = np.zeros((ves.shape[1], ves.shape[2]))\n ves_mask[np.abs(ves).sum(0) > 0] = ves_count\n mask_crop[x_loc:x_loc + ves.shape[1], int(max_height / 2 - ves.shape[2] / 2):int(max_height / 2 + ves.shape[2] / 2)] = ves_mask\n x_loc += ves.shape[1]\n ves_count += 1\n\n mag = np.zeros(( int(2*total_width), int(2*max_height)))\n\n [xx, yy] = np.meshgrid(np.linspace(-1, 1, mag.shape[0]), np.linspace(-1, 1, mag.shape[1]), indexing='ij')\n rad = xx * xx + yy * yy\n mag[rad < .90] = 1.0\n\n return mask_crop, mag, velv","def fwd_odm(prev_pose, od_mov):\n\n x = prev_pose[0]\n y = prev_pose[1]\n theta = prev_pose[2]\n\n d = od_mov[0]\n Phi1 = od_mov[1]\n Phi2 = od_mov[2]\n\n\n newx = x + d * cos(theta + Phi1)\n newy = y + d * sin(theta + Phi1)\n newtheta = theta + Phi1 + Phi2\n\n return (newx, newy, newtheta)","def initW_spikeslab(self, theta, alpha=None):\n\n # Simualte ARD precision\n if alpha is None:\n alpha = self.initAlpha()\n else:\n assert not any([0 in a for a in alpha]), 'alpha cannot be zero'\n\n # Simulate bernoulli variable S\n S = [ s.zeros((self.D[m],self.K)) for m in range(self.M) ]\n for m in range(self.M):\n\n # Completely vectorised, not sure if it works\n # S[m] = bernoulli.rvs(p=theta[m].flatten(), size=self.D[m]*self.K).reshape((self.D[m],self.K))\n\n # Partially vectorised\n for k in range(self.K):\n S[m][:,k] = bernoulli.rvs(p=theta[m][:,k], size=self.D[m])\n \n # Unvectorised\n # for d in range(self.D[m]):\n # for k in range(self.K):\n # S[m][d,k] = bernoulli.rvs(p=theta[m][d,k], size=1)\n\n\n # Simulate gaussian weights W\n W_hat = [ s.empty((self.D[m],self.K)) for m in range(self.M) ]\n W = [ s.empty((self.D[m],self.K)) for m in range(self.M) ]\n for m in range(self.M):\n for k in range(self.K):\n W_hat[m][:,k] = norm.rvs(loc=0, scale=s.sqrt(1./alpha[m][k]), size=self.D[m])\n W[m] = W_hat[m] * S[m]\n\n return S, W, W_hat, alpha","def spherical_parameters(self):\n phi_mu_list = []\n theta_mu_list = []\n \n for mu in self.mu_list:\n r, phi, theta = T_cartesian_to_spherical(x=mu[0], y=mu[1], z=mu[2])\n phi_mu_list.append(phi)\n theta_mu_list.append(theta)\n \n return phi_mu_list, theta_mu_list","def MSPBE(self, theta):\n V = np.array((theta * self.mu_phi).sum(axis=1))\n V2 = self.gamma * np.array((theta * self.mu_phi_next).sum(axis=1))\n return np.mean(np.array((V - np.dot(self.projection_operator(), V2 + self.mu_r))) ** 2)","def augment_data(data, theta):\n augmented_data = copy.deepcopy(data)\n\n for s in data:\n for t in theta:\n augmented_data.append([])\n for chord in s:\n if chord:\n if min(chord) + t >= 0 and max(chord) + t <= 87:\n augmented_data[-1].append(list(map(add, chord, [t] * len(chord))))\n\n return augmented_data","def cartesian_to_spherical(self, v):\n x = Vector.x(v)\n y = Vector.y(v)\n z = Vector.z(v)\n r = Vector.length(v)\n phi = atan2(y, x)\n theta = acos(z / r)\n \n return [r, phi, theta]","def _gen_r(theta, phi):\n return _gen_u(theta, phi - np.pi / 2, phi + np.pi / 2)","def Mt (theta, eta):\n ut = np.array([np.cos(theta), np.sin(theta)])\n mat = np.outer(ut,ut)\n\n M = np.sqrt(1+eta) * mat + np.sqrt(1-eta)*(np.eye(2)-mat) \n\n return M","def serot(B, theta=45, DIRECTION=\"CLOCKWISE\"):\n from string import upper\n from numpy import array, sin, cos, transpose\n from numpy import cos, sin, pi, concatenate, transpose, array\n\n DIRECTION = upper(DIRECTION) \n if DIRECTION == \"ANTI-CLOCKWISE\":\n theta = -theta\n SA = mat2set(B)\n theta = pi * theta//180\n (y,v)=SA\n if len(y)==0: return binary([0])\n x0 = y[:,1] * cos(theta) - y[:,0] * sin(theta)\n x1 = y[:,1] * sin(theta) + y[:,0] * cos(theta)\n x0 = to_int32((x0 +0.5)*(x0>=0) + (x0-0.5)*(x0<0))\n x1 = to_int32((x1 +0.5)*(x1>=0) + (x1-0.5)*(x1<0))\n x = transpose(array([transpose(x1),transpose(x0)]))\n BROT = set2mat((x,v))\n return BROT","def theta(self):\n tmp = [self._get_one_param_theta(p) for p in self._LIST_PARAMETERS]\n return np.hstack(tmp)","def select_sv(y, s, r, ar, criterion_f):\n # s: In sample size.\n # r: Out sample size.\n # ar:\n\n # Start timer.\n start = time.time()\n print(\"Started at:\", time.strftime(\"%H:%M:%S on %d-%m-%Y\"))\n \n t = len(y)\n\n delta = np.array([1]*22)\n\n # Calculate statistics from observed sample.\n obs_stats = sum_stat.sv_stats(delta, y)\n \n # Generate out theta.\n global theta_out\n theta_out = [generate_theta_sv(ar) for i in range(r)]\n theta_out = np.matrix(theta_out).T\n\n # Generate out sample of time series.\n out_y = [sim.sim_sv(t, theta_out[0, i], theta_out[1, i], theta_out[2, i],\n theta_out[3, i], 1) for i in range(r)]\n\n # Generate out sample statistics.\n global stats_out\n stats_out = [sum_stat.sv_stats(delta, out_y[i]) for i\n in range(len(out_y))]\n\n # Standardize the out-of-sample parameters.\n theta_out_mean = sum(theta_out.T)/r\n u = sum([np.square(theta_out[:, i]-theta_out_mean.T) for i in range(r)])/r\n theta_out = np.hstack([(theta_out[:, i] - theta_out_mean.T)/np.sqrt(u)\n for i in range(r)])\n global theta_out_sigma\n theta_out_sigma = np.sqrt(u)\n\n # Standardize the out-of-sample statistics.\n stats_out_mean = sum(stats_out)/r\n u = sum([np.square(stats_out[i]-stats_out_mean) for i in range(r)])/r\n stats_out = [(stats_out[i] - stats_out_mean)/np.sqrt(u) for i in range(r)]\n\n # Generate in theta.\n global theta_initial\n theta_initial = [generate_theta_sv(ar) for i in range(s)]\n theta_initial = np.matrix(theta_initial).T\n\n # Generate in sample of time series.\n in_y = [sim.sim_sv(t, theta_initial[0, i], theta_initial[1, i],\n theta_initial[2, i], theta_initial[3, i], 1)\n for i in range(s)]\n\n # Generate in sample statistics.\n global stats_initial\n stats_initial = [sum_stat.sv_stats(delta, in_y[i]) for i\n in range(s)]\n\n # Standardize parameters used for estimation.\n theta_initial_mean = sum(theta_initial.T)/s\n u = sum([np.square(theta_initial[:, i]-theta_initial_mean.T)\n for i in range(s)])/s\n theta_initial = np.hstack([(theta_initial[:, i]\n - theta_initial_mean.T)/np.sqrt(u)\n for i in range(s)])\n\n global theta_in_sigma\n global theta_in_mean\n theta_in_sigma = np.sqrt(u)\n theta_in_mean = theta_initial_mean\n\n # Standardize statistics for estimation.\n stats_initial_mean = sum(stats_initial)/s\n u = sum([np.square(stats_initial[i]-stats_initial_mean)\n for i in range(s)])/s\n stats_initial = [(stats_initial[i] - stats_initial_mean)/np.sqrt(u) for\n i in range(s)]\n\n # Standardize statistics calculated from observed sample.\n global obs_stats_standard\n obs_stats_standard = (obs_stats - stats_initial_mean)/np.sqrt(u)\n\n # Guess delta.\n delta = np.around(np.random.rand(1, 22)).flatten().astype(int)\n\n global criterion\n criterion = criterion_f\n\n # Summary of sample sizes.\n print(\"Out sample size:\", r)\n print(\"In sample size:\", s)\n print(\"Observed sample size:\", len(y))\n print(\"Number of persistence parameters:\", ar)\n\n # Initiate binary annealing algorithm and assign tuning parameters.\n print(\"Initial guess for delta is:\", delta)\n print(\"Criterion function is:\", criterion)\n opt = BinaryAnnealer(delta)\n opt.Tmax = 0.10 # 0.25\n opt.Tmin = 0.0001 # 0.001\n opt.steps = len(delta)*10\n opt.updates = len(delta)\n print(\"Simmulated annealing parameters are:\")\n print(\"Tmax:\", opt.Tmax)\n print(\"Tmin:\", opt.Tmin)\n print(\"Beginning simulated annealing at:\",\n time.strftime(\"%H:%M:%S on %d-%m-%Y\"))\n results = opt.anneal()\n\n results_file = open(\"annealing_results.txt\", \"a\")\n results_file.write(\"### Results from annealing run finished at: \" +\n time.strftime(\"%H:%M:%S on %d-%m-%Y\") + \" ###\\n\")\n results_file.write(str(results) + \"\\n\")\n results_file.close()\n\n print(\"Final selection and minimum are: \", results)\n print(\"Finished at :\", time.strftime(\"%H:%M:%S on %d-%m-%Y\"))\n print(\"Total time to run (in minutes):\", (time.time()-start)/60, \"\\n\")\n\n return results","def get_transformation_matrix(theta=45):\n\n theta = theta/360 * 2 * np.pi # in radians\n hx = np.cos(theta)\n sy = np.sin(theta)\n \n S = np.array([[1, hx, 0],\n [0, sy, 0],\n [0, 0, 1]])\n\n return S","def rot(theta):\n cos = np.cos(theta)\n sin = np.sin(theta)\n return( np.array( [[cos, sin], [-sin, cos]] ) )","def cartesian2spherical(v):\n theta = np.arcsin(v[2]) \n phi = np.arctan2(v[1], v[0])\n \n return [theta, phi]","def propose_sample(self) -> np.array:\n norm = np.random.normal\n normal_deviates = norm(size=self.dim_observed)\n r = np.sqrt((normal_deviates**2).sum(axis=0))\n update = normal_deviates / r * self.radius\n return self.theta + update","def makeframe(draw, R, r, rho, t, phi, hypo=True):\n if hypo:\n Rr = R - r # difference in radii\n i = 1\n else:\n Rr = R + r # sum in radii\n i = -1\n # sequence of angles from 0 up to t\n tt = np.arange(0, t + 1, 1)\n # coordinates of the smaller circle at various angle\n centre = np.array([np.cos(tt * RADIANS), np.sin(tt * RADIANS)]).T * Rr\n # angles of the \"dot\"\n dd = (Rr / r * tt + phi) * RADIANS\n # coordinates of the \"dot\" w.r.t. the centre of the inner circle\n dotoffset = np.array([i * np.cos(dd), -np.sin(dd)]).T * rho\n # actual coordinates of the \"dot\": this is the locus\n dot = centre + dotoffset\n # draw: big circle, small circle, the locus, radius, the dot\n circle(draw, 0, 0, R)\n circle(draw, centre[-1][0], centre[-1][1], r)\n lines(draw, dot, color=\"#FF0000FF\")\n lines(draw, [centre[-1], dot[-1]])\n fillcircle(draw, dot[-1][0], dot[-1][1], 3, \"#FF0000FF\")","def rot(phi, theta, omega):\n\n cos = jnp.cos(theta / 2)\n sin = jnp.sin(theta / 2)\n\n return jnp.array(\n [\n [\n jnp.exp(-0.5j * (phi + omega)) * cos,\n -(jnp.exp(0.5j * (phi - omega))) * sin,\n ],\n [jnp.exp(-0.5j * (phi - omega)) * sin, jnp.exp(0.5j * (phi + omega)) * cos],\n ]\n )","def sat_2d_pos(theta):\n r_sat = a * (1 - e**2) / (1 + e * np.cos(theta))\n return r_sat, theta","def OxygenTransmission(T,P,n_wv,wavelength,dr,freq_lim=np.array([lp.c/770e-9,lp.c/768e-9]),sim_nu=np.array([]),spec_file=''):\n # fraction of O2 by number density\n fO2 = (32*0.2320+28.02*0.7547+44.01*0.00046+39.94*0.0128+20.18*0.000012+4.0*0.0000007+83.8*0.000003+131.29*0.00004)*0.2320/32.0\n \n if len(spec_file) == 0:\n spec_file = '/Users/mhayman/Documents/DIAL/O2_HITRAN2012_760_781.txt'\n \n if sim_nu.size==0:\n sim_nu = np.arange(-3e9,3e9,20e6)\n \n# inu0 = np.argmin(np.abs(sim_nu)) # index to center of frequency array\n \n n_o2=fO2*(P/(lp.kB*T)-n_wv) # to convert atm to Pa use *101325\n ext_o2 = rb.ExtinctionFromHITRAN(lp.c/wavelength+sim_nu,T,P,(mO2*1e-3)/lp.N_A,nuLim=freq_lim,freqnorm=True,filename=spec_file).T\n T_o2 = np.exp(-np.cumsum(n_o2[np.newaxis,:]*ext_o2,axis=1)*dr)\n \n return T_o2,sim_nu","def _copy_cosineSequences(self, P):\n self._.omega = P / diagonal_matrix(P[0])","def spherical_to_cartesian(self, r, phi, theta):\n x = r*cos(phi)*sin(theta)\n y = r*sin(phi)*sin(theta)\n z = r*cos(theta)\n \n return Vector(float(x), float(y), float(z))","def MSBE_tar(self, theta):\n V = np.array((theta * self.mu_phi_tar).sum(axis=1))\n V2 = self.gamma * np.array((theta * self.mu_phi_next_tar).sum(axis=1))\n return np.mean((V - V2 - self.mu_r_tar) ** 2)","def _multi_term_cos(coef, power, multiplier, rho, theta):\n \n power2 = (coef + 1.) * -1.\n return ((coef * np.power(rho, power2) + (power * np.power(rho, power))) * np.cos(multiplier * theta))","def melting_temp_gc(seq):\n\n Na = 0.050 # log10([Na+] adjusts for the salt adjustment at 50 mM Na+\n total_nucleotide = sum([(seq.count('A') + seq.count('T') + seq.count('G')+ seq.count('C'))])\n\n tm_marmurdoty = 64.9 + 41.0 * (((seq.count('G')+ seq.count('C')) -16.4)/ total_nucleotide)\n\n tm_howley = 100.5 + 41.0 * (((seq.count('G')+ seq.count('C')) -16.4 )/ total_nucleotide)\n\n - (820.0/total_nucleotide) + 16.6 * math.log10(Na)\n \n # result_tm = \"Melting Temp by:: Marmur:{},Howley:{}\".format(tm_marmurdoty,tm_howley)\n result_tm = {\"mt_marmur\":tm_marmurdoty,\"mt_howley\":tm_howley}\n return result_tm","def spheric2cart(theta, phi):\n x = np.sin(theta) * np.cos(phi)\n y = np.sin(theta) * np.sin(phi)\n z = np.cos(theta)\n return x, y, z","def f_theta_omega(angles, times):\n # gravity = 9.81\n # arm_length = 0.1 \n\n # omega = angles[0]\n # theta = angles[1]\n # ftheta = omega\n # fomega = -(gravity/arm_length) * np.sin(theta)\n pass","def construct_MC_samples(self, N_MC):\n D = self.theta[\"long_cov\"]\n if self.MC_sep:\n n_samples = self.n_samples\n (U, V, y, N) = self.extracted_features[0]\n n_long_features = self.n_long_features\n phi = self.theta[\"phi\"]\n beta = np.hstack((self.theta[\"beta_0\"], self.theta[\"beta_1\"]))\n r = D.shape[0]\n Omega = np.random.multivariate_normal(np.zeros(r), np.eye(r), N_MC)\n S = np.zeros((n_samples, 2, 2 * N_MC, r))\n\n for i in range(n_samples):\n U_i, V_i, y_i, N_i = U[i], V[i], y[i], N[i]\n\n # compute Sigma_i\n Phi_i = [[1 / phi[l, 0]] * N_i[l]\n for l in range(n_long_features)]\n Sigma_i = np.diag(np.concatenate(Phi_i))\n\n # compute Omega_i\n D_inv = np.linalg.inv(D)\n A_i = np.linalg.inv(\n V_i.transpose().dot(Sigma_i).dot(V_i) + D_inv)\n # compute mu_i\n mu_i = (A_i.dot(V_i.transpose()).dot(Sigma_i).dot(\n y_i - U_i.dot(beta))).T[..., np.newaxis]\n C_i = np.linalg.cholesky(A_i)\n tmp = C_i.dot(Omega.T)\n S[i] = (mu_i + np.hstack((tmp, -tmp))).swapaxes(1, 2)\n else:\n C = np.linalg.cholesky(D)\n r = D.shape[0]\n Omega = np.random.multivariate_normal(np.zeros(r), np.eye(r), N_MC)\n b = Omega.dot(C.T)\n S = np.vstack((b, -b))\n\n return S","def test_merged_atmospheres(metallicity=0, gravity=4):\n cast = get_castelli_atmosphere(temperature=8000, \n metallicity=metallicity, gravity=gravity)\n\n ngen = get_nextgen_atmosphere(temperature=8000,\n metallicity=metallicity, gravity=gravity)\n\n # Now Plot the spectra\n py.figure(1)\n py.clf()\n py.loglog(cast.wave, cast.flux, 'r-', label='Castelli')\n py.plot(ngen.wave, ngen.flux, 'b-', label='NextGen')\n py.xlabel('Wavelength')\n py.ylabel('Flux')\n py.legend()\n py.xlim(3000, 50000)\n py.ylim(1e3, 1e8)\n\n\n ngen = get_nextgen_atmosphere(temperature=4000,\n metallicity=metallicity, gravity=gravity)\n\n phoe = get_phoenix_atmosphere(temperature=4000,\n metallicity=metallicity, gravity=gravity)\n # Now Plot the spectra\n py.figure(2)\n py.clf()\n py.loglog(phoe.wave, phoe.flux, 'r-', label='Phoenix')\n py.plot(ngen.wave, ngen.flux, 'b-', label='NextGen')\n py.xlabel('Wavelength')\n py.ylabel('Flux')\n py.legend()\n py.xlim(3000, 50000)\n py.ylim(1, 1e8)","def forward_theta(self):\n SW = self.simplesphere.sphere_wrapper\n for dm, m in enumerate(self.simplesphere.local_m):\n m_data = [f.data[dm] for f in self.component_fields]\n # Unpack for rank 0 to counteract shortcut bug in sphere_wrapper\n if self.rank == 0:\n m_data, = m_data\n self.coeffs[dm] = SW.forward(m, self.rank, m_data)","def sph_harm_gradient(m, l, r, theta, phi):\n c_theta = sph_harm_diff_theta(m, l, theta, phi) / r\n c_phi = sph_harm_diff_phi(m, l, theta, phi) / (r * np.sin(theta))\n return np.array((0, c_theta, c_phi))","def build_t_theta_pixel(N,theta_vec, tvec_set=None, circle=False):\n\n Nangle = len(theta_vec)\n\n if tvec_set is None:\n if not circle:\n N = int(np.ceil(N*np.sqrt(2)))\n t_vec = np.sqrt(2) * np.arange(-N/2+0.5, N/2 ) \n else:\n t_vec = np.arange(-N/2+0.5, N/2 ) \n else:\n t_vec = tvec_set\n\n grid_t = npmat.repmat(t_vec,1,len(theta_vec))\n grid_t = np.transpose(grid_t)\n\n grid_theta = np.tile(theta_vec,(len(t_vec),1)).T.flatten()\n grid_theta = grid_theta.reshape(-1,1)\n\n return t_vec, grid_t, grid_theta","def WaterVaporTransmission(T,P,n_wv,wavelength,dr,freq_lim=np.array([lp.c/828.5e-9,lp.c/828e-9]),sim_nu=np.array([])):\n \n if sim_nu.size==0:\n sim_nu = np.arange(-3e9,3e9,20e6)\n \n ext_wv = rb.ExtinctionFromHITRAN(lp.c/wavelength+sim_nu,T,P,(lp.mH2O*1e-3)/lp.N_A,nuLim=freq_lim,freqnorm=True).T\n T_wv = np.exp(-np.cumsum(n_wv[np.newaxis,:]*ext_wv,axis=1)*dr)\n \n return T_wv,sim_nu","def vsh2(m, l, theta, phi):\n c_theta = 1/np.sin(phi) * sph_harm_diff_theta(m, l, theta, phi)\n c_phi = sph_harm_diff_phi(m, l, theta, phi)\n return np.array((0, c_theta, c_phi))","def plot_psf_vs_rad(self, theta=\"0 deg\", energy=u.Quantity(1, \"TeV\")):\n theta = Angle(theta)\n table = self.to_table_psf(energy=energy, theta=theta)\n return table.plot_psf_vs_rad()","def sample_spherical(self):\n vec = np.random.randn(self.dims, self.arms)\n vec /= np.linalg.norm(vec, axis=0)\n self.contexts = vec.T","def theta(self, theta):\n self.kernel.theta = theta","def rot(a, alpha, S, theta):\n\treturn np.array([ # eqn 3.7 pg 36\n\t\t[cos(theta), -sin(theta), 0.0, a],\n\t\t[sin(theta) * cos(alpha), cos(theta) * cos(alpha), -sin(alpha), -sin(alpha) * S],\n\t\t[sin(theta) * sin(alpha), cos(theta) * sin(alpha), cos(alpha), cos(alpha) * S],\n\t\t[0.0, 0.0, 0.0, 1.0]\n\t])\n\n\t# return np.array([ # inverse of above ?? spong text\n\t# \t[cos(theta), -sin(theta) * cos(alpha), sin(theta) * sin(alpha), cos(theta) * a],\n\t# \t[sin(theta), cos(theta) * cos(alpha), -cos(theta) * sin(alpha), sin(theta) * a],\n\t# \t[0, sin(alpha), cos(alpha), S],\n\t# \t[0, 0, 0, 1]\n\t# ])","def generate_lin_reg_sample(delta, s, r, sample_dim, obs_stats):\n global theta_out\n global stats_out\n result = theta_and_stats(delta, r, sample_dim[0], sample_dim[1])\n theta_out = result[0]\n stats_out = result[1]\n\n # Standardize the out-of-sample parameters.\n theta_out_mean = sum(theta_out.T)/r\n u = sum([np.square(theta_out[:, i]-theta_out_mean.T) for i in range(r)])/r\n theta_out = np.hstack([(theta_out[:, i] - theta_out_mean.T)/np.sqrt(u)\n for i in range(r)])\n global theta_out_sigma\n theta_out_sigma = np.sqrt(u)\n\n # Standardize the out-of-sample statistics.\n stats_out_mean = sum(stats_out)/r\n u = sum([np.square(stats_out[i]-stats_out_mean) for i in range(r)])/r\n stats_out = [(stats_out[i] - stats_out_mean)/np.sqrt(u) for i in range(r)]\n\n # Draw from the prior and caclulate summary statistics for estimation.\n result = theta_and_stats(delta, s, sample_dim[0], sample_dim[1])\n global theta_initial\n global stats_initial\n theta_initial = result[0]\n stats_initial = result[1]\n\n # Standardize parameters used for estimation.\n theta_initial_mean = sum(theta_initial.T)/s\n u = sum([np.square(theta_initial[:, i]-theta_initial_mean.T)\n for i in range(s)])/s\n global theta_in_sigma\n theta_in_sigma = np.sqrt(u)\n theta_initial = np.hstack([(theta_initial[:, i]\n - theta_initial_mean.T)/np.sqrt(u)\n for i in range(s)])\n \n # Standardize statistics for estimation.\n stats_initial_mean = sum(stats_initial)/s\n u = sum([np.square(stats_initial[i]-stats_initial_mean)\n for i in range(s)])/s\n stats_initial = [(stats_initial[i] - stats_initial_mean)/np.sqrt(u) for\n i in range(s)]\n\n # Standardize statistics calculated from observed sample.\n global obs_stats_standard\n obs_stats_standard = (obs_stats - stats_initial_mean)/np.sqrt(u)","def generate_parameter_sample(self, t): \n \n theta_hat = np.zeros(self.K) \n k = np.random.choice(self.Npar, 1, p=self.w)[0] # np.random.choice outputs an array\n theta_hat = self.Particles[k] \n return theta_hat","def theta_hat( self, i, hidden_values ):\n assert len(hidden_values) == len(self.hidden)\n theta = matrix(self.observed[i].phi)\n for j, h in enumerate(hidden_values):\n assert self.hidden[j].family._check_u(h)\n update = self.W[i,j] * asmatrix(h).T\n theta += update.T\n return theta.A.reshape( (self.observed[i].family.size()) )","def cthick(f, g, Iab=None, n=-1, theta=45, DIRECTION=\"CLOCKWISE\"):\n from numpy import product\n from string import upper\n if Iab is None: Iab = homothick()\n DIRECTION = upper(DIRECTION) \n assert isbinary(f),'f must be binary image'\n if n == -1: n = product(f.shape)\n y = f\n old = y\n for i in xrange(n):\n for t in xrange(0,360,theta):\n sup = supgen( y, interot(Iab, t, DIRECTION))\n y = intersec(union( y, sup),g)\n if isequal(old,y): break\n old = y\n return y","def pegasos(feature_matrix, labels, T, L):\n theta = np.zeros((feature_matrix.shape[1],))\n theta_0 = 0\n update_counter = 0 # number_of updates\n for t in range(T):\n for i in get_order(feature_matrix.shape[0]):\n update_counter += 1\n eta = 1.0 / np.sqrt(update_counter)\n theta, theta_0 = pegasos_single_step_update(\n feature_matrix[i],\n labels[i],\n L,\n eta,\n theta,\n theta_0)\n return theta, theta_0","def _cmd_export_theta(args):\n tumor_cn = read_cna(args.tumor_segment)\n normal_cn = read_cna(args.reference) if args.reference else None\n table = export.export_theta(tumor_cn, normal_cn)\n if not args.output:\n args.output = tumor_cn.sample_id + \".interval_count\"\n table.to_csv(args.output, sep=\"\\t\", index=False)\n logging.info(\"Wrote %s\", args.output)\n if args.vcf:\n variants = load_het_snps(\n args.vcf,\n args.sample_id, # or tumor_cn.sample_id,\n args.normal_id,\n args.min_variant_depth,\n args.zygosity_freq,\n )\n if not len(variants):\n raise ValueError(\"VCF contains no usable SNV records\")\n try:\n tumor_snps, normal_snps = export.export_theta_snps(variants)\n except ValueError as exc:\n raise ValueError(\n \"VCF does not contain any tumor-normal paired samples\"\n ) from exc\n for title, table in [(\"tumor\", tumor_snps), (\"normal\", normal_snps)]:\n out_fname = f\"{tumor_cn.sample_id}.{title}.snp_formatted.txt\"\n table.to_csv(out_fname, sep=\"\\t\", index=False)\n logging.info(\"Wrote %s\", out_fname)"],"string":"[\n \"def scattering_direction(v, theta):\\r\\n # Sample cos_phi and sin_phi, phi is the azimuthal angle of the scattering event\\r\\n continue_loop = True\\r\\n while continue_loop:\\r\\n eta1 = 1-2*random.random()\\r\\n eta2 = 1-2*random.random()\\r\\n alpha = eta1**2 + eta2**2\\r\\n if alpha <= 1:\\r\\n continue_loop = False\\r\\n cos_phi = eta1/np.sqrt(alpha)\\r\\n sin_phi = eta2/np.sqrt(alpha)\\r\\n \\r\\n new_x = v[0]*np.cos(theta) - np.sin(theta)/np.sqrt(1-v[2]**2) * (v[0]*v[2]*cos_phi + v[1]*sin_phi)\\r\\n new_y = v[1]*np.cos(theta) - np.sin(theta)/np.sqrt(1-v[2]**2) * (v[1]*v[2]*cos_phi - v[0]*sin_phi)\\r\\n new_z = v[2]*np.cos(theta) + np.sqrt(1-v[2]**2)*np.sin(theta)*cos_phi\\r\\n \\r\\n return [new_x, new_y, new_z]\",\n \"def sph2car(r, theta, phi):\\n x = r * np.sin(theta) * np.cos(phi)\\n y = r * np.sin(theta) * np.sin(phi)\\n z = r * np.cos(theta)\\n\\n return x, y, z\",\n \"def MSPBE_tar(self, theta):\\n V = np.array((theta * self.mu_phi_tar).sum(axis=1))\\n V2 = self.gamma * np.array((theta * self.mu_phi_next_tar).sum(axis=1))\\n return np.mean(np.array((V - np.dot(self.projection_operator(), V2 + self.mu_r_tar))) ** 2)\",\n \"def generate_theta_sv(ar):\\n theta_out = []\\n\\n mu_y = 0\\n while abs(mu_y) < 0.5:\\n mu_y = np.random.uniform(-6, 6)\\n\\n theta_out.append(mu_y) # Expected return.\\n theta_out.append(np.random.uniform(0, 3)) # Mu_s.\\n theta_out.append(np.random.uniform(0, 0.7)) # Phi_1\\n theta_out.append(np.random.uniform(0, 0.7)) # Phi_2\\n\\n # Initialize autoregressive coefficients in lag polynomial.\\n #p = [-1, -1, 1]\\n\\n #while sum(abs(np.roots(p)) < 1.2) != 0:\\n #p = [np.random.randn() for i in range(ar)]\\n #p = [np.random.uniform(0, 1)*-1 for i in range(ar)]\\n #p.append(1)\\n\\n #theta_out.append(-1*p[1]) # Phi_1\\n #theta_out.append(-1*p[0]) # Phi_2\\n #theta_out.append(-1*p[1])\\n #theta_out.append(-1*p[0])\\n #theta_out.append(np.random.rand()*2) # Sigma_eta.\\n\\n return theta_out\",\n \"def theta():\\n pass\",\n \"def gpower_integrand(self,theta,phi):\\n\\n wavelength = 299.9/self.frequency\\n if(phi == 0): phi = .00001\\n if(phi == np.pi): phi = np.pi - .00001\\n\\n self.aa.alt = np.pi/2.0 - theta\\n self.aa.az = np.pi/2.0 - phi\\n\\n coords = self.aa.raDec(self.__lst_current,self.location)\\n\\n coords = self.Rotator(np.pi/2 - coords.dec,coords.ra)\\n\\n Tsky = hp.get_interp_val(self.hpmap,coords[0],coords[1])*(self.frequency/408.0)**(-2.55)\\n\\n ans = self.lofasm.beam_pattern(theta,phi,[0,0,1])\\n ans += self.lofasm.beam_pattern(theta,phi,[0,1,0]) \\n ans *= (Tsky*(1.3804e-23)/wavelength**2)/(1e-26)/2.0\\n\\n return ans\",\n \"def generate_variations(seed=425, th=150):\\n \\n # impact parameters\\n M = 1e8*u.Msun\\n B0 = 19.85*u.kpc\\n\\n V = 220*u.km/u.s\\n phi = coord.Angle(0*u.deg)\\n theta = coord.Angle(th*u.deg)\\n Tenc = 0.01*u.Gyr\\n T = 0.5*u.Gyr\\n dt = 0.05*u.Myr\\n rs = 0*u.pc\\n potential_perturb = 1\\n \\n # potential parameters (log halo)\\n potential = 3\\n Vh = 220*u.km/u.s\\n q = 1*u.Unit(1)\\n rhalo = 20*u.pc\\n par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])\\n \\n # setup tube\\n Nstar = 1400\\n wx = 30*u.kpc\\n wy = 0*u.pc\\n wz = 0*u.pc\\n sx = 0*u.km/u.s\\n \\n np.random.seed(seed)\\n observer = {'z_sun': 27.*u.pc, 'galcen_distance': 8.3*u.kpc, 'roll': 60*u.deg, 'galcen_coord': coord.SkyCoord(ra=300*u.deg, dec=-90*u.deg, frame='icrs')}\\n vobs = {'vcirc': 220*u.km/u.s, 'vlsr': [0, 0, 0]*u.km/u.s}\\n wangle = 180*u.deg\\n \\n xphi = np.linspace(-0.3*np.pi,0.3*np.pi, Nstar)\\n xphi0 = np.linspace(-0.1*np.pi, 0.1*np.pi, 1000)\\n xphi1 = np.linspace(-0.28*np.pi, -0.1*np.pi, 200)\\n xphi2 = np.linspace(0.1*np.pi, 0.32*np.pi, 200)\\n xphi = np.concatenate([xphi1, xphi0, xphi2])\\n \\n Bs = 20*u.kpc\\n xr = Bs + np.random.randn(Nstar)*0.0*u.kpc\\n x = np.sin(xphi) * xr\\n y = np.cos(xphi) * xr\\n z = x * 0\\n vx = -np.cos(xphi) * Vh\\n vy = np.sin(xphi) * Vh\\n vz = vx * 0\\n ienc = np.argmin(np.abs(x))\\n \\n farray = np.array([0.1, 0.3, 0.5, 1, 2, 3, 10])\\n farray = np.array([0.3,0.5,0.8,0.9,1,1.1,1.2,2,3])\\n \\n for e, f in enumerate(farray):\\n # unperturbed stream\\n par_perturb = np.array([0*M.si.value, 0., 0., 0.])\\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B0.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, (T*f).si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream0 = {}\\n stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal0 = coord.Galactocentric(stream0['x'], **observer)\\n xeq0 = xgal0.transform_to(coord.ICRS)\\n veq0_ = gc.vgal_to_hel(xeq0, stream0['v'], **vobs)\\n veq0 = [None] * 3\\n veq0[0] = veq0_[0].to(u.mas/u.yr)\\n veq0[1] = veq0_[1].to(u.mas/u.yr)\\n veq0[2] = veq0_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n R = find_greatcircle(xeq0.ra.deg[::10], xeq0.dec.deg[::10])\\n xi0, eta0 = myutils.rotate_angles(xeq0.ra, xeq0.dec, R)\\n xi0 = coord.Angle(xi0*u.deg)\\n \\n # place gap at xi~0\\n xioff = xi0[ienc]\\n xi0 -= xioff\\n \\n par_perturb = np.array([M.si.value, 0., 0., 0.])\\n dB = (B0 - Bs)\\n B = dB + Bs\\n \\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, (T*f).si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream = {}\\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal = coord.Galactocentric(stream['x'], **observer)\\n xeq = xgal.transform_to(coord.ICRS)\\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\\n veq = [None] * 3\\n veq[0] = veq_[0].to(u.mas/u.yr)\\n veq[1] = veq_[1].to(u.mas/u.yr)\\n veq[2] = veq_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\\n xi = coord.Angle(xi*u.deg)\\n xi -= xioff\\n \\n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'observer': observer, 'vobs': vobs, 'R': R, 'xi0': xioff, 'x0': stream0['x'], 'v0': stream0['v']}\\n pickle.dump(outdict, open('../data/variations/vary_th{:03d}_T_{:.1f}.pkl'.format(th, f), 'wb'))\\n \\n # unperturbed stream\\n par_perturb = np.array([0*M.si.value, 0., 0., 0.])\\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B0.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream0 = {}\\n stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal0 = coord.Galactocentric(stream0['x'], **observer)\\n xeq0 = xgal0.transform_to(coord.ICRS)\\n veq0_ = gc.vgal_to_hel(xeq0, stream0['v'], **vobs)\\n veq0 = [None] * 3\\n veq0[0] = veq0_[0].to(u.mas/u.yr)\\n veq0[1] = veq0_[1].to(u.mas/u.yr)\\n veq0[2] = veq0_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n R = find_greatcircle(xeq0.ra.deg[::10], xeq0.dec.deg[::10])\\n xi0, eta0 = myutils.rotate_angles(xeq0.ra, xeq0.dec, R)\\n xi0 = coord.Angle(xi0*u.deg)\\n \\n # place gap at xi~0\\n xioff = xi0[ienc]\\n xi0 -= xioff\\n \\n for e, f in enumerate(farray):\\n par_perturb = np.array([f*M.si.value, 0., 0., 0.])\\n dB = (B0 - Bs)\\n B = dB + Bs\\n \\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, (T).si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream = {}\\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal = coord.Galactocentric(stream['x'], **observer)\\n xeq = xgal.transform_to(coord.ICRS)\\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\\n veq = [None] * 3\\n veq[0] = veq_[0].to(u.mas/u.yr)\\n veq[1] = veq_[1].to(u.mas/u.yr)\\n veq[2] = veq_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\\n xi = coord.Angle(xi*u.deg)\\n xi -= xioff\\n \\n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'observer': observer, 'vobs': vobs, 'R': R, 'xi0': xioff, 'x0': stream0['x'], 'v0': stream0['v']}\\n pickle.dump(outdict, open('../data/variations/vary_th{:03d}_M_{:.1f}.pkl'.format(th, f), 'wb'))\\n \\n for e, f in enumerate(farray):\\n par_perturb = np.array([M.si.value, 0., 0., 0.])\\n dB = (B0 - Bs)\\n B = dB*f + Bs\\n \\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream = {}\\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal = coord.Galactocentric(stream['x'], **observer)\\n xeq = xgal.transform_to(coord.ICRS)\\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\\n veq = [None] * 3\\n veq[0] = veq_[0].to(u.mas/u.yr)\\n veq[1] = veq_[1].to(u.mas/u.yr)\\n veq[2] = veq_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\\n xi = coord.Angle(xi*u.deg)\\n xi -= xioff\\n \\n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'observer': observer, 'vobs': vobs, 'R': R, 'xi0': xioff, 'x0': stream0['x'], 'v0': stream0['v']}\\n pickle.dump(outdict, open('../data/variations/vary_th{:03d}_B_{:.1f}.pkl'.format(th, f), 'wb'))\\n \\n theta0 = theta\\n V0 = V\\n \\n for e, f in enumerate(farray):\\n par_perturb = np.array([M.si.value, 0., 0., 0.])\\n dB = (B0 - Bs)\\n B = dB + Bs\\n \\n vpar = Vh + np.cos(theta0.rad)*V0\\n vperp = np.sin(theta0.rad)*V0\\n vpar_scaled = vpar*f\\n vperp_scaled = vperp*f\\n \\n V = np.sqrt((vpar_scaled-Vh)**2 + vperp_scaled**2)\\n theta = coord.Angle(np.arctan2(vperp_scaled, vpar_scaled-Vh))\\n \\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream = {}\\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal = coord.Galactocentric(stream['x'], **observer)\\n xeq = xgal.transform_to(coord.ICRS)\\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\\n veq = [None] * 3\\n veq[0] = veq_[0].to(u.mas/u.yr)\\n veq[1] = veq_[1].to(u.mas/u.yr)\\n veq[2] = veq_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\\n xi = coord.Angle(xi*u.deg)\\n xi -= xioff\\n \\n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'observer': observer, 'vobs': vobs, 'R': R, 'xi0': xioff, 'x0': stream0['x'], 'v0': stream0['v']}\\n pickle.dump(outdict, open('../data/variations/vary_th{:03d}_V_{:.1f}.pkl'.format(th, f), 'wb'))\",\n \"def _theta(num_vars):\\n theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)\\n # rotate theta such that the first axis is at the top\\n theta += np.pi/2\\n return theta\",\n \"def Psi(l,m,theta,phi):\\n if numpy.isscalar(theta): \\n theta=numpy.array([[theta]])\\n phi=numpy.array([[phi]])\\n Psilm_th=numpy.zeros(theta.shape,dtype=complex)\\n Psilm_ph=numpy.zeros(theta.shape,dtype=complex)\\n x=numpy.cos(theta)\\n thetaNonZerosIdx=numpy.where(theta!=0.0)\\n if len(thetaNonZerosIdx[0]) != 0:\\n Ylm=scipy.special.sph_harm(m,l,phi[thetaNonZerosIdx],theta[thetaNonZerosIdx])\\n #Compute derivative of sphrHarm function w.r.t. theta:\\n if l>=numpy.abs(m):\\n Plmpo=legendreLM(l,m+1,x[thetaNonZerosIdx])\\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/float(math.factorial(l+m)))*Plmpo*numpy.exp(1j*m*phi[thetaNonZerosIdx])\\n #YlmPmpo=sqrt((l-m)*(l+m+1))*spharm(l,m+1,theta,phi)*exp(-i*phi) %Should be equivalent to above formula.\\n dtYlm=+YlmPmpo+m*x[thetaNonZerosIdx]*Ylm/numpy.sin(theta[thetaNonZerosIdx])\\n # thetZerInd=[find(theta==0); find(theta==pi)]\\n # dtYlm(thetZerInd)=0; %This is a fudge to remove NaNs\\n else:\\n dtYlm=numpy.zeros(theta[thetaNonZerosIdx].shape,dtype=complex)\\n\\n #dtYlm=spharmDtheta(l,m,theta,phi)\\n\\n Psilm_ph[thetaNonZerosIdx]=+1j*m/numpy.sin(theta[thetaNonZerosIdx])*Ylm\\n Psilm_th[thetaNonZerosIdx]=+dtYlm\\n #Ref: http://mathworld.wolfram.com/VectorSphericalHarmonic.html\\n\\n thetaZerosIdx=numpy.where(theta==0.0)\\n if len(thetaZerosIdx[0]) != 0:\\n if numpy.abs(m)==1:\\n Yl1B=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*PBl1(l,m)*numpy.exp(1j*m*phi[thetaZerosIdx])\\n Plmpo=legendreLM(l,m+1,x[thetaZerosIdx])\\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*Plmpo*numpy.exp(1j*m*phi[thetaZerosIdx])\\n dtYlm=+YlmPmpo+m*Yl1B\\n Psilm_ph[thetaZerosIdx]=+1j*m*Yl1B\\n Psilm_th[thetaZerosIdx]=+dtYlm\\n else:\\n Plmpo=legendreLM(l,m+1,x[thetaZerosIdx])\\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*Plmpo*numpy.exp(1j*m*phi[thetaZerosIdx])\\n dtYlm=+YlmPmpo+0\\n Psilm_ph[thetaZerosIdx]=0\\n Psilm_th[thetaZerosIdx]=+dtYlm\\n return Psilm_th,Psilm_ph\",\n \"def twist(self, theta):\\n self.G_indv = li.expm(self.xi_hat * theta)\",\n \"def batch_rodrigues(theta):\\n l2norm = torch.norm(theta + 1e-08, p=2, dim=1)\\n angle = torch.unsqueeze(l2norm, -1)\\n normalized = torch.div(theta, angle)\\n angle = angle * 0.5\\n v_cos = torch.cos(angle)\\n v_sin = torch.sin(angle)\\n quat = torch.cat([v_cos, v_sin * normalized], dim=1)\\n return quat_to_rotmat(quat)\",\n \"def theta(conc, S, educts):\\n\\n educts_per_reaction = educts.T\\n\\n # in every reaction j row, element at pos (column, species) i equals conc_i^educt_{ij}\\n # educt_{ij} - how many units of i are educts in reaction j\\n multiplicative_term_rows = np.power(conc, educts_per_reaction)\\n\\n # concentrations to educt product ----> product_{i=1}^{n_s}(conc_i^{educt_{ij}}\\n concentration_product = np.prod(multiplicative_term_rows, axis=1)\\n\\n # returns one row with #reactions elements -> fluxes\\n return concentration_product * S\",\n \"def grad_chi(self, theta):\\n theta = np.asarray(theta)\\n assert theta.size == 12 + self.nspots * 8 + self.mmax * 2, \\\"Parameter vector with wrong size\\\"\\n theta_star = theta[:12]\\n theta_spot = theta[12:12 + self.nspots * 8]\\n theta_inst = theta[12 + self.nspots * 8:]\\n\\n result = macula(self.t, theta_star, theta_spot, theta_inst, tstart=self.tstart, tend=self.tend,\\n full_output=True, derivatives=True)\\n yf = result[0]\\n dy_star = result[1]\\n dy_spot = result[2]\\n dy_inst = result[3]\\n # TODO: review this whole function!\\n dic_star = {}\\n for i, key in enumerate(self.star_pars.keys()):\\n dic_star[key] = dy_star[:, i]\\n dic_spot = {}\\n for i, key in enumerate(self.spot_pars.keys()):\\n dic_spot[key] = dy_spot[:, i]\\n dic_inst = {}\\n for i, key in enumerate(self.inst_pars.keys()):\\n dic_inst[key] = dy_inst[:, i]\\n dic_full = {**dic_star, **dic_spot, **dic_inst}\\n dy = []\\n for key in self.fit_names:\\n if key in self.spot_pars.keys():\\n for j in range(self.nspots):\\n dy.append(np.sum(2 * (yf - self.y) * dic_full[key][:, j]) / np.std(self.y))\\n elif key in self.inst_pars.keys():\\n for j in range(self.mmax):\\n dy.append(np.sum(2 * (yf - self.y) * dic_full[key][:, j]) / np.std(self.y))\\n else:\\n dy.append(np.sum(2 * (yf - self.y) * dic_full[key]) / np.std(self.y))\\n return np.array(dy)\",\n \"def theta(a, b):\\n \\n \\n def norm_vec(x):\\n norm_out = sqrt(dot(x, x))\\n return norm_out\\n \\n theta = acos(dot(a, b) / (norm_vec(a) * norm_vec(b))) * 180 / pi\\n \\n print theta\",\n \"def inject(energy, theta_x, theta_y, flux=1, noise=0):\\n respfile_f = calc_resp(energy, theta_x, theta_y)\\n image = f2image(respfile_f) * flux + np.random.poisson(noise, (128, 128))\\n return image\",\n \"def _gen_rxx(theta):\\n return np.array([[np.cos(theta / 2), 0, 0, -1j * np.sin(theta / 2)],\\n [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0],\\n [0, -1j * np.sin(theta / 2), np.cos(theta / 2), 0],\\n [-1j * np.sin(theta / 2), 0, 0, np.cos(theta / 2)]])\",\n \"def theta_rot(od, theta):\\n rot_mat = np.array([[np.cos(theta), -np.sin(theta), 0],\\n [np.sin(theta), np.cos(theta), 0],\\n [0, 0, 1]])\\n return rot_mat.dot(od)\",\n \"def set_phi_theta_r(phi, theta, r=1):\\n return np.array([sin(theta) * cos(phi),\\n sin(theta) * sin(phi),\\n cos(theta)]) * r\",\n \"def piston( f, # frequency\\n a_h, a_v,\\n theta, phi,\\n c=343 ): # speed of sound, in m/s.\\n k = 2*np.pi*f/c # wave number\\n \\n if type(theta) is types.IntType or type(theta) is types.FloatType or type(theta) is np.float64:\\n theta = np.array([theta], dtype=np.float64)\\n else:\\n theta = np.array(theta, dtype=np.float64)\\n if type(phi) is types.IntType or type(phi) is types.FloatType or type(phi) is np.float64:\\n phi = np.array([phi], dtype=np.float64)\\n else:\\n phi = np.array(phi, dtype=np.float64)\\n h_term = k*a_h*np.sin(theta)\\n v_term = k*a_v*np.sin(phi)\\n\\n h_factor = .5*np.ones(shape=h_term.shape)\\n for k in range(len(h_factor)):\\n if np.abs(h_term[k]) > 4*np.finfo(np.float64).eps:\\n h_factor[k] = sp_special.jn(1, h_term[k])/h_term[k]\\n \\n v_factor = .5*np.ones(shape=v_term.shape)\\n for k in range(len(v_factor)):\\n if np.abs(v_term[k]) > 4*np.finfo(np.float64).eps:\\n v_factor[k] = sp_special.jn(1, v_term[k])/v_term[k]\\n \\n if v_factor.shape[0] > 1 and h_factor.shape[0] > 1:\\n return 4*np.outer(np.abs(v_factor), np.abs(h_factor)) # make P from outer product.\\n else:\\n return 4*np.abs(v_factor*h_factor)\",\n \"def _single_term_cos(power, rho, theta):\\n\\n return np.power(rho, power) * np.cos(power * theta)\",\n \"def theta(lam, gam, p):\\n #lam = lam - 1e-15\\n return np.pi - np.arccos(np.divide(-1 + lam*np.cos(2*np.pi*p ), w(lam, gam, p) ) )\",\n \"def _gen_rzz(theta):\\n return np.diag([1, np.exp(1j * theta), np.exp(1j * theta), 1])\",\n \"def restrict_theta(theta):\\n tnew = theta + np.pi\\n tnew += -2.0*np.pi*np.floor(tnew/(2.0*np.pi))\\n tnew -= np.pi\\n return tnew\",\n \"def theta(flag, S, K, t, r, sigma, q): \\n\\n b = r-q\\n\\n return numerical_theta(flag, S, K, t, r, sigma, b, f)\",\n \"def op_half_wave_plate(theta):\\n C2 = np.cos(2 * theta)\\n S2 = np.sin(2 * theta)\\n qwp = np.array([[1, 0, 0, 0],\\n [0, C2**2 - S2**2, 2 * C2 * S2, 0],\\n [0, 2 * C2 * S2, S2 * S2 - C2**2, 0],\\n [0, 0, 0, -1]])\\n return qwp\",\n \"def syntheticSeismogram(d, rho, v, wavf, wavA=1., usingT=True, wavtyp = 'RICKER', dt=0.0001, dmax=200):\\n\\n v, rho, d = np.array(v, dtype=float), np.array(rho, dtype=float), np.array(d, dtype=float)\\n usingT = np.array(usingT, dtype=bool)\\n\\n _, t = getTimeDepth(d,v,dmax)\\n rseries,R = getReflectivity(d,rho,v)\\n\\n # time for reflectivity series\\n tref = t[1:-1]\\n\\n # create time vector\\n t = np.arange(t.min(),t.max(),dt)\\n\\n # make wavelet\\n twav = np.arange(-2.0/np.min(wavf), 2.0/np.min(wavf), dt)\\n\\n # Get source wavelet\\n wav = {'RICKER':getRicker, 'ORMSBY':getOrmsby, 'KLAUDER':getKlauder}[wavtyp](wavf,twav)\\n wav = wavA*wav\\n\\n rseriesconv = np.zeros(len(t))\\n for i in range(len(tref)):\\n index = np.abs(t - tref[i]).argmin()\\n rseriesconv[index] = rseries[i]\\n\\n # Do the convolution\\n seis = np.convolve(wav,rseriesconv)\\n tseis = np.min(twav)+dt*np.arange(len(seis))\\n index = np.logical_and(tseis >= 0, tseis <= np.max(t))\\n tseis = tseis[index]\\n seis = seis[index]\\n\\n return tseis, seis, twav, wav, tref, rseries\",\n \"def model(theta, x):\\n\\tw, b = theta\\n\\treturn w * x + b\",\n \"def compute_theta(tx, index_theta, mean=[],std=[]):\\n tx_new = np.cos(tx[:,index_theta])\\n return standardize(tx_new,mean,std)\",\n \"def _single_term_sin(power, rho, theta):\\n\\n return np.power(rho, power) * np.sin(power * theta)\",\n \"def transform_scan(self, particle, distance, theta):\\n return (particle.x + distance * math.cos(math.radians(particle.theta + theta)),\\n particle.y + distance * math.sin(math.radians(particle.theta + theta)))\",\n \"def theta_v_time():\\n pass\",\n \"def dir_vect(theta):\\n return np.array([np.cos(theta),np.sin(theta)])\",\n \"def op_quarter_wave_plate(theta):\\n C2 = np.cos(2 * theta)\\n S2 = np.sin(2 * theta)\\n qwp = np.array([[1, 0, 0, 0],\\n [0, C2**2, C2 * S2, -S2],\\n [0, C2 * S2, S2 * S2, C2],\\n [0, S2, -C2, 0]])\\n return qwp\",\n \"def get_theta_from_cov(self, Sigma, theta):\\n sigma_values = np.triu(Sigma)\\n ind_u = np.triu_indices(self.dim)\\n sigma_values= sigma_values[ind_u]\\n return np.append(self.get_mu(theta), sigma_values)\",\n \"def morphology(seed=425, th=120):\\n \\n # impact parameters\\n M = 1e8*u.Msun\\n B = 19.85*u.kpc\\n V = 220*u.km/u.s\\n phi = coord.Angle(0*u.deg)\\n theta = coord.Angle(th*u.deg)\\n Tenc = 0.01*u.Gyr\\n T = 0.5*u.Gyr\\n dt = 0.1*u.Myr\\n rs = 0*u.pc\\n \\n # potential parameters\\n potential = 3\\n Vh = 220*u.km/u.s\\n q = 1*u.Unit(1)\\n rhalo = 20*u.pc\\n par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])\\n \\n # setup tube\\n Nstar = 3000\\n wx = 30*u.kpc\\n wy = 0*u.pc\\n wz = 0*u.pc\\n sx = 0*u.km/u.s\\n \\n np.random.seed(seed)\\n \\n xphi = np.linspace(-0.3*np.pi,0.3*np.pi, Nstar)\\n xr = 20*u.kpc + np.random.randn(Nstar)*0.02*u.kpc\\n x = np.sin(xphi) * xr\\n y = np.cos(xphi) * xr\\n z = x * 0\\n vx = -np.cos(xphi) * Vh\\n vy = np.sin(xphi) * Vh\\n vz = vx * 0\\n \\n potential_perturb = 1\\n par_perturb = np.array([M.si.value, 0., 0., 0.])\\n \\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream = {}\\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n\\n plt.close()\\n fig, ax = plt.subplots(3,1,figsize=(12,8), sharex=True)\\n \\n c_init = mpl.cm.Blues_r(1)\\n c_fin0 = mpl.cm.Blues_r(0.5)\\n c_fin = mpl.cm.Blues_r(0.2)\\n \\n eta = coord.Angle(np.arctan2(np.sqrt(stream['x'][0].to(u.kpc).value**2 + stream['x'][1].to(u.kpc).value**2),xr.to(u.kpc).value)*u.rad)\\n xi = np.arctan2(stream['x'][1].to(u.kpc).value, stream['x'][0].to(u.kpc).value)\\n xi = coord.Angle((xi - np.median(xi))*u.rad)\\n \\n vlabel = ['x', 'y', 'z']\\n \\n for i in range(3):\\n plt.sca(ax[i])\\n im = plt.scatter(xi.deg, eta.deg, c=stream['v'][i].value, s=20)\\n \\n plt.xlim(-60, 50)\\n plt.ylim(55, 35)\\n plt.gca().set_aspect('equal')\\n \\n if i==2:\\n plt.xlabel('$\\\\phi_1$ [deg]')\\n plt.ylabel('$\\\\phi_2$ [deg]')\\n \\n divider = make_axes_locatable(plt.gca())\\n cax = divider.append_axes(\\\"right\\\", size=\\\"3%\\\", pad=0.1)\\n plt.colorbar(im, cax=cax)\\n plt.ylabel('$V_{{{}}}$ [km s$^{{-1}}$]'.format(vlabel[i]))\\n \\n plt.tight_layout()\",\n \"def _gen_u(theta, phi, lamda):\\n m11 = (np.e ** (1j * (phi + lamda) / 2)) * np.cos(theta / 2)\\n m12 = (-1) * (np.e ** (1j * (phi - lamda) / 2)) * np.sin(theta / 2)\\n m21 = (np.e ** (1j * (phi - lamda) / 2)) * np.sin(theta / 2)\\n m22 = (np.e ** (1j * (phi + lamda) / 2)) * np.cos(theta / 2)\\n return np.array([[m11, m12], [m21, m22]], dtype=np.complex128)\",\n \"def y(theta):\\n return ((theta[1] + theta[2]) / theta[0]) - ((theta[2] * 0.01) + random.gauss(0, 0.1))\",\n \"def mieScatteringCrossSections(refractiveIndex,\\r\\n particleDiameters,\\r\\n wavelength, \\r\\n theta):\\r\\n cos_theta = np.cos(theta)\\r\\n # Calculation of Mie parameters\\r\\n (a,b) = mie_abcd(refractiveIndex, \\r\\n np.pi*particleDiameters/wavelength)\\r\\n nmax = np.size(a,0)\\r\\n nangles = len(cos_theta)\\r\\n nd = len(particleDiameters)\\r\\n \\r\\n pi = np.empty((nangles,nmax,nd))\\r\\n tau = np.empty((nangles,nmax,nd))\\r\\n header = np.tile(Header(nmax), (nd,1)).T\\r\\n for (i, ctheta) in enumerate(cos_theta):\\r\\n pigen = Pi(nmax, ctheta)\\r\\n pitemp = np.fromiter(pigen, np.float)\\r\\n tautemp = Tau(pitemp, ctheta)\\r\\n pi[i,:,:] = np.tile(pitemp[:-1],(nd,1)).T\\r\\n tau[i,:,:] = np.tile(tautemp[:-1], (nd,1)).T\\r\\n \\r\\n i1 = header * (a * pi + b * tau)\\r\\n i2 = header * (b * pi + a * tau)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n The following sum puts the coefficients in the following form:\\r\\n < ndiameters >\\r\\n i1,i2 = [[i1, i1, ... i1], ^\\r\\n [i1, i1, ... i1], nangles\\r\\n ...\\r\\n [i1, i1, ... i1]] v\\r\\n so, each particle diameter is represented by a column\\r\\n \\\"\\\"\\\"\\r\\n i1 = np.sum(i1,1)\\r\\n i2 = np.sum(i2,1)\\r\\n\\r\\n i1 = (np.abs(i1)**2) * (1/4) * (wavelength/np.pi)**2\\r\\n i2 = (np.abs(i2)**2) * (1/4) * (wavelength/np.pi)**2\\r\\n \\r\\n return (i1, i2)\",\n \"def extendpt(p, theta, length):\\n\\treturn [ p[0]+cos(theta)*length, p[1]+sin(theta)*length]\",\n \"def samplePatchOnSphere(phi, theta, delta, size, rng, degrees=True):\\n u = rng.uniform(size=size)\\n v = rng.uniform(size=size)\\n phi = np.radians(phi)\\n theta = np.radians(theta)\\n delta = np.radians(delta)\\n\\n phivals = 2. * delta * u + (phi - delta)\\n phivals = np.where(phivals >= 0., phivals, phivals + 2. * np.pi)\\n\\n # use conventions in spherical coordinates\\n # theta = np.pi/2.0 - theta\\n thetamax = theta + delta\\n thetamin = theta - delta\\n\\n # if thetamax > np.pi or thetamin < 0. :\\n # raise ValueError('Function not implemented to cover wrap around poles')\\n\\n # Cumulative Density Function is cos(thetamin) - cos(theta) / cos(thetamin) - cos(thetamax)\\n a = np.cos(thetamin) - np.cos(thetamax)\\n thetavals = np.arccos(-v * a + np.cos(thetamin))\\n\\n if degrees:\\n return np.degrees(phivals), np.degrees(thetavals)\\n else:\\n return phivals, thetavals\",\n \"def spherical2cartesian(phi, theta, depth):\\n x = depth * np.sin(theta) * np.cos(phi)\\n y = depth * np.cos(theta)\\n z = depth * np.sin(theta) * np.sin(phi)\\n\\n return x, y, z\",\n \"def generate_image(self, theta, context):\\n raise NotImplementedError()\",\n \"def generate_image(self, theta, context):\\n raise NotImplementedError()\",\n \"def make_spectra(directory,frame):\\n oober = st.short_oober(directory, frame=frame)\\n #st.MakeVelocitySpectra(oober,frame)\\n #st.MakeAccelSpectra(oober,frame)\\n #st.MakeMagneticSpectra(oober,frame)\\n st.MakeDensitySpectra(oober,frame)\",\n \"def Spin(phi,theta):\\n return 1/2*(cos(phi)*sin(theta)*xhat + sin(phi)*sin(theta)*yhat + cos(theta)*zhat)\",\n \"def vector_compute_spherical_harmonics(theta, phi, selected_modes=None):\\n # Only copies if input is scalar, else returns original array\\n theta = np.array(theta, copy=False, ndmin=1)\\n theta = np.array(phi, copy=False, ndmin=1)\\n\\n Ylms = {}\\n one_m_theta = 1.0 - np.cos(theta)\\n one_p_theta = 1.0 + np.cos(theta)\\n snTheta = np.sin(theta)\\n for m in range(-2, 3):\\n if selected_modes is not None and (2,m) not in selected_modes:\\n continue\\n if m == -2:\\n Ylms[(2,m)] = _a2m2 * one_m_theta * one_m_theta * np.exp(1j*m*phi)\\n elif m == -1:\\n Ylms[(2,m)] = _a2m1 * snTheta * one_m_theta * np.exp(1j*m*phi)\\n elif m == 0:\\n Ylms[(2,m)] = _a20 * snTheta * snTheta\\n elif m == 1:\\n Ylms[(2,m)] = _a21 * snTheta * one_p_theta * np.exp(1j*m*phi)\\n elif m == 2:\\n Ylms[(2,m)] = _a22 * one_p_theta * one_p_theta * np.exp(1j*m*phi)\\n\\n return Ylms\",\n \"def gen_omega(costheta0, phi0, costheta1, phi1):\\n global pgamma\\n pgamma = [TLorentzVector(), TLorentzVector(), TLorentzVector()]\\n q_omega = (m_omega**2 - m_pi0**2) / (2 * m_omega)\\n sintheta1 = sqrt(1 - costheta1*costheta1)\\n pgamma[0].SetXYZT(q_omega * sintheta1 * math.cos(phi1),\\n q_omega * sintheta1 * math.sin(phi1),\\n q_omega * costheta1, q_omega)\\n q_pi0 = m_pi0 / 2\\n sintheta0 = sqrt(1 - costheta0**2)\\n pgamma[1].SetXYZT(q_pi0 * sintheta0 * math.cos(phi0),\\n q_pi0 * sintheta0 * math.sin(phi0),\\n q_pi0 * costheta0, q_pi0)\\n pgamma[2].SetXYZT(-q_pi0 * sintheta0 * math.cos(phi0),\\n -q_pi0 * sintheta0 * math.sin(phi0),\\n -q_pi0 * costheta0, q_pi0)\\n beta = pgamma[0].Vect() * (1 / math.sqrt(q_omega**2 + m_pi0**2))\\n pgamma[1].Boost(-beta)\\n pgamma[2].Boost(-beta)\\n global pomega\\n pomega = pgamma[0] + pgamma[1] + pgamma[2]\\n return pomega\",\n \"def generate_image(self, theta, context):\\n\\n raise NotImplementedError()\",\n \"def _unpolarized_simulation(self, frequency, theta_0=0):\\n s_data = self.simulate(frequency, 's', theta_0)\\n p_data = self.simulate(frequency, 'p', theta_0)\\n T = (s_data + p_data)/2\\n return T\",\n \"def scattering_amplitude(self, theta, pol=1):\\r\\n c = np.atleast_1d(np.cos(theta)) # vectorize\\r\\n s = np.expand_dims(np.sin(theta), -1)\\r\\n p = np.moveaxis([lpmn(1, self.n, c) for c in c], 0, 2)\\r\\n pi = p[0,1,:,1:]/s\\r\\n tau = -p[1,1,:,1:]*s\\r\\n n = np.arange(1, self.n + 1)\\r\\n k = (2*n+1)/n/(n+1) # Bohren and Huffman, eq(4.74)\\r\\n if pol==1: S = np.dot(self.a * pi + self.b * tau, k)\\r\\n elif pol==2: S = np.dot(self.a * tau + self.b * pi, k)\\r\\n else: raise RuntimeError(\\\"pol==1 or pol==2\\\")\\r\\n return np.squeeze(S)/self.x\",\n \"def music(csi_corr, csi_target, Ntx, Nrx, d_tx, d_rx, t):\\n\\n In = 0\\n s = phase_correction(csi_corr, csi_target)\\n s_lin = (s[:, :, 0, t:t + 2].reshape(6, 2, order='F'))\\n\\n '''Compute the covariance matrix and the eigendecompositon'''\\n R_hat = np.cov(s_lin)\\n D, Q = ln.eig(R_hat)\\n\\n '''Sort the eigenvalues in D'''\\n Do = np.abs(D)\\n D = np.sort(Do)[::-1]\\n I = np.argsort(Do)[::-1]\\n Q = Q[:, I]\\n\\n ''' Compute the Number of signal that are significative'''\\n T = np.cumsum(np.real(D))\\n for i in range(1, 1, np.size(T)):\\n if T(i) >= 0.99 * T(np.size(T)):\\n In = i\\n break\\n\\n ''' Get the signal eigenvectors'''\\n In = 0 # take the first signal\\n Qs = Q[:, :In]\\n\\n ''' Get the noise eigenvectors'''\\n Qn = Q[:, In + 1:]\\n\\n ''' Angles at which MUSIC Pseudospectrum will be computed '''\\n angles1 = np.arange(-90, 90, 1)\\n angles2 = np.arange(-90, 90, 1)\\n\\n '''Compute steering vectors corresponding values in angles'''\\n a1 = np.exp(-1.j * 2 * np.pi * d_rx * np.tensordot(arange(Nrx), sin(angles1 * np.pi / 180), 0))\\n a2 = np.exp(-1.j * 2 * np.pi * d_tx * np.tensordot(arange(Ntx), sin(angles1 * np.pi / 180), 0))\\n\\n '''Compute MUSIC \\\"spectrum\\\" '''\\n music_spectrum = np.zeros((np.size(angles1), np.size(angles2)), dtype=complex)\\n for k in range(1, np.size(angles2)):\\n for j in range(1, np.size(angles1)):\\n K = np.kron(a1[:, j], a2[:, k])\\n s = dot(K.T, Qn)\\n music_spectrum[j, k] = 1 / dot(abs(s), abs(s).T)\\n\\n ''' compute the mesh and plot the surf of the pseudospectrum '''\\n\\n fig = plt.figure()\\n ax = fig.gca(projection='3d')\\n x = angles2\\n y = angles1\\n X, Y = np.meshgrid(x, y)\\n Z = np.abs(np.squeeze(music_spectrum))\\n ax = fig.add_subplot(111, projection='3d')\\n ax.set_ylabel('AoA')\\n ax.set_xlabel('AoD')\\n ax.set_xlim3d(-90, 90)\\n ax.set_ylim3d(-90, 90)\\n ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=cm.jet, alpha=0.7, linewidth=0.25)\\n\\n ''' detect the peaks corresponding to DoD and DoA '''\\n detect = detect_peaks(Z)\\n index_max = np.column_stack(np.where(detect))\\n x_ind = index_max[:, 0]\\n y_ind = index_max[:, 1]\\n tab = (np.transpose(np.array((Z[x_ind, y_ind], x[x_ind], y[y_ind])))).tolist()\\n tab.sort(key=lambda e: e[0], reverse=True)\\n myarray = np.asarray(tab[0])\\n angles = myarray[1:]\\n plt.show()\\n\\n return angles\",\n \"def getPhi(mass,resonance):\\n return numpy.arctan((resonance.r0*resonance.w0)/(mass**2-resonance.w0**2)) #need to make this arccotan? invert args\",\n \"def x_rotmat(theta):\\n cos_t = np.cos(theta)\\n sin_t = np.sin(theta)\\n return np.array([[1, 0, 0],\\n [0, cos_t, -sin_t],\\n [0, sin_t, cos_t]])\",\n \"def sample_torsion(phi, psi, kappa_scalar=8, random_state=1):\\n \\n phi_sample = torch.tensor(np.round([randvonmises(phi, i, kappa_scalar, random_state) for i in range(phi.shape[3])], 4))\\n psi_sample = torch.tensor(np.round([randvonmises(psi, i, kappa_scalar, random_state) for i in range(psi.shape[3])], 4))\\n return phi_sample, psi_sample\",\n \"def lsf_multimodal_function(theta):\\n y_out = -((theta[:, 0] ** 2 + 4) * (theta[:, 1] - 1) / 20 - np.sin(5 * theta[:, 0] / 2) - 2)\\n return y_out.reshape(y_out.shape[0], -1)\",\n \"def getSpectrumNextGen(teff=None, logg=None, mstar=None, lstar=None, rstar=None, modeldir=None, wav=None):\\n\\n #\\n # Sanity check\\n #\\n if teff is None:\\n raise ValueError('Unknown teff. NextGen spectrum cannot be calculated without the stellar effective'\\n + 'temperature.')\\n if logg is None:\\n if mstar is None:\\n raise ValueError('Unknown logg and mstar. For NextGen atmosphere models either logg or mstar and '\\n + ' rstar/lstar should be specified')\\n else:\\n if rstar is None:\\n if lstar is None:\\n raise ValueError('Unknown logg, rstar, lstar thus logg cannot be calculated. For NextGen '\\n + 'atmosphere models either logg should be given or a combination of mstar, lstar, rstar '\\n + 'should be specified from which logg can be calculated for a given effective temperature. ')\\n else:\\n rstar = np.sqrt(lstar / (4. * np.pi * nc.ss * teff**4.))\\n else:\\n lstar = 4. * np.pi * rstar**2 * nc.ss * teff**4\\n\\n logg = np.log10(nc.gg * mstar / rstar**2)\\n else:\\n if rstar is None:\\n if lstar is None:\\n raise ValueError('Unknown rstar and lstar thus luminosity cannot be calculated. For NextGen '\\n + 'atmosphere models either lstar or rstar should be given')\\n else:\\n rstar = np.sqrt(lstar / (4. * np.pi * nc.ss * teff**4.))\\n else:\\n lstar = 4. * np.pi * rstar**2 * nc.ss * teff**4\\n\\n mstar = 10.**logg * rstar**2 / nc.gg\\n\\n assert (teff >= 0.), 'Negative effective temperature!'\\n assert (mstar >= 0.), 'Negative stellar mass!'\\n assert (lstar >= 0.), 'Negative stellar luminosity!'\\n assert (rstar >= 0.), 'Negative stellar radius!'\\n\\n print('-------------------------------------------')\\n print('Interpolating in NextGen model atmospheres')\\n print('Stellar parameters: ')\\n print('-------------------------------------------')\\n print('Teff [K] : ', teff)\\n print('Radius [Rsun] : ', rstar / nc.rs)\\n print('Luminosity [Lsun] : ', lstar / nc.ls)\\n print('Mass [Msun] : ', mstar / nc.ms)\\n print('logg : ', logg)\\n print('-------------------------------------------')\\n\\n teff_grid = np.append((np.arange(31.) + 9.), (np.arange(30.) * 2. + 40.))\\n logg_grid = np.arange(6.) * 0.5 + 3.5\\n\\n # Bracket the input teff and logg values\\n ii = abs(teff_grid - teff / 100.).argmin()\\n idt1 = ii\\n if teff_grid[ii] > teff / 100.:\\n idt1 = ii - 1\\n else:\\n idt1 = ii\\n idt2 = idt1 + 1\\n\\n ii = abs(logg_grid - logg).argmin()\\n if logg < logg_grid[0]:\\n idg1 = 0\\n idg2 = 0\\n elif logg > logg_grid[-1]:\\n idg1 = logg_grid.shape[0] - 1\\n idg2 = logg_grid.shape[0] - 1\\n else:\\n idg1 = ii\\n if logg_grid[ii] > logg:\\n idg1 = ii - 1\\n else:\\n idg1 = ii\\n idg2 = idg1 + 1\\n\\n print('Bracketing spectrum : ', teff, logg)\\n print('Teff : ', teff_grid[idt1], teff_grid[idt2])\\n print('log(g): ', logg_grid[idg1], logg_grid[idg2])\\n\\n # Generate the spectral file names\\n mph = '0.0'\\n fname_11 = 'lte' + (\\\"%d\\\" % teff_grid[idt1]) + '-' + (\\\"%.1f\\\" % logg_grid[idg1]) + '-' + mph + '.NextGen.spec.gz'\\n fname_12 = 'lte' + (\\\"%d\\\" % teff_grid[idt1]) + '-' + (\\\"%.1f\\\" % logg_grid[idg2]) + '-' + mph + '.NextGen.spec.gz'\\n fname_22 = 'lte' + (\\\"%d\\\" % teff_grid[idt2]) + '-' + (\\\"%.1f\\\" % logg_grid[idg2]) + '-' + mph + '.NextGen.spec.gz'\\n fname_21 = 'lte' + (\\\"%d\\\" % teff_grid[idt2]) + '-' + (\\\"%.1f\\\" % logg_grid[idg1]) + '-' + mph + '.NextGen.spec.gz'\\n\\n # Create a directory\\n if os.path.exists(\\\"./tmp\\\"):\\n shutil.rmtree(\\\"./tmp\\\")\\n\\n os.system('mkdir tmp')\\n os.system('cp -v ' + modeldir + '/' + fname_11 + ' ./tmp')\\n os.system('cp -v ' + modeldir + '/' + fname_12 + ' ./tmp')\\n os.system('cp -v ' + modeldir + '/' + fname_22 + ' ./tmp')\\n os.system('cp -v ' + modeldir + '/' + fname_21 + ' ./tmp')\\n\\n # Unzip the files\\n os.chdir('./tmp')\\n os.system('gunzip ' + fname_11)\\n os.system('gunzip ' + fname_12)\\n os.system('gunzip ' + fname_22)\\n os.system('gunzip ' + fname_21)\\n os.chdir('../')\\n\\n # Read the spectra\\n sp11 = readNextGenSpectrum(fname='./tmp/' + fname_11[:-3])\\n sp12 = readNextGenSpectrum(fname='./tmp/' + fname_12[:-3])\\n sp22 = readNextGenSpectrum(fname='./tmp/' + fname_22[:-3])\\n sp21 = readNextGenSpectrum(fname='./tmp/' + fname_21[:-3])\\n\\n # Do the interpolation\\n c11 = (teff_grid[idt2] - teff / 100.) * (logg_grid[idg2] - logg)\\n c12 = (teff_grid[idt2] - teff / 100.) * (logg - logg_grid[idg1])\\n c22 = (teff / 100. - teff_grid[idt1]) * (logg - logg_grid[idg1])\\n c21 = (teff / 100. - teff_grid[idt1]) * (logg_grid[idg2] - logg)\\n c00 = 1. / ((teff_grid[idt2] - teff_grid[idt1]) * (logg_grid[idg2] - logg_grid[idg1]))\\n\\n lnu = c00 * (c11 * sp11['inu'] + c12 * sp12['inu'] + c22 * sp22['inu'] + c21 * sp21['inu'])\\n bnu = c00 * (c11 * sp11['bnu'] + c12 * sp12['bnu'] + c22 * sp22['bnu'] + c21 * sp21['bnu'])\\n\\n shutil.rmtree('./tmp')\\n\\n #\\n # Scale the spectrum to give the same luminosity as required\\n #\\n nu = nc.cc / sp11['wav'] * 1e4\\n lum = (0.5 * abs(nu[1:] - nu[:-1]) * (lnu[1:] + lnu[:-1])).sum()\\n lnu *= lstar / lum\\n\\n lum = (0.5 * abs(nu[1:] - nu[:-1]) * (bnu[1:] + bnu[:-1])).sum()\\n bnu *= lstar / lum\\n\\n return {'wav': sp11['wav'], 'lnu': lnu, 'bnu': bnu}\",\n \"def photoangular_distribution(Dmo, Amo, LMs, energy):\\n # number of continuum orbitals\\n nmo = Amo.shape[-1]\\n # photon energy\\n omega = energy # + IE ???????\\n\\n tdipvecs = Dmo.transpose()\\n \\n # convert transition dipoles from cartesian to spherical coordinates\\n # <i|x|n> sin(tdip_th) cos(tdip_ph)\\n # <i|y|n> = tdip_r * sin(tdip_th) cos(tdip_ph)\\n # <i|z|n> cos(tdip_th)\\n #\\n tdip_r, tdip_th, tdip_ph = cartesian2spherical(tdipvecs)\\n \\n # spherical harmonics Y_(1,m1)(tdip_th, tdip_ph)\\n Y1 = np.zeros((3,nmo), dtype=complex)\\n for Y1m1,l1,m1 in spherical_harmonics_it(tdip_th, tdip_ph):\\n if l1 > 1:\\n break\\n if l1 == 1:\\n Y1[m1,:] = Y1m1\\n\\n print \\\"angular distributions for pairs of orbitals ...\\\"\\n # coefficients of Legendre polynomials of degrees L=0,1,2\\n # for pairs of molecular orbitals with indices a,b\\n # coefsPmo[L,a,b]\\n coefsPmo = np.zeros((3,nmo,nmo), dtype=complex)\\n for LM,(L,M) in enumerate(LMs):\\n cL = np.sqrt((2*L+1.)/(4.0*np.pi)) * Wigner3J(1,0, 1,0, L,0) * 4.0*np.pi/3.0 \\\\\\n * np.outer(tdip_r[:], tdip_r[:]) \\\\\\n * Amo[LM,:,:]\\n yyLM = np.zeros((nmo,nmo), dtype=complex)\\n for m1 in [-1,0,1]:\\n for m2 in [-1,0,1]:\\n if not (-m1 + m2 + M == 0):\\n continue\\n \\n yyLM += (-1)**m1 * Wigner3J(1,-m1, 1,m2, L,M) \\\\\\n * np.outer( Y1[m1,:], Y1[m2,:].conjugate() )\\n cL *= yyLM\\n cL *= 2*omega\\n \\n coefsPmo[L,:,:] += cL\\n \\n coefsP = np.sum(coefsPmo, axis=(1,2))\\n\\n # anisotropy parameter in\\n # sigma(th) = sigma / (4 pi) [ 1 + beta P2(cos(th)) ]\\n # = c0 c2 P2(cos(th))\\n sigma = coefsP[0] * 4.0*np.pi\\n beta = coefsP[2]/coefsP[0]\\n assert -1.0-0.01 <= beta <= 2.0+0.01\\n\\n # sigma should be equal to sum of oscillator strengths from bound to continuum\\n sigma_oscsum = 2.0/3.0 * omega * np.sum(Dmo**2)\\n assert abs(sigma - sigma_oscsum) < 1.0e-4\\n \\n return sigma.real, beta.real\",\n \"def gen_phantom_parts(signal = (1.0, 1.0), s_res = .7, oversamp = 8, diam = (4, 6, 8, 10), n_frames = 20):\\n all_ves = []\\n for d in diam:\\n ves = gen_vessel(d, s_res/oversamp, oversamp, n_frames)\\n all_ves.append(ves)\\n\\n total_width = 0\\n max_height = 0\\n for ves in all_ves:\\n total_width += ves.shape[1]\\n max_height = max(max_height, ves.shape[2])\\n\\n velv = np.zeros((n_frames, total_width, max_height))\\n mask_crop = np.zeros((total_width, max_height))\\n\\n x_loc = 0\\n ves_count = 1\\n for ves in all_ves:\\n velv[:, x_loc:x_loc+ves.shape[1], int(max_height/2 - ves.shape[2]/2):int(max_height/2 + ves.shape[2]/2)] = ves\\n ves_mask = np.zeros((ves.shape[1], ves.shape[2]))\\n ves_mask[np.abs(ves).sum(0) > 0] = ves_count\\n mask_crop[x_loc:x_loc + ves.shape[1], int(max_height / 2 - ves.shape[2] / 2):int(max_height / 2 + ves.shape[2] / 2)] = ves_mask\\n x_loc += ves.shape[1]\\n ves_count += 1\\n\\n mag = np.zeros(( int(2*total_width), int(2*max_height)))\\n\\n [xx, yy] = np.meshgrid(np.linspace(-1, 1, mag.shape[0]), np.linspace(-1, 1, mag.shape[1]), indexing='ij')\\n rad = xx * xx + yy * yy\\n mag[rad < .90] = 1.0\\n\\n return mask_crop, mag, velv\",\n \"def fwd_odm(prev_pose, od_mov):\\n\\n x = prev_pose[0]\\n y = prev_pose[1]\\n theta = prev_pose[2]\\n\\n d = od_mov[0]\\n Phi1 = od_mov[1]\\n Phi2 = od_mov[2]\\n\\n\\n newx = x + d * cos(theta + Phi1)\\n newy = y + d * sin(theta + Phi1)\\n newtheta = theta + Phi1 + Phi2\\n\\n return (newx, newy, newtheta)\",\n \"def initW_spikeslab(self, theta, alpha=None):\\n\\n # Simualte ARD precision\\n if alpha is None:\\n alpha = self.initAlpha()\\n else:\\n assert not any([0 in a for a in alpha]), 'alpha cannot be zero'\\n\\n # Simulate bernoulli variable S\\n S = [ s.zeros((self.D[m],self.K)) for m in range(self.M) ]\\n for m in range(self.M):\\n\\n # Completely vectorised, not sure if it works\\n # S[m] = bernoulli.rvs(p=theta[m].flatten(), size=self.D[m]*self.K).reshape((self.D[m],self.K))\\n\\n # Partially vectorised\\n for k in range(self.K):\\n S[m][:,k] = bernoulli.rvs(p=theta[m][:,k], size=self.D[m])\\n \\n # Unvectorised\\n # for d in range(self.D[m]):\\n # for k in range(self.K):\\n # S[m][d,k] = bernoulli.rvs(p=theta[m][d,k], size=1)\\n\\n\\n # Simulate gaussian weights W\\n W_hat = [ s.empty((self.D[m],self.K)) for m in range(self.M) ]\\n W = [ s.empty((self.D[m],self.K)) for m in range(self.M) ]\\n for m in range(self.M):\\n for k in range(self.K):\\n W_hat[m][:,k] = norm.rvs(loc=0, scale=s.sqrt(1./alpha[m][k]), size=self.D[m])\\n W[m] = W_hat[m] * S[m]\\n\\n return S, W, W_hat, alpha\",\n \"def spherical_parameters(self):\\n phi_mu_list = []\\n theta_mu_list = []\\n \\n for mu in self.mu_list:\\n r, phi, theta = T_cartesian_to_spherical(x=mu[0], y=mu[1], z=mu[2])\\n phi_mu_list.append(phi)\\n theta_mu_list.append(theta)\\n \\n return phi_mu_list, theta_mu_list\",\n \"def MSPBE(self, theta):\\n V = np.array((theta * self.mu_phi).sum(axis=1))\\n V2 = self.gamma * np.array((theta * self.mu_phi_next).sum(axis=1))\\n return np.mean(np.array((V - np.dot(self.projection_operator(), V2 + self.mu_r))) ** 2)\",\n \"def augment_data(data, theta):\\n augmented_data = copy.deepcopy(data)\\n\\n for s in data:\\n for t in theta:\\n augmented_data.append([])\\n for chord in s:\\n if chord:\\n if min(chord) + t >= 0 and max(chord) + t <= 87:\\n augmented_data[-1].append(list(map(add, chord, [t] * len(chord))))\\n\\n return augmented_data\",\n \"def cartesian_to_spherical(self, v):\\n x = Vector.x(v)\\n y = Vector.y(v)\\n z = Vector.z(v)\\n r = Vector.length(v)\\n phi = atan2(y, x)\\n theta = acos(z / r)\\n \\n return [r, phi, theta]\",\n \"def _gen_r(theta, phi):\\n return _gen_u(theta, phi - np.pi / 2, phi + np.pi / 2)\",\n \"def Mt (theta, eta):\\n ut = np.array([np.cos(theta), np.sin(theta)])\\n mat = np.outer(ut,ut)\\n\\n M = np.sqrt(1+eta) * mat + np.sqrt(1-eta)*(np.eye(2)-mat) \\n\\n return M\",\n \"def serot(B, theta=45, DIRECTION=\\\"CLOCKWISE\\\"):\\n from string import upper\\n from numpy import array, sin, cos, transpose\\n from numpy import cos, sin, pi, concatenate, transpose, array\\n\\n DIRECTION = upper(DIRECTION) \\n if DIRECTION == \\\"ANTI-CLOCKWISE\\\":\\n theta = -theta\\n SA = mat2set(B)\\n theta = pi * theta//180\\n (y,v)=SA\\n if len(y)==0: return binary([0])\\n x0 = y[:,1] * cos(theta) - y[:,0] * sin(theta)\\n x1 = y[:,1] * sin(theta) + y[:,0] * cos(theta)\\n x0 = to_int32((x0 +0.5)*(x0>=0) + (x0-0.5)*(x0<0))\\n x1 = to_int32((x1 +0.5)*(x1>=0) + (x1-0.5)*(x1<0))\\n x = transpose(array([transpose(x1),transpose(x0)]))\\n BROT = set2mat((x,v))\\n return BROT\",\n \"def theta(self):\\n tmp = [self._get_one_param_theta(p) for p in self._LIST_PARAMETERS]\\n return np.hstack(tmp)\",\n \"def select_sv(y, s, r, ar, criterion_f):\\n # s: In sample size.\\n # r: Out sample size.\\n # ar:\\n\\n # Start timer.\\n start = time.time()\\n print(\\\"Started at:\\\", time.strftime(\\\"%H:%M:%S on %d-%m-%Y\\\"))\\n \\n t = len(y)\\n\\n delta = np.array([1]*22)\\n\\n # Calculate statistics from observed sample.\\n obs_stats = sum_stat.sv_stats(delta, y)\\n \\n # Generate out theta.\\n global theta_out\\n theta_out = [generate_theta_sv(ar) for i in range(r)]\\n theta_out = np.matrix(theta_out).T\\n\\n # Generate out sample of time series.\\n out_y = [sim.sim_sv(t, theta_out[0, i], theta_out[1, i], theta_out[2, i],\\n theta_out[3, i], 1) for i in range(r)]\\n\\n # Generate out sample statistics.\\n global stats_out\\n stats_out = [sum_stat.sv_stats(delta, out_y[i]) for i\\n in range(len(out_y))]\\n\\n # Standardize the out-of-sample parameters.\\n theta_out_mean = sum(theta_out.T)/r\\n u = sum([np.square(theta_out[:, i]-theta_out_mean.T) for i in range(r)])/r\\n theta_out = np.hstack([(theta_out[:, i] - theta_out_mean.T)/np.sqrt(u)\\n for i in range(r)])\\n global theta_out_sigma\\n theta_out_sigma = np.sqrt(u)\\n\\n # Standardize the out-of-sample statistics.\\n stats_out_mean = sum(stats_out)/r\\n u = sum([np.square(stats_out[i]-stats_out_mean) for i in range(r)])/r\\n stats_out = [(stats_out[i] - stats_out_mean)/np.sqrt(u) for i in range(r)]\\n\\n # Generate in theta.\\n global theta_initial\\n theta_initial = [generate_theta_sv(ar) for i in range(s)]\\n theta_initial = np.matrix(theta_initial).T\\n\\n # Generate in sample of time series.\\n in_y = [sim.sim_sv(t, theta_initial[0, i], theta_initial[1, i],\\n theta_initial[2, i], theta_initial[3, i], 1)\\n for i in range(s)]\\n\\n # Generate in sample statistics.\\n global stats_initial\\n stats_initial = [sum_stat.sv_stats(delta, in_y[i]) for i\\n in range(s)]\\n\\n # Standardize parameters used for estimation.\\n theta_initial_mean = sum(theta_initial.T)/s\\n u = sum([np.square(theta_initial[:, i]-theta_initial_mean.T)\\n for i in range(s)])/s\\n theta_initial = np.hstack([(theta_initial[:, i]\\n - theta_initial_mean.T)/np.sqrt(u)\\n for i in range(s)])\\n\\n global theta_in_sigma\\n global theta_in_mean\\n theta_in_sigma = np.sqrt(u)\\n theta_in_mean = theta_initial_mean\\n\\n # Standardize statistics for estimation.\\n stats_initial_mean = sum(stats_initial)/s\\n u = sum([np.square(stats_initial[i]-stats_initial_mean)\\n for i in range(s)])/s\\n stats_initial = [(stats_initial[i] - stats_initial_mean)/np.sqrt(u) for\\n i in range(s)]\\n\\n # Standardize statistics calculated from observed sample.\\n global obs_stats_standard\\n obs_stats_standard = (obs_stats - stats_initial_mean)/np.sqrt(u)\\n\\n # Guess delta.\\n delta = np.around(np.random.rand(1, 22)).flatten().astype(int)\\n\\n global criterion\\n criterion = criterion_f\\n\\n # Summary of sample sizes.\\n print(\\\"Out sample size:\\\", r)\\n print(\\\"In sample size:\\\", s)\\n print(\\\"Observed sample size:\\\", len(y))\\n print(\\\"Number of persistence parameters:\\\", ar)\\n\\n # Initiate binary annealing algorithm and assign tuning parameters.\\n print(\\\"Initial guess for delta is:\\\", delta)\\n print(\\\"Criterion function is:\\\", criterion)\\n opt = BinaryAnnealer(delta)\\n opt.Tmax = 0.10 # 0.25\\n opt.Tmin = 0.0001 # 0.001\\n opt.steps = len(delta)*10\\n opt.updates = len(delta)\\n print(\\\"Simmulated annealing parameters are:\\\")\\n print(\\\"Tmax:\\\", opt.Tmax)\\n print(\\\"Tmin:\\\", opt.Tmin)\\n print(\\\"Beginning simulated annealing at:\\\",\\n time.strftime(\\\"%H:%M:%S on %d-%m-%Y\\\"))\\n results = opt.anneal()\\n\\n results_file = open(\\\"annealing_results.txt\\\", \\\"a\\\")\\n results_file.write(\\\"### Results from annealing run finished at: \\\" +\\n time.strftime(\\\"%H:%M:%S on %d-%m-%Y\\\") + \\\" ###\\\\n\\\")\\n results_file.write(str(results) + \\\"\\\\n\\\")\\n results_file.close()\\n\\n print(\\\"Final selection and minimum are: \\\", results)\\n print(\\\"Finished at :\\\", time.strftime(\\\"%H:%M:%S on %d-%m-%Y\\\"))\\n print(\\\"Total time to run (in minutes):\\\", (time.time()-start)/60, \\\"\\\\n\\\")\\n\\n return results\",\n \"def get_transformation_matrix(theta=45):\\n\\n theta = theta/360 * 2 * np.pi # in radians\\n hx = np.cos(theta)\\n sy = np.sin(theta)\\n \\n S = np.array([[1, hx, 0],\\n [0, sy, 0],\\n [0, 0, 1]])\\n\\n return S\",\n \"def rot(theta):\\n cos = np.cos(theta)\\n sin = np.sin(theta)\\n return( np.array( [[cos, sin], [-sin, cos]] ) )\",\n \"def cartesian2spherical(v):\\n theta = np.arcsin(v[2]) \\n phi = np.arctan2(v[1], v[0])\\n \\n return [theta, phi]\",\n \"def propose_sample(self) -> np.array:\\n norm = np.random.normal\\n normal_deviates = norm(size=self.dim_observed)\\n r = np.sqrt((normal_deviates**2).sum(axis=0))\\n update = normal_deviates / r * self.radius\\n return self.theta + update\",\n \"def makeframe(draw, R, r, rho, t, phi, hypo=True):\\n if hypo:\\n Rr = R - r # difference in radii\\n i = 1\\n else:\\n Rr = R + r # sum in radii\\n i = -1\\n # sequence of angles from 0 up to t\\n tt = np.arange(0, t + 1, 1)\\n # coordinates of the smaller circle at various angle\\n centre = np.array([np.cos(tt * RADIANS), np.sin(tt * RADIANS)]).T * Rr\\n # angles of the \\\"dot\\\"\\n dd = (Rr / r * tt + phi) * RADIANS\\n # coordinates of the \\\"dot\\\" w.r.t. the centre of the inner circle\\n dotoffset = np.array([i * np.cos(dd), -np.sin(dd)]).T * rho\\n # actual coordinates of the \\\"dot\\\": this is the locus\\n dot = centre + dotoffset\\n # draw: big circle, small circle, the locus, radius, the dot\\n circle(draw, 0, 0, R)\\n circle(draw, centre[-1][0], centre[-1][1], r)\\n lines(draw, dot, color=\\\"#FF0000FF\\\")\\n lines(draw, [centre[-1], dot[-1]])\\n fillcircle(draw, dot[-1][0], dot[-1][1], 3, \\\"#FF0000FF\\\")\",\n \"def rot(phi, theta, omega):\\n\\n cos = jnp.cos(theta / 2)\\n sin = jnp.sin(theta / 2)\\n\\n return jnp.array(\\n [\\n [\\n jnp.exp(-0.5j * (phi + omega)) * cos,\\n -(jnp.exp(0.5j * (phi - omega))) * sin,\\n ],\\n [jnp.exp(-0.5j * (phi - omega)) * sin, jnp.exp(0.5j * (phi + omega)) * cos],\\n ]\\n )\",\n \"def sat_2d_pos(theta):\\n r_sat = a * (1 - e**2) / (1 + e * np.cos(theta))\\n return r_sat, theta\",\n \"def OxygenTransmission(T,P,n_wv,wavelength,dr,freq_lim=np.array([lp.c/770e-9,lp.c/768e-9]),sim_nu=np.array([]),spec_file=''):\\n # fraction of O2 by number density\\n fO2 = (32*0.2320+28.02*0.7547+44.01*0.00046+39.94*0.0128+20.18*0.000012+4.0*0.0000007+83.8*0.000003+131.29*0.00004)*0.2320/32.0\\n \\n if len(spec_file) == 0:\\n spec_file = '/Users/mhayman/Documents/DIAL/O2_HITRAN2012_760_781.txt'\\n \\n if sim_nu.size==0:\\n sim_nu = np.arange(-3e9,3e9,20e6)\\n \\n# inu0 = np.argmin(np.abs(sim_nu)) # index to center of frequency array\\n \\n n_o2=fO2*(P/(lp.kB*T)-n_wv) # to convert atm to Pa use *101325\\n ext_o2 = rb.ExtinctionFromHITRAN(lp.c/wavelength+sim_nu,T,P,(mO2*1e-3)/lp.N_A,nuLim=freq_lim,freqnorm=True,filename=spec_file).T\\n T_o2 = np.exp(-np.cumsum(n_o2[np.newaxis,:]*ext_o2,axis=1)*dr)\\n \\n return T_o2,sim_nu\",\n \"def _copy_cosineSequences(self, P):\\n self._.omega = P / diagonal_matrix(P[0])\",\n \"def spherical_to_cartesian(self, r, phi, theta):\\n x = r*cos(phi)*sin(theta)\\n y = r*sin(phi)*sin(theta)\\n z = r*cos(theta)\\n \\n return Vector(float(x), float(y), float(z))\",\n \"def MSBE_tar(self, theta):\\n V = np.array((theta * self.mu_phi_tar).sum(axis=1))\\n V2 = self.gamma * np.array((theta * self.mu_phi_next_tar).sum(axis=1))\\n return np.mean((V - V2 - self.mu_r_tar) ** 2)\",\n \"def _multi_term_cos(coef, power, multiplier, rho, theta):\\n \\n power2 = (coef + 1.) * -1.\\n return ((coef * np.power(rho, power2) + (power * np.power(rho, power))) * np.cos(multiplier * theta))\",\n \"def melting_temp_gc(seq):\\n\\n Na = 0.050 # log10([Na+] adjusts for the salt adjustment at 50 mM Na+\\n total_nucleotide = sum([(seq.count('A') + seq.count('T') + seq.count('G')+ seq.count('C'))])\\n\\n tm_marmurdoty = 64.9 + 41.0 * (((seq.count('G')+ seq.count('C')) -16.4)/ total_nucleotide)\\n\\n tm_howley = 100.5 + 41.0 * (((seq.count('G')+ seq.count('C')) -16.4 )/ total_nucleotide)\\n\\n - (820.0/total_nucleotide) + 16.6 * math.log10(Na)\\n \\n # result_tm = \\\"Melting Temp by:: Marmur:{},Howley:{}\\\".format(tm_marmurdoty,tm_howley)\\n result_tm = {\\\"mt_marmur\\\":tm_marmurdoty,\\\"mt_howley\\\":tm_howley}\\n return result_tm\",\n \"def spheric2cart(theta, phi):\\n x = np.sin(theta) * np.cos(phi)\\n y = np.sin(theta) * np.sin(phi)\\n z = np.cos(theta)\\n return x, y, z\",\n \"def f_theta_omega(angles, times):\\n # gravity = 9.81\\n # arm_length = 0.1 \\n\\n # omega = angles[0]\\n # theta = angles[1]\\n # ftheta = omega\\n # fomega = -(gravity/arm_length) * np.sin(theta)\\n pass\",\n \"def construct_MC_samples(self, N_MC):\\n D = self.theta[\\\"long_cov\\\"]\\n if self.MC_sep:\\n n_samples = self.n_samples\\n (U, V, y, N) = self.extracted_features[0]\\n n_long_features = self.n_long_features\\n phi = self.theta[\\\"phi\\\"]\\n beta = np.hstack((self.theta[\\\"beta_0\\\"], self.theta[\\\"beta_1\\\"]))\\n r = D.shape[0]\\n Omega = np.random.multivariate_normal(np.zeros(r), np.eye(r), N_MC)\\n S = np.zeros((n_samples, 2, 2 * N_MC, r))\\n\\n for i in range(n_samples):\\n U_i, V_i, y_i, N_i = U[i], V[i], y[i], N[i]\\n\\n # compute Sigma_i\\n Phi_i = [[1 / phi[l, 0]] * N_i[l]\\n for l in range(n_long_features)]\\n Sigma_i = np.diag(np.concatenate(Phi_i))\\n\\n # compute Omega_i\\n D_inv = np.linalg.inv(D)\\n A_i = np.linalg.inv(\\n V_i.transpose().dot(Sigma_i).dot(V_i) + D_inv)\\n # compute mu_i\\n mu_i = (A_i.dot(V_i.transpose()).dot(Sigma_i).dot(\\n y_i - U_i.dot(beta))).T[..., np.newaxis]\\n C_i = np.linalg.cholesky(A_i)\\n tmp = C_i.dot(Omega.T)\\n S[i] = (mu_i + np.hstack((tmp, -tmp))).swapaxes(1, 2)\\n else:\\n C = np.linalg.cholesky(D)\\n r = D.shape[0]\\n Omega = np.random.multivariate_normal(np.zeros(r), np.eye(r), N_MC)\\n b = Omega.dot(C.T)\\n S = np.vstack((b, -b))\\n\\n return S\",\n \"def test_merged_atmospheres(metallicity=0, gravity=4):\\n cast = get_castelli_atmosphere(temperature=8000, \\n metallicity=metallicity, gravity=gravity)\\n\\n ngen = get_nextgen_atmosphere(temperature=8000,\\n metallicity=metallicity, gravity=gravity)\\n\\n # Now Plot the spectra\\n py.figure(1)\\n py.clf()\\n py.loglog(cast.wave, cast.flux, 'r-', label='Castelli')\\n py.plot(ngen.wave, ngen.flux, 'b-', label='NextGen')\\n py.xlabel('Wavelength')\\n py.ylabel('Flux')\\n py.legend()\\n py.xlim(3000, 50000)\\n py.ylim(1e3, 1e8)\\n\\n\\n ngen = get_nextgen_atmosphere(temperature=4000,\\n metallicity=metallicity, gravity=gravity)\\n\\n phoe = get_phoenix_atmosphere(temperature=4000,\\n metallicity=metallicity, gravity=gravity)\\n # Now Plot the spectra\\n py.figure(2)\\n py.clf()\\n py.loglog(phoe.wave, phoe.flux, 'r-', label='Phoenix')\\n py.plot(ngen.wave, ngen.flux, 'b-', label='NextGen')\\n py.xlabel('Wavelength')\\n py.ylabel('Flux')\\n py.legend()\\n py.xlim(3000, 50000)\\n py.ylim(1, 1e8)\",\n \"def forward_theta(self):\\n SW = self.simplesphere.sphere_wrapper\\n for dm, m in enumerate(self.simplesphere.local_m):\\n m_data = [f.data[dm] for f in self.component_fields]\\n # Unpack for rank 0 to counteract shortcut bug in sphere_wrapper\\n if self.rank == 0:\\n m_data, = m_data\\n self.coeffs[dm] = SW.forward(m, self.rank, m_data)\",\n \"def sph_harm_gradient(m, l, r, theta, phi):\\n c_theta = sph_harm_diff_theta(m, l, theta, phi) / r\\n c_phi = sph_harm_diff_phi(m, l, theta, phi) / (r * np.sin(theta))\\n return np.array((0, c_theta, c_phi))\",\n \"def build_t_theta_pixel(N,theta_vec, tvec_set=None, circle=False):\\n\\n Nangle = len(theta_vec)\\n\\n if tvec_set is None:\\n if not circle:\\n N = int(np.ceil(N*np.sqrt(2)))\\n t_vec = np.sqrt(2) * np.arange(-N/2+0.5, N/2 ) \\n else:\\n t_vec = np.arange(-N/2+0.5, N/2 ) \\n else:\\n t_vec = tvec_set\\n\\n grid_t = npmat.repmat(t_vec,1,len(theta_vec))\\n grid_t = np.transpose(grid_t)\\n\\n grid_theta = np.tile(theta_vec,(len(t_vec),1)).T.flatten()\\n grid_theta = grid_theta.reshape(-1,1)\\n\\n return t_vec, grid_t, grid_theta\",\n \"def WaterVaporTransmission(T,P,n_wv,wavelength,dr,freq_lim=np.array([lp.c/828.5e-9,lp.c/828e-9]),sim_nu=np.array([])):\\n \\n if sim_nu.size==0:\\n sim_nu = np.arange(-3e9,3e9,20e6)\\n \\n ext_wv = rb.ExtinctionFromHITRAN(lp.c/wavelength+sim_nu,T,P,(lp.mH2O*1e-3)/lp.N_A,nuLim=freq_lim,freqnorm=True).T\\n T_wv = np.exp(-np.cumsum(n_wv[np.newaxis,:]*ext_wv,axis=1)*dr)\\n \\n return T_wv,sim_nu\",\n \"def vsh2(m, l, theta, phi):\\n c_theta = 1/np.sin(phi) * sph_harm_diff_theta(m, l, theta, phi)\\n c_phi = sph_harm_diff_phi(m, l, theta, phi)\\n return np.array((0, c_theta, c_phi))\",\n \"def plot_psf_vs_rad(self, theta=\\\"0 deg\\\", energy=u.Quantity(1, \\\"TeV\\\")):\\n theta = Angle(theta)\\n table = self.to_table_psf(energy=energy, theta=theta)\\n return table.plot_psf_vs_rad()\",\n \"def sample_spherical(self):\\n vec = np.random.randn(self.dims, self.arms)\\n vec /= np.linalg.norm(vec, axis=0)\\n self.contexts = vec.T\",\n \"def theta(self, theta):\\n self.kernel.theta = theta\",\n \"def rot(a, alpha, S, theta):\\n\\treturn np.array([ # eqn 3.7 pg 36\\n\\t\\t[cos(theta), -sin(theta), 0.0, a],\\n\\t\\t[sin(theta) * cos(alpha), cos(theta) * cos(alpha), -sin(alpha), -sin(alpha) * S],\\n\\t\\t[sin(theta) * sin(alpha), cos(theta) * sin(alpha), cos(alpha), cos(alpha) * S],\\n\\t\\t[0.0, 0.0, 0.0, 1.0]\\n\\t])\\n\\n\\t# return np.array([ # inverse of above ?? spong text\\n\\t# \\t[cos(theta), -sin(theta) * cos(alpha), sin(theta) * sin(alpha), cos(theta) * a],\\n\\t# \\t[sin(theta), cos(theta) * cos(alpha), -cos(theta) * sin(alpha), sin(theta) * a],\\n\\t# \\t[0, sin(alpha), cos(alpha), S],\\n\\t# \\t[0, 0, 0, 1]\\n\\t# ])\",\n \"def generate_lin_reg_sample(delta, s, r, sample_dim, obs_stats):\\n global theta_out\\n global stats_out\\n result = theta_and_stats(delta, r, sample_dim[0], sample_dim[1])\\n theta_out = result[0]\\n stats_out = result[1]\\n\\n # Standardize the out-of-sample parameters.\\n theta_out_mean = sum(theta_out.T)/r\\n u = sum([np.square(theta_out[:, i]-theta_out_mean.T) for i in range(r)])/r\\n theta_out = np.hstack([(theta_out[:, i] - theta_out_mean.T)/np.sqrt(u)\\n for i in range(r)])\\n global theta_out_sigma\\n theta_out_sigma = np.sqrt(u)\\n\\n # Standardize the out-of-sample statistics.\\n stats_out_mean = sum(stats_out)/r\\n u = sum([np.square(stats_out[i]-stats_out_mean) for i in range(r)])/r\\n stats_out = [(stats_out[i] - stats_out_mean)/np.sqrt(u) for i in range(r)]\\n\\n # Draw from the prior and caclulate summary statistics for estimation.\\n result = theta_and_stats(delta, s, sample_dim[0], sample_dim[1])\\n global theta_initial\\n global stats_initial\\n theta_initial = result[0]\\n stats_initial = result[1]\\n\\n # Standardize parameters used for estimation.\\n theta_initial_mean = sum(theta_initial.T)/s\\n u = sum([np.square(theta_initial[:, i]-theta_initial_mean.T)\\n for i in range(s)])/s\\n global theta_in_sigma\\n theta_in_sigma = np.sqrt(u)\\n theta_initial = np.hstack([(theta_initial[:, i]\\n - theta_initial_mean.T)/np.sqrt(u)\\n for i in range(s)])\\n \\n # Standardize statistics for estimation.\\n stats_initial_mean = sum(stats_initial)/s\\n u = sum([np.square(stats_initial[i]-stats_initial_mean)\\n for i in range(s)])/s\\n stats_initial = [(stats_initial[i] - stats_initial_mean)/np.sqrt(u) for\\n i in range(s)]\\n\\n # Standardize statistics calculated from observed sample.\\n global obs_stats_standard\\n obs_stats_standard = (obs_stats - stats_initial_mean)/np.sqrt(u)\",\n \"def generate_parameter_sample(self, t): \\n \\n theta_hat = np.zeros(self.K) \\n k = np.random.choice(self.Npar, 1, p=self.w)[0] # np.random.choice outputs an array\\n theta_hat = self.Particles[k] \\n return theta_hat\",\n \"def theta_hat( self, i, hidden_values ):\\n assert len(hidden_values) == len(self.hidden)\\n theta = matrix(self.observed[i].phi)\\n for j, h in enumerate(hidden_values):\\n assert self.hidden[j].family._check_u(h)\\n update = self.W[i,j] * asmatrix(h).T\\n theta += update.T\\n return theta.A.reshape( (self.observed[i].family.size()) )\",\n \"def cthick(f, g, Iab=None, n=-1, theta=45, DIRECTION=\\\"CLOCKWISE\\\"):\\n from numpy import product\\n from string import upper\\n if Iab is None: Iab = homothick()\\n DIRECTION = upper(DIRECTION) \\n assert isbinary(f),'f must be binary image'\\n if n == -1: n = product(f.shape)\\n y = f\\n old = y\\n for i in xrange(n):\\n for t in xrange(0,360,theta):\\n sup = supgen( y, interot(Iab, t, DIRECTION))\\n y = intersec(union( y, sup),g)\\n if isequal(old,y): break\\n old = y\\n return y\",\n \"def pegasos(feature_matrix, labels, T, L):\\n theta = np.zeros((feature_matrix.shape[1],))\\n theta_0 = 0\\n update_counter = 0 # number_of updates\\n for t in range(T):\\n for i in get_order(feature_matrix.shape[0]):\\n update_counter += 1\\n eta = 1.0 / np.sqrt(update_counter)\\n theta, theta_0 = pegasos_single_step_update(\\n feature_matrix[i],\\n labels[i],\\n L,\\n eta,\\n theta,\\n theta_0)\\n return theta, theta_0\",\n \"def _cmd_export_theta(args):\\n tumor_cn = read_cna(args.tumor_segment)\\n normal_cn = read_cna(args.reference) if args.reference else None\\n table = export.export_theta(tumor_cn, normal_cn)\\n if not args.output:\\n args.output = tumor_cn.sample_id + \\\".interval_count\\\"\\n table.to_csv(args.output, sep=\\\"\\\\t\\\", index=False)\\n logging.info(\\\"Wrote %s\\\", args.output)\\n if args.vcf:\\n variants = load_het_snps(\\n args.vcf,\\n args.sample_id, # or tumor_cn.sample_id,\\n args.normal_id,\\n args.min_variant_depth,\\n args.zygosity_freq,\\n )\\n if not len(variants):\\n raise ValueError(\\\"VCF contains no usable SNV records\\\")\\n try:\\n tumor_snps, normal_snps = export.export_theta_snps(variants)\\n except ValueError as exc:\\n raise ValueError(\\n \\\"VCF does not contain any tumor-normal paired samples\\\"\\n ) from exc\\n for title, table in [(\\\"tumor\\\", tumor_snps), (\\\"normal\\\", normal_snps)]:\\n out_fname = f\\\"{tumor_cn.sample_id}.{title}.snp_formatted.txt\\\"\\n table.to_csv(out_fname, sep=\\\"\\\\t\\\", index=False)\\n logging.info(\\\"Wrote %s\\\", out_fname)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5524242","0.5429524","0.539759","0.5299873","0.5297758","0.52611303","0.5256927","0.52566576","0.52441525","0.5228684","0.5216859","0.51940954","0.5164453","0.5148786","0.51425505","0.51343614","0.513167","0.51285547","0.5123628","0.5120493","0.51005423","0.5092579","0.50549173","0.50468886","0.50388557","0.5017623","0.5015748","0.50118434","0.50078505","0.50055254","0.500311","0.4997146","0.49898794","0.4982144","0.49587798","0.49537122","0.49348277","0.49160627","0.49134886","0.49096417","0.49081838","0.4901029","0.4901029","0.48915574","0.48893633","0.48862517","0.4877193","0.4865695","0.48551512","0.4854766","0.48404825","0.48393738","0.48291767","0.48283753","0.48269635","0.48262993","0.4825418","0.48244342","0.48239684","0.4816441","0.4802665","0.48021653","0.47971362","0.47946346","0.47887403","0.47838017","0.4782073","0.4776945","0.47685793","0.4768064","0.476741","0.4763651","0.4754563","0.47442505","0.47416598","0.47374567","0.47364148","0.47349524","0.47269943","0.47254997","0.4720639","0.47165704","0.47117326","0.4703796","0.4701457","0.4696779","0.4682627","0.46785188","0.4672692","0.4672508","0.46669465","0.46611115","0.46596673","0.46556193","0.46536508","0.4652915","0.46499813","0.46477738","0.46464878","0.46438745","0.46400794"],"string":"[\n \"0.5524242\",\n \"0.5429524\",\n \"0.539759\",\n \"0.5299873\",\n \"0.5297758\",\n \"0.52611303\",\n \"0.5256927\",\n \"0.52566576\",\n \"0.52441525\",\n \"0.5228684\",\n \"0.5216859\",\n \"0.51940954\",\n \"0.5164453\",\n \"0.5148786\",\n \"0.51425505\",\n \"0.51343614\",\n \"0.513167\",\n \"0.51285547\",\n \"0.5123628\",\n \"0.5120493\",\n \"0.51005423\",\n \"0.5092579\",\n \"0.50549173\",\n \"0.50468886\",\n \"0.50388557\",\n \"0.5017623\",\n \"0.5015748\",\n \"0.50118434\",\n \"0.50078505\",\n \"0.50055254\",\n \"0.500311\",\n \"0.4997146\",\n \"0.49898794\",\n \"0.4982144\",\n \"0.49587798\",\n \"0.49537122\",\n \"0.49348277\",\n \"0.49160627\",\n \"0.49134886\",\n \"0.49096417\",\n \"0.49081838\",\n \"0.4901029\",\n \"0.4901029\",\n \"0.48915574\",\n \"0.48893633\",\n \"0.48862517\",\n \"0.4877193\",\n \"0.4865695\",\n \"0.48551512\",\n \"0.4854766\",\n \"0.48404825\",\n \"0.48393738\",\n \"0.48291767\",\n \"0.48283753\",\n \"0.48269635\",\n \"0.48262993\",\n \"0.4825418\",\n \"0.48244342\",\n \"0.48239684\",\n \"0.4816441\",\n \"0.4802665\",\n \"0.48021653\",\n \"0.47971362\",\n \"0.47946346\",\n \"0.47887403\",\n \"0.47838017\",\n \"0.4782073\",\n \"0.4776945\",\n \"0.47685793\",\n \"0.4768064\",\n \"0.476741\",\n \"0.4763651\",\n \"0.4754563\",\n \"0.47442505\",\n \"0.47416598\",\n \"0.47374567\",\n \"0.47364148\",\n \"0.47349524\",\n \"0.47269943\",\n \"0.47254997\",\n \"0.4720639\",\n \"0.47165704\",\n \"0.47117326\",\n \"0.4703796\",\n \"0.4701457\",\n \"0.4696779\",\n \"0.4682627\",\n \"0.46785188\",\n \"0.4672692\",\n \"0.4672508\",\n \"0.46669465\",\n \"0.46611115\",\n \"0.46596673\",\n \"0.46556193\",\n \"0.46536508\",\n \"0.4652915\",\n \"0.46499813\",\n \"0.46477738\",\n \"0.46464878\",\n \"0.46438745\",\n \"0.46400794\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":25591,"cells":{"query":{"kind":"string","value":"Get the SED of one component for a multicomponent composite SFH. Should set this up to work as an iterator."},"document":{"kind":"string","value":"def one_sed(self, component_index=0, filterlist=[]):\n # Pass the model parameters through to the sps object, and keep track\n # of the mass of this component\n mass = 1.0\n for k, vs in list(self.params.items()):\n try:\n v = vs[component_index]\n except(IndexError, TypeError):\n v = vs\n if k in self.csp.params.all_params:\n if k == 'zmet':\n vv = np.abs(v - (np.arange(len(self.csp.zlegend)) + 1)).argmin() + 1\n else:\n vv = v.copy()\n self.csp.params[k] = vv\n if k == 'mass':\n mass = v\n # Now get the magnitudes and spectrum. The spectrum is in units of\n # Lsun/Hz/per solar mass *formed*\n w, spec = self.csp.get_spectrum(tage=self.csp.params['tage'], peraa=False)\n mags = getSED(w, lightspeed/w**2 * spec * to_cgs, filterlist)\n mfrac = self.csp.stellar_mass\n if np.all(self.params.get('mass_units', 'mstar') == 'mstar'):\n # Convert normalization units from per stellar masss to per mass formed\n mass /= mfrac\n # Output correct units\n return mass * spec, mass * 10**(-0.4*(mags)), mfrac"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getComponent(self):\n return _libsbml.SpeciesFeature_getComponent(self)","def getComponent(self):\n return _libsbml.SubListOfSpeciesFeatures_getComponent(self)","def __iter__(self):\n return self.cli.essids.essids().__iter__()","def getComponent(self):\n return _libsbml.SpeciesTypeComponentIndex_getComponent(self)","def C ( self ) :\n lst = [ i for i in self.__nums_components ]\n if not lst : return () ## extended fit? no other components?\n elif 1 == len(lst) : return lst[0] ## single component?\n return tuple ( lst )","def C ( self ) :\n lst = [ i for i in self.__nums_components ]\n if not lst : return () ## extended fit? no other components?\n elif 1 == len(lst) : return lst[0] ## single component?\n return tuple ( lst )","def __iter__(self):\n return self.essids.__iter__()","def getCompartment(self):\n return _libsbml.MultiSpeciesType_getCompartment(self)","def get_component():\n\t\tcomponentConsumed = consumed\n\t\tfor i in range(len(components)):\n\t\t\tif componentConsumed < len(components[-i]):\n\t\t\t\treturn components[-i][:-componentConsumed if componentConsumed else None]\n\t\t\telse:\n\t\t\t\tcomponentConsumed -= len(components[-i])\n\t\treturn []","def scissors(self):\n all_h = True if 'all_h' in self.bdes else False\n if all_h:\n self.bdes.pop(self.bdes.index('all_h'))\n for entry in self.bdes:\n if len(entry) != 2:\n raise SpeciesError('Could not interpret entry {0} in {1} for BDEs calculations.'.format(\n entry, self.bdes))\n if not isinstance(entry, (tuple, list)):\n raise SpeciesError('`indices` entries must be tuples or lists, got {0} which is a {1} in {2}'.format(\n entry, type(entry), self.bdes))\n self.bdes = [tuple(bde) for bde in self.bdes]\n if all_h:\n for atom1 in self.mol.atoms:\n if atom1.isHydrogen():\n for atom2, bond12 in atom1.edges.items():\n if bond12.isSingle():\n atom_indices = (self.mol.atoms.index(atom2) + 1, self.mol.atoms.index(atom1) + 1)\n atom_indices_reverse = (atom_indices[1], atom_indices[0])\n if atom_indices not in self.bdes and atom_indices_reverse not in self.bdes:\n self.bdes.append(atom_indices)\n resulting_species = list()\n for index_tuple in self.bdes:\n new_species_list = self._scissors(indices=index_tuple)\n for new_species in new_species_list:\n if new_species.label not in [existing_species.label for existing_species in resulting_species]:\n # mainly checks that the H species doesn't already exist\n resulting_species.append(new_species)\n return resulting_species","def get_component(self):\n component = []\n component = [self.component_type, self.component_value, self.spot]\n\n if component[2] != None:\n print component\n return component","def component(self, index):\n return self.components[index]","def component(self):\n return self._component","def component(self):\n return self._component","def get_component(self, sCompName):\n return self._dComponents.get(sCompName, None)","def getProductComponent(self):\n return _libsbml.SpeciesTypeComponentMapInProduct_getProductComponent(self)","def get(self, entity):\n\t\treturn entity.get_component(self.component_type)","def get_compss_module(self):\n return self.compss_module","def from_ical(st, multiple=False):\n stack = [] # a stack of components\n comps = []\n for line in Contentlines.from_ical(st): # raw parsing\n if not line:\n continue\n name, params, vals = line.parts()\n uname = name.upper()\n # check for start of component\n if uname == 'BEGIN':\n # try and create one of the components defined in the spec,\n # otherwise get a general Components for robustness.\n c_name = vals.upper()\n c_class = component_factory.get(c_name, Component)\n component = c_class()\n if not getattr(component, 'name', ''): # undefined components\n component.name = c_name\n stack.append(component)\n # check for end of event\n elif uname == 'END':\n # we are done adding properties to this component\n # so pop it from the stack and add it to the new top.\n component = stack.pop()\n if not stack: # we are at the end\n comps.append(component)\n else:\n if not component.is_broken:\n stack[-1].add_component(component)\n # we are adding properties to the current top of the stack\n else:\n factory = types_factory.for_property(name)\n component = stack[-1]\n try:\n if name in ('DTSTART', 'DTEND', 'RECURRENCE-ID')\\\n and 'TZID' in params: # TODO: add DUE, FREEBUSY, RDATE, EXDATE ..\n vals = factory(factory.from_ical(vals, params['TZID']))\n else:\n vals = factory(factory.from_ical(vals))\n except ValueError:\n if not component.ignore_exceptions:\n raise\n component.is_broken = True\n else:\n vals.params = params\n component.add(name, vals, encode=0)\n\n if multiple:\n return comps\n if len(comps) > 1:\n raise ValueError('Found multiple components where '\n 'only one is allowed: {st!r}'.format(**locals()))\n if len(comps) < 1:\n raise ValueError('Found no components where '\n 'exactly one is required: '\n '{st!r}'.format(**locals()))\n return comps[0]","def get_component(self, name):\n for cmpt in self.components:\n if cmpt['name'] == name:\n return cmpt","def iter_components(self):\n return self.components.values()","def ThisComponent(self):\n comp = self.StarDesktop.getCurrentComponent()\n if comp is None:\n return None\n impl = comp.ImplementationName\n if impl in ('com.sun.star.comp.basic.BasicIDE', 'com.sun.star.comp.sfx2.BackingComp'):\n return None # None when Basic IDE or welcome screen\n return comp","def component(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"component\")","def getCompartment(self):\n return _libsbml.Species_getCompartment(self)","def components(self):\n return self._components","def get_component_html(self, harmonization_unit):\n source = [tr.get_name_link_html() for tr in (\n self.component_source_traits.all() & harmonization_unit.component_source_traits.all())]\n harmonized_trait_set_versions = [trait_set_version for trait_set_version in (\n self.component_harmonized_trait_set_versions.all() &\n harmonization_unit.component_harmonized_trait_set_versions.all())]\n harmonized = [tr.get_name_link_html() for trait_set in harmonized_trait_set_versions\n for tr in trait_set.harmonizedtrait_set.all()\n if not tr.i_is_unique_key]\n component_html = ''\n if len(source) > 0:\n trait_list = '\\n'.join([LIST_ELEMENT_HTML.format(element=trait) for trait in source])\n component_html += INLINE_LIST_HTML.format(\n list_title='Component study variables for {}'.format(self.trait_flavor_name),\n list_elements=trait_list)\n if len(harmonized) > 0:\n trait_list = '\\n'.join([LIST_ELEMENT_HTML.format(element=trait) for trait in harmonized])\n component_html += '\\n' + INLINE_LIST_HTML.format(\n list_title='Component harmonized variables for {}'.format(self.trait_flavor_name),\n list_elements=trait_list)\n return component_html","def SS ( self ) :\n return self.__ss","def SS ( self ) :\n return self.__ss","def cse_elastic(energy, elements, stoic):\n i = 0\n cs_el = 0\n gamma = float(1.+energy/ElectronMass)\n beta = sqrt(1.-1./(gamma*gamma))\n for Z in elements:\n Z = float(Z)\n cs_el += 1.0e-14*1.4e-6*(Z**1.5)*(1.-(0.26*Z/(137.*beta)))/(beta*beta)*stoic[i]\n i += 1\n\n return cs_el","def computerhs(self, ue1, inletf, t, a, alpha, msh, Minv, S):\n # compute all edge fluxes (loop over all edges)\n flux = self.computeF(ue1, inletf, t, a, alpha, msh)\n #print 'flux=',flux\n\n # update DG elements (could be done in parallel)\n #ne = ue1.shape[1]\n rhs = np.zeros(msh.nu)\n for el in msh.elms:\n rhs[el.idx:el.idx+el.nnod] = self.computerhs1e(ue1, el, flux, a, Minv, S)\n #print 'rhs=', rhs\n return rhs","def components_for_entity(eman, entity, components):\n\n return tuple(eman.component_for_entity(entity, c) for c in components)","def get_components(state: ChemicalSystem) -> ParseCompRet:\n def _get_single_comps(comp_list, comptype):\n ret_comps = [comp for comp in comp_list\n if isinstance(comp, comptype)]\n if ret_comps:\n return ret_comps[0]\n else:\n return None\n\n solvent_comp: Optional[SolventComponent] = _get_single_comps(\n list(state.values()), SolventComponent\n )\n\n protein_comp: Optional[ProteinComponent] = _get_single_comps(\n list(state.values()), ProteinComponent\n )\n\n small_mols = []\n for comp in state.components.values():\n if isinstance(comp, SmallMoleculeComponent):\n small_mols.append(comp)\n\n return solvent_comp, protein_comp, small_mols","def getElementBySId(self, *args):\n return _libsbml.CompModelPlugin_getElementBySId(self, *args)","def getElementBySId(self, *args):\n return _libsbml.CompSBasePlugin_getElementBySId(self, *args)","def output_multiple(self):\n return _spacegrant_swig.ax25_pdu_unpacker_sptr_output_multiple(self)","def components(self):\r\n return list(self._components)","def getCompartment(self):\n return _libsbml.QualitativeSpecies_getCompartment(self)","def get(self, participant_id, session_id, component_id):\n \n query = \"\"\"\n select distinct * where {\n\n BIND (\"%s\" AS ?pid)\n BIND (%s as ?sessionid)\n BIND (\"%s\" as ?shortname)\n \n ?participant austalk:id ?pid .\n ?rc rdf:type austalk:RecordedComponent .\n ?rc olac:speaker ?participant . \n \n }\n \"\"\" % (participant_id, session_id, component_id)\n\n sparql_results = self.query (query)\n\n bindings = sparql_results[\"results\"][\"bindings\"]\n if len(bindings) == 1:\n comp = Component (\n client = self.client,\n identifier = sparql_results[\"rc\"][\"value\"], \n participantId = sparql_results[\"pid\"][\"value\"],\n sessionId = sparql_results[\"sessionid\"][\"value\"],\n )\n comp.details()\n return comp\n else:\n return None","def an_element(self):\n return self.semigroup_generators()[0]","def getSpecies(self):\n return _libsbml.SimpleSpeciesReference_getSpecies(self)","def _parse_composite(\n composite: Union[mapry.Class, mapry.Embed], py: mapry.Py) -> str:\n references = mapry.references(a_type=composite)\n\n # yapf: disable\n registry_exprs = {\n ref_cls: '{}_registry'.format(\n mapry.py.naming.as_variable(ref_cls.plural))\n for ref_cls in references\n }\n # yapf: enable\n\n auto_id = mapry.py.generate.AutoID()\n\n # yapf: disable\n property_parsing = {\n prop: _parse_property(\n target_obj_expr=\"target\",\n value_obj_expr=\"value\",\n ref_obj_parts=[\"ref\"],\n a_property=prop,\n registry_exprs=registry_exprs,\n auto_id=auto_id,\n py=py)\n for prop in composite.properties.values()\n }\n # yapf: enable\n\n return _PARSE_COMPOSITE_TPL.render(\n composite=composite,\n is_class=isinstance(composite, mapry.Class),\n references=references,\n property_parsing=property_parsing,\n py=py)","def get_components(self):\n Phi = (self.image_vec - self.mean_face) / self.std_face\n A = Phi\n C = np.matmul(A, A.T)\n C = np.divide(C, self.num_examples - 1)\n evals, Vi = np.linalg.eigh(C)\n z = list(zip(evals, Vi))\n z.sort(reverse=True)\n idx = np.argsort(evals)[::-1]\n pc = Vi[:, idx]\n pc = pc[:, :self.k]\n\n # final components (num pixels by k matrix)\n components = np.matmul(A.T, pc)\n components = components / np.linalg.norm(components, axis=0)\n # get singluar values\n sorted_evals = np.array([x[0] for x in z])\n postive_evals = sorted_evals[:self.k]\n singular_values = np.sqrt(postive_evals.reshape(1, -1))\n\n return components, singular_values","def components(self):\n with sql_connection.TRN as TRN:\n sql = \"\"\"SELECT input_composition_id, input_volume\n FROM qiita.pool_composition_components\n JOIN qiita.pool_composition\n ON output_pool_composition_id = pool_composition_id\n JOIN qiita.composition USING (composition_id)\n WHERE upstream_process_id = %s\n ORDER BY pool_composition_components_id\"\"\"\n TRN.add(sql, [self.process_id])\n return [(composition_module.Composition.factory(comp_id), vol)\n for comp_id, vol in TRN.execute_fetchindex()]","def S(self):\n return self._S","def component(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"component\")","def setComponent(self, *args):\n return _libsbml.SubListOfSpeciesFeatures_setComponent(self, *args)","def at_SES(self):\n\t t = self.t\n\t dM = self.dM\n\t rLbl = transLabel(t,self.P,self.t0,self.tdur*2)\n\n\t # Hack. K2 doesn't have seasons\n\t q = np.zeros(t.size) - 1\n\t season = np.mod(q,4)\n\t dtype = [('ses',float),('tnum',int),('season',int)]\n\t dM.fill_value = np.nan\n\t rses = np.array(list(zip(dM.filled(),rLbl['tLbl'],season)),dtype=dtype )\n\t rses = rses[ rLbl['tLbl'] >= 0 ]\n\n\t # If no good transits, break out\n\t if rses.size==0:\n\t return\n\n\t self.add_dset('rLbl',rLbl,\n\t description='Transit/continuum labeled (see transLabel doc string')\n\t self.add_dset('SES',rses,\n\t description='Record array with single event statistic')\n\t self.add_attr('num_trans',rses.size,\n\t description='Number of good transits')\n\n\t # Median SES, even/odd\n\t for sfx,i in zip(['even','odd'],[0,1]):\n\t medses = np.median( rses['ses'][rses['tnum'] % 2 == i] ) \n\t self.add_attr('SES_%s' % sfx, medses,\n\t description='Median SES %s' % sfx)\n\n\t # Median SES, different seasons\n\t for i in range(4):\n\t medses = -99 #Hack\n\t self.add_attr('SES_%i' % i, medses,\n\t description='Median SES [Season %i]' % i )","def at_SES(self):\n\t t = self.t\n\t dM = self.dM\n\t rLbl = transLabel(t,self.P,self.t0,self.tdur*2)\n\n\t # Hack. K2 doesn't have seasons\n\t q = np.zeros(t.size) - 1\n\t season = np.mod(q,4)\n\t dtype = [('ses',float),('tnum',int),('season',int)]\n\t dM.fill_value = np.nan\n\t rses = np.array(list(zip(dM.filled(),rLbl['tLbl'],season)),dtype=dtype )\n\t rses = rses[ rLbl['tLbl'] >= 0 ]\n\n\t # If no good transits, break out\n\t if rses.size==0:\n\t return\n\n\t self.add_dset('rLbl',rLbl,\n\t description='Transit/continuum labeled (see transLabel doc string')\n\t self.add_dset('SES',rses,\n\t description='Record array with single event statistic')\n\t self.add_attr('num_trans',rses.size,\n\t description='Number of good transits')\n\n\t # Median SES, even/odd\n\t for sfx,i in zip(['even','odd'],[0,1]):\n\t medses = np.median( rses['ses'][rses['tnum'] % 2 == i] ) \n\t self.add_attr('SES_%s' % sfx, medses,\n\t description='Median SES %s' % sfx)\n\n\t # Median SES, different seasons\n\t for i in range(4):\n\t medses = -99 #Hack\n\t self.add_attr('SES_%i' % i, medses,\n\t description='Median SES [Season %i]' % i )","def _get_linkable_component(script):\n component = None\n for c in script.components:\n if isinstance(c, SessionComponent):\n return c\n if isinstance(c, SpecialMixerComponent) and not c.is_return_mixer:\n component = c\n\n if component is None:\n if hasattr(script, '_session_ring'):\n return script._session_ring\n return component","def components(self):\n skel = self.clone()\n forest = self._compute_components(skel)\n \n if len(forest) == 0:\n return []\n elif len(forest) == 1:\n return [ skel ]\n\n skeletons = []\n for edge_list in forest:\n edge_list = np.array(edge_list, dtype=np.uint32)\n vert_idx = fastremap.unique(edge_list)\n\n vert_list = skel.vertices[vert_idx]\n radii = skel.radii[vert_idx]\n vtypes = skel.vertex_types[vert_idx]\n\n remap = { vid: i for i, vid in enumerate(vert_idx) }\n edge_list = fastremap.remap(edge_list, remap, in_place=True)\n\n skeletons.append(\n Skeleton(vert_list, edge_list, radii, vtypes, skel.id)\n )\n\n return skeletons","def getSpeciesTypeComponentIndex(self, *args):\n return _libsbml.MultiSpeciesType_getSpeciesTypeComponentIndex(self, *args)","def get_component_html(self):\n study_list = '\\n'.join([study.get_name_link_html() for study in self.get_source_studies()])\n age_list = '\\n'.join([trait.get_name_link_html() for trait in self.component_age_traits.all()])\n component_html = '\\n'.join([\n trait.get_component_html(harmonization_unit=self) for trait in self.harmonizedtrait_set.all()])\n panel_body = []\n if len(study_list) > 0:\n study_html = INLINE_LIST_HTML.format(list_title='Included studies', list_elements=study_list)\n panel_body.append(study_html)\n if len(age_list) > 0:\n age_html = INLINE_LIST_HTML.format(list_title='Component age variables', list_elements=age_list)\n panel_body.append(age_html)\n panel_body.append(component_html)\n panel_body = '\\n'.join(panel_body)\n unit_panel = PANEL_HTML.format(panel_title='Harmonization unit: {}'.format(self.i_tag), panel_body=panel_body)\n return unit_panel","def _component_specs(self):\n specs = dict(pretransformed_input=self._input_spec)\n if self._transform_is_composite:\n specs['bijector'] = self.transform_or_spec\n return specs","def getComponent(self):\n return self.flowComponent","def get_con_sf(self, j):\n return self.je[ self.ie[j] : self.ie[j+1] ]","def setComponent(self, *args):\n return _libsbml.SpeciesFeature_setComponent(self, *args)","def get_ccs_subsystem(subsystems):\n for item in subsystems:\n try:\n check_serial_number(item)\n return item\n except RebTestingException:\n pass\n message = \"No CCS subsystem found for REB %s.\" % siteUtils.getUnitId()\n raise RebTestingException(message)","def components(self):\n # The '_components' attribute is defined according to the\n # subclass of Dyadic the instance belongs to.\n return self._components","def components(self):\n return self.__components","def components(self):\n return self.__components","def find_component(component):\n if component == 'C1':\n return C1\n elif component == 'C2':\n return C2\n elif component == 'C3':\n return C3\n elif component == 'C4':\n return C4\n elif component == 'C5':\n return C5\n elif component == 'C6':\n return C6\n elif component == 'AS':\n return AS","def _get_component(self):\n return AssemblyComponent.ByKeys(**self.db_key)","def get_description(self):\n return COMPONENT_LIST[self.index][1]","def species(self):\n\n return self._species","def species(self):\n\n return self._species","def _scissors(self, indices):\n if any([i < 1 for i in indices]):\n raise SpeciesError('Indices must be larger than 0')\n if not all([isinstance(i, int) for i in indices]):\n raise SpeciesError('Indices must be integers')\n if self.final_xyz is None:\n raise SpeciesError('Cannot use scissors without the .final_xyz attribute of species {0}'.format(self.label))\n indices = (indices[0] - 1, indices[1] - 1) # convert to 0-indexed atoms\n atom1 = self.mol.atoms[indices[0]]\n atom2 = self.mol.atoms[indices[1]]\n if atom1.isHydrogen():\n top1 = [self.mol.atoms.index(atom1)]\n top2 = [i for i in range(len(self.mol.atoms)) if i not in top1]\n elif atom2.isHydrogen():\n top2 = [self.mol.atoms.index(atom2)]\n top1 = [i for i in range(len(self.mol.atoms)) if i not in top2]\n else:\n # for robustness, only use the smaller top,\n # determine_top_group_indices() might get confused for (large) convolved tops.\n top1 = conformers.determine_top_group_indices(self.mol, atom1, atom2, index=0)[0]\n top2 = conformers.determine_top_group_indices(self.mol, atom2, atom1, index=0)[0]\n if len(top1) > len(top2):\n top1 = [i for i in range(len(self.mol.atoms)) if i not in top2]\n elif len(top2) > len(top1):\n top2 = [i for i in range(len(self.mol.atoms)) if i not in top1]\n split_xyz = self.final_xyz.splitlines()\n xyz1 = '\\n'.join([split_xyz[i] for i in top1])\n xyz2 = '\\n'.join([split_xyz[i] for i in top2])\n xyz1, xyz2 = translate_to_center_of_mass(xyz1), translate_to_center_of_mass(xyz2)\n\n mol_copy = self.mol.copy(deep=True)\n # We are about to change the connectivity of the atoms in the molecule,\n # which invalidates any existing vertex connectivity information; thus we reset it.\n mol_copy.resetConnectivityValues()\n atom1 = mol_copy.atoms[indices[0]] # Note: redefining atom1 and atom2\n atom2 = mol_copy.atoms[indices[1]]\n if not mol_copy.hasBond(atom1, atom2):\n raise SpeciesError('Attempted to remove a nonexistent bond.')\n bond = mol_copy.getBond(atom1, atom2)\n mol_copy.removeBond(bond)\n mol1, mol2 = mol_copy.split()\n\n used_a_label = False\n if len(mol1.atoms) == 1 and mol1.atoms[0].isHydrogen():\n label1 = 'H'\n else:\n label1 = self.label + '_BDE_' + str(indices[0] + 1) + '_' + str(indices[1] + 1) + '_A'\n used_a_label = True\n if len(mol2.atoms) == 1 and mol2.atoms[0].isHydrogen():\n label2 = 'H'\n else:\n letter = 'B' if used_a_label else 'A'\n label2 = self.label + '_BDE_' + str(indices[0] + 1) + '_' + str(indices[1] + 1) + '_' + letter\n\n added_radical = list()\n for mol, label in zip([mol1, mol2], [label1, label2]):\n for atom in mol.atoms:\n theoretical_charge = elements.PeriodicSystem.valence_electrons[atom.symbol] \\\n - atom.getBondOrdersForAtom() \\\n - atom.radicalElectrons -\\\n 2 * atom.lonePairs\n if theoretical_charge == atom.charge + 1:\n # we're missing a radical electron on this atom\n if label not in added_radical or label == 'H':\n atom.radicalElectrons += 1\n added_radical.append(label)\n else:\n raise SpeciesError('Could not figure out which atom should gain a radical '\n 'due to scission in {0}'.format(self.label))\n mol1.update()\n mol2.update()\n\n # match xyz to mol:\n if len(mol1.atoms) != len(mol2.atoms):\n # easy\n if len(mol1.atoms) != len(top1):\n xyz1, xyz2 = xyz2, xyz1\n else:\n # harder\n element_dict_mol1, element_dict_top1 = dict(), dict()\n for atom in mol1.atoms:\n if atom.element.symbol in element_dict_mol1:\n element_dict_mol1[atom.element.symbol] += 1\n else:\n element_dict_mol1[atom.element.symbol] = 1\n for i in top1:\n atom = mol_copy.atoms[i - 1]\n if atom.element.symbol in element_dict_top1:\n element_dict_top1[atom.element.symbol] += 1\n else:\n element_dict_top1[atom.element.symbol] = 1\n for element, count in element_dict_mol1.items():\n if element not in element_dict_top1 or count != element_dict_top1[element]:\n xyz1, xyz2 = xyz2, xyz1\n\n spc1 = ARCSpecies(label=label1, mol=mol1, xyz=xyz1, multiplicity=mol1.multiplicity, charge=mol1.getNetCharge(),\n generate_thermo=False)\n spc1.initial_xyz = xyz1\n spc2 = ARCSpecies(label=label2, mol=mol2, xyz=xyz2, multiplicity=mol2.multiplicity, charge=mol2.getNetCharge(),\n generate_thermo=False)\n spc2.initial_xyz = xyz2\n\n return [spc1, spc2]","def getStdChemComp(self):\n dataDict = self.__dict__\n stdCcpCode = self.stdChemCompCode\n if stdCcpCode is None:\n result = None\n else:\n result = self.memopsRoot.findFirstChemComp(molType=self.molType, ccpCode=stdCcpCode)\n return result","def components(self):\n return self._components","def components(self):\n return self._components","def get_component(self, name: str) -> Any:\n for c in self._components:\n if c.name == name:\n return c\n raise ValueError(f\"No component found with name {name}\")","def output_multiple(self):\n return _spacegrant_swig.ax25_pdu_packer_sptr_output_multiple(self)","def getComponent(self):\n return _libsbml.OutwardBindingSite_getComponent(self)","def component_children(self, component): \n return self.components(\"parent.identifier = '%s'\" % _obj_id(component))","def getReactantComponent(self):\n return _libsbml.SpeciesTypeComponentMapInProduct_getReactantComponent(self)","def getChemElement(self):\n dataDict = self.__dict__\n result = self.root.currentChemElementStore.findFirstChemElement(symbol=self.elementSymbol)\n return result","def scatters(self):\n\t\treturn self._scatter","def hse_cb(self):\n\n return {\n residue: exposure\n for residue, exposure in self._hse_cb_complex.property_dict.items()\n if (residue[1][1] in self._residue_ids) and (residue[1][2] == \" \")\n }","def comp(self, componentname):\n retv = self.components.lookup(componentname)\n if (retv == None):\n raise Exception(\"Component not found: '{0}'.\".format(componentname))\n return retv","def __getstate__(self):\n state = composites.Composite.__getstate__(self)\n return state","def __getitem__(self, index):\n return self.components[index]","def get_datacomponent_of():\n global datacomponent_of\n\n if not datacomponent_of:\n datacomponent_of = stixhelpers.datacomponent_of()\n \n return datacomponent_of","def __repr__(self):\n return '<HERON Component \"{}\"\">'.format(self.name)","def get_random_component(self):\n return self.random_state.choice(\n ['f_x', 'f_css', 'f_cos'],\n p=self.component_mutation_probabilities)","def isSetComponent(self):\n return _libsbml.SubListOfSpeciesFeatures_isSetComponent(self)","def __iter__(self):\n with SessionContext(self.SessionClass) as session:\n essids = session.query(ESSID_DBObject.essid)\n return (str(c[0]) for c in essids)","def get_equipment_slot(self, source_entity):\n open_slots = (source_entity.equipment.get_open_slots_of_type\n (self.parent.equipment_type.value))\n if len(open_slots) > 0:\n return open_slots[0]\n else:\n return (source_entity.equipment.get_slots_of_type\n (self.parent.equipment_type.value))[0]","def get_name(self):\n return COMPONENT_LIST[self.index][0]","def s(self) :\n\t\ttry :\n\t\t\treturn self._s\n\t\texcept Exception as e:\n\t\t\traise e","def createSpeciesTypeComponentIndex(self):\n return _libsbml.MultiSpeciesType_createSpeciesTypeComponentIndex(self)","def DumpStudy(Study):\n itcomp = Study.NewComponentIterator()\n Builder = Study.NewBuilder()\n while itcomp.More():\n SC = itcomp.Value()\n name = SC.ComponentDataType()\n print \"-> ComponentDataType is \" + name\n DumpComponent(Study, SC,Builder, 1)\n itcomp.Next()","def unsetComponent(self):\n return _libsbml.SubListOfSpeciesFeatures_unsetComponent(self)","def isSetComponent(self):\n return _libsbml.SpeciesFeature_isSetComponent(self)","def __tuple__(self):\n return tuple(self.components)","def __tuple__(self):\n return tuple(self.components)","def species(self):\n return self.name","def get_product_with_editions_list ( self ) :\n tile_list = []\n stmt = \"select p.name from sdb_productedition e, sdb_product p where e.sys003 = 4319 and e.sys001 = p.id\"\n self.oracle_cursor.arraysize = 100000\n self.oracle_cursor.execute(stmt)\n resultset = self.oracle_cursor.fetchmany()\n if resultset :\n for row in resultset :\n tile_list.append(str(row[0]))\n return tile_list","def OneModeCoherentHD(Ns,t,nth,shots):\n s1 = (1+1j)*np.zeros(shots)\n\n alpha = np.sqrt(Ns/4)\n \n for i in range(shots):\n prog= sf.Program(1)\n \n with prog.context as q:\n \n sf.ops.Coherent(alpha) | q[0] # State preparation\n sf.ops.ThermalLossChannel(t,nth) | q[0] # Thermal loss channel mimicing target\n \n sf.ops.MeasureHD | q[0] # Het. Msmnt of signal 1\n\n\n # Need to run twice because of bug in the bosonic backend in dealing with repeated HD measurements\n \n eng = sf.Engine(\"bosonic\")\n results = eng.run(prog)\n \n \n #Collecting the samples\n samples = results.all_samples\n \n #Creating the measurement records\n s1[i] = samples[0][0]\n \n # Interation over number of shots is done, outputing the records\n \n return s1","def Schoof(self):\n if self.ch in (2, 3):\n raise NotImplementedError(\"characteristic should be >> 1\")\n\n if len(self) != 2:\n return self.simple().Schoof()\n\n traces = []\n D, prime_moduli = self.divPoly()\n self.division_polynomials = D # temporary attribute\n\n # the main loop\n for l in prime_moduli:\n _log.debug(\"l = %d\" % l)\n traces.append(self._Schoof_mod_l(l))\n\n del self.division_polynomials # temporary attribute deleted\n\n trace = arith1.CRT(traces)\n modulus = arith1.product(prime_moduli)\n if trace > modulus//2:\n trace -= modulus\n assert abs(trace) <= 2*arith1.floorsqrt(card(self.basefield)), str(self)\n return trace","def output_multiple(self):\n return _spacegrant_swig.hdlc_deframer_sptr_output_multiple(self)","def get_secondary_structure_string(self):\n d = self.data\n struc = self.struc\n \n n = 0\n output = \"\"\n for i, (ires, inscode, chain, aa, sec_struc) in enumerate(zip(d.resnum, d.inscode, d.chain, d.aa, d.struct)):\n if aa == \"!*\":\n continue\n S = sec_struc[0]\n res = self.struc[n]\n assert res.ires == int(ires)\n assert res.inscode == inscode\n assert res.chain == chain\n output += S\n n += 1\n \n assert len(output) == len(struc)\n return output"],"string":"[\n \"def getComponent(self):\\n return _libsbml.SpeciesFeature_getComponent(self)\",\n \"def getComponent(self):\\n return _libsbml.SubListOfSpeciesFeatures_getComponent(self)\",\n \"def __iter__(self):\\n return self.cli.essids.essids().__iter__()\",\n \"def getComponent(self):\\n return _libsbml.SpeciesTypeComponentIndex_getComponent(self)\",\n \"def C ( self ) :\\n lst = [ i for i in self.__nums_components ]\\n if not lst : return () ## extended fit? no other components?\\n elif 1 == len(lst) : return lst[0] ## single component?\\n return tuple ( lst )\",\n \"def C ( self ) :\\n lst = [ i for i in self.__nums_components ]\\n if not lst : return () ## extended fit? no other components?\\n elif 1 == len(lst) : return lst[0] ## single component?\\n return tuple ( lst )\",\n \"def __iter__(self):\\n return self.essids.__iter__()\",\n \"def getCompartment(self):\\n return _libsbml.MultiSpeciesType_getCompartment(self)\",\n \"def get_component():\\n\\t\\tcomponentConsumed = consumed\\n\\t\\tfor i in range(len(components)):\\n\\t\\t\\tif componentConsumed < len(components[-i]):\\n\\t\\t\\t\\treturn components[-i][:-componentConsumed if componentConsumed else None]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcomponentConsumed -= len(components[-i])\\n\\t\\treturn []\",\n \"def scissors(self):\\n all_h = True if 'all_h' in self.bdes else False\\n if all_h:\\n self.bdes.pop(self.bdes.index('all_h'))\\n for entry in self.bdes:\\n if len(entry) != 2:\\n raise SpeciesError('Could not interpret entry {0} in {1} for BDEs calculations.'.format(\\n entry, self.bdes))\\n if not isinstance(entry, (tuple, list)):\\n raise SpeciesError('`indices` entries must be tuples or lists, got {0} which is a {1} in {2}'.format(\\n entry, type(entry), self.bdes))\\n self.bdes = [tuple(bde) for bde in self.bdes]\\n if all_h:\\n for atom1 in self.mol.atoms:\\n if atom1.isHydrogen():\\n for atom2, bond12 in atom1.edges.items():\\n if bond12.isSingle():\\n atom_indices = (self.mol.atoms.index(atom2) + 1, self.mol.atoms.index(atom1) + 1)\\n atom_indices_reverse = (atom_indices[1], atom_indices[0])\\n if atom_indices not in self.bdes and atom_indices_reverse not in self.bdes:\\n self.bdes.append(atom_indices)\\n resulting_species = list()\\n for index_tuple in self.bdes:\\n new_species_list = self._scissors(indices=index_tuple)\\n for new_species in new_species_list:\\n if new_species.label not in [existing_species.label for existing_species in resulting_species]:\\n # mainly checks that the H species doesn't already exist\\n resulting_species.append(new_species)\\n return resulting_species\",\n \"def get_component(self):\\n component = []\\n component = [self.component_type, self.component_value, self.spot]\\n\\n if component[2] != None:\\n print component\\n return component\",\n \"def component(self, index):\\n return self.components[index]\",\n \"def component(self):\\n return self._component\",\n \"def component(self):\\n return self._component\",\n \"def get_component(self, sCompName):\\n return self._dComponents.get(sCompName, None)\",\n \"def getProductComponent(self):\\n return _libsbml.SpeciesTypeComponentMapInProduct_getProductComponent(self)\",\n \"def get(self, entity):\\n\\t\\treturn entity.get_component(self.component_type)\",\n \"def get_compss_module(self):\\n return self.compss_module\",\n \"def from_ical(st, multiple=False):\\n stack = [] # a stack of components\\n comps = []\\n for line in Contentlines.from_ical(st): # raw parsing\\n if not line:\\n continue\\n name, params, vals = line.parts()\\n uname = name.upper()\\n # check for start of component\\n if uname == 'BEGIN':\\n # try and create one of the components defined in the spec,\\n # otherwise get a general Components for robustness.\\n c_name = vals.upper()\\n c_class = component_factory.get(c_name, Component)\\n component = c_class()\\n if not getattr(component, 'name', ''): # undefined components\\n component.name = c_name\\n stack.append(component)\\n # check for end of event\\n elif uname == 'END':\\n # we are done adding properties to this component\\n # so pop it from the stack and add it to the new top.\\n component = stack.pop()\\n if not stack: # we are at the end\\n comps.append(component)\\n else:\\n if not component.is_broken:\\n stack[-1].add_component(component)\\n # we are adding properties to the current top of the stack\\n else:\\n factory = types_factory.for_property(name)\\n component = stack[-1]\\n try:\\n if name in ('DTSTART', 'DTEND', 'RECURRENCE-ID')\\\\\\n and 'TZID' in params: # TODO: add DUE, FREEBUSY, RDATE, EXDATE ..\\n vals = factory(factory.from_ical(vals, params['TZID']))\\n else:\\n vals = factory(factory.from_ical(vals))\\n except ValueError:\\n if not component.ignore_exceptions:\\n raise\\n component.is_broken = True\\n else:\\n vals.params = params\\n component.add(name, vals, encode=0)\\n\\n if multiple:\\n return comps\\n if len(comps) > 1:\\n raise ValueError('Found multiple components where '\\n 'only one is allowed: {st!r}'.format(**locals()))\\n if len(comps) < 1:\\n raise ValueError('Found no components where '\\n 'exactly one is required: '\\n '{st!r}'.format(**locals()))\\n return comps[0]\",\n \"def get_component(self, name):\\n for cmpt in self.components:\\n if cmpt['name'] == name:\\n return cmpt\",\n \"def iter_components(self):\\n return self.components.values()\",\n \"def ThisComponent(self):\\n comp = self.StarDesktop.getCurrentComponent()\\n if comp is None:\\n return None\\n impl = comp.ImplementationName\\n if impl in ('com.sun.star.comp.basic.BasicIDE', 'com.sun.star.comp.sfx2.BackingComp'):\\n return None # None when Basic IDE or welcome screen\\n return comp\",\n \"def component(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"component\\\")\",\n \"def getCompartment(self):\\n return _libsbml.Species_getCompartment(self)\",\n \"def components(self):\\n return self._components\",\n \"def get_component_html(self, harmonization_unit):\\n source = [tr.get_name_link_html() for tr in (\\n self.component_source_traits.all() & harmonization_unit.component_source_traits.all())]\\n harmonized_trait_set_versions = [trait_set_version for trait_set_version in (\\n self.component_harmonized_trait_set_versions.all() &\\n harmonization_unit.component_harmonized_trait_set_versions.all())]\\n harmonized = [tr.get_name_link_html() for trait_set in harmonized_trait_set_versions\\n for tr in trait_set.harmonizedtrait_set.all()\\n if not tr.i_is_unique_key]\\n component_html = ''\\n if len(source) > 0:\\n trait_list = '\\\\n'.join([LIST_ELEMENT_HTML.format(element=trait) for trait in source])\\n component_html += INLINE_LIST_HTML.format(\\n list_title='Component study variables for {}'.format(self.trait_flavor_name),\\n list_elements=trait_list)\\n if len(harmonized) > 0:\\n trait_list = '\\\\n'.join([LIST_ELEMENT_HTML.format(element=trait) for trait in harmonized])\\n component_html += '\\\\n' + INLINE_LIST_HTML.format(\\n list_title='Component harmonized variables for {}'.format(self.trait_flavor_name),\\n list_elements=trait_list)\\n return component_html\",\n \"def SS ( self ) :\\n return self.__ss\",\n \"def SS ( self ) :\\n return self.__ss\",\n \"def cse_elastic(energy, elements, stoic):\\n i = 0\\n cs_el = 0\\n gamma = float(1.+energy/ElectronMass)\\n beta = sqrt(1.-1./(gamma*gamma))\\n for Z in elements:\\n Z = float(Z)\\n cs_el += 1.0e-14*1.4e-6*(Z**1.5)*(1.-(0.26*Z/(137.*beta)))/(beta*beta)*stoic[i]\\n i += 1\\n\\n return cs_el\",\n \"def computerhs(self, ue1, inletf, t, a, alpha, msh, Minv, S):\\n # compute all edge fluxes (loop over all edges)\\n flux = self.computeF(ue1, inletf, t, a, alpha, msh)\\n #print 'flux=',flux\\n\\n # update DG elements (could be done in parallel)\\n #ne = ue1.shape[1]\\n rhs = np.zeros(msh.nu)\\n for el in msh.elms:\\n rhs[el.idx:el.idx+el.nnod] = self.computerhs1e(ue1, el, flux, a, Minv, S)\\n #print 'rhs=', rhs\\n return rhs\",\n \"def components_for_entity(eman, entity, components):\\n\\n return tuple(eman.component_for_entity(entity, c) for c in components)\",\n \"def get_components(state: ChemicalSystem) -> ParseCompRet:\\n def _get_single_comps(comp_list, comptype):\\n ret_comps = [comp for comp in comp_list\\n if isinstance(comp, comptype)]\\n if ret_comps:\\n return ret_comps[0]\\n else:\\n return None\\n\\n solvent_comp: Optional[SolventComponent] = _get_single_comps(\\n list(state.values()), SolventComponent\\n )\\n\\n protein_comp: Optional[ProteinComponent] = _get_single_comps(\\n list(state.values()), ProteinComponent\\n )\\n\\n small_mols = []\\n for comp in state.components.values():\\n if isinstance(comp, SmallMoleculeComponent):\\n small_mols.append(comp)\\n\\n return solvent_comp, protein_comp, small_mols\",\n \"def getElementBySId(self, *args):\\n return _libsbml.CompModelPlugin_getElementBySId(self, *args)\",\n \"def getElementBySId(self, *args):\\n return _libsbml.CompSBasePlugin_getElementBySId(self, *args)\",\n \"def output_multiple(self):\\n return _spacegrant_swig.ax25_pdu_unpacker_sptr_output_multiple(self)\",\n \"def components(self):\\r\\n return list(self._components)\",\n \"def getCompartment(self):\\n return _libsbml.QualitativeSpecies_getCompartment(self)\",\n \"def get(self, participant_id, session_id, component_id):\\n \\n query = \\\"\\\"\\\"\\n select distinct * where {\\n\\n BIND (\\\"%s\\\" AS ?pid)\\n BIND (%s as ?sessionid)\\n BIND (\\\"%s\\\" as ?shortname)\\n \\n ?participant austalk:id ?pid .\\n ?rc rdf:type austalk:RecordedComponent .\\n ?rc olac:speaker ?participant . \\n \\n }\\n \\\"\\\"\\\" % (participant_id, session_id, component_id)\\n\\n sparql_results = self.query (query)\\n\\n bindings = sparql_results[\\\"results\\\"][\\\"bindings\\\"]\\n if len(bindings) == 1:\\n comp = Component (\\n client = self.client,\\n identifier = sparql_results[\\\"rc\\\"][\\\"value\\\"], \\n participantId = sparql_results[\\\"pid\\\"][\\\"value\\\"],\\n sessionId = sparql_results[\\\"sessionid\\\"][\\\"value\\\"],\\n )\\n comp.details()\\n return comp\\n else:\\n return None\",\n \"def an_element(self):\\n return self.semigroup_generators()[0]\",\n \"def getSpecies(self):\\n return _libsbml.SimpleSpeciesReference_getSpecies(self)\",\n \"def _parse_composite(\\n composite: Union[mapry.Class, mapry.Embed], py: mapry.Py) -> str:\\n references = mapry.references(a_type=composite)\\n\\n # yapf: disable\\n registry_exprs = {\\n ref_cls: '{}_registry'.format(\\n mapry.py.naming.as_variable(ref_cls.plural))\\n for ref_cls in references\\n }\\n # yapf: enable\\n\\n auto_id = mapry.py.generate.AutoID()\\n\\n # yapf: disable\\n property_parsing = {\\n prop: _parse_property(\\n target_obj_expr=\\\"target\\\",\\n value_obj_expr=\\\"value\\\",\\n ref_obj_parts=[\\\"ref\\\"],\\n a_property=prop,\\n registry_exprs=registry_exprs,\\n auto_id=auto_id,\\n py=py)\\n for prop in composite.properties.values()\\n }\\n # yapf: enable\\n\\n return _PARSE_COMPOSITE_TPL.render(\\n composite=composite,\\n is_class=isinstance(composite, mapry.Class),\\n references=references,\\n property_parsing=property_parsing,\\n py=py)\",\n \"def get_components(self):\\n Phi = (self.image_vec - self.mean_face) / self.std_face\\n A = Phi\\n C = np.matmul(A, A.T)\\n C = np.divide(C, self.num_examples - 1)\\n evals, Vi = np.linalg.eigh(C)\\n z = list(zip(evals, Vi))\\n z.sort(reverse=True)\\n idx = np.argsort(evals)[::-1]\\n pc = Vi[:, idx]\\n pc = pc[:, :self.k]\\n\\n # final components (num pixels by k matrix)\\n components = np.matmul(A.T, pc)\\n components = components / np.linalg.norm(components, axis=0)\\n # get singluar values\\n sorted_evals = np.array([x[0] for x in z])\\n postive_evals = sorted_evals[:self.k]\\n singular_values = np.sqrt(postive_evals.reshape(1, -1))\\n\\n return components, singular_values\",\n \"def components(self):\\n with sql_connection.TRN as TRN:\\n sql = \\\"\\\"\\\"SELECT input_composition_id, input_volume\\n FROM qiita.pool_composition_components\\n JOIN qiita.pool_composition\\n ON output_pool_composition_id = pool_composition_id\\n JOIN qiita.composition USING (composition_id)\\n WHERE upstream_process_id = %s\\n ORDER BY pool_composition_components_id\\\"\\\"\\\"\\n TRN.add(sql, [self.process_id])\\n return [(composition_module.Composition.factory(comp_id), vol)\\n for comp_id, vol in TRN.execute_fetchindex()]\",\n \"def S(self):\\n return self._S\",\n \"def component(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"component\\\")\",\n \"def setComponent(self, *args):\\n return _libsbml.SubListOfSpeciesFeatures_setComponent(self, *args)\",\n \"def at_SES(self):\\n\\t t = self.t\\n\\t dM = self.dM\\n\\t rLbl = transLabel(t,self.P,self.t0,self.tdur*2)\\n\\n\\t # Hack. K2 doesn't have seasons\\n\\t q = np.zeros(t.size) - 1\\n\\t season = np.mod(q,4)\\n\\t dtype = [('ses',float),('tnum',int),('season',int)]\\n\\t dM.fill_value = np.nan\\n\\t rses = np.array(list(zip(dM.filled(),rLbl['tLbl'],season)),dtype=dtype )\\n\\t rses = rses[ rLbl['tLbl'] >= 0 ]\\n\\n\\t # If no good transits, break out\\n\\t if rses.size==0:\\n\\t return\\n\\n\\t self.add_dset('rLbl',rLbl,\\n\\t description='Transit/continuum labeled (see transLabel doc string')\\n\\t self.add_dset('SES',rses,\\n\\t description='Record array with single event statistic')\\n\\t self.add_attr('num_trans',rses.size,\\n\\t description='Number of good transits')\\n\\n\\t # Median SES, even/odd\\n\\t for sfx,i in zip(['even','odd'],[0,1]):\\n\\t medses = np.median( rses['ses'][rses['tnum'] % 2 == i] ) \\n\\t self.add_attr('SES_%s' % sfx, medses,\\n\\t description='Median SES %s' % sfx)\\n\\n\\t # Median SES, different seasons\\n\\t for i in range(4):\\n\\t medses = -99 #Hack\\n\\t self.add_attr('SES_%i' % i, medses,\\n\\t description='Median SES [Season %i]' % i )\",\n \"def at_SES(self):\\n\\t t = self.t\\n\\t dM = self.dM\\n\\t rLbl = transLabel(t,self.P,self.t0,self.tdur*2)\\n\\n\\t # Hack. K2 doesn't have seasons\\n\\t q = np.zeros(t.size) - 1\\n\\t season = np.mod(q,4)\\n\\t dtype = [('ses',float),('tnum',int),('season',int)]\\n\\t dM.fill_value = np.nan\\n\\t rses = np.array(list(zip(dM.filled(),rLbl['tLbl'],season)),dtype=dtype )\\n\\t rses = rses[ rLbl['tLbl'] >= 0 ]\\n\\n\\t # If no good transits, break out\\n\\t if rses.size==0:\\n\\t return\\n\\n\\t self.add_dset('rLbl',rLbl,\\n\\t description='Transit/continuum labeled (see transLabel doc string')\\n\\t self.add_dset('SES',rses,\\n\\t description='Record array with single event statistic')\\n\\t self.add_attr('num_trans',rses.size,\\n\\t description='Number of good transits')\\n\\n\\t # Median SES, even/odd\\n\\t for sfx,i in zip(['even','odd'],[0,1]):\\n\\t medses = np.median( rses['ses'][rses['tnum'] % 2 == i] ) \\n\\t self.add_attr('SES_%s' % sfx, medses,\\n\\t description='Median SES %s' % sfx)\\n\\n\\t # Median SES, different seasons\\n\\t for i in range(4):\\n\\t medses = -99 #Hack\\n\\t self.add_attr('SES_%i' % i, medses,\\n\\t description='Median SES [Season %i]' % i )\",\n \"def _get_linkable_component(script):\\n component = None\\n for c in script.components:\\n if isinstance(c, SessionComponent):\\n return c\\n if isinstance(c, SpecialMixerComponent) and not c.is_return_mixer:\\n component = c\\n\\n if component is None:\\n if hasattr(script, '_session_ring'):\\n return script._session_ring\\n return component\",\n \"def components(self):\\n skel = self.clone()\\n forest = self._compute_components(skel)\\n \\n if len(forest) == 0:\\n return []\\n elif len(forest) == 1:\\n return [ skel ]\\n\\n skeletons = []\\n for edge_list in forest:\\n edge_list = np.array(edge_list, dtype=np.uint32)\\n vert_idx = fastremap.unique(edge_list)\\n\\n vert_list = skel.vertices[vert_idx]\\n radii = skel.radii[vert_idx]\\n vtypes = skel.vertex_types[vert_idx]\\n\\n remap = { vid: i for i, vid in enumerate(vert_idx) }\\n edge_list = fastremap.remap(edge_list, remap, in_place=True)\\n\\n skeletons.append(\\n Skeleton(vert_list, edge_list, radii, vtypes, skel.id)\\n )\\n\\n return skeletons\",\n \"def getSpeciesTypeComponentIndex(self, *args):\\n return _libsbml.MultiSpeciesType_getSpeciesTypeComponentIndex(self, *args)\",\n \"def get_component_html(self):\\n study_list = '\\\\n'.join([study.get_name_link_html() for study in self.get_source_studies()])\\n age_list = '\\\\n'.join([trait.get_name_link_html() for trait in self.component_age_traits.all()])\\n component_html = '\\\\n'.join([\\n trait.get_component_html(harmonization_unit=self) for trait in self.harmonizedtrait_set.all()])\\n panel_body = []\\n if len(study_list) > 0:\\n study_html = INLINE_LIST_HTML.format(list_title='Included studies', list_elements=study_list)\\n panel_body.append(study_html)\\n if len(age_list) > 0:\\n age_html = INLINE_LIST_HTML.format(list_title='Component age variables', list_elements=age_list)\\n panel_body.append(age_html)\\n panel_body.append(component_html)\\n panel_body = '\\\\n'.join(panel_body)\\n unit_panel = PANEL_HTML.format(panel_title='Harmonization unit: {}'.format(self.i_tag), panel_body=panel_body)\\n return unit_panel\",\n \"def _component_specs(self):\\n specs = dict(pretransformed_input=self._input_spec)\\n if self._transform_is_composite:\\n specs['bijector'] = self.transform_or_spec\\n return specs\",\n \"def getComponent(self):\\n return self.flowComponent\",\n \"def get_con_sf(self, j):\\n return self.je[ self.ie[j] : self.ie[j+1] ]\",\n \"def setComponent(self, *args):\\n return _libsbml.SpeciesFeature_setComponent(self, *args)\",\n \"def get_ccs_subsystem(subsystems):\\n for item in subsystems:\\n try:\\n check_serial_number(item)\\n return item\\n except RebTestingException:\\n pass\\n message = \\\"No CCS subsystem found for REB %s.\\\" % siteUtils.getUnitId()\\n raise RebTestingException(message)\",\n \"def components(self):\\n # The '_components' attribute is defined according to the\\n # subclass of Dyadic the instance belongs to.\\n return self._components\",\n \"def components(self):\\n return self.__components\",\n \"def components(self):\\n return self.__components\",\n \"def find_component(component):\\n if component == 'C1':\\n return C1\\n elif component == 'C2':\\n return C2\\n elif component == 'C3':\\n return C3\\n elif component == 'C4':\\n return C4\\n elif component == 'C5':\\n return C5\\n elif component == 'C6':\\n return C6\\n elif component == 'AS':\\n return AS\",\n \"def _get_component(self):\\n return AssemblyComponent.ByKeys(**self.db_key)\",\n \"def get_description(self):\\n return COMPONENT_LIST[self.index][1]\",\n \"def species(self):\\n\\n return self._species\",\n \"def species(self):\\n\\n return self._species\",\n \"def _scissors(self, indices):\\n if any([i < 1 for i in indices]):\\n raise SpeciesError('Indices must be larger than 0')\\n if not all([isinstance(i, int) for i in indices]):\\n raise SpeciesError('Indices must be integers')\\n if self.final_xyz is None:\\n raise SpeciesError('Cannot use scissors without the .final_xyz attribute of species {0}'.format(self.label))\\n indices = (indices[0] - 1, indices[1] - 1) # convert to 0-indexed atoms\\n atom1 = self.mol.atoms[indices[0]]\\n atom2 = self.mol.atoms[indices[1]]\\n if atom1.isHydrogen():\\n top1 = [self.mol.atoms.index(atom1)]\\n top2 = [i for i in range(len(self.mol.atoms)) if i not in top1]\\n elif atom2.isHydrogen():\\n top2 = [self.mol.atoms.index(atom2)]\\n top1 = [i for i in range(len(self.mol.atoms)) if i not in top2]\\n else:\\n # for robustness, only use the smaller top,\\n # determine_top_group_indices() might get confused for (large) convolved tops.\\n top1 = conformers.determine_top_group_indices(self.mol, atom1, atom2, index=0)[0]\\n top2 = conformers.determine_top_group_indices(self.mol, atom2, atom1, index=0)[0]\\n if len(top1) > len(top2):\\n top1 = [i for i in range(len(self.mol.atoms)) if i not in top2]\\n elif len(top2) > len(top1):\\n top2 = [i for i in range(len(self.mol.atoms)) if i not in top1]\\n split_xyz = self.final_xyz.splitlines()\\n xyz1 = '\\\\n'.join([split_xyz[i] for i in top1])\\n xyz2 = '\\\\n'.join([split_xyz[i] for i in top2])\\n xyz1, xyz2 = translate_to_center_of_mass(xyz1), translate_to_center_of_mass(xyz2)\\n\\n mol_copy = self.mol.copy(deep=True)\\n # We are about to change the connectivity of the atoms in the molecule,\\n # which invalidates any existing vertex connectivity information; thus we reset it.\\n mol_copy.resetConnectivityValues()\\n atom1 = mol_copy.atoms[indices[0]] # Note: redefining atom1 and atom2\\n atom2 = mol_copy.atoms[indices[1]]\\n if not mol_copy.hasBond(atom1, atom2):\\n raise SpeciesError('Attempted to remove a nonexistent bond.')\\n bond = mol_copy.getBond(atom1, atom2)\\n mol_copy.removeBond(bond)\\n mol1, mol2 = mol_copy.split()\\n\\n used_a_label = False\\n if len(mol1.atoms) == 1 and mol1.atoms[0].isHydrogen():\\n label1 = 'H'\\n else:\\n label1 = self.label + '_BDE_' + str(indices[0] + 1) + '_' + str(indices[1] + 1) + '_A'\\n used_a_label = True\\n if len(mol2.atoms) == 1 and mol2.atoms[0].isHydrogen():\\n label2 = 'H'\\n else:\\n letter = 'B' if used_a_label else 'A'\\n label2 = self.label + '_BDE_' + str(indices[0] + 1) + '_' + str(indices[1] + 1) + '_' + letter\\n\\n added_radical = list()\\n for mol, label in zip([mol1, mol2], [label1, label2]):\\n for atom in mol.atoms:\\n theoretical_charge = elements.PeriodicSystem.valence_electrons[atom.symbol] \\\\\\n - atom.getBondOrdersForAtom() \\\\\\n - atom.radicalElectrons -\\\\\\n 2 * atom.lonePairs\\n if theoretical_charge == atom.charge + 1:\\n # we're missing a radical electron on this atom\\n if label not in added_radical or label == 'H':\\n atom.radicalElectrons += 1\\n added_radical.append(label)\\n else:\\n raise SpeciesError('Could not figure out which atom should gain a radical '\\n 'due to scission in {0}'.format(self.label))\\n mol1.update()\\n mol2.update()\\n\\n # match xyz to mol:\\n if len(mol1.atoms) != len(mol2.atoms):\\n # easy\\n if len(mol1.atoms) != len(top1):\\n xyz1, xyz2 = xyz2, xyz1\\n else:\\n # harder\\n element_dict_mol1, element_dict_top1 = dict(), dict()\\n for atom in mol1.atoms:\\n if atom.element.symbol in element_dict_mol1:\\n element_dict_mol1[atom.element.symbol] += 1\\n else:\\n element_dict_mol1[atom.element.symbol] = 1\\n for i in top1:\\n atom = mol_copy.atoms[i - 1]\\n if atom.element.symbol in element_dict_top1:\\n element_dict_top1[atom.element.symbol] += 1\\n else:\\n element_dict_top1[atom.element.symbol] = 1\\n for element, count in element_dict_mol1.items():\\n if element not in element_dict_top1 or count != element_dict_top1[element]:\\n xyz1, xyz2 = xyz2, xyz1\\n\\n spc1 = ARCSpecies(label=label1, mol=mol1, xyz=xyz1, multiplicity=mol1.multiplicity, charge=mol1.getNetCharge(),\\n generate_thermo=False)\\n spc1.initial_xyz = xyz1\\n spc2 = ARCSpecies(label=label2, mol=mol2, xyz=xyz2, multiplicity=mol2.multiplicity, charge=mol2.getNetCharge(),\\n generate_thermo=False)\\n spc2.initial_xyz = xyz2\\n\\n return [spc1, spc2]\",\n \"def getStdChemComp(self):\\n dataDict = self.__dict__\\n stdCcpCode = self.stdChemCompCode\\n if stdCcpCode is None:\\n result = None\\n else:\\n result = self.memopsRoot.findFirstChemComp(molType=self.molType, ccpCode=stdCcpCode)\\n return result\",\n \"def components(self):\\n return self._components\",\n \"def components(self):\\n return self._components\",\n \"def get_component(self, name: str) -> Any:\\n for c in self._components:\\n if c.name == name:\\n return c\\n raise ValueError(f\\\"No component found with name {name}\\\")\",\n \"def output_multiple(self):\\n return _spacegrant_swig.ax25_pdu_packer_sptr_output_multiple(self)\",\n \"def getComponent(self):\\n return _libsbml.OutwardBindingSite_getComponent(self)\",\n \"def component_children(self, component): \\n return self.components(\\\"parent.identifier = '%s'\\\" % _obj_id(component))\",\n \"def getReactantComponent(self):\\n return _libsbml.SpeciesTypeComponentMapInProduct_getReactantComponent(self)\",\n \"def getChemElement(self):\\n dataDict = self.__dict__\\n result = self.root.currentChemElementStore.findFirstChemElement(symbol=self.elementSymbol)\\n return result\",\n \"def scatters(self):\\n\\t\\treturn self._scatter\",\n \"def hse_cb(self):\\n\\n return {\\n residue: exposure\\n for residue, exposure in self._hse_cb_complex.property_dict.items()\\n if (residue[1][1] in self._residue_ids) and (residue[1][2] == \\\" \\\")\\n }\",\n \"def comp(self, componentname):\\n retv = self.components.lookup(componentname)\\n if (retv == None):\\n raise Exception(\\\"Component not found: '{0}'.\\\".format(componentname))\\n return retv\",\n \"def __getstate__(self):\\n state = composites.Composite.__getstate__(self)\\n return state\",\n \"def __getitem__(self, index):\\n return self.components[index]\",\n \"def get_datacomponent_of():\\n global datacomponent_of\\n\\n if not datacomponent_of:\\n datacomponent_of = stixhelpers.datacomponent_of()\\n \\n return datacomponent_of\",\n \"def __repr__(self):\\n return '<HERON Component \\\"{}\\\"\\\">'.format(self.name)\",\n \"def get_random_component(self):\\n return self.random_state.choice(\\n ['f_x', 'f_css', 'f_cos'],\\n p=self.component_mutation_probabilities)\",\n \"def isSetComponent(self):\\n return _libsbml.SubListOfSpeciesFeatures_isSetComponent(self)\",\n \"def __iter__(self):\\n with SessionContext(self.SessionClass) as session:\\n essids = session.query(ESSID_DBObject.essid)\\n return (str(c[0]) for c in essids)\",\n \"def get_equipment_slot(self, source_entity):\\n open_slots = (source_entity.equipment.get_open_slots_of_type\\n (self.parent.equipment_type.value))\\n if len(open_slots) > 0:\\n return open_slots[0]\\n else:\\n return (source_entity.equipment.get_slots_of_type\\n (self.parent.equipment_type.value))[0]\",\n \"def get_name(self):\\n return COMPONENT_LIST[self.index][0]\",\n \"def s(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._s\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def createSpeciesTypeComponentIndex(self):\\n return _libsbml.MultiSpeciesType_createSpeciesTypeComponentIndex(self)\",\n \"def DumpStudy(Study):\\n itcomp = Study.NewComponentIterator()\\n Builder = Study.NewBuilder()\\n while itcomp.More():\\n SC = itcomp.Value()\\n name = SC.ComponentDataType()\\n print \\\"-> ComponentDataType is \\\" + name\\n DumpComponent(Study, SC,Builder, 1)\\n itcomp.Next()\",\n \"def unsetComponent(self):\\n return _libsbml.SubListOfSpeciesFeatures_unsetComponent(self)\",\n \"def isSetComponent(self):\\n return _libsbml.SpeciesFeature_isSetComponent(self)\",\n \"def __tuple__(self):\\n return tuple(self.components)\",\n \"def __tuple__(self):\\n return tuple(self.components)\",\n \"def species(self):\\n return self.name\",\n \"def get_product_with_editions_list ( self ) :\\n tile_list = []\\n stmt = \\\"select p.name from sdb_productedition e, sdb_product p where e.sys003 = 4319 and e.sys001 = p.id\\\"\\n self.oracle_cursor.arraysize = 100000\\n self.oracle_cursor.execute(stmt)\\n resultset = self.oracle_cursor.fetchmany()\\n if resultset :\\n for row in resultset :\\n tile_list.append(str(row[0]))\\n return tile_list\",\n \"def OneModeCoherentHD(Ns,t,nth,shots):\\n s1 = (1+1j)*np.zeros(shots)\\n\\n alpha = np.sqrt(Ns/4)\\n \\n for i in range(shots):\\n prog= sf.Program(1)\\n \\n with prog.context as q:\\n \\n sf.ops.Coherent(alpha) | q[0] # State preparation\\n sf.ops.ThermalLossChannel(t,nth) | q[0] # Thermal loss channel mimicing target\\n \\n sf.ops.MeasureHD | q[0] # Het. Msmnt of signal 1\\n\\n\\n # Need to run twice because of bug in the bosonic backend in dealing with repeated HD measurements\\n \\n eng = sf.Engine(\\\"bosonic\\\")\\n results = eng.run(prog)\\n \\n \\n #Collecting the samples\\n samples = results.all_samples\\n \\n #Creating the measurement records\\n s1[i] = samples[0][0]\\n \\n # Interation over number of shots is done, outputing the records\\n \\n return s1\",\n \"def Schoof(self):\\n if self.ch in (2, 3):\\n raise NotImplementedError(\\\"characteristic should be >> 1\\\")\\n\\n if len(self) != 2:\\n return self.simple().Schoof()\\n\\n traces = []\\n D, prime_moduli = self.divPoly()\\n self.division_polynomials = D # temporary attribute\\n\\n # the main loop\\n for l in prime_moduli:\\n _log.debug(\\\"l = %d\\\" % l)\\n traces.append(self._Schoof_mod_l(l))\\n\\n del self.division_polynomials # temporary attribute deleted\\n\\n trace = arith1.CRT(traces)\\n modulus = arith1.product(prime_moduli)\\n if trace > modulus//2:\\n trace -= modulus\\n assert abs(trace) <= 2*arith1.floorsqrt(card(self.basefield)), str(self)\\n return trace\",\n \"def output_multiple(self):\\n return _spacegrant_swig.hdlc_deframer_sptr_output_multiple(self)\",\n \"def get_secondary_structure_string(self):\\n d = self.data\\n struc = self.struc\\n \\n n = 0\\n output = \\\"\\\"\\n for i, (ires, inscode, chain, aa, sec_struc) in enumerate(zip(d.resnum, d.inscode, d.chain, d.aa, d.struct)):\\n if aa == \\\"!*\\\":\\n continue\\n S = sec_struc[0]\\n res = self.struc[n]\\n assert res.ires == int(ires)\\n assert res.inscode == inscode\\n assert res.chain == chain\\n output += S\\n n += 1\\n \\n assert len(output) == len(struc)\\n return output\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60309696","0.5875762","0.5732701","0.5669978","0.54934925","0.54934925","0.5313908","0.5306956","0.5271111","0.5270919","0.52329254","0.52045023","0.5201842","0.5201842","0.51868373","0.51427984","0.51417166","0.5088495","0.5074315","0.5063659","0.50567997","0.5054169","0.50254995","0.5009054","0.49198642","0.48786214","0.48514575","0.48514575","0.4849265","0.48457724","0.48325825","0.48250845","0.48129913","0.48025358","0.47601935","0.47597826","0.47534797","0.47515902","0.47451708","0.47395504","0.47332358","0.47313377","0.47223657","0.46994138","0.46973836","0.46891558","0.46779284","0.46779284","0.46714956","0.467117","0.46711153","0.46708876","0.46633956","0.46513703","0.4644751","0.46398547","0.4638744","0.46340033","0.46303958","0.46303958","0.46258587","0.46178806","0.46078962","0.46066147","0.46066147","0.46010828","0.4599476","0.459565","0.459565","0.45945814","0.45918065","0.45768374","0.45720977","0.45656285","0.4558733","0.45489088","0.4548005","0.45425662","0.45380637","0.45364273","0.45324317","0.4531618","0.4528679","0.4525251","0.4520095","0.4517656","0.45131493","0.45087543","0.44934535","0.44720298","0.4467636","0.44628614","0.4449998","0.4449998","0.44364107","0.44359982","0.44349152","0.44277918","0.4420312","0.44174784"],"string":"[\n \"0.60309696\",\n \"0.5875762\",\n \"0.5732701\",\n \"0.5669978\",\n \"0.54934925\",\n \"0.54934925\",\n \"0.5313908\",\n \"0.5306956\",\n \"0.5271111\",\n \"0.5270919\",\n \"0.52329254\",\n \"0.52045023\",\n \"0.5201842\",\n \"0.5201842\",\n \"0.51868373\",\n \"0.51427984\",\n \"0.51417166\",\n \"0.5088495\",\n \"0.5074315\",\n \"0.5063659\",\n \"0.50567997\",\n \"0.5054169\",\n \"0.50254995\",\n \"0.5009054\",\n \"0.49198642\",\n \"0.48786214\",\n \"0.48514575\",\n \"0.48514575\",\n \"0.4849265\",\n \"0.48457724\",\n \"0.48325825\",\n \"0.48250845\",\n \"0.48129913\",\n \"0.48025358\",\n \"0.47601935\",\n \"0.47597826\",\n \"0.47534797\",\n \"0.47515902\",\n \"0.47451708\",\n \"0.47395504\",\n \"0.47332358\",\n \"0.47313377\",\n \"0.47223657\",\n \"0.46994138\",\n \"0.46973836\",\n \"0.46891558\",\n \"0.46779284\",\n \"0.46779284\",\n \"0.46714956\",\n \"0.467117\",\n \"0.46711153\",\n \"0.46708876\",\n \"0.46633956\",\n \"0.46513703\",\n \"0.4644751\",\n \"0.46398547\",\n \"0.4638744\",\n \"0.46340033\",\n \"0.46303958\",\n \"0.46303958\",\n \"0.46258587\",\n \"0.46178806\",\n \"0.46078962\",\n \"0.46066147\",\n \"0.46066147\",\n \"0.46010828\",\n \"0.4599476\",\n \"0.459565\",\n \"0.459565\",\n \"0.45945814\",\n \"0.45918065\",\n \"0.45768374\",\n \"0.45720977\",\n \"0.45656285\",\n \"0.4558733\",\n \"0.45489088\",\n \"0.4548005\",\n \"0.45425662\",\n \"0.45380637\",\n \"0.45364273\",\n \"0.45324317\",\n \"0.4531618\",\n \"0.4528679\",\n \"0.4525251\",\n \"0.4520095\",\n \"0.4517656\",\n \"0.45131493\",\n \"0.45087543\",\n \"0.44934535\",\n \"0.44720298\",\n \"0.4467636\",\n \"0.44628614\",\n \"0.4449998\",\n \"0.4449998\",\n \"0.44364107\",\n \"0.44359982\",\n \"0.44349152\",\n \"0.44277918\",\n \"0.4420312\",\n \"0.44174784\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5463816"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":25592,"cells":{"query":{"kind":"string","value":"Lay down mutiple gaussians on the xaxis."},"document":{"kind":"string","value":"def gauss(x, mu, A, sigma):\n mu, A, sigma = np.atleast_2d(mu), np.atleast_2d(A), np.atleast_2d(sigma)\n val = (A / (sigma * np.sqrt(np.pi * 2)) *\n np.exp(-(x[:, None] - mu)**2 / (2 * sigma**2)))\n return val.sum(axis=-1)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __draw_xaxis(self):\n self.ax.set_xlim(self.xlims)\n # put x ticks on top\n xticks = [1]\n xticks.extend(range(5, self.xmax+5, 5))\n fs = self.settings.rcParams[\"axes.labelsize\"] if self.settings.otherParams[\n \"xlabel.fontsize\"] is None else self.settings.otherParams[\"xlabel.fontsize\"]\n color = self.settings.rcParams[\"axes.labelcolor\"] if self.settings.otherParams[\n \"xlabel.color\"] is None else self.settings.otherParams[\"xlabel.color\"]\n self.ax.set_xticks(xticks)\n self.ax.set_xticklabels(xticks[:-1])\n self.ax.set_xlabel(self.xaxis_label, fontsize=fs, color=color)\n self.ax.xaxis.set_label_coords(\n *self.settings.otherParams[\"xlabel.position\"])","def hide_x_ticks():\n ax = plt.gca()\n ax.axes.get_xaxis().set_ticks([])","def to_x_coordinates(self):\n self.plotter.to_x_coordinates(self.ax)\n self.plotter.replot(self.ax)\n self.plotter.cells.draw(self.ax)\n self.x_label.set_text(self.plotter.plot_xlabel)\n self.fig.canvas.draw()","def __set_ax_prop(self, ax):\n ax.set_xticks([])\n ax.set_yticks([])","def add_grid(axs, xax=True):\r\n\r\n for ax in axs:\r\n ax.grid(color='grey', linewidth=0.25, zorder=0)\r\n ax.xaxis.grid(xax)","def format_regression_axis(ax):\n ax.set_xticks(np.arange(0, 1.1, 0.25))\n ax.set_yticks(np.arange(0, 1.1, 0.25))\n ax.set_xticklabels('')\n ax.set_yticklabels('')\n ax.set_xlabel('')\n ax.set_ylabel('')\n ax.set_xlim([0, 1])\n ax.set_ylim([0, 1])\n sn.despine(ax=ax)","def reverse_x():\n plt.xlim(plt.xlim()[::-1])","def plot_xents(name, col1=\"darkblue\", col2=\"darkred\", ylim=0.2):\n\n mean5 = np.loadtxt(\"mean5_{}.txt\".format(name))\n mean15 = np.loadtxt(\"mean15_{}.txt\".format(name))\n pos1 = np.arange(1, len(mean5)+1)\n pos2 = np.arange(1, len(mean15)+1)\n\n sns.set_style(\"darkgrid\")\n plt.plot(pos1, mean5, col1, pos2, mean15, col2, linewidth=2.0)\n\n plt.xlabel(\"Position in sequence\")\n plt.ylabel(\"Increase in CrossEntropy\")\n plt.title(\"CrossEntropy perturbation per position in {} sequences\".format(\n str(name)))\n\n plt.ylim([0, ylim])\n patch1 = mpatches.Patch(color=col1, label='window = 5 aa')\n patch2 = mpatches.Patch(color=col2, label='window = 15 aa')\n plt.legend(handles=[patch1, patch2], loc=1)\n\n plt.show()","def _plot_rawdata(self):\n fig, ax = plt.subplots(1, 1)\n ax.imshow(self.data, origin='top')\n ax.set_title('Gauss-Legendre Quadrature Grid')\n ax.set_xlabel('longitude index')\n ax.set_ylabel('latitude index')\n fig.tight_layout(pad=0.5)\n return fig,ax","def _nice_axes(self, ax):\n ax.ticklabel_format(axis='y', style='sci', scilimits=(-2, 3))\n pstyle.set_xaxis_label(ax)\n try:\n pstyle.set_xLimits(self.twiss_df.SEQUENCE, ax)\n except pstyle.ArgumentError:\n pass\n if self._ip_pos is not None and len(self._ip_pos) > 0:\n pstyle.show_ir(self._ip_pos, ax)","def xz_combined(Feaff, Fe, Fi, muVn, length, x, z):\n\n fig, ax = plt.subplots(figsize=(8, 6))\n\n plt.title(\n '$\\\\nu_e^{aff}$, $\\\\nu_e$, $\\\\nu_i$ and $\\\\mu_V^{N}$ for pixel (' + str(x) + ', ' + str(z) + ')')\n axes = [ax, ax.twinx(), ax.twinx(), ax.twinx()]\n\n fig.subplots_adjust(right=0.75)\n axes[-2].spines['right'].set_position(('axes', 1.3))\n axes[-2].set_frame_on(True)\n axes[-2].patch.set_visible(False)\n axes[-1].spines['right'].set_position(('axes', 1.6))\n axes[-1].set_frame_on(True)\n axes[-1].patch.set_visible(False)\n\n axes[0].plot(Feaff[:length, x, z], color='Blue')\n axes[0].set_ylabel('$\\\\nu_e^{aff}(x, t)$', color='Blue')\n axes[0].set_xlabel('t (ms)')\n axes[0].tick_params(axis='y', colors='Blue')\n\n axes[1].plot(Fe[:length, x, z], color='Orange')\n axes[1].set_ylabel('$\\\\nu_e(x, t)$', color='Orange')\n axes[1].set_xlabel('t (ms)')\n axes[1].tick_params(axis='y', colors='Orange')\n\n axes[2].plot(Fi[:length, x, z], color='Green')\n axes[2].set_ylabel('$\\\\nu_i(x, t)$', color='Green')\n axes[2].set_xlabel('t (ms)')\n axes[2].tick_params(axis='y', colors='Green')\n\n axes[3].plot(muVn[:length, x, z], color='Red')\n axes[3].set_ylabel('$\\\\mu_V^{N}(x, t)$', color='Red')\n axes[3].set_xlabel('t (ms)')\n axes[3].tick_params(axis='y', colors='Red')\n\n plt.setp(\n ax,\n xticks=np.linspace(0, length, 5),\n xticklabels=np.linspace(0, length/2, 5, dtype=int)\n )\n fig.tight_layout()\n plt.show()\n\n return","def thin_xticks(ax, n):\n ax.xaxis.set_major_locator(MaxNLocator(n + 1))","def setupXAxis(plot, minVal, maxVal, label, logarithmic):\n plot.set_xlabel(label)\n\n if logarithmic:\n plot.set_xscale(\"log\")\n plot.set_xlim(minVal, maxVal)\n # plot.set_xscale('log', basex=2)\n # tickLabels = [1]\n # labelValue = minVal\n # while labelValue <= maxVal:\n # tickLabels.append (labelValue)\n # labelValue = labelValue*2\n # # Expand the axis a little above and below the data\n # inflationFactor = 0.95\n # plot.set_xlim(minVal*inflationFactor, maxVal/inflationFactor)\n # # Need a blank label on the front for the added axis point on the left. No need for an extra\n # # annotation on the right.\n # plot.set_xticklabels([' '] + tickLabels)\n else:\n plot.set_xlim((0 if minVal == 1 else minVal), maxVal)","def xax(self):\n return self.__xax","def format_x_axis(self, x_tick, x_limits):\n self._fig.update_layout(\n xaxis=dict(\n range=x_limits,\n dtick=x_tick,\n ),\n )","def xlim(self, left=None, right=None):\r\n for ax in self._subaxes:\r\n ax.set_xlim(left, right)\r\n self.figure.canvas.draw()","def simple_xy_axes(ax):\n\n # Hide the right and top spines\n ax.spines['right'].set_visible(False)\n ax.spines['top'].set_visible(False)\n\n # Only show ticks on the left and bottom spines\n ax.yaxis.set_ticks_position('left')\n ax.xaxis.set_ticks_position('bottom')","def triangle_axis(ax):\n ax.spines['right'].set_visible(False)\n ax.spines['top'].set_visible(False)\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')","def xaxis ( self ) :\n return self.__xaxis","def xaxis ( self ) :\n return self.__xaxis","def xaxis ( self ) :\n return self.__xaxis","def gx_set_labels_and_ticks_over_360deg(ax):\n \n #~ plt.gca().invert_xaxis()\n ax.set_ylim(-20, 40)\n #~ ax.set_xlim(380, 260)\n ax.set_xlim(370, 270)\n\n ax.xaxis.set_major_locator(ticker.MultipleLocator(20))\n t = ax.get_xticks()\n xtick_labels = [int(x) if x<360 else int(x-360) for x in t]\n ax.set_xticklabels(xtick_labels)\n\n ax.set_xlabel('l [deg]')\n ax.set_ylabel('b [deg]')\n ax.set_aspect('equal')\n\n return ax","def flip_x(self):\n self.x_lim_helper.flip_limits()","def flip_x(self):\n self.x_lim_helper.flip_limits()","def fix_auto(self):\n if self.share_x:\n self.rescale_axes(x=True, y=False)\n self.fix_axes_ticks(axis='x')\n if self.share_y:\n self.rescale_axes(x=False, y=True)\n self.fix_axes_ticks(axis='y')","def setup_axes():\n\taxes = visuals.subplots(1, 2, figsize = (14, 7))\n\taxes[1].set_yscale(\"log\")\n\taxes[0].set_xlabel(\"[Fe/H]\")\n\taxes[0].set_ylabel(\"[Sr/Fe]\")\n\taxes[1].set_xlabel(\"[Sr/Fe]\")\n\taxes[1].set_ylabel(\"Stellar Probability Density\")\n\taxes[0].set_xlim([-2.2, 0.2])\n\taxes[0].set_ylim([-2.4, 0.4])\n\taxes[1].set_xlim([-1.4, 0.4])\n\taxes[1].set_ylim([0.05, 50])\n\treturn axes","def x(self):\n return self.axes[1]","def _add_octave_band_xticks(ax, bands=np.array(_third_octave_bands)[:, 0]):\n left, right = ax.get_xlim()\n b = bands[np.logical_and(left <= bands, bands <= right)]\n ax.set_xticks(b)\n ax.set_xticks([], minor=True)\n ax.set_xticklabels([int(round(bs)) for bs in b], minor=False)","def gini_graph(self,x):\n \n name = self['name']\n id = self._getGraphId()\n figname = 'G_%s.eps' % id\n G = self['M_GINI']\n sxlabel = 'Pixel Order' ; sylabel = 'Cumul Flux' \n title = 'Gini, %s, G=%4.2f' % (name,G)\n x = num.sort(x)\n cumul = num.cumsum(x)\n lorenz_y = 100.* cumul/cumul[-1]\n lorenz_x = 100. * (num.arange(len(x))+1)/float(len(x))\n fakearray = num.array([0.,100.])\n xy = ((lorenz_x,lorenz_y),(fakearray,fakearray))\n Plot(xy,figname,sxlabel,sylabel,title)\n self['figures']['gini'] = figname","def style_graph(ax):\n ax.set_facecolor('.8')\n ax.tick_params(labelsize=8, length=5)\n ax.grid(True, axis='x', color='white')\n ax.set_axisbelow(True)\n [spine.set_visible(False) for spine in ax.spines.values()]","def xaxis(self,label,units):\n if units != \"\": label = label + \" (\" + units + \")\"\n self.subplot.set_xlabel(label)\n pass","def make_x_axis(**kwargs):\n xmax = kwargs.get('xmax', 40)\n xmin = kwargs.get('xmin', 0)\n stepsize = kwargs.get('stepsize', 5)\n xlabel = kwargs.get('xlabel', 'Generations from\\nSenescence')\n figsize = kwargs.get('figsize', (2.5, 2.5))\n fontsize = kwargs.get('fontsize', 12)\n savepath = kwargs.get('savepath', f'legend_xlim_{xmin}-{xmax}.svg')\n # Create the figure and plot\n fig = plt.figure(figsize=figsize)\n fig.set_dpi(300)\n ax = fig.add_subplot(111)\n ax.set_xlim(xmin, xmax)\n ax.set_xticks(np.arange(xmin, xmax+1, stepsize))\n # Remove spines\n for spine in [ax.spines[key] for key in ['top', 'right', 'left']]:\n spine.set_visible(False)\n ax.set_xlabel(xlabel, fontsize=fontsize)\n # No y ticks!\n ax.set_yticks([])\n fig.savefig(savepath)","def _extended_discrete_xaxis(x_axis, n_points=100, eps=0.10):\n min_value = np.min(x_axis)\n max_value = np.max(x_axis)\n distance = max_value - min_value\n return np.linspace(min_value - eps * distance, max_value + eps * distance,\n num=n_points)","def clean_axis(ax):\n ax.get_xaxis().set_ticks([])\n ax.get_yaxis().set_ticks([])\n for sp in ax.spines.values():\n sp.set_visible(False)","def hogg_lim_and_label():\n plt.xlim(-20., 1020.)\n plt.xlabel(\"time (d)\")\n plt.ylim(-20., 20.)\n plt.ylabel(\"radial velocity (m\\,s$^{-1}$)\")\n return None","def cla(self):\n # Don't forget to call the base class\n Axes.cla(self)\n \n x_min = 0\n y_min = 0\n x_max = 1\n y_max = 1\n x_spacing = 0.1\n y_spacing = 0.1\n self.xaxis.set_minor_locator(NullLocator())\n self.yaxis.set_minor_locator(NullLocator())\n self.xaxis.set_ticks_position('bottom')\n self.yaxis.set_ticks_position('left')\n Axes.set_xlim(self, x_min, x_max)\n Axes.set_ylim(self, y_min, y_max)\n self.xaxis.set_ticks(np.arange(x_min, x_max+x_spacing, x_spacing))\n self.yaxis.set_ticks(np.arange(y_min, y_max+y_spacing, y_spacing))","def set_xticks(ax, xlabels_log=None, show_log=True):\n if show_log is False:\n ax.set_xscale('log', basex=2) # show regular numbers (512, 1024, ...)\n ax.get_xaxis().set_major_formatter( matplotlib.ticker.ScalarFormatter() )\n else:\n ax.get_xaxis().set_major_formatter( matplotlib.ticker.ScalarFormatter() )\n ax.set_xscale('log', basex=2) # show power number (2^9, 2^10, ...)\n \n if xlabels_log is not None:\n ax.set_xticks(xlabels_log)\n return ax","def plot(self):\n\t\tself.plotOfXray().plot()","def get_axis_x(self):\r\n return self.__x_axis","def uninformativePlot(self):\n\n self.initPlotY()\n for iPlot in range(len(self.plotFineX)):\n thisX = self.plotFineX[iPlot]\n\n self.plotFineY[iPlot] = thisX*0. + 1.","def plot_grid(filename, title, names, x):\n fig = plt.figure(figsize=(10,6))\n ax = fig.add_subplot(111)\n ax.set_title(title)\n plt.imshow(x, interpolation=\"nearest\", cmap=plt.get_cmap(\"hot\"))\n ax.set_aspect('equal')\n plt.xticks(range(6), names, rotation='vertical')\n plt.yticks(range(6), names)\n plt.subplots_adjust(bottom=0.25)\n # ax.set_xticklabels(('',) + names)\n # ax.set_yticklabels(('',) + names)\n cax = fig.add_axes([0.12, 0.1, 0.78, 0.8])\n cax.get_xaxis().set_visible(False)\n cax.get_yaxis().set_visible(False)\n cax.patch.set_alpha(0)\n cax.set_frame_on(False)\n plt.colorbar(orientation='vertical')\n plt.savefig(filename+\".pdf\")\n fig.clear()","def plot_w_xticks(all_xticks, major_xticks, major_xticks_labels, yplots):\n fig = plt.figure()\n graph = fig.add_subplot(111)\n x = all_xticks\n for yplot in yplots:\n graph.plot(x, yplot[0], yplot[1])\n graph.set_xticks(major_xticks)\n graph.set_xticklabels(major_xticks_labels)\n return graph","def plotTotEfixedX(monthlyData):\n \n #assign x-angles (must be equally distributed between 0 and 90 deg)\n Xangles = (np.array(range(len(monthlyData['angles']['y_angles'])))-10)*90./(len(monthlyData['angles']['y_angles'])-1)\n \n fig = plt.figure()\n ax1=plt.subplot(2,1,1)\n plt.plot(Xangles, np.sum(monthlyData['H'], axis=1)/np.mean( np.sum(monthlyData['H'], axis=1)), label='H', color='r')\n plt.plot(Xangles, np.sum(monthlyData['C'], axis=1)/np.mean( np.sum(monthlyData['C'], axis=1)), label='C', color='b')\n plt.plot(Xangles, np.sum(monthlyData['L'], axis=1)/np.mean( np.sum(monthlyData['L'], axis=1)), label='L', color='g')\n plt.plot(Xangles, np.sum(monthlyData['PV'], axis=1)/np.mean( np.sum(monthlyData['PV'], axis=1)), label='PV', color='c')\n plt.plot(Xangles, np.sum(monthlyData['E_HCL'], axis=1)/np.mean( np.sum(monthlyData['E_HCL'], axis=1)), label='E_HCL', color='m')\n plt.plot(Xangles, np.sum(monthlyData['E_tot'], axis=1)/np.mean( np.sum(monthlyData['E_tot'], axis=1)), label='E_tot', color='k')\n plt.legend()\n \n plt.subplot(2,1,2, sharex=ax1)\n plt.plot(Xangles, np.sum(monthlyData['H'], axis=1), label='H', color='r')\n plt.plot(Xangles, np.sum(monthlyData['C'], axis=1), label='C', color='b')\n plt.plot(Xangles, np.sum(monthlyData['L'], axis=1), label='L', color='g')\n plt.plot(Xangles, np.sum(monthlyData['PV'], axis=1), label='PV', color='c')\n plt.plot(Xangles, np.sum(monthlyData['E_HCL'], axis=1), label='E_HCL', color='m')\n plt.plot(Xangles, np.sum(monthlyData['E_tot'], axis=1), label='E_tot', color='k')\n plt.legend()\n \n return fig","def populate_plot_axis(self,plot,ax='x'):\n\n fig=plt.gcf()\n\n extra_ax=[]\n\n if ax=='x':\n\n ticks=plot.get_xticks()\n\n lim=plot.get_xlim()\n\n for i in range(len(self.names)):\n\n if i==0:\n\n axn=plot\n\n axn.spines['bottom'].set_position(('outward',10))\n\n axn.spines['bottom'].set_visible(True)\n\n else:\n\n dy_fig=0.08\n\n prev_ax_position=axn.get_position()\n\n extra_ax.append(fig.add_axes(\\\n (prev_ax_position.x0,\\\n prev_ax_position.y0-2*dy_fig,\\\n prev_ax_position.width,\\\n 0),'autoscalex_on',True))\n\n axn=extra_ax[i-1]\n\n axn.yaxis.set_visible(False)\n\n for side in axn.spines.keys():\n\n axn.spines[side].set_linewidth(1)\n\n axn.set_xticks(ticks)\n\n ticksnames=[float(str(x)) for x in self.values[i]]\n\n axn.set_xticklabels(\\\n [\"{:.2f}\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\n rotation = 45)\n\n xlab=axn.set_xlabel(self.names[i])\n\n xlab.set_fontsize(10)\n\n axn.tick_params(axis='x',labelsize=10)\n\n axn.set_xlim(lim)\n\n\n\n elif ax=='y':\n\n ticks=plot.get_yticks()\n\n lim=plot.get_ylim()\n\n for i in range(len(self.names)):\n\n if i==0:\n\n axn=plot\n\n axn.spines['left'].set_position(('outward',10))\n\n axn.spines['left'].set_visible(True)\n\n else:\n\n dx_fig=0.08\n\n plot_position=plot.get_position()\n\n prev_ax_position=axn.get_position()\n\n extra_ax.append(fig.add_axes(\\\n (prev_ax_position.x0-2*dx_fig,\\\n prev_ax_position.y0,\\\n 0,\\\n prev_ax_position.height),'autoscalex_on',True))\n\n axn=extra_ax[i-1]\n\n axn.xaxis.set_visible(False) # hide the yaxis\n\n for side in axn.spines.keys(): # 'top', 'bottom', 'left', 'right'\n\n axn.spines[side].set_linewidth(1)\n\n axn.set_yticks(ticks)\n\n ticksnames=[float(str(x)) for x in self.values[i]]\n\n axn.set_yticklabels(\\\n [\"{:.2f}\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\n rotation = 45)\n\n ylab=axn.set_ylabel(self.names[i])\n\n ylab.set_fontsize(10)\n\n axn.tick_params(axis='y',labelsize=10)\n\n axn.set_ylim(lim)\n\n else:\n\n raise ValueError(\"Axis can be 'x' or 'y'\")","def xaxis(self):\n return self._xaxis","def setup_axes():\n fig, ax = plt.subplots(1)\n\n ax.set_xlabel(\"Density [$n_H$ cm$^{-3}$]\")\n ax.set_ylabel(\"Temperature [K]\")\n\n ax.loglog()\n\n return fig, ax","def AllSidesTicks( ax ):\n return; ## depreceate for now as it doesn't work correctly...\n axy = ax.twinx()\n axy.set_ylim( ax.get_ylim() )\n axy.set_yscale( ax.get_yscale() )\n axy.set_yticklabels(labels=[])\n\n axx = ax.twiny()\n axx.set_xlim( ax.get_xlim() )\n axx.set_xscale( ax.get_xscale() )\n axx.set_xticklabels(labels=[])","def plot_Gini(self):\n p = np.linspace(0,1, 1000)\n not_p = 1 - p\n \n gini = 1 - np.sum(np.c_[p, not_p]**2, axis=1)\n fig, ax = plt.subplots(1,1, figsize=(10,5))\n _ = ax.plot(p, gini)\n _ = ax.set_xlabel(\"p\")\n _ = ax.set_ylabel(\"Gini\")\n _ = ax.set_title(\"Gini: Two class example\")\n\n return fig, ax","def plot_XDR_PDR_Gauss():\n\n fig,axes = plt.subplots(nrows=2, ncols=2, squeeze=True, sharex='col', sharey='row', figsize=(6,6))\n fig.subplots_adjust(hspace=0, wspace=0) #, top=0.80, bottom=0.04, left=0.04, right=0.93)\n\n # get data\n sscs = [SSC['no'] for SSC in SSCs]\n colors = [plt.cm.inferno(i/(len(SSCs)+1)) for i in SSCs['no']]\n HCO_HCN, HNC_HCN, HNC_HCO = [],[],[]\n HCO_HCN_err, HNC_HCN_err, HNC_HCO_err = [],[],[]\n for SSC in SSCs:\n try:\n hco_hcn = ratios_Gauss['HCO+/HCN'][SSC['num']]['bestfit']\n hco_hcn_err = ratios_Gauss['HCO+/HCN'][SSC['num']]['error']\n HCO_HCN.append( np.log10(hco_hcn) )\n HCO_HCN_err.append( 0.434*hco_hcn_err/hco_hcn )\n except:\n HCO_HCN.append( np.nan )\n HCO_HCN_err.append( np.nan )\n try:\n hnc_hcn = ratios_Gauss['HNC/HCN'][SSC['num']]['bestfit']\n hnc_hcn_err = ratios_Gauss['HNC/HCN'][SSC['num']]['error']\n HNC_HCN.append( np.log10(hnc_hcn) )\n HNC_HCN_err.append( 0.434*hnc_hcn_err/hnc_hcn )\n except:\n HNC_HCN.append( np.nan )\n HNC_HCN_err.append( np.nan )\n try:\n hnc_hco = ratios_Gauss['H15NC/HCO+'][SSC['num']]['bestfit']*ratios_Gauss['14N/15N'][SSC['num']]['bestfit']\n hnc_hco_err = np.sqrt( (ratios_Gauss['H15NC/HCO+'][SSC['num']]['error']/ratios_Gauss['H15NC/HCO+'][SSC['num']]['bestfit'])**2 +(ratios_Gauss['14N/15N'][SSC['num']]['error']/ratios_Gauss['14N/15N'][SSC['num']]['bestfit'])**2 )\n HNC_HCO.append( np.log10(hnc_hco) )\n HNC_HCO_err.append( 0.434*hnc_hco_err/hnc_hco )\n except:\n HNC_HCO.append( np.nan )\n HNC_HCO_err.append( np.nan )\n\n # comparison from Baan+08\n B_hcn = [318.2, 14]\n B_hnc = [234.0, 7]\n B_hco = [276.1, 14]\n B_hco_hcn = [B_hco[0]/B_hcn[0], B_hco[0]/B_hcn[0]*np.sqrt((B_hco[1]/B_hco[0])**2+(B_hcn[1]/B_hcn[0])**2)]\n B_hnc_hcn = [B_hnc[0]/B_hcn[0], B_hnc[0]/B_hcn[0]*np.sqrt((B_hnc[1]/B_hnc[0])**2+(B_hcn[1]/B_hcn[0])**2)]\n B_hnc_hco = [B_hnc[0]/B_hco[0], B_hnc[0]/B_hco[0]*np.sqrt((B_hnc[1]/B_hnc[0])**2+(B_hco[1]/B_hco[0])**2)]\n B_HCO_HCN = [np.log10(B_hco_hcn[0]), 0.434*B_hco_hcn[1]/B_hco_hcn[0]]\n B_HNC_HCN = [np.log10(B_hnc_hcn[0]), 0.434*B_hnc_hcn[1]/B_hnc_hcn[0]]\n B_HNC_HCO = [np.log10(B_hnc_hco[0]), 0.434*B_hnc_hco[1]/B_hnc_hco[0]]\n\n def format_panel(ax):\n ax.xaxis.set_major_locator(MultipleLocator(0.5))\n ax.xaxis.set_minor_locator(MultipleLocator(0.25))\n ax.yaxis.set_major_locator(MultipleLocator(0.5))\n ax.yaxis.set_minor_locator(MultipleLocator(0.25))\n ax.set_axisbelow(True)\n ax.grid(axis='both', which='both')\n\n def label_regions(ax):\n ax.text(0.95, 0.9, 'XDR', color='k', transform=ax.transAxes, ha='right', va='top', weight='bold', fontsize=16)\n ax.text(0.05, 0.1, 'PDR', color='k', transform=ax.transAxes, ha='left', va='bottom', weight='bold', fontsize=16)\n\n # panel 1: HCO+/HCN over HNC/HCO+\n ax = axes[0][0]\n ax.plot([-10,10],[10,-10], ls='-', lw=1, c='grey', zorder=2)\n ax.fill_between([-10,10],[10,-10],[10,10], color='lightgrey', alpha=0.5, zorder=1)\n label_regions(ax)\n for a,b,a_err,b_err,c,s in zip(HNC_HCO, HCO_HCN, HNC_HCO_err, HCO_HCN_err, colors, SSCs):\n if np.isfinite(a) and np.isfinite(b):\n ax.errorbar(a,b, xerr=a_err, yerr=b_err, marker='o', ms=5, lw=0, color=c, elinewidth=1, ecolor=c, label='SSC '+str(s['no']), zorder=3)\n ax.errorbar(B_HCO_HCN[0],B_HNC_HCO[0], xerr=B_HCO_HCN[1], yerr=B_HNC_HCO[1], marker='o', ms=5, lw=0, color='lime', elinewidth=1, ecolor='lime', label=r'NGC 253 (Baan +08)', zorder=4)\n ax.set_xlim(-1.15,0.45)\n ax.set_ylim(-0.80,0.80)\n format_panel(ax)\n ax.set_ylabel(r'log I(HCO$^+$) / I(HCN)', fontsize=12)\n\n # panel 2: HNC/HCN over HCO/HCN\n ax = axes[0][1]\n ax.plot([0,0],[-10,10], ls='-', lw=1, c='grey', zorder=2)\n ax.fill_between([0,10],[-10,-10],[10,10], color='lightgrey', alpha=0.5, zorder=1)\n label_regions(ax)\n for a,b,a_err,b_err,c in zip(HNC_HCN, HCO_HCN, HNC_HCN_err, HCO_HCN_err, colors):\n if np.isfinite(a) and np.isfinite(b):\n ax.errorbar(a,b, xerr=a_err, yerr=b_err, marker='o', ms=5, lw=0, color=c, elinewidth=1, ecolor=c, zorder=3)\n ax.errorbar(B_HNC_HCN[0],B_HCO_HCN[0], xerr=B_HCO_HCN[1], yerr=B_HNC_HCO[1], marker='o', ms=5, lw=0, color='lime', elinewidth=1, ecolor='lime', zorder=4)\n ax.set_xlim(-1.15,0.45)\n ax.set_ylim(-0.80,0.80)\n ax.xaxis.set_tick_params(which='both', labelbottom=True)\n format_panel(ax)\n ax.set_xlabel(r'log I(HNC) / I(HCN)', fontsize=12)\n\n # panel 3: HNC/HCO over HNC/HCN\n ax = axes[1][0]\n ax.plot([-10,10],[0,0], ls='-', lw=1, c='grey', zorder=2)\n ax.fill_between([-10,10],[0,0],[10,10], color='lightgrey', alpha=0.5, zorder=1)\n label_regions(ax)\n for a,b,a_err,b_err,c in zip(HNC_HCO, HNC_HCN, HNC_HCO_err, HNC_HCN_err, colors):\n if np.isfinite(a) and np.isfinite(b):\n ax.errorbar(a,b, xerr=a_err, yerr=b_err, marker='o', ms=5, lw=0, color=c, elinewidth=1, ecolor=c, zorder=3)\n ax.errorbar(B_HNC_HCO[0],B_HNC_HCN[0], xerr=B_HCO_HCN[1], yerr=B_HNC_HCO[1], marker='o', ms=5, lw=0, color='lime', elinewidth=1, ecolor='lime', zorder=4)\n ax.set_xlim(-1.15,0.45)\n ax.set_ylim(-1.00,0.60)\n format_panel(ax)\n ax.set_xlabel(r'log I(HNC$^{**}$) / I(HCO$^+$)', fontsize=12)\n ax.set_ylabel(r'log I(HNC) / I(HCN)', fontsize=12)\n\n # panel 4: legend\n ax = axes[1][1]\n ax.set_axis_off()\n fig.legend(loc=3, bbox_to_anchor=(0.55,0.05,0.14,0.3), ncol=1, mode=\"expand\", borderaxespad=0., fontsize=12, frameon=False)\n\n savepath = escape_fname(os.path.join(plotdir, '10.results', 'XDR-PDR_line_ratio.pdf'))\n os.system('mkdir -p '+os.path.dirname(savepath))\n fig.savefig(savepath, dpi=300, bbox_inches='tight')","def one_period_plot():\n file = \"Data/matfiles/20131221.mat\"\n object = MatReader(file)\n\n NeA = object.NeA\n latA = object.latA\n times = object.secondsA\n mlt = object.mltA\n ind1 = 2606 #lat inds\n ind2 = 13940 #lat inds\n \n ind1 = 3197 #mlat inds\n ind2 = 14390 #mlat inds\n \n T = ind2 - ind1\n ind1 += int(T/2)\n ind2 += int(T/2)\n\n latA = latA[ind1:ind2]\n NeA = NeA[ind1:ind2]\n # NeA = object.meanie(NeA, 5)\n times = times[ind1:ind2]\n mlt = mlt[ind1:ind2]\n mlt = hour_round(mlt)\n\n lats = np.zeros_like(latA)\n lats[0] = latA[0]\n for i in range(len(latA)-1):\n dlat = latA[i+1] - latA[i]\n if dlat < 0:\n lats[i+1] = lats[i] - dlat\n else:\n lats[i+1] = lats[i] + dlat\n\n lats += 90\n\n xticks = np.array([-90, -70, -30, 30, 70, 110, 150, 210, 250, 270]) + 90\n gridticks = np.array([-90, -70, -30, 30, 70, 77, 103, 110, 150, 210, 250, 270]) + 90\n # plt.plot(lats, NeA, \".\", markersize = 1)\n # plt.plot([0, 0], [0, np.max(NeA)], \"k\")\n # plt.plot([30, 30], [0, np.max(NeA)], \"k\")\n # plt.plot([60, 60], [0, np.max(NeA)], \"k\")\n # plt.plot([120, 120],[0, np.max(NeA)], \"k\")\n # plt.plot([150, 150], [0, np.max(NeA)], \"k\")\n # plt.plot([167, 167], [0, np.max(NeA)], \"k\")\n # plt.plot([193, 193], [0, np.max(NeA)], \"k\")\n # plt.plot([210, 210], [0, np.max(NeA)], \"k\")\n # plt.plot([240, 244], [0, np.max(NeA)], \"k\")\n # plt.plot([300, 300], [0, np.max(NeA)], \"k\")\n # plt.plot([330, 330], [0, np.max(NeA)], \"k\")\n # plt.plot([360, 360], [0, np.max(NeA)], \"k\")\n # plt.xticks(xticks)\n # plt.xlabel(\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\")\n # plt.ylabel(\"Electron density [cm$^{-1}$]\")\n # plt.title(\"One SWARM satellite period\")\n # plt.grid(\"on\", axis = \"x\", xdata = gridticks)\n #adding letters\n x = (gridticks[:-1] + gridticks[1:])/2 - 3\n y = np.zeros_like(x) - np.max(NeA)/40\n s = [\"S\", \"B\", \"A\", \"B\", \"C\", \"D\", \"C\", \"B\", \"A\", \"B\", \"S\"]\n # for i in range(len(x)):\n # plt.text(x[i], y[i], s[i], fontsize = 10)\n # plt.savefig(\"Figures/swarm_period.pdf\")\n # plt.show()\n\n # plt.plot(times, latA)\n # plt.plot(times, mlt)\n # plt.show()\n print(lats[0])\n print(lats[-1])\n \n fig, ax = plt.subplots()\n ax.plot(lats, NeA, \".\", markersize = 1)\n ax.set_xticks(xticks, minor=False)\n ax.set_xticks([167, 193], minor=True)\n ax.xaxis.grid(True, which = \"major\")\n ax.xaxis.grid(True, which = \"minor\")\n for i in range(len(x)):\n ax.text(x[i], y[i], s[i], fontsize = 10)\n ax.set_xlabel(\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\")\n ax.set_ylabel(\"Electron density [cm$^{-1}$]\")\n ax.set_title(\"One Swarm satellite period\")\n # plt.savefig(\"Figures/swarm_period.pdf\")\n plt.show()\n plt.plot(mlt, NeA)\n plt.show()\n plt.plot(mlt, lats)\n plt.show()","def test_negative_ticks(self):\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n ax.set_ternary_min(0, 3, -3)","def figure_10_12_b():\n xs = np.arange(-6,6,0.1)\n plt.plot(xs,sigmoid(xs))\n x=2.5\n plt.scatter(x,sigmoid(x))\n plt.plot(xs,logistic_lower_bound(xs,x))\n plt.show()","def style_x_labels(fig):\r\n for label in fig.get_xticklabels():\r\n label.set_rotation(36)\r\n label.set_fontsize(9)","def secondaryXaxis(low,high,first,step,length,name,direction,x,y,log=0):\n if log:\n dislin.xaxlg(low,high,first,step,length,name,direction,x,y)\n else:\n dislin.xaxis(low,high,first,step,length,name,direction,x,y)","def scree_plot(self, ev):\n plt.scatter(range(1,len(ev)+1), ev)\n plt.plot(range(1,len(ev)+1), ev)\n plt.title(\"Scree Plot\")\n plt.xlabel(\"Factors\")\n plt.ylabel(\"Eigenvalue\")\n plt.grid()\n plt.show()","def _hr_mean_style_x_axis(ax: plt.Axes, phase_dict: Dict[str, Sequence[str]], num_subphases: Sequence[int], **kwargs):\n if sum(num_subphases) == 0:\n # no subphases\n ax.set_xticklabels(phase_dict.keys())\n ax.set_xlabel(kwargs.get(\"xlabel\", \"Phases\"))\n else:\n ax.set_xticklabels([s for subph in phase_dict.values() for s in subph])\n ax.set_xlabel(kwargs.get(\"xlabel\", \"Subphases\"))","def visulize_5(X):\n fig, axes1 = plt.subplots(5,5,figsize=(3,3))\n for j in range(5):\n for k in range(5):\n i = np.random.choice(range(len(X)))\n axes1[j][k].set_axis_off()\n axes1[j][k].imshow(X[:,i].reshape(32, 32, 3))\n plt.show()","def set_x_axis_scale_to_pi():\n\n # Para formatear el eje X con multiplos de PI\n # Defino aqui la funcion para que no ensucie el resto del codigo\n def format_func(value, tick_number):\n # Calcula el numero de multiplos de PI / 2\n N = int(np.round(2 * value / np.pi))\n\n # Formatea acorde a este multiplo\n if N == 0:\n return \"0\"\n elif N == 1:\n return r\"$\\pi/2$\"\n elif N == 2:\n return r\"$\\pi$\"\n elif N % 2 > 0:\n return r\"${0}\\pi/2$\".format(N)\n else:\n return r\"${0}\\pi$\".format(N // 2)\n\n # Toma el objeto ax para hacer manipulaciones complejas del plot\n _, ax = plt.subplots()\n\n # Coloca los multiplos descritos\n ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))\n ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))\n ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))","def visualisation(self):\n plt.plot(self.x, self.y, 'o', label = 'Example data')\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\n plt.xlim([-1,1])\n plt.ylim([-1,1])","def frame():\n fig = plt.figure(figsize = (6, 3))\n\n plt.subplots_adjust(left=.15, bottom=.2, right=.95, top=.9)\n ax = fig.add_subplot(111)\n \n ax.tick_params(axis=\"x\", labelsize=12)\n ax.tick_params(axis=\"y\", labelsize=12)\n\n return fig, ax","def graphe_gains(res_alea, res_glou, res_glou_e, res_ucb):\n T = np.arange(res_alea.size)\n fig, ax = plt.subplots()\n ax.grid(True)\n plt.xlabel(\"T\")\n plt.ylabel(\"Gain\")\n \n ax.plot(T, res_alea, label = 'aléatoire') \n ax.plot(T, res_glou, label = 'glouton')\n ax.plot(T, res_glou_e, label = 'e-glouton')\n ax.plot(T, res_ucb, label = 'UCB')\n ax.legend(loc = \"upper left\")\n plt.title(\"Gains des 4 algorithmes par rapport à T\")","def clean_chart(ax):\n edges = ['top', 'bottom', 'right', 'left']\n ax.tick_params(color=cbox('dark gray'))\n for edge in edges:\n ax.spines[edge].set_color(cbox('dark gray'))\n ax.spines[edge].set_linewidth(0.4)\n ax.yaxis.label.set_color(cbox('dark gray'))\n ax.xaxis.label.set_color(cbox('dark gray'))\n ax.tick_params(axis='x', colors=(0.05, 0.05, 0.05), width=0.5, which='major', top=True)\n ax.tick_params(axis='y', colors=(0.05, 0.05, 0.05), width=0.5, which='major', left=True)","def setup_figure(xmin):\n # Setup gridspec\n gs = gridspec.GridSpec(1, 2)\n gs.update(wspace=0.00, hspace=0.00)\n\n # Setup figure\n w, h = plt.figaspect(0.5)\n fig = plt.figure(figsize=(w, h))\n logax = fig.add_subplot(gs[0])\n linax = fig.add_subplot(gs[1])\n\n # Axis formatting\n linax.set_xlim([0.1, 1])\n logax.set_xlim([min(gpdata[\"xgrid\"]), 0.1])\n plt.setp(linax.get_yticklabels(), visible=False)\n logax.set_xscale('log')\n linax.xaxis.set_major_locator(MaxNLocator(5, prune='lower'))\n return fig, logax, linax","def set_up(self):\n self.h, = self.ax.plot(self.x, lw=2)\n self.ax.set_ylim(0,100)\n self.ax.set_xlim(0,100)\n self.ax.title.set_text(self.config[\"title\"])\n self.ax.set_xlabel(self.config[\"x_label\"])\n self.ax.set_ylabel(self.config[\"y_label\"])","def set_ax_lims(ax, xs, ys, width=2.5):\n center = (xs.mean(), ys.mean())\n xlim, ylim = compute_xy_lims(center, width)\n ax.set_xlim(xlim)\n ax.set_ylim(ylim)","def set_xscale(self, value):\n if value in [\"linear\", \"lin\"]:\n self._pad.SetLogx(0)\n self._logx = False\n\n elif value in [\"log\", \"logy\"]:\n left, right = self.get_xlim()\n if right <= 0:\n warnings.warn(\n \"Current frame has no positive values, and therefore cannot \"\n \"be log-scaled. Try running ax.set_xlim() first.\"\n )\n elif left <= 0:\n # Arbitrarily set left to 0.1 (or 0.1*right if right <= 0.1)\n # so that the frame can be displayed\n if right <= 0.1:\n self.set_xlim(left=0.1 * right)\n else:\n self.set_xlim(left=0.1)\n\n self._pad.cd()\n self._pad.SetLogx(1)\n self._pad.Modified()\n self._logx = True","def show_grid(self):\n for ax in (self.time_velocity, self.time_power, self.power_velocity):\n ax.grid(True)","def plot1dim(i_dim):\n freq = plt.hist(x=x[:,i_dim], bins=min(100,4*self.grid_shape[i_dim]))[0]\n plt.plot(self.xg[i_dim][:,0],np.zeros(self.grid_shape[i_dim]) + 0.5*np.max(freq),'ko',markersize=3)\n plt.xlabel(r'x_%d'%i_dim)\n plt.ylabel('Frequency')\n plt.title('Dim %d, m = %d' % (i_dim, self.grid_shape[i_dim]))","def get_xticks_labels(self):\n xticks = np.arange(-1, self.space_between_glyphs * len(self.coevolving_positions) * 3)\n xticklabels = [' ']\n for p1, p2 in self.coevolving_positions:\n xticklabels += [str(p1), ' ', str(p2)] + [' '] * self.space_between_glyphs\n return xticks, xticklabels","def l_x_normalized(self):\n return (self.l_x_axis - 128) / 127","def userToPlotX(x):\n return dislin.nxposn(x)","def generate_plot(self):\r\n\t\tx, y = zip(*[p.p for p in self.universe])\r\n\t\tself.ax.cla()\r\n\t\tself.ax.plot(x, y, '.')\r\n\t\tself.ax.set_title('Universe at time: %d' % self.universe.time)\r\n\t\tself.ax.set_xlim([P_MU-4*P_STD, P_MU+4*P_STD])\r\n\t\tself.ax.set_ylim([P_MU-4*P_STD, P_MU+4*P_STD])","def plot_U_vectors(self, ax):\n U = self.U\n t = self.t\n fig = figure(figsize=(12,7))\n axs = []\n for i in range(8):\n ax = fig.add_subplot(240 + (i+1))\n ax.plot(t, U[:,i], 'k-', lw=2.0)\n ax.grid()\n if i > 3: ax.set_xlabel(r'$t$')\n ax.set_title(r'$\\vec{u}_{%i}$' % i)\n show()","def centerAxis():\n dislin.center()","def plot_mean_and_max():\n plt.rc('font', size=16)\n data = np.array(\n [\n [0.0000, 0.000, 0.002],\n [0.0001, 0.000, 0.000],\n [0.0005, 0.001, 0.008],\n [0.0008, 0.001, 0.003],\n [0.0012, 0.002, 0.005],\n [0.0100, 0.016, 0.041],\n [0.0150, 0.025, 0.068],\n [0.0200, 0.039, 0.096],\n [0.0300, 0.053, 0.140],\n [0.0400, 0.080, 0.242],\n [0.0500, 0.098, 0.202]\n ])\n rb, mean, maxd = data[:, 0], data[:, 1], data[:, 2]\n plt.plot(rb, mean, marker='.', markerfacecolor='steelblue',\\\n markeredgecolor='steelblue', linestyle=' ', markersize=15)\n plt.plot(rb, maxd, marker='.', markerfacecolor='orchid',\\\n markeredgecolor='orchid', linestyle=' ', markersize=15)\n plt.grid()\n plt.xlabel(r'$r_B$')\n plt.ylabel(r'$\\delta\\beta$ (deg)')\n # plt.ylim([0., 0.15])\n plt.tight_layout()\n # plt.semilogx()\n # plt.semilogy()\n\n plt.show()","def make_montage_axial(overlay, underlay, png_name, cbar_name):\n import matplotlib\n import commands\n# matplotlib.use('Agg')\n import os\n matplotlib.rcParams.update({'font.size': 5})\n import matplotlib.cm as cm\n ###\n try:\n from mpl_toolkits.axes_grid1 import ImageGrid\n except:\n from mpl_toolkits.axes_grid import ImageGrid\n import matplotlib.pyplot as plt\n import matplotlib.colors as col\n import nibabel as nb\n import numpy as np\n\n def determine_start_and_end(data, direction, percent):\n x, y, z = data.shape\n xx1 = 0\n xx2 = x - 1\n zz1 = 0\n zz2 = z - 1\n total_non_zero_voxels = len(np.nonzero(data.flatten())[0])\n thresh = percent * float(total_non_zero_voxels)\n start = None\n end = None\n if 'axial' in direction:\n while(zz2 > 0):\n d = len(np.nonzero(data[:, :, zz2].flatten())[0])\n if float(d) > thresh:\n break\n zz2 -= 1\n while(zz1 < zz2):\n d = len(np.nonzero(data[:, :, zz1].flatten())[0])\n if float(d) > thresh:\n break\n zz1 += 1\n start = zz1\n end = zz2\n else:\n while(xx2 > 0):\n d = len(np.nonzero(data[xx2, :, :].flatten())[0])\n if float(d) > thresh:\n break\n xx2 -= 1\n while(xx1 < xx2):\n d = len(np.nonzero(data[xx1, :, :].flatten())[0])\n if float(d) > thresh:\n break\n xx1 += 1\n start = xx1\n end = xx2\n return start, end\n def get_spacing(across, down, dimension):\n space = 10\n prod = (across*down*space)\n if prod > dimension:\n while(across*down*space) > dimension:\n space -= 1\n else:\n while(across*down*space) < dimension:\n space += 1\n return space\n\n Y = nb.load(underlay).get_data()\n X = nb.load(overlay).get_data()\n X = X.astype(np.float16)\n Y = Y.astype(np.float16)\n\n if 'skull_vis' in png_name:\n X[X < 20.0] = 0.0\n if 'skull_vis' in png_name or 't1_edge_on_mean_func_in_t1' in png_name or 'MNI_edge_on_mean_func_mni' in png_name:\n max_ = np.nanmax(np.abs(X.flatten()))\n X[X != 0.0] = max_\n print '^^', np.unique(X)\n z1, z2 = determine_start_and_end(Y, 'axial', 0.0001)\n spacing = get_spacing(6, 3, z2 - z1)\n x, y, z = Y.shape\n fig = plt.figure(1)\n max_ = np.max(np.abs(Y))\n\n if ('snr' in png_name) or ('reho' in png_name) or ('vmhc' in png_name) or ('sca_' in png_name) or ('alff' in png_name) or ('centrality' in png_name) or ('temporal_regression_sca' in png_name) or ('temporal_dual_regression' in png_name):\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, cbar_mode=\"single\", cbar_pad=0.2, direction=\"row\")\n else:\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, direction=\"row\")\n\n zz = z1\n for i in range(6*3):\n\n if zz >= z2:\n break\n\n im = grid[i].imshow(np.rot90(Y[:, :, zz]), cmap=cm.Greys_r)\n zz += spacing\n\n x, y, z = X.shape\n X[X == 0.0] = np.nan\n max_ = np.nanmax(np.abs(X.flatten()))\n print '~~', max_\n\n\n zz = z1\n im = None\n print '~~~', z1, ' ', z2\n for i in range(6*3):\n\n\n if zz >= z2:\n break\n if cbar_name is 'red_to_blue':\n\n im = grid[i].imshow(np.rot90(X[:, :, zz]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=0, vmax=max_) ###\n elif cbar_name is 'green':\n im = grid[i].imshow(np.rot90(X[:, :, zz]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=0, vmax=max_)\n else:\n im = grid[i].imshow(np.rot90(X[:, :, zz]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=- max_, vmax=max_)\n\n grid[i].axes.get_xaxis().set_visible(False)\n grid[i].axes.get_yaxis().set_visible(False)\n zz += spacing\n\n cbar = grid.cbar_axes[0].colorbar(im)\n\n if 'snr' in png_name:\n cbar.ax.set_yticks(drange(0, max_))\n\n elif ('reho' in png_name) or ('vmhc' in png_name) or ('sca_' in png_name) or ('alff' in png_name) or ('centrality' in png_name) or ('temporal_regression_sca' in png_name) or ('temporal_dual_regression' in png_name):\n cbar.ax.set_yticks(drange(-max_, max_))\n\n\n plt.show()\n plt.axis(\"off\")\n png_name = str(os.path.join(os.getcwd(), png_name))\n plt.savefig(png_name, dpi=300, bbox_inches='tight')\n plt.close()\n\n matplotlib.rcdefaults()\n\n return png_name","def plot_xyz():\n plt.subplot(3,1,1) # for x axis\n plt.title('x value v.s. time')\n plt.grid(True)\n plt.ylabel('X')\n plt.xlabel('t')\n plt.plot(x, '-r')\n\n plt.subplot(3,1,2) # for y axis\n plt.title('y value v.s. time')\n plt.grid(True)\n plt.ylabel('Y')\n plt.xlabel('t')\n plt.plot(y, '-g')\n\n plt.subplot(3,1,3) # for z axis\n plt.title('z value v.s. time')\n plt.grid(True)\n plt.ylabel('Z')\n plt.xlabel('t')\n plt.plot(z, '-b')","def plot_plasma(self):\n x = self.geom.x\n fig, axes = plt.subplots(1, 2, figsize=(8, 3),\n constrained_layout=True)\n # plot densities\n ax = axes[0]\n ax.plot(x, self.ne, 'b-')\n ax.plot(x, self.ni, 'r-')\n ax.legend(['E', 'Ion'])\n ax.set_xlabel('Position (m)')\n ax.set_ylabel('Density (m^-3)')\n # plot temperature\n ax = axes[1]\n ax.plot(x, self.Te, 'b-')\n ax.plot(x, self.Ti, 'r-')\n ax.legend(['Te', 'Ti'])\n ax.set_xlabel('Position (m)')\n ax.set_ylabel('Temperature (eV)')\n plt.show()","def plot_x_y_drift(x, y):\n\tx = [np.nan if i is None else i for i in x]\n\ty = [np.nan if i is None else i for i in y]\n\tmask_x = np.where(x == np.nan)\n\tmask_y = np.where(y == np.nan)\n\tmx = np.ma.array(x)\n\tmx[mask_x] = np.ma.masked\n\tmy = np.ma.array(y)\n\tmy[mask_y] = np.ma.masked\n\tfig = plt.figure()\n\tfig.suptitle('Beam Centroid Drift in MFX1161 Yag', fontsize=20)\n\tax = fig.add_subplot(121)\n\tplt.xlabel('Event Number')\n\tplt.ylabel('Pixel Value')\n\tplt.title('Drift in X')\n\tplt.axis([0, len(x), 0, 1000])\n\tplt.plot(range(len(x)), mx)\n\tplt.grid()\n\tbx = fig.add_subplot(122)\n\tplt.xlabel('Event Number')\n\tplt.ylabel('Pixel Value')\n\tplt.title('Drift in Y')\n\tplt.axis([0, len(y), 0, 1000])\n\tplt.plot(range(len(y)), my)\n\tplt.grid()\n\tplt.show()","def setup_anime(self, xmin_off=0, ymin_off=0, xmax_off=0, ymax_off=0):\n xtremes = [(min(x), min(y), max(x), max(y)) for x, y in self.artists]\n xmin = min(map(lambda lst: lst[0], xtremes)) + xmin_off\n ymin = min(map(lambda lst: lst[1], xtremes)) + ymin_off\n xmax = max(map(lambda lst: lst[2], xtremes)) + xmax_off\n ymax = max(map(lambda lst: lst[3], xtremes)) + ymax_off\n print(\"Xtremes:\", xmin, xmax, ymin, ymax)\n\n self.fig = plt.figure()\n self.ax = plt.axes(xlim=(xmin, xmax), ylim=(ymin, ymax),\n autoscale_on=False)\n self.ax.set_facecolor('k')\n self.ax.set(xlabel='x [a.u.]', ylabel='y [a.u.]',\n title='Projectile motion')\n self.ax.set_aspect('equal')\n self.ax.grid()\n\n for a in range(self.art_num):\n ln, = self.ax.plot([], [], '--')\n ln.set_clip_on(False)\n self.lines.append(ln)\n\n plt.gca().set_prop_cycle(None)\n\n for a in range(self.art_num):\n pt, = self.ax.plot([], [], 'o')\n pt.set_clip_on(False)\n self.points.append(pt)\n\n self.time_template = 'time = %d a.u.'\n self.time_text = self.ax.text(.5, .5, '', color='c',\n transform=self.ax.transAxes,\n horizontalalignment='center',\n verticalalignment='center')","def compute_axes(self):\n mini, maxi = self._get_extremes()\n self.y_axis.min = mini\n self.y_axis.max = maxi\n self.y_axis._max_min()\n\n if not None in [s.xvalues for s in self]:\n mini, maxi = self._get_extremes('xvalues')\n self.x_axis.min = mini\n self.x_axis.max = maxi\n self.x_axis._max_min()","def plotCumulativeMovingAverage(self, x: list, title: str = \"Cumulative moving average\") -> None:\n C = self.cumulativeMovingAverage(x)\n plt.plot(C)\n plt.xlabel('index')\n plt.ylabel('cumulative moving average')\n plt.title(title)\n plt.show()","def rug(self):\n self.rax_y = self.ax.inset_axes(bounds=[0.97, 0, 0.03, 1], zorder=-1)\n for index, value in self.df[f\"order_{self.y}\"].items():\n if self.df.loc[index, f\"highlight_{self.y}\"] == 1:\n color_set = self.fgcolors\n zorder = 1\n else:\n color_set = self.bgcolors\n zorder = 0\n color = (\n color_set[0]\n if self.df.loc[index, self.obs] == 0\n else color_set[1]\n )\n self.rax_y.hlines(\n y=value,\n xmin=0,\n xmax=len(self.df),\n color=color,\n alpha=0.5,\n lw=3,\n zorder=zorder,\n )\n self.rax_y.margins(0.02)\n self.rax_y.axis(\"off\")\n # And the x-rug.\n self.rax_x = self.ax.inset_axes(bounds=[0, 0, 1, 0.03], zorder=-1)\n for index, value in self.df[f\"order_{self.x}\"].items():\n if self.df.loc[index, f\"highlight_{self.x}\"] == 1:\n color_set = self.fgcolors\n zorder = 1\n else:\n color_set = self.bgcolors\n zorder = 0\n color = (\n color_set[0]\n if self.df.loc[index, self.obs] == 0\n else color_set[1]\n )\n self.rax_x.vlines(\n x=value,\n ymin=0,\n ymax=len(self.df),\n color=color,\n alpha=0.5,\n lw=3,\n zorder=zorder,\n )\n self.rax_x.margins(0.02)\n self.rax_x.axis(\"off\")\n # Set some space for the rugs.\n xpad, ypad = (0 - self.pad, len(self.df) + self.pad)\n self.ax.set_xlim(xpad, ypad)\n self.ax.set_ylim(xpad, ypad)\n self.rax_y.set_ylim(xpad, ypad)\n self.rax_x.set_xlim(xpad, ypad)\n\n return self","def make_plot_original(lx, ly):\n plt.plot(lx, ly, 'ro')\n plt.axis([-5, max(lx) + 5, -5, max(ly) + 5])","def set_axis_x(self, new_axis_point):\r\n self.__x_axis = new_axis_point","def plot(self, fig=None):\n # Ignore warnings from matplotlib\n warnings.filterwarnings(\"ignore\")\n if fig is None:\n fig = plt.figure()\n means = np.mean(self.intervals, 1)\n yerr = self.maxs - means\n ax = fig.add_subplot(111)\n n_intervals = np.alen(self.maxs)\n x = np.arange(n_intervals)\n ax.errorbar(x, means, yerr=yerr, fmt='o')\n plt.xticks(x, self.labels, rotation='horizontal')\n ax.set_xlim(x + [-1, 1])\n plt.show()","def buildPlotX(self):\n\n self.plotFineX = []\n for iPlot in range(len(self.plotSpacerMethods)):\n thisMeth = self.plotSpacerMethods[iPlot]\n limLo = self.plotLimsLo[iPlot]\n limHi = self.plotLimsHi[iPlot]\n \n # generate the fine grid for this parameter\n thisUnif = thisMeth(limLo, limHi, num=self.plotNfine, \\\n endpoint=True)\n\n # and append onto the list\n self.plotFineX.append(thisUnif)","def updatePlot(self,*args):\n # set x limits\n timeDisplayOptions = {'10 minutes':10,'1 hour':60,'6 hours':6*60,'24 hours':24*60,'All':0}\n try:\n lastDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[-1])\n firstDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[0])\n except IndexError: # no data yet\n now = datetime.datetime.utcnow().toordinal()\n firstDatetime = mpl.dates.num2date(now)\n lastDatetime = firstDatetime\n xMin = lastDatetime-datetime.timedelta(minutes=timeDisplayOptions[self.wScale.get()])\n xMin = max([ firstDatetime, xMin ])\n if self.wScale.get() == 'All':\n xMin = firstDatetime\n xMinIndex = numpy.searchsorted( self.stage60K.get_xdata(), mpl.dates.date2num(xMin) )\n # rescale axes, with the x being scaled by the slider\n if self.toolbar._active == 'HOME' or self.toolbar._active == None:\n ymin,ymax = 10000000, -10000000\n lineAndVar = { self.stage60K: self.t60K,\n self.stage03K: self.t3K,\n self.stageGGG: self.tGGG,\n self.stageFAA: self.tFAA }\n if len(self.stage60K.get_xdata()) > 1:\n for line in lineAndVar.keys():\n if lineAndVar[line].get() == 0:\n line.set_visible(False)\n else:\n line.set_visible(True)\n ydata = line.get_ydata()[xMinIndex:-1]\n try:\n ymin = min(ymin, numpy.nanmin(ydata))\n ymax = max(ymax, numpy.nanmax(ydata))\n except ValueError as e:\n pass\n self.ax.set_xlim(xMin,lastDatetime)\n self.ax.set_ylim(ymin - (ymax-ymin)/10, ymax + (ymax-ymin)/10)\n hfmt = mpl.dates.DateFormatter('%H:%M:%S', tz=tz.tzlocal())\n self.ax.xaxis.set_major_formatter(hfmt)\n self.fig.autofmt_xdate()\n self.fig.tight_layout()\n #draw\n self.canvas.draw()","def sse_plot(self):\n df_sse = self.df[\"sse\"].sort_values(ascending=False)\n plt.figure(figsize=(self.plot_width, self.plot_height))\n df_sse.plot(\"bar\")\n plt.title(\"SSE por cluster\")\n output_path_sse = os.path.join(self.output_folder, 'sse_plot.png')\n plt.savefig(output_path_sse)","def cla(self):\n\t\tAxes.cla(self)\n\t\tself.set_longitude_grid(45)\n\t\tself.set_latitude_grid(20)\n\t\t# Do not display ticks -- we only want gridlines and text\n\t\tself.xaxis.set_ticks_position('none')\n\t\tself.yaxis.set_ticks_position('none')\n\n\t\tself.x_lim = [-180, 180]\n\t\tself.y_lim = [-90, 90]\n\t\tself.set_xlim(self.x_lim)\n\t\tself.set_ylim(self.y_lim)","def x_lb(self):\n pass","def plot(self): \n\t\txandy = sep_xy(self.start, self.end)\n\t\tplt.plot(xandy[0], xandy[1], 'k-', lw=1, color='green')","def ploter(self):\n if len(self.dataset[self.first_title]) != 2:\n print('plot is only avilable for two features')\n return\n x_axis = []\n y_axis = []\n for title in self.dataset:\n x_axis.append(self.dataset[title][0])\n y_axis.append(self.dataset[title][1])\n plt.plot(x_axis, y_axis, 'o')\n plt.show()","def test_x(self):\n g = gca()\n lines = g.get_lines() \n self.assertEquals(lines[0].get_xdata().tolist(), [3, 5, 5, 3, 3])","def xlim(self):\r\n lim = [ax.get_xlim() for ax in self._subaxes]\r\n if lim == []:\r\n lim = None\r\n return lim","def plot_gauss(x, y, amp, center, width, name, outfile):\n#\n#--- set plotting range\n#\n xmin = min(x)\n xmax = max(x) + 1\n ymin = 0\n ymax = int(1.1 * max(y))\n#\n#--- create Gaussian distribution\n#\n p = (amp, center, width, 0)\n est_v = []\n est_list = []\n for v in range(0, xmax):\n est = funcG(p, v)\n est_v.append(v)\n est_list.append(est)\n#\n#--- clean up the plotting device\n#\n plt.close('all')\n#\n#---- set a few parameters\n#\n mpl.rcParams['font.size'] = 9\n props = font_manager.FontProperties(size=9)\n \n plt.axis([xmin, xmax, ymin, ymax])\n plt.xlabel('PHA', size=9)\n plt.ylabel('Counts', size=9)\n plt.title(name, size=9)\n#\n#--- set information text postion and content\n#\n tx = 0.5 * xmax\n ty = 0.9 * ymax\n line = 'Amp: ' + str(round(amp,2)) + ' Center: ' + str(round(center,2)) + ' Width: ' + str(round(width,2))\n plt.text(tx, ty, line)\n#\n#--- actual plotting\n#\n p, = plt.plot(x, y, marker='.', markersize=4.0, lw = 0)\n p, = plt.plot(est_v, est_list, marker= '', lw=3)\n#\n#--- set the size of the plotting area in inch (width: 10.0in, height 2.08in x number of panels)\n#\n fig = matplotlib.pyplot.gcf()\n fig.set_size_inches(10.0, 5.0)\n#\n#--- save the plot in png format\n#\n plt.savefig(outfile, format='png', dpi=100)","def format_xaxis (self, axes, \n n_ticks = 10, # Number of ticks we would like\n timestamp_formatting = '(%Y-%m-%d)%H:%M', # Specified formatting \n xaxis_mode = None): # Several automatic modes\n if (self.X_type == \"categorical\"):\n axes.set_xticks(self.X[self.start_indx:self.end_indx], minor=False)\n axes.set_xticklabels(self.Xcategories[self.start_indx:self.end_indx][:,0], minor=False)\n \n elif(self.X_type == \"numerical\"):\n # If regular numerical we just plot the values\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\n# ax.get_xaxis().get_major_formatter().set_useOffset(False)\n \n elif(self.X_type == \"timestamp\"):\n axes.xaxis.set_major_formatter(mdates.DateFormatter(timestamp_formatting))\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\n axes.xaxis_date()\n # ax.xaxis.set_major_formatter(FuncFormatter(self.ticklabels[val:val + wsize]))\n self.figure.autofmt_xdate()\n# print (type(self.X), type(self.X[0]))\n \n elif(self.formatXaxis == \"intraday\"):\n # If the data is intraday and we want to apply the Gap Remover !!! \n gap_remover_flag = 1;\n if (gap_remover_flag):\n formatter = FuncFormatter(ul.detransformer_Formatter)\n axes.xaxis.set_major_formatter(formatter) \n # mdates.DateFormatter(formatting)\n \n else:\n axes.xaxis.set_major_formatter(mdates.DateFormatter(formatting))\n \n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))","def plot(self): \n\t\txandy = sep_xy(self.start, self.end)\n\t\tplt.plot(xandy[0], xandy[1], 'k-', lw=1, color='red')","def plot_time_series(df, plt):\n # Remove the plot frame lines\n delta = (df[\"timestamp\"].max() - df[\"timestamp\"].min()) / 10\n plt.xticks(\n np.arange(\n df[\"timestamp\"].min(),\n df[\"timestamp\"].max(),\n step=np.around(delta, decimals=1),\n )\n )\n plt.grid()","def _plot_rawdata(self):\n fig, ax = plt.subplots(1, 1)\n ax.imshow(self.data, origin='top', extent=(0., 360., -90., 90.))\n ax.set_title('Driscoll Healy Grid')\n ax.set_xlabel('longitude')\n ax.set_ylabel('latitude')\n fig.tight_layout(pad=0.5)\n return fig,ax","def getXLimit(self):\n return self.axes.get_xlim()"],"string":"[\n \"def __draw_xaxis(self):\\n self.ax.set_xlim(self.xlims)\\n # put x ticks on top\\n xticks = [1]\\n xticks.extend(range(5, self.xmax+5, 5))\\n fs = self.settings.rcParams[\\\"axes.labelsize\\\"] if self.settings.otherParams[\\n \\\"xlabel.fontsize\\\"] is None else self.settings.otherParams[\\\"xlabel.fontsize\\\"]\\n color = self.settings.rcParams[\\\"axes.labelcolor\\\"] if self.settings.otherParams[\\n \\\"xlabel.color\\\"] is None else self.settings.otherParams[\\\"xlabel.color\\\"]\\n self.ax.set_xticks(xticks)\\n self.ax.set_xticklabels(xticks[:-1])\\n self.ax.set_xlabel(self.xaxis_label, fontsize=fs, color=color)\\n self.ax.xaxis.set_label_coords(\\n *self.settings.otherParams[\\\"xlabel.position\\\"])\",\n \"def hide_x_ticks():\\n ax = plt.gca()\\n ax.axes.get_xaxis().set_ticks([])\",\n \"def to_x_coordinates(self):\\n self.plotter.to_x_coordinates(self.ax)\\n self.plotter.replot(self.ax)\\n self.plotter.cells.draw(self.ax)\\n self.x_label.set_text(self.plotter.plot_xlabel)\\n self.fig.canvas.draw()\",\n \"def __set_ax_prop(self, ax):\\n ax.set_xticks([])\\n ax.set_yticks([])\",\n \"def add_grid(axs, xax=True):\\r\\n\\r\\n for ax in axs:\\r\\n ax.grid(color='grey', linewidth=0.25, zorder=0)\\r\\n ax.xaxis.grid(xax)\",\n \"def format_regression_axis(ax):\\n ax.set_xticks(np.arange(0, 1.1, 0.25))\\n ax.set_yticks(np.arange(0, 1.1, 0.25))\\n ax.set_xticklabels('')\\n ax.set_yticklabels('')\\n ax.set_xlabel('')\\n ax.set_ylabel('')\\n ax.set_xlim([0, 1])\\n ax.set_ylim([0, 1])\\n sn.despine(ax=ax)\",\n \"def reverse_x():\\n plt.xlim(plt.xlim()[::-1])\",\n \"def plot_xents(name, col1=\\\"darkblue\\\", col2=\\\"darkred\\\", ylim=0.2):\\n\\n mean5 = np.loadtxt(\\\"mean5_{}.txt\\\".format(name))\\n mean15 = np.loadtxt(\\\"mean15_{}.txt\\\".format(name))\\n pos1 = np.arange(1, len(mean5)+1)\\n pos2 = np.arange(1, len(mean15)+1)\\n\\n sns.set_style(\\\"darkgrid\\\")\\n plt.plot(pos1, mean5, col1, pos2, mean15, col2, linewidth=2.0)\\n\\n plt.xlabel(\\\"Position in sequence\\\")\\n plt.ylabel(\\\"Increase in CrossEntropy\\\")\\n plt.title(\\\"CrossEntropy perturbation per position in {} sequences\\\".format(\\n str(name)))\\n\\n plt.ylim([0, ylim])\\n patch1 = mpatches.Patch(color=col1, label='window = 5 aa')\\n patch2 = mpatches.Patch(color=col2, label='window = 15 aa')\\n plt.legend(handles=[patch1, patch2], loc=1)\\n\\n plt.show()\",\n \"def _plot_rawdata(self):\\n fig, ax = plt.subplots(1, 1)\\n ax.imshow(self.data, origin='top')\\n ax.set_title('Gauss-Legendre Quadrature Grid')\\n ax.set_xlabel('longitude index')\\n ax.set_ylabel('latitude index')\\n fig.tight_layout(pad=0.5)\\n return fig,ax\",\n \"def _nice_axes(self, ax):\\n ax.ticklabel_format(axis='y', style='sci', scilimits=(-2, 3))\\n pstyle.set_xaxis_label(ax)\\n try:\\n pstyle.set_xLimits(self.twiss_df.SEQUENCE, ax)\\n except pstyle.ArgumentError:\\n pass\\n if self._ip_pos is not None and len(self._ip_pos) > 0:\\n pstyle.show_ir(self._ip_pos, ax)\",\n \"def xz_combined(Feaff, Fe, Fi, muVn, length, x, z):\\n\\n fig, ax = plt.subplots(figsize=(8, 6))\\n\\n plt.title(\\n '$\\\\\\\\nu_e^{aff}$, $\\\\\\\\nu_e$, $\\\\\\\\nu_i$ and $\\\\\\\\mu_V^{N}$ for pixel (' + str(x) + ', ' + str(z) + ')')\\n axes = [ax, ax.twinx(), ax.twinx(), ax.twinx()]\\n\\n fig.subplots_adjust(right=0.75)\\n axes[-2].spines['right'].set_position(('axes', 1.3))\\n axes[-2].set_frame_on(True)\\n axes[-2].patch.set_visible(False)\\n axes[-1].spines['right'].set_position(('axes', 1.6))\\n axes[-1].set_frame_on(True)\\n axes[-1].patch.set_visible(False)\\n\\n axes[0].plot(Feaff[:length, x, z], color='Blue')\\n axes[0].set_ylabel('$\\\\\\\\nu_e^{aff}(x, t)$', color='Blue')\\n axes[0].set_xlabel('t (ms)')\\n axes[0].tick_params(axis='y', colors='Blue')\\n\\n axes[1].plot(Fe[:length, x, z], color='Orange')\\n axes[1].set_ylabel('$\\\\\\\\nu_e(x, t)$', color='Orange')\\n axes[1].set_xlabel('t (ms)')\\n axes[1].tick_params(axis='y', colors='Orange')\\n\\n axes[2].plot(Fi[:length, x, z], color='Green')\\n axes[2].set_ylabel('$\\\\\\\\nu_i(x, t)$', color='Green')\\n axes[2].set_xlabel('t (ms)')\\n axes[2].tick_params(axis='y', colors='Green')\\n\\n axes[3].plot(muVn[:length, x, z], color='Red')\\n axes[3].set_ylabel('$\\\\\\\\mu_V^{N}(x, t)$', color='Red')\\n axes[3].set_xlabel('t (ms)')\\n axes[3].tick_params(axis='y', colors='Red')\\n\\n plt.setp(\\n ax,\\n xticks=np.linspace(0, length, 5),\\n xticklabels=np.linspace(0, length/2, 5, dtype=int)\\n )\\n fig.tight_layout()\\n plt.show()\\n\\n return\",\n \"def thin_xticks(ax, n):\\n ax.xaxis.set_major_locator(MaxNLocator(n + 1))\",\n \"def setupXAxis(plot, minVal, maxVal, label, logarithmic):\\n plot.set_xlabel(label)\\n\\n if logarithmic:\\n plot.set_xscale(\\\"log\\\")\\n plot.set_xlim(minVal, maxVal)\\n # plot.set_xscale('log', basex=2)\\n # tickLabels = [1]\\n # labelValue = minVal\\n # while labelValue <= maxVal:\\n # tickLabels.append (labelValue)\\n # labelValue = labelValue*2\\n # # Expand the axis a little above and below the data\\n # inflationFactor = 0.95\\n # plot.set_xlim(minVal*inflationFactor, maxVal/inflationFactor)\\n # # Need a blank label on the front for the added axis point on the left. No need for an extra\\n # # annotation on the right.\\n # plot.set_xticklabels([' '] + tickLabels)\\n else:\\n plot.set_xlim((0 if minVal == 1 else minVal), maxVal)\",\n \"def xax(self):\\n return self.__xax\",\n \"def format_x_axis(self, x_tick, x_limits):\\n self._fig.update_layout(\\n xaxis=dict(\\n range=x_limits,\\n dtick=x_tick,\\n ),\\n )\",\n \"def xlim(self, left=None, right=None):\\r\\n for ax in self._subaxes:\\r\\n ax.set_xlim(left, right)\\r\\n self.figure.canvas.draw()\",\n \"def simple_xy_axes(ax):\\n\\n # Hide the right and top spines\\n ax.spines['right'].set_visible(False)\\n ax.spines['top'].set_visible(False)\\n\\n # Only show ticks on the left and bottom spines\\n ax.yaxis.set_ticks_position('left')\\n ax.xaxis.set_ticks_position('bottom')\",\n \"def triangle_axis(ax):\\n ax.spines['right'].set_visible(False)\\n ax.spines['top'].set_visible(False)\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\",\n \"def xaxis ( self ) :\\n return self.__xaxis\",\n \"def xaxis ( self ) :\\n return self.__xaxis\",\n \"def xaxis ( self ) :\\n return self.__xaxis\",\n \"def gx_set_labels_and_ticks_over_360deg(ax):\\n \\n #~ plt.gca().invert_xaxis()\\n ax.set_ylim(-20, 40)\\n #~ ax.set_xlim(380, 260)\\n ax.set_xlim(370, 270)\\n\\n ax.xaxis.set_major_locator(ticker.MultipleLocator(20))\\n t = ax.get_xticks()\\n xtick_labels = [int(x) if x<360 else int(x-360) for x in t]\\n ax.set_xticklabels(xtick_labels)\\n\\n ax.set_xlabel('l [deg]')\\n ax.set_ylabel('b [deg]')\\n ax.set_aspect('equal')\\n\\n return ax\",\n \"def flip_x(self):\\n self.x_lim_helper.flip_limits()\",\n \"def flip_x(self):\\n self.x_lim_helper.flip_limits()\",\n \"def fix_auto(self):\\n if self.share_x:\\n self.rescale_axes(x=True, y=False)\\n self.fix_axes_ticks(axis='x')\\n if self.share_y:\\n self.rescale_axes(x=False, y=True)\\n self.fix_axes_ticks(axis='y')\",\n \"def setup_axes():\\n\\taxes = visuals.subplots(1, 2, figsize = (14, 7))\\n\\taxes[1].set_yscale(\\\"log\\\")\\n\\taxes[0].set_xlabel(\\\"[Fe/H]\\\")\\n\\taxes[0].set_ylabel(\\\"[Sr/Fe]\\\")\\n\\taxes[1].set_xlabel(\\\"[Sr/Fe]\\\")\\n\\taxes[1].set_ylabel(\\\"Stellar Probability Density\\\")\\n\\taxes[0].set_xlim([-2.2, 0.2])\\n\\taxes[0].set_ylim([-2.4, 0.4])\\n\\taxes[1].set_xlim([-1.4, 0.4])\\n\\taxes[1].set_ylim([0.05, 50])\\n\\treturn axes\",\n \"def x(self):\\n return self.axes[1]\",\n \"def _add_octave_band_xticks(ax, bands=np.array(_third_octave_bands)[:, 0]):\\n left, right = ax.get_xlim()\\n b = bands[np.logical_and(left <= bands, bands <= right)]\\n ax.set_xticks(b)\\n ax.set_xticks([], minor=True)\\n ax.set_xticklabels([int(round(bs)) for bs in b], minor=False)\",\n \"def gini_graph(self,x):\\n \\n name = self['name']\\n id = self._getGraphId()\\n figname = 'G_%s.eps' % id\\n G = self['M_GINI']\\n sxlabel = 'Pixel Order' ; sylabel = 'Cumul Flux' \\n title = 'Gini, %s, G=%4.2f' % (name,G)\\n x = num.sort(x)\\n cumul = num.cumsum(x)\\n lorenz_y = 100.* cumul/cumul[-1]\\n lorenz_x = 100. * (num.arange(len(x))+1)/float(len(x))\\n fakearray = num.array([0.,100.])\\n xy = ((lorenz_x,lorenz_y),(fakearray,fakearray))\\n Plot(xy,figname,sxlabel,sylabel,title)\\n self['figures']['gini'] = figname\",\n \"def style_graph(ax):\\n ax.set_facecolor('.8')\\n ax.tick_params(labelsize=8, length=5)\\n ax.grid(True, axis='x', color='white')\\n ax.set_axisbelow(True)\\n [spine.set_visible(False) for spine in ax.spines.values()]\",\n \"def xaxis(self,label,units):\\n if units != \\\"\\\": label = label + \\\" (\\\" + units + \\\")\\\"\\n self.subplot.set_xlabel(label)\\n pass\",\n \"def make_x_axis(**kwargs):\\n xmax = kwargs.get('xmax', 40)\\n xmin = kwargs.get('xmin', 0)\\n stepsize = kwargs.get('stepsize', 5)\\n xlabel = kwargs.get('xlabel', 'Generations from\\\\nSenescence')\\n figsize = kwargs.get('figsize', (2.5, 2.5))\\n fontsize = kwargs.get('fontsize', 12)\\n savepath = kwargs.get('savepath', f'legend_xlim_{xmin}-{xmax}.svg')\\n # Create the figure and plot\\n fig = plt.figure(figsize=figsize)\\n fig.set_dpi(300)\\n ax = fig.add_subplot(111)\\n ax.set_xlim(xmin, xmax)\\n ax.set_xticks(np.arange(xmin, xmax+1, stepsize))\\n # Remove spines\\n for spine in [ax.spines[key] for key in ['top', 'right', 'left']]:\\n spine.set_visible(False)\\n ax.set_xlabel(xlabel, fontsize=fontsize)\\n # No y ticks!\\n ax.set_yticks([])\\n fig.savefig(savepath)\",\n \"def _extended_discrete_xaxis(x_axis, n_points=100, eps=0.10):\\n min_value = np.min(x_axis)\\n max_value = np.max(x_axis)\\n distance = max_value - min_value\\n return np.linspace(min_value - eps * distance, max_value + eps * distance,\\n num=n_points)\",\n \"def clean_axis(ax):\\n ax.get_xaxis().set_ticks([])\\n ax.get_yaxis().set_ticks([])\\n for sp in ax.spines.values():\\n sp.set_visible(False)\",\n \"def hogg_lim_and_label():\\n plt.xlim(-20., 1020.)\\n plt.xlabel(\\\"time (d)\\\")\\n plt.ylim(-20., 20.)\\n plt.ylabel(\\\"radial velocity (m\\\\,s$^{-1}$)\\\")\\n return None\",\n \"def cla(self):\\n # Don't forget to call the base class\\n Axes.cla(self)\\n \\n x_min = 0\\n y_min = 0\\n x_max = 1\\n y_max = 1\\n x_spacing = 0.1\\n y_spacing = 0.1\\n self.xaxis.set_minor_locator(NullLocator())\\n self.yaxis.set_minor_locator(NullLocator())\\n self.xaxis.set_ticks_position('bottom')\\n self.yaxis.set_ticks_position('left')\\n Axes.set_xlim(self, x_min, x_max)\\n Axes.set_ylim(self, y_min, y_max)\\n self.xaxis.set_ticks(np.arange(x_min, x_max+x_spacing, x_spacing))\\n self.yaxis.set_ticks(np.arange(y_min, y_max+y_spacing, y_spacing))\",\n \"def set_xticks(ax, xlabels_log=None, show_log=True):\\n if show_log is False:\\n ax.set_xscale('log', basex=2) # show regular numbers (512, 1024, ...)\\n ax.get_xaxis().set_major_formatter( matplotlib.ticker.ScalarFormatter() )\\n else:\\n ax.get_xaxis().set_major_formatter( matplotlib.ticker.ScalarFormatter() )\\n ax.set_xscale('log', basex=2) # show power number (2^9, 2^10, ...)\\n \\n if xlabels_log is not None:\\n ax.set_xticks(xlabels_log)\\n return ax\",\n \"def plot(self):\\n\\t\\tself.plotOfXray().plot()\",\n \"def get_axis_x(self):\\r\\n return self.__x_axis\",\n \"def uninformativePlot(self):\\n\\n self.initPlotY()\\n for iPlot in range(len(self.plotFineX)):\\n thisX = self.plotFineX[iPlot]\\n\\n self.plotFineY[iPlot] = thisX*0. + 1.\",\n \"def plot_grid(filename, title, names, x):\\n fig = plt.figure(figsize=(10,6))\\n ax = fig.add_subplot(111)\\n ax.set_title(title)\\n plt.imshow(x, interpolation=\\\"nearest\\\", cmap=plt.get_cmap(\\\"hot\\\"))\\n ax.set_aspect('equal')\\n plt.xticks(range(6), names, rotation='vertical')\\n plt.yticks(range(6), names)\\n plt.subplots_adjust(bottom=0.25)\\n # ax.set_xticklabels(('',) + names)\\n # ax.set_yticklabels(('',) + names)\\n cax = fig.add_axes([0.12, 0.1, 0.78, 0.8])\\n cax.get_xaxis().set_visible(False)\\n cax.get_yaxis().set_visible(False)\\n cax.patch.set_alpha(0)\\n cax.set_frame_on(False)\\n plt.colorbar(orientation='vertical')\\n plt.savefig(filename+\\\".pdf\\\")\\n fig.clear()\",\n \"def plot_w_xticks(all_xticks, major_xticks, major_xticks_labels, yplots):\\n fig = plt.figure()\\n graph = fig.add_subplot(111)\\n x = all_xticks\\n for yplot in yplots:\\n graph.plot(x, yplot[0], yplot[1])\\n graph.set_xticks(major_xticks)\\n graph.set_xticklabels(major_xticks_labels)\\n return graph\",\n \"def plotTotEfixedX(monthlyData):\\n \\n #assign x-angles (must be equally distributed between 0 and 90 deg)\\n Xangles = (np.array(range(len(monthlyData['angles']['y_angles'])))-10)*90./(len(monthlyData['angles']['y_angles'])-1)\\n \\n fig = plt.figure()\\n ax1=plt.subplot(2,1,1)\\n plt.plot(Xangles, np.sum(monthlyData['H'], axis=1)/np.mean( np.sum(monthlyData['H'], axis=1)), label='H', color='r')\\n plt.plot(Xangles, np.sum(monthlyData['C'], axis=1)/np.mean( np.sum(monthlyData['C'], axis=1)), label='C', color='b')\\n plt.plot(Xangles, np.sum(monthlyData['L'], axis=1)/np.mean( np.sum(monthlyData['L'], axis=1)), label='L', color='g')\\n plt.plot(Xangles, np.sum(monthlyData['PV'], axis=1)/np.mean( np.sum(monthlyData['PV'], axis=1)), label='PV', color='c')\\n plt.plot(Xangles, np.sum(monthlyData['E_HCL'], axis=1)/np.mean( np.sum(monthlyData['E_HCL'], axis=1)), label='E_HCL', color='m')\\n plt.plot(Xangles, np.sum(monthlyData['E_tot'], axis=1)/np.mean( np.sum(monthlyData['E_tot'], axis=1)), label='E_tot', color='k')\\n plt.legend()\\n \\n plt.subplot(2,1,2, sharex=ax1)\\n plt.plot(Xangles, np.sum(monthlyData['H'], axis=1), label='H', color='r')\\n plt.plot(Xangles, np.sum(monthlyData['C'], axis=1), label='C', color='b')\\n plt.plot(Xangles, np.sum(monthlyData['L'], axis=1), label='L', color='g')\\n plt.plot(Xangles, np.sum(monthlyData['PV'], axis=1), label='PV', color='c')\\n plt.plot(Xangles, np.sum(monthlyData['E_HCL'], axis=1), label='E_HCL', color='m')\\n plt.plot(Xangles, np.sum(monthlyData['E_tot'], axis=1), label='E_tot', color='k')\\n plt.legend()\\n \\n return fig\",\n \"def populate_plot_axis(self,plot,ax='x'):\\n\\n fig=plt.gcf()\\n\\n extra_ax=[]\\n\\n if ax=='x':\\n\\n ticks=plot.get_xticks()\\n\\n lim=plot.get_xlim()\\n\\n for i in range(len(self.names)):\\n\\n if i==0:\\n\\n axn=plot\\n\\n axn.spines['bottom'].set_position(('outward',10))\\n\\n axn.spines['bottom'].set_visible(True)\\n\\n else:\\n\\n dy_fig=0.08\\n\\n prev_ax_position=axn.get_position()\\n\\n extra_ax.append(fig.add_axes(\\\\\\n (prev_ax_position.x0,\\\\\\n prev_ax_position.y0-2*dy_fig,\\\\\\n prev_ax_position.width,\\\\\\n 0),'autoscalex_on',True))\\n\\n axn=extra_ax[i-1]\\n\\n axn.yaxis.set_visible(False)\\n\\n for side in axn.spines.keys():\\n\\n axn.spines[side].set_linewidth(1)\\n\\n axn.set_xticks(ticks)\\n\\n ticksnames=[float(str(x)) for x in self.values[i]]\\n\\n axn.set_xticklabels(\\\\\\n [\\\"{:.2f}\\\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\\\\n rotation = 45)\\n\\n xlab=axn.set_xlabel(self.names[i])\\n\\n xlab.set_fontsize(10)\\n\\n axn.tick_params(axis='x',labelsize=10)\\n\\n axn.set_xlim(lim)\\n\\n\\n\\n elif ax=='y':\\n\\n ticks=plot.get_yticks()\\n\\n lim=plot.get_ylim()\\n\\n for i in range(len(self.names)):\\n\\n if i==0:\\n\\n axn=plot\\n\\n axn.spines['left'].set_position(('outward',10))\\n\\n axn.spines['left'].set_visible(True)\\n\\n else:\\n\\n dx_fig=0.08\\n\\n plot_position=plot.get_position()\\n\\n prev_ax_position=axn.get_position()\\n\\n extra_ax.append(fig.add_axes(\\\\\\n (prev_ax_position.x0-2*dx_fig,\\\\\\n prev_ax_position.y0,\\\\\\n 0,\\\\\\n prev_ax_position.height),'autoscalex_on',True))\\n\\n axn=extra_ax[i-1]\\n\\n axn.xaxis.set_visible(False) # hide the yaxis\\n\\n for side in axn.spines.keys(): # 'top', 'bottom', 'left', 'right'\\n\\n axn.spines[side].set_linewidth(1)\\n\\n axn.set_yticks(ticks)\\n\\n ticksnames=[float(str(x)) for x in self.values[i]]\\n\\n axn.set_yticklabels(\\\\\\n [\\\"{:.2f}\\\".format(x).rstrip('0').rstrip('.') for x in ticksnames],\\\\\\n rotation = 45)\\n\\n ylab=axn.set_ylabel(self.names[i])\\n\\n ylab.set_fontsize(10)\\n\\n axn.tick_params(axis='y',labelsize=10)\\n\\n axn.set_ylim(lim)\\n\\n else:\\n\\n raise ValueError(\\\"Axis can be 'x' or 'y'\\\")\",\n \"def xaxis(self):\\n return self._xaxis\",\n \"def setup_axes():\\n fig, ax = plt.subplots(1)\\n\\n ax.set_xlabel(\\\"Density [$n_H$ cm$^{-3}$]\\\")\\n ax.set_ylabel(\\\"Temperature [K]\\\")\\n\\n ax.loglog()\\n\\n return fig, ax\",\n \"def AllSidesTicks( ax ):\\n return; ## depreceate for now as it doesn't work correctly...\\n axy = ax.twinx()\\n axy.set_ylim( ax.get_ylim() )\\n axy.set_yscale( ax.get_yscale() )\\n axy.set_yticklabels(labels=[])\\n\\n axx = ax.twiny()\\n axx.set_xlim( ax.get_xlim() )\\n axx.set_xscale( ax.get_xscale() )\\n axx.set_xticklabels(labels=[])\",\n \"def plot_Gini(self):\\n p = np.linspace(0,1, 1000)\\n not_p = 1 - p\\n \\n gini = 1 - np.sum(np.c_[p, not_p]**2, axis=1)\\n fig, ax = plt.subplots(1,1, figsize=(10,5))\\n _ = ax.plot(p, gini)\\n _ = ax.set_xlabel(\\\"p\\\")\\n _ = ax.set_ylabel(\\\"Gini\\\")\\n _ = ax.set_title(\\\"Gini: Two class example\\\")\\n\\n return fig, ax\",\n \"def plot_XDR_PDR_Gauss():\\n\\n fig,axes = plt.subplots(nrows=2, ncols=2, squeeze=True, sharex='col', sharey='row', figsize=(6,6))\\n fig.subplots_adjust(hspace=0, wspace=0) #, top=0.80, bottom=0.04, left=0.04, right=0.93)\\n\\n # get data\\n sscs = [SSC['no'] for SSC in SSCs]\\n colors = [plt.cm.inferno(i/(len(SSCs)+1)) for i in SSCs['no']]\\n HCO_HCN, HNC_HCN, HNC_HCO = [],[],[]\\n HCO_HCN_err, HNC_HCN_err, HNC_HCO_err = [],[],[]\\n for SSC in SSCs:\\n try:\\n hco_hcn = ratios_Gauss['HCO+/HCN'][SSC['num']]['bestfit']\\n hco_hcn_err = ratios_Gauss['HCO+/HCN'][SSC['num']]['error']\\n HCO_HCN.append( np.log10(hco_hcn) )\\n HCO_HCN_err.append( 0.434*hco_hcn_err/hco_hcn )\\n except:\\n HCO_HCN.append( np.nan )\\n HCO_HCN_err.append( np.nan )\\n try:\\n hnc_hcn = ratios_Gauss['HNC/HCN'][SSC['num']]['bestfit']\\n hnc_hcn_err = ratios_Gauss['HNC/HCN'][SSC['num']]['error']\\n HNC_HCN.append( np.log10(hnc_hcn) )\\n HNC_HCN_err.append( 0.434*hnc_hcn_err/hnc_hcn )\\n except:\\n HNC_HCN.append( np.nan )\\n HNC_HCN_err.append( np.nan )\\n try:\\n hnc_hco = ratios_Gauss['H15NC/HCO+'][SSC['num']]['bestfit']*ratios_Gauss['14N/15N'][SSC['num']]['bestfit']\\n hnc_hco_err = np.sqrt( (ratios_Gauss['H15NC/HCO+'][SSC['num']]['error']/ratios_Gauss['H15NC/HCO+'][SSC['num']]['bestfit'])**2 +(ratios_Gauss['14N/15N'][SSC['num']]['error']/ratios_Gauss['14N/15N'][SSC['num']]['bestfit'])**2 )\\n HNC_HCO.append( np.log10(hnc_hco) )\\n HNC_HCO_err.append( 0.434*hnc_hco_err/hnc_hco )\\n except:\\n HNC_HCO.append( np.nan )\\n HNC_HCO_err.append( np.nan )\\n\\n # comparison from Baan+08\\n B_hcn = [318.2, 14]\\n B_hnc = [234.0, 7]\\n B_hco = [276.1, 14]\\n B_hco_hcn = [B_hco[0]/B_hcn[0], B_hco[0]/B_hcn[0]*np.sqrt((B_hco[1]/B_hco[0])**2+(B_hcn[1]/B_hcn[0])**2)]\\n B_hnc_hcn = [B_hnc[0]/B_hcn[0], B_hnc[0]/B_hcn[0]*np.sqrt((B_hnc[1]/B_hnc[0])**2+(B_hcn[1]/B_hcn[0])**2)]\\n B_hnc_hco = [B_hnc[0]/B_hco[0], B_hnc[0]/B_hco[0]*np.sqrt((B_hnc[1]/B_hnc[0])**2+(B_hco[1]/B_hco[0])**2)]\\n B_HCO_HCN = [np.log10(B_hco_hcn[0]), 0.434*B_hco_hcn[1]/B_hco_hcn[0]]\\n B_HNC_HCN = [np.log10(B_hnc_hcn[0]), 0.434*B_hnc_hcn[1]/B_hnc_hcn[0]]\\n B_HNC_HCO = [np.log10(B_hnc_hco[0]), 0.434*B_hnc_hco[1]/B_hnc_hco[0]]\\n\\n def format_panel(ax):\\n ax.xaxis.set_major_locator(MultipleLocator(0.5))\\n ax.xaxis.set_minor_locator(MultipleLocator(0.25))\\n ax.yaxis.set_major_locator(MultipleLocator(0.5))\\n ax.yaxis.set_minor_locator(MultipleLocator(0.25))\\n ax.set_axisbelow(True)\\n ax.grid(axis='both', which='both')\\n\\n def label_regions(ax):\\n ax.text(0.95, 0.9, 'XDR', color='k', transform=ax.transAxes, ha='right', va='top', weight='bold', fontsize=16)\\n ax.text(0.05, 0.1, 'PDR', color='k', transform=ax.transAxes, ha='left', va='bottom', weight='bold', fontsize=16)\\n\\n # panel 1: HCO+/HCN over HNC/HCO+\\n ax = axes[0][0]\\n ax.plot([-10,10],[10,-10], ls='-', lw=1, c='grey', zorder=2)\\n ax.fill_between([-10,10],[10,-10],[10,10], color='lightgrey', alpha=0.5, zorder=1)\\n label_regions(ax)\\n for a,b,a_err,b_err,c,s in zip(HNC_HCO, HCO_HCN, HNC_HCO_err, HCO_HCN_err, colors, SSCs):\\n if np.isfinite(a) and np.isfinite(b):\\n ax.errorbar(a,b, xerr=a_err, yerr=b_err, marker='o', ms=5, lw=0, color=c, elinewidth=1, ecolor=c, label='SSC '+str(s['no']), zorder=3)\\n ax.errorbar(B_HCO_HCN[0],B_HNC_HCO[0], xerr=B_HCO_HCN[1], yerr=B_HNC_HCO[1], marker='o', ms=5, lw=0, color='lime', elinewidth=1, ecolor='lime', label=r'NGC 253 (Baan +08)', zorder=4)\\n ax.set_xlim(-1.15,0.45)\\n ax.set_ylim(-0.80,0.80)\\n format_panel(ax)\\n ax.set_ylabel(r'log I(HCO$^+$) / I(HCN)', fontsize=12)\\n\\n # panel 2: HNC/HCN over HCO/HCN\\n ax = axes[0][1]\\n ax.plot([0,0],[-10,10], ls='-', lw=1, c='grey', zorder=2)\\n ax.fill_between([0,10],[-10,-10],[10,10], color='lightgrey', alpha=0.5, zorder=1)\\n label_regions(ax)\\n for a,b,a_err,b_err,c in zip(HNC_HCN, HCO_HCN, HNC_HCN_err, HCO_HCN_err, colors):\\n if np.isfinite(a) and np.isfinite(b):\\n ax.errorbar(a,b, xerr=a_err, yerr=b_err, marker='o', ms=5, lw=0, color=c, elinewidth=1, ecolor=c, zorder=3)\\n ax.errorbar(B_HNC_HCN[0],B_HCO_HCN[0], xerr=B_HCO_HCN[1], yerr=B_HNC_HCO[1], marker='o', ms=5, lw=0, color='lime', elinewidth=1, ecolor='lime', zorder=4)\\n ax.set_xlim(-1.15,0.45)\\n ax.set_ylim(-0.80,0.80)\\n ax.xaxis.set_tick_params(which='both', labelbottom=True)\\n format_panel(ax)\\n ax.set_xlabel(r'log I(HNC) / I(HCN)', fontsize=12)\\n\\n # panel 3: HNC/HCO over HNC/HCN\\n ax = axes[1][0]\\n ax.plot([-10,10],[0,0], ls='-', lw=1, c='grey', zorder=2)\\n ax.fill_between([-10,10],[0,0],[10,10], color='lightgrey', alpha=0.5, zorder=1)\\n label_regions(ax)\\n for a,b,a_err,b_err,c in zip(HNC_HCO, HNC_HCN, HNC_HCO_err, HNC_HCN_err, colors):\\n if np.isfinite(a) and np.isfinite(b):\\n ax.errorbar(a,b, xerr=a_err, yerr=b_err, marker='o', ms=5, lw=0, color=c, elinewidth=1, ecolor=c, zorder=3)\\n ax.errorbar(B_HNC_HCO[0],B_HNC_HCN[0], xerr=B_HCO_HCN[1], yerr=B_HNC_HCO[1], marker='o', ms=5, lw=0, color='lime', elinewidth=1, ecolor='lime', zorder=4)\\n ax.set_xlim(-1.15,0.45)\\n ax.set_ylim(-1.00,0.60)\\n format_panel(ax)\\n ax.set_xlabel(r'log I(HNC$^{**}$) / I(HCO$^+$)', fontsize=12)\\n ax.set_ylabel(r'log I(HNC) / I(HCN)', fontsize=12)\\n\\n # panel 4: legend\\n ax = axes[1][1]\\n ax.set_axis_off()\\n fig.legend(loc=3, bbox_to_anchor=(0.55,0.05,0.14,0.3), ncol=1, mode=\\\"expand\\\", borderaxespad=0., fontsize=12, frameon=False)\\n\\n savepath = escape_fname(os.path.join(plotdir, '10.results', 'XDR-PDR_line_ratio.pdf'))\\n os.system('mkdir -p '+os.path.dirname(savepath))\\n fig.savefig(savepath, dpi=300, bbox_inches='tight')\",\n \"def one_period_plot():\\n file = \\\"Data/matfiles/20131221.mat\\\"\\n object = MatReader(file)\\n\\n NeA = object.NeA\\n latA = object.latA\\n times = object.secondsA\\n mlt = object.mltA\\n ind1 = 2606 #lat inds\\n ind2 = 13940 #lat inds\\n \\n ind1 = 3197 #mlat inds\\n ind2 = 14390 #mlat inds\\n \\n T = ind2 - ind1\\n ind1 += int(T/2)\\n ind2 += int(T/2)\\n\\n latA = latA[ind1:ind2]\\n NeA = NeA[ind1:ind2]\\n # NeA = object.meanie(NeA, 5)\\n times = times[ind1:ind2]\\n mlt = mlt[ind1:ind2]\\n mlt = hour_round(mlt)\\n\\n lats = np.zeros_like(latA)\\n lats[0] = latA[0]\\n for i in range(len(latA)-1):\\n dlat = latA[i+1] - latA[i]\\n if dlat < 0:\\n lats[i+1] = lats[i] - dlat\\n else:\\n lats[i+1] = lats[i] + dlat\\n\\n lats += 90\\n\\n xticks = np.array([-90, -70, -30, 30, 70, 110, 150, 210, 250, 270]) + 90\\n gridticks = np.array([-90, -70, -30, 30, 70, 77, 103, 110, 150, 210, 250, 270]) + 90\\n # plt.plot(lats, NeA, \\\".\\\", markersize = 1)\\n # plt.plot([0, 0], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([30, 30], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([60, 60], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([120, 120],[0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([150, 150], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([167, 167], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([193, 193], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([210, 210], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([240, 244], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([300, 300], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([330, 330], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([360, 360], [0, np.max(NeA)], \\\"k\\\")\\n # plt.xticks(xticks)\\n # plt.xlabel(\\\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\\\")\\n # plt.ylabel(\\\"Electron density [cm$^{-1}$]\\\")\\n # plt.title(\\\"One SWARM satellite period\\\")\\n # plt.grid(\\\"on\\\", axis = \\\"x\\\", xdata = gridticks)\\n #adding letters\\n x = (gridticks[:-1] + gridticks[1:])/2 - 3\\n y = np.zeros_like(x) - np.max(NeA)/40\\n s = [\\\"S\\\", \\\"B\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"C\\\", \\\"B\\\", \\\"A\\\", \\\"B\\\", \\\"S\\\"]\\n # for i in range(len(x)):\\n # plt.text(x[i], y[i], s[i], fontsize = 10)\\n # plt.savefig(\\\"Figures/swarm_period.pdf\\\")\\n # plt.show()\\n\\n # plt.plot(times, latA)\\n # plt.plot(times, mlt)\\n # plt.show()\\n print(lats[0])\\n print(lats[-1])\\n \\n fig, ax = plt.subplots()\\n ax.plot(lats, NeA, \\\".\\\", markersize = 1)\\n ax.set_xticks(xticks, minor=False)\\n ax.set_xticks([167, 193], minor=True)\\n ax.xaxis.grid(True, which = \\\"major\\\")\\n ax.xaxis.grid(True, which = \\\"minor\\\")\\n for i in range(len(x)):\\n ax.text(x[i], y[i], s[i], fontsize = 10)\\n ax.set_xlabel(\\\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\\\")\\n ax.set_ylabel(\\\"Electron density [cm$^{-1}$]\\\")\\n ax.set_title(\\\"One Swarm satellite period\\\")\\n # plt.savefig(\\\"Figures/swarm_period.pdf\\\")\\n plt.show()\\n plt.plot(mlt, NeA)\\n plt.show()\\n plt.plot(mlt, lats)\\n plt.show()\",\n \"def test_negative_ticks(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(projection='ternary')\\n ax.set_ternary_min(0, 3, -3)\",\n \"def figure_10_12_b():\\n xs = np.arange(-6,6,0.1)\\n plt.plot(xs,sigmoid(xs))\\n x=2.5\\n plt.scatter(x,sigmoid(x))\\n plt.plot(xs,logistic_lower_bound(xs,x))\\n plt.show()\",\n \"def style_x_labels(fig):\\r\\n for label in fig.get_xticklabels():\\r\\n label.set_rotation(36)\\r\\n label.set_fontsize(9)\",\n \"def secondaryXaxis(low,high,first,step,length,name,direction,x,y,log=0):\\n if log:\\n dislin.xaxlg(low,high,first,step,length,name,direction,x,y)\\n else:\\n dislin.xaxis(low,high,first,step,length,name,direction,x,y)\",\n \"def scree_plot(self, ev):\\n plt.scatter(range(1,len(ev)+1), ev)\\n plt.plot(range(1,len(ev)+1), ev)\\n plt.title(\\\"Scree Plot\\\")\\n plt.xlabel(\\\"Factors\\\")\\n plt.ylabel(\\\"Eigenvalue\\\")\\n plt.grid()\\n plt.show()\",\n \"def _hr_mean_style_x_axis(ax: plt.Axes, phase_dict: Dict[str, Sequence[str]], num_subphases: Sequence[int], **kwargs):\\n if sum(num_subphases) == 0:\\n # no subphases\\n ax.set_xticklabels(phase_dict.keys())\\n ax.set_xlabel(kwargs.get(\\\"xlabel\\\", \\\"Phases\\\"))\\n else:\\n ax.set_xticklabels([s for subph in phase_dict.values() for s in subph])\\n ax.set_xlabel(kwargs.get(\\\"xlabel\\\", \\\"Subphases\\\"))\",\n \"def visulize_5(X):\\n fig, axes1 = plt.subplots(5,5,figsize=(3,3))\\n for j in range(5):\\n for k in range(5):\\n i = np.random.choice(range(len(X)))\\n axes1[j][k].set_axis_off()\\n axes1[j][k].imshow(X[:,i].reshape(32, 32, 3))\\n plt.show()\",\n \"def set_x_axis_scale_to_pi():\\n\\n # Para formatear el eje X con multiplos de PI\\n # Defino aqui la funcion para que no ensucie el resto del codigo\\n def format_func(value, tick_number):\\n # Calcula el numero de multiplos de PI / 2\\n N = int(np.round(2 * value / np.pi))\\n\\n # Formatea acorde a este multiplo\\n if N == 0:\\n return \\\"0\\\"\\n elif N == 1:\\n return r\\\"$\\\\pi/2$\\\"\\n elif N == 2:\\n return r\\\"$\\\\pi$\\\"\\n elif N % 2 > 0:\\n return r\\\"${0}\\\\pi/2$\\\".format(N)\\n else:\\n return r\\\"${0}\\\\pi$\\\".format(N // 2)\\n\\n # Toma el objeto ax para hacer manipulaciones complejas del plot\\n _, ax = plt.subplots()\\n\\n # Coloca los multiplos descritos\\n ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))\\n ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))\\n ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))\",\n \"def visualisation(self):\\n plt.plot(self.x, self.y, 'o', label = 'Example data')\\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\\n plt.xlim([-1,1])\\n plt.ylim([-1,1])\",\n \"def frame():\\n fig = plt.figure(figsize = (6, 3))\\n\\n plt.subplots_adjust(left=.15, bottom=.2, right=.95, top=.9)\\n ax = fig.add_subplot(111)\\n \\n ax.tick_params(axis=\\\"x\\\", labelsize=12)\\n ax.tick_params(axis=\\\"y\\\", labelsize=12)\\n\\n return fig, ax\",\n \"def graphe_gains(res_alea, res_glou, res_glou_e, res_ucb):\\n T = np.arange(res_alea.size)\\n fig, ax = plt.subplots()\\n ax.grid(True)\\n plt.xlabel(\\\"T\\\")\\n plt.ylabel(\\\"Gain\\\")\\n \\n ax.plot(T, res_alea, label = 'aléatoire') \\n ax.plot(T, res_glou, label = 'glouton')\\n ax.plot(T, res_glou_e, label = 'e-glouton')\\n ax.plot(T, res_ucb, label = 'UCB')\\n ax.legend(loc = \\\"upper left\\\")\\n plt.title(\\\"Gains des 4 algorithmes par rapport à T\\\")\",\n \"def clean_chart(ax):\\n edges = ['top', 'bottom', 'right', 'left']\\n ax.tick_params(color=cbox('dark gray'))\\n for edge in edges:\\n ax.spines[edge].set_color(cbox('dark gray'))\\n ax.spines[edge].set_linewidth(0.4)\\n ax.yaxis.label.set_color(cbox('dark gray'))\\n ax.xaxis.label.set_color(cbox('dark gray'))\\n ax.tick_params(axis='x', colors=(0.05, 0.05, 0.05), width=0.5, which='major', top=True)\\n ax.tick_params(axis='y', colors=(0.05, 0.05, 0.05), width=0.5, which='major', left=True)\",\n \"def setup_figure(xmin):\\n # Setup gridspec\\n gs = gridspec.GridSpec(1, 2)\\n gs.update(wspace=0.00, hspace=0.00)\\n\\n # Setup figure\\n w, h = plt.figaspect(0.5)\\n fig = plt.figure(figsize=(w, h))\\n logax = fig.add_subplot(gs[0])\\n linax = fig.add_subplot(gs[1])\\n\\n # Axis formatting\\n linax.set_xlim([0.1, 1])\\n logax.set_xlim([min(gpdata[\\\"xgrid\\\"]), 0.1])\\n plt.setp(linax.get_yticklabels(), visible=False)\\n logax.set_xscale('log')\\n linax.xaxis.set_major_locator(MaxNLocator(5, prune='lower'))\\n return fig, logax, linax\",\n \"def set_up(self):\\n self.h, = self.ax.plot(self.x, lw=2)\\n self.ax.set_ylim(0,100)\\n self.ax.set_xlim(0,100)\\n self.ax.title.set_text(self.config[\\\"title\\\"])\\n self.ax.set_xlabel(self.config[\\\"x_label\\\"])\\n self.ax.set_ylabel(self.config[\\\"y_label\\\"])\",\n \"def set_ax_lims(ax, xs, ys, width=2.5):\\n center = (xs.mean(), ys.mean())\\n xlim, ylim = compute_xy_lims(center, width)\\n ax.set_xlim(xlim)\\n ax.set_ylim(ylim)\",\n \"def set_xscale(self, value):\\n if value in [\\\"linear\\\", \\\"lin\\\"]:\\n self._pad.SetLogx(0)\\n self._logx = False\\n\\n elif value in [\\\"log\\\", \\\"logy\\\"]:\\n left, right = self.get_xlim()\\n if right <= 0:\\n warnings.warn(\\n \\\"Current frame has no positive values, and therefore cannot \\\"\\n \\\"be log-scaled. Try running ax.set_xlim() first.\\\"\\n )\\n elif left <= 0:\\n # Arbitrarily set left to 0.1 (or 0.1*right if right <= 0.1)\\n # so that the frame can be displayed\\n if right <= 0.1:\\n self.set_xlim(left=0.1 * right)\\n else:\\n self.set_xlim(left=0.1)\\n\\n self._pad.cd()\\n self._pad.SetLogx(1)\\n self._pad.Modified()\\n self._logx = True\",\n \"def show_grid(self):\\n for ax in (self.time_velocity, self.time_power, self.power_velocity):\\n ax.grid(True)\",\n \"def plot1dim(i_dim):\\n freq = plt.hist(x=x[:,i_dim], bins=min(100,4*self.grid_shape[i_dim]))[0]\\n plt.plot(self.xg[i_dim][:,0],np.zeros(self.grid_shape[i_dim]) + 0.5*np.max(freq),'ko',markersize=3)\\n plt.xlabel(r'x_%d'%i_dim)\\n plt.ylabel('Frequency')\\n plt.title('Dim %d, m = %d' % (i_dim, self.grid_shape[i_dim]))\",\n \"def get_xticks_labels(self):\\n xticks = np.arange(-1, self.space_between_glyphs * len(self.coevolving_positions) * 3)\\n xticklabels = [' ']\\n for p1, p2 in self.coevolving_positions:\\n xticklabels += [str(p1), ' ', str(p2)] + [' '] * self.space_between_glyphs\\n return xticks, xticklabels\",\n \"def l_x_normalized(self):\\n return (self.l_x_axis - 128) / 127\",\n \"def userToPlotX(x):\\n return dislin.nxposn(x)\",\n \"def generate_plot(self):\\r\\n\\t\\tx, y = zip(*[p.p for p in self.universe])\\r\\n\\t\\tself.ax.cla()\\r\\n\\t\\tself.ax.plot(x, y, '.')\\r\\n\\t\\tself.ax.set_title('Universe at time: %d' % self.universe.time)\\r\\n\\t\\tself.ax.set_xlim([P_MU-4*P_STD, P_MU+4*P_STD])\\r\\n\\t\\tself.ax.set_ylim([P_MU-4*P_STD, P_MU+4*P_STD])\",\n \"def plot_U_vectors(self, ax):\\n U = self.U\\n t = self.t\\n fig = figure(figsize=(12,7))\\n axs = []\\n for i in range(8):\\n ax = fig.add_subplot(240 + (i+1))\\n ax.plot(t, U[:,i], 'k-', lw=2.0)\\n ax.grid()\\n if i > 3: ax.set_xlabel(r'$t$')\\n ax.set_title(r'$\\\\vec{u}_{%i}$' % i)\\n show()\",\n \"def centerAxis():\\n dislin.center()\",\n \"def plot_mean_and_max():\\n plt.rc('font', size=16)\\n data = np.array(\\n [\\n [0.0000, 0.000, 0.002],\\n [0.0001, 0.000, 0.000],\\n [0.0005, 0.001, 0.008],\\n [0.0008, 0.001, 0.003],\\n [0.0012, 0.002, 0.005],\\n [0.0100, 0.016, 0.041],\\n [0.0150, 0.025, 0.068],\\n [0.0200, 0.039, 0.096],\\n [0.0300, 0.053, 0.140],\\n [0.0400, 0.080, 0.242],\\n [0.0500, 0.098, 0.202]\\n ])\\n rb, mean, maxd = data[:, 0], data[:, 1], data[:, 2]\\n plt.plot(rb, mean, marker='.', markerfacecolor='steelblue',\\\\\\n markeredgecolor='steelblue', linestyle=' ', markersize=15)\\n plt.plot(rb, maxd, marker='.', markerfacecolor='orchid',\\\\\\n markeredgecolor='orchid', linestyle=' ', markersize=15)\\n plt.grid()\\n plt.xlabel(r'$r_B$')\\n plt.ylabel(r'$\\\\delta\\\\beta$ (deg)')\\n # plt.ylim([0., 0.15])\\n plt.tight_layout()\\n # plt.semilogx()\\n # plt.semilogy()\\n\\n plt.show()\",\n \"def make_montage_axial(overlay, underlay, png_name, cbar_name):\\n import matplotlib\\n import commands\\n# matplotlib.use('Agg')\\n import os\\n matplotlib.rcParams.update({'font.size': 5})\\n import matplotlib.cm as cm\\n ###\\n try:\\n from mpl_toolkits.axes_grid1 import ImageGrid\\n except:\\n from mpl_toolkits.axes_grid import ImageGrid\\n import matplotlib.pyplot as plt\\n import matplotlib.colors as col\\n import nibabel as nb\\n import numpy as np\\n\\n def determine_start_and_end(data, direction, percent):\\n x, y, z = data.shape\\n xx1 = 0\\n xx2 = x - 1\\n zz1 = 0\\n zz2 = z - 1\\n total_non_zero_voxels = len(np.nonzero(data.flatten())[0])\\n thresh = percent * float(total_non_zero_voxels)\\n start = None\\n end = None\\n if 'axial' in direction:\\n while(zz2 > 0):\\n d = len(np.nonzero(data[:, :, zz2].flatten())[0])\\n if float(d) > thresh:\\n break\\n zz2 -= 1\\n while(zz1 < zz2):\\n d = len(np.nonzero(data[:, :, zz1].flatten())[0])\\n if float(d) > thresh:\\n break\\n zz1 += 1\\n start = zz1\\n end = zz2\\n else:\\n while(xx2 > 0):\\n d = len(np.nonzero(data[xx2, :, :].flatten())[0])\\n if float(d) > thresh:\\n break\\n xx2 -= 1\\n while(xx1 < xx2):\\n d = len(np.nonzero(data[xx1, :, :].flatten())[0])\\n if float(d) > thresh:\\n break\\n xx1 += 1\\n start = xx1\\n end = xx2\\n return start, end\\n def get_spacing(across, down, dimension):\\n space = 10\\n prod = (across*down*space)\\n if prod > dimension:\\n while(across*down*space) > dimension:\\n space -= 1\\n else:\\n while(across*down*space) < dimension:\\n space += 1\\n return space\\n\\n Y = nb.load(underlay).get_data()\\n X = nb.load(overlay).get_data()\\n X = X.astype(np.float16)\\n Y = Y.astype(np.float16)\\n\\n if 'skull_vis' in png_name:\\n X[X < 20.0] = 0.0\\n if 'skull_vis' in png_name or 't1_edge_on_mean_func_in_t1' in png_name or 'MNI_edge_on_mean_func_mni' in png_name:\\n max_ = np.nanmax(np.abs(X.flatten()))\\n X[X != 0.0] = max_\\n print '^^', np.unique(X)\\n z1, z2 = determine_start_and_end(Y, 'axial', 0.0001)\\n spacing = get_spacing(6, 3, z2 - z1)\\n x, y, z = Y.shape\\n fig = plt.figure(1)\\n max_ = np.max(np.abs(Y))\\n\\n if ('snr' in png_name) or ('reho' in png_name) or ('vmhc' in png_name) or ('sca_' in png_name) or ('alff' in png_name) or ('centrality' in png_name) or ('temporal_regression_sca' in png_name) or ('temporal_dual_regression' in png_name):\\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, cbar_mode=\\\"single\\\", cbar_pad=0.2, direction=\\\"row\\\")\\n else:\\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, direction=\\\"row\\\")\\n\\n zz = z1\\n for i in range(6*3):\\n\\n if zz >= z2:\\n break\\n\\n im = grid[i].imshow(np.rot90(Y[:, :, zz]), cmap=cm.Greys_r)\\n zz += spacing\\n\\n x, y, z = X.shape\\n X[X == 0.0] = np.nan\\n max_ = np.nanmax(np.abs(X.flatten()))\\n print '~~', max_\\n\\n\\n zz = z1\\n im = None\\n print '~~~', z1, ' ', z2\\n for i in range(6*3):\\n\\n\\n if zz >= z2:\\n break\\n if cbar_name is 'red_to_blue':\\n\\n im = grid[i].imshow(np.rot90(X[:, :, zz]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=0, vmax=max_) ###\\n elif cbar_name is 'green':\\n im = grid[i].imshow(np.rot90(X[:, :, zz]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=0, vmax=max_)\\n else:\\n im = grid[i].imshow(np.rot90(X[:, :, zz]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=- max_, vmax=max_)\\n\\n grid[i].axes.get_xaxis().set_visible(False)\\n grid[i].axes.get_yaxis().set_visible(False)\\n zz += spacing\\n\\n cbar = grid.cbar_axes[0].colorbar(im)\\n\\n if 'snr' in png_name:\\n cbar.ax.set_yticks(drange(0, max_))\\n\\n elif ('reho' in png_name) or ('vmhc' in png_name) or ('sca_' in png_name) or ('alff' in png_name) or ('centrality' in png_name) or ('temporal_regression_sca' in png_name) or ('temporal_dual_regression' in png_name):\\n cbar.ax.set_yticks(drange(-max_, max_))\\n\\n\\n plt.show()\\n plt.axis(\\\"off\\\")\\n png_name = str(os.path.join(os.getcwd(), png_name))\\n plt.savefig(png_name, dpi=300, bbox_inches='tight')\\n plt.close()\\n\\n matplotlib.rcdefaults()\\n\\n return png_name\",\n \"def plot_xyz():\\n plt.subplot(3,1,1) # for x axis\\n plt.title('x value v.s. time')\\n plt.grid(True)\\n plt.ylabel('X')\\n plt.xlabel('t')\\n plt.plot(x, '-r')\\n\\n plt.subplot(3,1,2) # for y axis\\n plt.title('y value v.s. time')\\n plt.grid(True)\\n plt.ylabel('Y')\\n plt.xlabel('t')\\n plt.plot(y, '-g')\\n\\n plt.subplot(3,1,3) # for z axis\\n plt.title('z value v.s. time')\\n plt.grid(True)\\n plt.ylabel('Z')\\n plt.xlabel('t')\\n plt.plot(z, '-b')\",\n \"def plot_plasma(self):\\n x = self.geom.x\\n fig, axes = plt.subplots(1, 2, figsize=(8, 3),\\n constrained_layout=True)\\n # plot densities\\n ax = axes[0]\\n ax.plot(x, self.ne, 'b-')\\n ax.plot(x, self.ni, 'r-')\\n ax.legend(['E', 'Ion'])\\n ax.set_xlabel('Position (m)')\\n ax.set_ylabel('Density (m^-3)')\\n # plot temperature\\n ax = axes[1]\\n ax.plot(x, self.Te, 'b-')\\n ax.plot(x, self.Ti, 'r-')\\n ax.legend(['Te', 'Ti'])\\n ax.set_xlabel('Position (m)')\\n ax.set_ylabel('Temperature (eV)')\\n plt.show()\",\n \"def plot_x_y_drift(x, y):\\n\\tx = [np.nan if i is None else i for i in x]\\n\\ty = [np.nan if i is None else i for i in y]\\n\\tmask_x = np.where(x == np.nan)\\n\\tmask_y = np.where(y == np.nan)\\n\\tmx = np.ma.array(x)\\n\\tmx[mask_x] = np.ma.masked\\n\\tmy = np.ma.array(y)\\n\\tmy[mask_y] = np.ma.masked\\n\\tfig = plt.figure()\\n\\tfig.suptitle('Beam Centroid Drift in MFX1161 Yag', fontsize=20)\\n\\tax = fig.add_subplot(121)\\n\\tplt.xlabel('Event Number')\\n\\tplt.ylabel('Pixel Value')\\n\\tplt.title('Drift in X')\\n\\tplt.axis([0, len(x), 0, 1000])\\n\\tplt.plot(range(len(x)), mx)\\n\\tplt.grid()\\n\\tbx = fig.add_subplot(122)\\n\\tplt.xlabel('Event Number')\\n\\tplt.ylabel('Pixel Value')\\n\\tplt.title('Drift in Y')\\n\\tplt.axis([0, len(y), 0, 1000])\\n\\tplt.plot(range(len(y)), my)\\n\\tplt.grid()\\n\\tplt.show()\",\n \"def setup_anime(self, xmin_off=0, ymin_off=0, xmax_off=0, ymax_off=0):\\n xtremes = [(min(x), min(y), max(x), max(y)) for x, y in self.artists]\\n xmin = min(map(lambda lst: lst[0], xtremes)) + xmin_off\\n ymin = min(map(lambda lst: lst[1], xtremes)) + ymin_off\\n xmax = max(map(lambda lst: lst[2], xtremes)) + xmax_off\\n ymax = max(map(lambda lst: lst[3], xtremes)) + ymax_off\\n print(\\\"Xtremes:\\\", xmin, xmax, ymin, ymax)\\n\\n self.fig = plt.figure()\\n self.ax = plt.axes(xlim=(xmin, xmax), ylim=(ymin, ymax),\\n autoscale_on=False)\\n self.ax.set_facecolor('k')\\n self.ax.set(xlabel='x [a.u.]', ylabel='y [a.u.]',\\n title='Projectile motion')\\n self.ax.set_aspect('equal')\\n self.ax.grid()\\n\\n for a in range(self.art_num):\\n ln, = self.ax.plot([], [], '--')\\n ln.set_clip_on(False)\\n self.lines.append(ln)\\n\\n plt.gca().set_prop_cycle(None)\\n\\n for a in range(self.art_num):\\n pt, = self.ax.plot([], [], 'o')\\n pt.set_clip_on(False)\\n self.points.append(pt)\\n\\n self.time_template = 'time = %d a.u.'\\n self.time_text = self.ax.text(.5, .5, '', color='c',\\n transform=self.ax.transAxes,\\n horizontalalignment='center',\\n verticalalignment='center')\",\n \"def compute_axes(self):\\n mini, maxi = self._get_extremes()\\n self.y_axis.min = mini\\n self.y_axis.max = maxi\\n self.y_axis._max_min()\\n\\n if not None in [s.xvalues for s in self]:\\n mini, maxi = self._get_extremes('xvalues')\\n self.x_axis.min = mini\\n self.x_axis.max = maxi\\n self.x_axis._max_min()\",\n \"def plotCumulativeMovingAverage(self, x: list, title: str = \\\"Cumulative moving average\\\") -> None:\\n C = self.cumulativeMovingAverage(x)\\n plt.plot(C)\\n plt.xlabel('index')\\n plt.ylabel('cumulative moving average')\\n plt.title(title)\\n plt.show()\",\n \"def rug(self):\\n self.rax_y = self.ax.inset_axes(bounds=[0.97, 0, 0.03, 1], zorder=-1)\\n for index, value in self.df[f\\\"order_{self.y}\\\"].items():\\n if self.df.loc[index, f\\\"highlight_{self.y}\\\"] == 1:\\n color_set = self.fgcolors\\n zorder = 1\\n else:\\n color_set = self.bgcolors\\n zorder = 0\\n color = (\\n color_set[0]\\n if self.df.loc[index, self.obs] == 0\\n else color_set[1]\\n )\\n self.rax_y.hlines(\\n y=value,\\n xmin=0,\\n xmax=len(self.df),\\n color=color,\\n alpha=0.5,\\n lw=3,\\n zorder=zorder,\\n )\\n self.rax_y.margins(0.02)\\n self.rax_y.axis(\\\"off\\\")\\n # And the x-rug.\\n self.rax_x = self.ax.inset_axes(bounds=[0, 0, 1, 0.03], zorder=-1)\\n for index, value in self.df[f\\\"order_{self.x}\\\"].items():\\n if self.df.loc[index, f\\\"highlight_{self.x}\\\"] == 1:\\n color_set = self.fgcolors\\n zorder = 1\\n else:\\n color_set = self.bgcolors\\n zorder = 0\\n color = (\\n color_set[0]\\n if self.df.loc[index, self.obs] == 0\\n else color_set[1]\\n )\\n self.rax_x.vlines(\\n x=value,\\n ymin=0,\\n ymax=len(self.df),\\n color=color,\\n alpha=0.5,\\n lw=3,\\n zorder=zorder,\\n )\\n self.rax_x.margins(0.02)\\n self.rax_x.axis(\\\"off\\\")\\n # Set some space for the rugs.\\n xpad, ypad = (0 - self.pad, len(self.df) + self.pad)\\n self.ax.set_xlim(xpad, ypad)\\n self.ax.set_ylim(xpad, ypad)\\n self.rax_y.set_ylim(xpad, ypad)\\n self.rax_x.set_xlim(xpad, ypad)\\n\\n return self\",\n \"def make_plot_original(lx, ly):\\n plt.plot(lx, ly, 'ro')\\n plt.axis([-5, max(lx) + 5, -5, max(ly) + 5])\",\n \"def set_axis_x(self, new_axis_point):\\r\\n self.__x_axis = new_axis_point\",\n \"def plot(self, fig=None):\\n # Ignore warnings from matplotlib\\n warnings.filterwarnings(\\\"ignore\\\")\\n if fig is None:\\n fig = plt.figure()\\n means = np.mean(self.intervals, 1)\\n yerr = self.maxs - means\\n ax = fig.add_subplot(111)\\n n_intervals = np.alen(self.maxs)\\n x = np.arange(n_intervals)\\n ax.errorbar(x, means, yerr=yerr, fmt='o')\\n plt.xticks(x, self.labels, rotation='horizontal')\\n ax.set_xlim(x + [-1, 1])\\n plt.show()\",\n \"def buildPlotX(self):\\n\\n self.plotFineX = []\\n for iPlot in range(len(self.plotSpacerMethods)):\\n thisMeth = self.plotSpacerMethods[iPlot]\\n limLo = self.plotLimsLo[iPlot]\\n limHi = self.plotLimsHi[iPlot]\\n \\n # generate the fine grid for this parameter\\n thisUnif = thisMeth(limLo, limHi, num=self.plotNfine, \\\\\\n endpoint=True)\\n\\n # and append onto the list\\n self.plotFineX.append(thisUnif)\",\n \"def updatePlot(self,*args):\\n # set x limits\\n timeDisplayOptions = {'10 minutes':10,'1 hour':60,'6 hours':6*60,'24 hours':24*60,'All':0}\\n try:\\n lastDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[-1])\\n firstDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[0])\\n except IndexError: # no data yet\\n now = datetime.datetime.utcnow().toordinal()\\n firstDatetime = mpl.dates.num2date(now)\\n lastDatetime = firstDatetime\\n xMin = lastDatetime-datetime.timedelta(minutes=timeDisplayOptions[self.wScale.get()])\\n xMin = max([ firstDatetime, xMin ])\\n if self.wScale.get() == 'All':\\n xMin = firstDatetime\\n xMinIndex = numpy.searchsorted( self.stage60K.get_xdata(), mpl.dates.date2num(xMin) )\\n # rescale axes, with the x being scaled by the slider\\n if self.toolbar._active == 'HOME' or self.toolbar._active == None:\\n ymin,ymax = 10000000, -10000000\\n lineAndVar = { self.stage60K: self.t60K,\\n self.stage03K: self.t3K,\\n self.stageGGG: self.tGGG,\\n self.stageFAA: self.tFAA }\\n if len(self.stage60K.get_xdata()) > 1:\\n for line in lineAndVar.keys():\\n if lineAndVar[line].get() == 0:\\n line.set_visible(False)\\n else:\\n line.set_visible(True)\\n ydata = line.get_ydata()[xMinIndex:-1]\\n try:\\n ymin = min(ymin, numpy.nanmin(ydata))\\n ymax = max(ymax, numpy.nanmax(ydata))\\n except ValueError as e:\\n pass\\n self.ax.set_xlim(xMin,lastDatetime)\\n self.ax.set_ylim(ymin - (ymax-ymin)/10, ymax + (ymax-ymin)/10)\\n hfmt = mpl.dates.DateFormatter('%H:%M:%S', tz=tz.tzlocal())\\n self.ax.xaxis.set_major_formatter(hfmt)\\n self.fig.autofmt_xdate()\\n self.fig.tight_layout()\\n #draw\\n self.canvas.draw()\",\n \"def sse_plot(self):\\n df_sse = self.df[\\\"sse\\\"].sort_values(ascending=False)\\n plt.figure(figsize=(self.plot_width, self.plot_height))\\n df_sse.plot(\\\"bar\\\")\\n plt.title(\\\"SSE por cluster\\\")\\n output_path_sse = os.path.join(self.output_folder, 'sse_plot.png')\\n plt.savefig(output_path_sse)\",\n \"def cla(self):\\n\\t\\tAxes.cla(self)\\n\\t\\tself.set_longitude_grid(45)\\n\\t\\tself.set_latitude_grid(20)\\n\\t\\t# Do not display ticks -- we only want gridlines and text\\n\\t\\tself.xaxis.set_ticks_position('none')\\n\\t\\tself.yaxis.set_ticks_position('none')\\n\\n\\t\\tself.x_lim = [-180, 180]\\n\\t\\tself.y_lim = [-90, 90]\\n\\t\\tself.set_xlim(self.x_lim)\\n\\t\\tself.set_ylim(self.y_lim)\",\n \"def x_lb(self):\\n pass\",\n \"def plot(self): \\n\\t\\txandy = sep_xy(self.start, self.end)\\n\\t\\tplt.plot(xandy[0], xandy[1], 'k-', lw=1, color='green')\",\n \"def ploter(self):\\n if len(self.dataset[self.first_title]) != 2:\\n print('plot is only avilable for two features')\\n return\\n x_axis = []\\n y_axis = []\\n for title in self.dataset:\\n x_axis.append(self.dataset[title][0])\\n y_axis.append(self.dataset[title][1])\\n plt.plot(x_axis, y_axis, 'o')\\n plt.show()\",\n \"def test_x(self):\\n g = gca()\\n lines = g.get_lines() \\n self.assertEquals(lines[0].get_xdata().tolist(), [3, 5, 5, 3, 3])\",\n \"def xlim(self):\\r\\n lim = [ax.get_xlim() for ax in self._subaxes]\\r\\n if lim == []:\\r\\n lim = None\\r\\n return lim\",\n \"def plot_gauss(x, y, amp, center, width, name, outfile):\\n#\\n#--- set plotting range\\n#\\n xmin = min(x)\\n xmax = max(x) + 1\\n ymin = 0\\n ymax = int(1.1 * max(y))\\n#\\n#--- create Gaussian distribution\\n#\\n p = (amp, center, width, 0)\\n est_v = []\\n est_list = []\\n for v in range(0, xmax):\\n est = funcG(p, v)\\n est_v.append(v)\\n est_list.append(est)\\n#\\n#--- clean up the plotting device\\n#\\n plt.close('all')\\n#\\n#---- set a few parameters\\n#\\n mpl.rcParams['font.size'] = 9\\n props = font_manager.FontProperties(size=9)\\n \\n plt.axis([xmin, xmax, ymin, ymax])\\n plt.xlabel('PHA', size=9)\\n plt.ylabel('Counts', size=9)\\n plt.title(name, size=9)\\n#\\n#--- set information text postion and content\\n#\\n tx = 0.5 * xmax\\n ty = 0.9 * ymax\\n line = 'Amp: ' + str(round(amp,2)) + ' Center: ' + str(round(center,2)) + ' Width: ' + str(round(width,2))\\n plt.text(tx, ty, line)\\n#\\n#--- actual plotting\\n#\\n p, = plt.plot(x, y, marker='.', markersize=4.0, lw = 0)\\n p, = plt.plot(est_v, est_list, marker= '', lw=3)\\n#\\n#--- set the size of the plotting area in inch (width: 10.0in, height 2.08in x number of panels)\\n#\\n fig = matplotlib.pyplot.gcf()\\n fig.set_size_inches(10.0, 5.0)\\n#\\n#--- save the plot in png format\\n#\\n plt.savefig(outfile, format='png', dpi=100)\",\n \"def format_xaxis (self, axes, \\n n_ticks = 10, # Number of ticks we would like\\n timestamp_formatting = '(%Y-%m-%d)%H:%M', # Specified formatting \\n xaxis_mode = None): # Several automatic modes\\n if (self.X_type == \\\"categorical\\\"):\\n axes.set_xticks(self.X[self.start_indx:self.end_indx], minor=False)\\n axes.set_xticklabels(self.Xcategories[self.start_indx:self.end_indx][:,0], minor=False)\\n \\n elif(self.X_type == \\\"numerical\\\"):\\n # If regular numerical we just plot the values\\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\\n# ax.get_xaxis().get_major_formatter().set_useOffset(False)\\n \\n elif(self.X_type == \\\"timestamp\\\"):\\n axes.xaxis.set_major_formatter(mdates.DateFormatter(timestamp_formatting))\\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\\n axes.xaxis_date()\\n # ax.xaxis.set_major_formatter(FuncFormatter(self.ticklabels[val:val + wsize]))\\n self.figure.autofmt_xdate()\\n# print (type(self.X), type(self.X[0]))\\n \\n elif(self.formatXaxis == \\\"intraday\\\"):\\n # If the data is intraday and we want to apply the Gap Remover !!! \\n gap_remover_flag = 1;\\n if (gap_remover_flag):\\n formatter = FuncFormatter(ul.detransformer_Formatter)\\n axes.xaxis.set_major_formatter(formatter) \\n # mdates.DateFormatter(formatting)\\n \\n else:\\n axes.xaxis.set_major_formatter(mdates.DateFormatter(formatting))\\n \\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\",\n \"def plot(self): \\n\\t\\txandy = sep_xy(self.start, self.end)\\n\\t\\tplt.plot(xandy[0], xandy[1], 'k-', lw=1, color='red')\",\n \"def plot_time_series(df, plt):\\n # Remove the plot frame lines\\n delta = (df[\\\"timestamp\\\"].max() - df[\\\"timestamp\\\"].min()) / 10\\n plt.xticks(\\n np.arange(\\n df[\\\"timestamp\\\"].min(),\\n df[\\\"timestamp\\\"].max(),\\n step=np.around(delta, decimals=1),\\n )\\n )\\n plt.grid()\",\n \"def _plot_rawdata(self):\\n fig, ax = plt.subplots(1, 1)\\n ax.imshow(self.data, origin='top', extent=(0., 360., -90., 90.))\\n ax.set_title('Driscoll Healy Grid')\\n ax.set_xlabel('longitude')\\n ax.set_ylabel('latitude')\\n fig.tight_layout(pad=0.5)\\n return fig,ax\",\n \"def getXLimit(self):\\n return self.axes.get_xlim()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60257566","0.59820426","0.5593813","0.55852216","0.55148125","0.55004704","0.5493635","0.545422","0.54387575","0.54352844","0.5398524","0.53769404","0.5369894","0.5365591","0.5359699","0.5343257","0.53026277","0.52932596","0.5254157","0.52503586","0.52503586","0.524545","0.5218069","0.5218069","0.52130127","0.5192948","0.51832753","0.5180361","0.5175472","0.5158744","0.51584834","0.5135225","0.5131717","0.5125533","0.51208895","0.51205575","0.5109597","0.51067007","0.5084301","0.5072217","0.50604534","0.5058471","0.5048757","0.5045514","0.50416523","0.5041235","0.5031774","0.5029571","0.50277424","0.49977323","0.49945602","0.4981135","0.49806944","0.49733138","0.4966914","0.49645138","0.49588713","0.49522164","0.4947727","0.49440405","0.4928053","0.49244475","0.4923956","0.49174604","0.49138618","0.49125502","0.49123165","0.4896664","0.489541","0.48940158","0.489387","0.488887","0.488693","0.48666334","0.48654863","0.4860348","0.4859434","0.48540553","0.48510903","0.48399788","0.4835072","0.48340327","0.4829447","0.4828207","0.48273262","0.48210844","0.48190334","0.48131123","0.48008978","0.47992092","0.4798931","0.47940865","0.4793308","0.47921684","0.477913","0.47787413","0.47775224","0.4769007","0.47683918","0.47666118","0.4759975"],"string":"[\n \"0.60257566\",\n \"0.59820426\",\n \"0.5593813\",\n \"0.55852216\",\n \"0.55148125\",\n \"0.55004704\",\n \"0.5493635\",\n \"0.545422\",\n \"0.54387575\",\n \"0.54352844\",\n \"0.5398524\",\n \"0.53769404\",\n \"0.5369894\",\n \"0.5365591\",\n \"0.5359699\",\n \"0.5343257\",\n \"0.53026277\",\n \"0.52932596\",\n \"0.5254157\",\n \"0.52503586\",\n \"0.52503586\",\n \"0.524545\",\n \"0.5218069\",\n \"0.5218069\",\n \"0.52130127\",\n \"0.5192948\",\n \"0.51832753\",\n \"0.5180361\",\n \"0.5175472\",\n \"0.5158744\",\n \"0.51584834\",\n \"0.5135225\",\n \"0.5131717\",\n \"0.5125533\",\n \"0.51208895\",\n \"0.51205575\",\n \"0.5109597\",\n \"0.51067007\",\n \"0.5084301\",\n \"0.5072217\",\n \"0.50604534\",\n \"0.5058471\",\n \"0.5048757\",\n \"0.5045514\",\n \"0.50416523\",\n \"0.5041235\",\n \"0.5031774\",\n \"0.5029571\",\n \"0.50277424\",\n \"0.49977323\",\n \"0.49945602\",\n \"0.4981135\",\n \"0.49806944\",\n \"0.49733138\",\n \"0.4966914\",\n \"0.49645138\",\n \"0.49588713\",\n \"0.49522164\",\n \"0.4947727\",\n \"0.49440405\",\n \"0.4928053\",\n \"0.49244475\",\n \"0.4923956\",\n \"0.49174604\",\n \"0.49138618\",\n \"0.49125502\",\n \"0.49123165\",\n \"0.4896664\",\n \"0.489541\",\n \"0.48940158\",\n \"0.489387\",\n \"0.488887\",\n \"0.488693\",\n \"0.48666334\",\n \"0.48654863\",\n \"0.4860348\",\n \"0.4859434\",\n \"0.48540553\",\n \"0.48510903\",\n \"0.48399788\",\n \"0.4835072\",\n \"0.48340327\",\n \"0.4829447\",\n \"0.4828207\",\n \"0.48273262\",\n \"0.48210844\",\n \"0.48190334\",\n \"0.48131123\",\n \"0.48008978\",\n \"0.47992092\",\n \"0.4798931\",\n \"0.47940865\",\n \"0.4793308\",\n \"0.47921684\",\n \"0.477913\",\n \"0.47787413\",\n \"0.47775224\",\n \"0.4769007\",\n \"0.47683918\",\n \"0.47666118\",\n \"0.4759975\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":25593,"cells":{"query":{"kind":"string","value":"Validates the data and creates the config objects"},"document":{"kind":"string","value":"def validate(data):\n if 'project' not in data:\n raise PolyaxonfileError(\"The Polyaxonfile must contain a project section.\")\n\n if 'model' not in data:\n raise PolyaxonfileError(\"The Polyaxonfile must contain a model section.\")\n\n validated_data = {\n 'version': data['version'],\n 'project': ProjectConfig.from_dict(data['project']),\n 'model': ModelConfig.from_dict(data['model'])\n }\n if data.get('settings'):\n validated_data['settings'] = SettingsConfig.from_dict(data['settings'])\n\n if data.get('train'):\n validated_data['train'] = TrainConfig.from_dict(data['train'])\n\n if data.get('eval'):\n validated_data['eval'] = EvalConfig.from_dict(data['eval'])\n\n return validated_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def validate_config(self):\r\n c = self.config\r\n \r\n # Make sure that we have a database_path, and an image_path...\r\n assert 'database_path' in c\r\n assert 'image_path' in c\r\n # We should probably check if these paths exist and make them as well...\r\n \r\n # Set the default values.\r\n graph_draw_frequency = c['graph_draw_frequency']\r\n for period, interval in self.default_config['graph_draw_frequency'].iteritems():\r\n graph_draw_frequency.setdefault(period, interval)\r\n \r\n # A quick check to make sure that our port is an integer.\r\n c['httpd_port'] = int(c['httpd_port'])\r\n \r\n # Make sure that no duplicate IDs exist, and that the template exists as well.\r\n ids = set()\r\n for graph in c['graphs']:\r\n graph.setdefault('config', {})\r\n graph['config'].setdefault('periods', [])\r\n assert graph['id'] not in ids\r\n ids.add(graph['id'])\r\n assert(template_exists(graph['template']))","def _validate_config(self):\n pass","def validate_config(self):\n pass","def validate_config(self):\n pass","def prepare_data(self, config: TreeConfigParser) -> None:\n self.data = Data(config)\n self.data.prepare_input()\n self.data.prepare_output()","def _validate_create_data(self, data):\n return","def _further_validate_and_setup(self) -> None:\n\n # Make sure parameters make sense/are valid\n if len(self.validated['learners']) != len(self.validated['param_grids']):\n raise SchemaError(autos=None,\n errors='The lists of of learners and parameter '\n 'grids must be the same size.')\n if (self.validated['hashed_features'] is not None\n and self.validated['hashed_features'] == 0):\n self.validated['hashed_features'] = self._n_features_feature_hashing\n if self.validated['lognormal'] and self.validated['power_transform']:\n raise SchemaError(autos=None,\n errors='Both \"lognormal\" and \"power_transform\" '\n 'were set simultaneously.')\n if len(self.validated['learners']) != len(self.validated['param_grids']):\n raise SchemaError(autos=None,\n errors='The \"learners\" and \"param_grids\" '\n 'parameters were both set and the '\n 'lengths of the lists are unequal.')","def __record(self, data={}):\n # Create a config file\n if not self.config_file:\n self.config_file = \"./default.config\"\n\n # Create empty config json file if not there\n if not os.path.isfile(self.config_file):\n with open(self.config_file, 'w') as f:\n d = json.dumps({})\n f.write(d)\n\n # This structure ensures that for different servers, there can exist\n # multiple licenses (`license_key`), which contains one `device_token`\n # each and multiple users (identified by `user_email`), each with its\n # own `user_token`.\n\n # Overwrite values with current values\n if not data or data == {}:\n with open(self.config_file, 'r') as f:\n data = json.load(f)\n data[self.server] = {}\n if self.license_key != '':\n data[self.server][self.license_key] = {}\n if self.device_token != '':\n data[self.server][self.license_key][\"device_token\"] = self.device_token\n if self.user.email != '':\n data[self.server][self.license_key][self.user.email] = {}\n if self.user_token != '':\n data[self.server][self.license_key][self.user.email][\"user_token\"] = self.user_token\n else:\n data = data\n\n # Clean up the remaining values (i.e. get rid of it if it's empty)\n copied = copy.deepcopy(data)\n for server in copied.keys():\n if server not in self.__valid_servers.keys():\n data.pop(server, None)\n\n for key in copied[server].keys():\n data[server].pop('', None)\n data[server].pop(' ', None)\n if copied[server][key] == {}:\n data[server].pop(key, None)\n\n for k in copied[server][key].keys():\n if k != \"device_token\":\n data[server][key].pop('', None)\n data[server][key].pop(' ', None)\n if copied[server][key][k] == {} or copied[server][key][k] == \"\":\n data[server][key].pop(k, None)\n\n with open(self.config_file, 'w') as f:\n d = json.dumps(data)\n f.write(d)","def _validate_configurations(self) -> None:\n if self.__exception:\n raise self.__exception","def validate_config(self):\n reference = data_file(\"../config/template/minimum_aiscalator.conf\")\n ref = pyhocon.ConfigFactory.parse_file(reference)\n msg = \"In Global Application Configuration file \"\n _validate_configs(self._app_conf, ref, msg,\n missing_exception=True,\n type_mismatch_exception=True)\n reference = data_file(\"../config/template/aiscalator.conf\")\n ref = pyhocon.ConfigFactory.parse_file(reference)\n msg = \"In Global Application Configuration file \"\n _validate_configs(self._app_conf, ref, msg,\n missing_exception=False,\n type_mismatch_exception=True)\n if self._step_name:\n reference = data_file(\"../config/template/minimum_step.conf\")\n ref = pyhocon.ConfigFactory.parse_file(reference)\n msg = \"in step named \" + self._step_name\n _validate_configs(self._step,\n ref[\"steps\"][\"Untitled\"],\n msg,\n missing_exception=True,\n type_mismatch_exception=True)\n reference = data_file(\"../config/template/step.conf\")\n ref = pyhocon.ConfigFactory.parse_file(reference)\n msg = \"in step named \" + self._step_name\n _validate_configs(self._step,\n ref[\"steps\"][\"Untitled\"],\n msg,\n missing_exception=False,\n type_mismatch_exception=True)\n if self._dag_name:\n reference = data_file(\"../config/template/minimum_dag.conf\")\n ref = pyhocon.ConfigFactory.parse_file(reference)\n msg = \"in dag named \" + self._dag_name\n _validate_configs(self._dag,\n ref[\"dags\"][\"Untitled\"],\n msg,\n missing_exception=True,\n type_mismatch_exception=True)\n reference = data_file(\"../config/template/step.conf\")\n ref = pyhocon.ConfigFactory.parse_file(reference)\n msg = \"in dag named \" + self._dag_name\n _validate_configs(self._dag,\n ref[\"dags\"][\"Untitled\"],\n msg,\n missing_exception=False,\n type_mismatch_exception=True)","def validate(self, data):\n logger.debug(data)\n upload = data['upload']\n config_type = data['config_type']\n content_type = validators.validate_content_type(upload, config_type)\n if config_type == 'PRESET':\n validators.validate_preset(upload)\n data['content_type'] = content_type\n fname = data['upload'].name\n data['filename'] = fname.replace(' ', '_').lower()\n return data","def initiate(self, data):\n self._parse_config()","def validate(self, config_json):\n pass","def defaultconfig(self):\r\n\r\n config_data = {\r\n \"path_to_database\": \"FUDB/FOLLOWUP.DB\",\r\n \"path_to_frontend\": \"FUDB/\",\r\n \"path_to_dcs_info\": \"FUDB/\",\r\n \"path_to_bin\": \"bin/\",\r\n \"path_to_excels_exported_from_database\": \"excels exported/\",\r\n \"path_to_excels_to_be_imported_in_database\": \"excels to be imported/\",\r\n \"path_to_new_opfiles\": \"DC BATCHES IN WORK/0 NEW/\",\r\n \"path_to_batches_unassigned\": \"DC BATCHES IN WORK/1 UNASSIGNED/\",\r\n \"path_to_batches_prepfiles\": \"DC BATCHES IN WORK/2 PREPARED FILES/\",\r\n \"path_to_batches_assigned\": \"DC BATCHES IN WORK/3 ASSIGNED/\",\r\n \"path_to_batches_tobechecked\": \"DC BATCHES IN WORK/4 TO BE CHECKED/\",\r\n \"path_to_batches_tbimported\": \"DC BATCHES IN WORK/5 TO BE IMPORTED/\",\r\n \"path_to_batches_finished\": \"DC BATCHES IN WORK/6 FINISHED/\",\r\n \"path_to_batches_instandby\": \"DC BATCHES IN WORK/7 IN STANDBY/\",\r\n \"path_to_batches_unrecordable\": \"DC BATCHES IN WORK/8 UNRECORDABLE/\",\r\n \"batch_status_options_responsible\": \"PREP. OP FILE, IMPORTATION & SPLIT FILE, RELIABILITY & DATA UPGRADE, CHECK OP FILE, CHECK SPLIT FILE, CHECK FRONT END, **TO BE CHECKED\",\r\n \"batch_status_options_proofreader\": \"OP FILE OK, SPLIT FILE OK, FRONT END OK, **TO BE IMPORTED, **FINISHED, **REWORK, **STANDBY, **UNRECORDABLE\",\r\n \"batch_status_options_overall\": \"ONGOING, STANDBY, FINISHED, UNRECORDABLE\",\r\n \"aircrafts\": \"A300, A300-600, A310, A320, A330, A340, A350, A380\",\r\n \"split_batch_factor\": \"2, 3, 4, 5, 6, 7, 8, 9\",\r\n \"IDlentgh\": \"6\",\r\n \"port\": \"5000\"\r\n }\r\n \r\n if not os.path.isfile(os.path.join(self.cwd, \"config.json\")):\r\n self.func.write_json(config_data, self.cwd, fname=\"config.json\")","def _validate_config(self):\n # Simulation ID\n empty_string_check(self._config_dict['@id'])\n \n # Output\n empty_string_check(self._config_dict['output']['@baseDirectory'])\n self._config_dict['output']['@saveInteractionLog'] = parse_boolean(self._config_dict['output']['@saveInteractionLog'])\n self._config_dict['output']['@saveRelevanceJudgments'] = parse_boolean(self._config_dict['output']['@saveRelevanceJudgments'])\n self._config_dict['output']['@trec_eval'] = parse_boolean(self._config_dict['output']['@trec_eval'])\n \n # Topics\n def check_topic(t):\n \"\"\"\n Checks a given topic, t. Looks for a topic ID and a valid topic description file.\n \"\"\"\n empty_string_check(t['@id'])\n filesystem_exists_check(t['@filename'])\n filesystem_exists_check(t['@qrelsFilename'])\n \n if '@backgroundFilename' in t: # A background file was specified.\n filesystem_exists_check(t['@backgroundFilename'])\n else:\n t['@backgroundFilename'] = None # No background file was specified.\n \n topics = self._config_dict['topics']['topic']\n \n if type(topics) == list:\n for topic in topics:\n check_topic(topic)\n else:\n check_topic(topics)\n \n # Users\n users = self._config_dict['users']['user']\n \n if type(users) == list:\n for user in users:\n filesystem_exists_check(user['@configurationFile'])\n else:\n filesystem_exists_check(users['@configurationFile'])\n \n # Search Interface\n empty_string_check(self._config_dict['searchInterface']['@class'])\n check_attributes(self._config_dict['searchInterface'])","def create(self, validated_data):\n return ExportConfig.objects.create(**validated_data)","def create_config(self) -> None:\n pass","def create_config(self) -> None:\n pass","def test_valid_configurations_create(self):\n expected_configs = self.expected_default_datastore_configs()\n values = json.dumps(expected_configs.get('valid_values'))\n expected_values = json.loads(values)\n result = instance_info.dbaas.configurations.create(\n CONFIG_NAME,\n values,\n CONFIG_DESC,\n datastore=instance_info.dbaas_datastore,\n datastore_version=instance_info.dbaas_datastore_version)\n resp, body = instance_info.dbaas.client.last_response\n assert_equal(resp.status, 200)\n with TypeCheck('Configuration', result) as configuration:\n configuration.has_field('name', str)\n configuration.has_field('description', str)\n configuration.has_field('values', dict)\n configuration.has_field('datastore_name', str)\n configuration.has_field('datastore_version_id', str)\n configuration.has_field('datastore_version_name', str)\n global configuration_info\n configuration_info = result\n assert_equal(configuration_info.name, CONFIG_NAME)\n assert_equal(configuration_info.description, CONFIG_DESC)\n assert_equal(configuration_info.values, expected_values)","def save_config(self, data, validate=True):\n if isinstance(data, list):\n # Convert list to plain text\n r = []\n for d in sorted(data, key=operator.itemgetter(\"name\")):\n r += [\n \"==[ %s ]========================================\\n%s\"\n % (d[\"name\"], d[\"config\"])\n ]\n data = \"\\n\".join(r)\n # Wipe out unnecessary parts\n if self.config_filter_handler:\n if self.config_filter_handler.allow_config_filter:\n handler = self.config_filter_handler.get_handler()\n data = handler(self, data) or \"\"\n else:\n logger.warning(\"Handler is not allowed for config filter\")\n # Pass data through config filter, if given\n if self.config_diff_filter_handler:\n if self.config_diff_filter_handler.allow_config_diff_filter:\n handler = self.config_diff_filter_handler.get_handler()\n data = handler(self, data) or \"\"\n else:\n logger.warning(\"Handler is not allowed for config diff filter\")\n # Pass data through the validation filter, if given\n # @todo: Replace with config validation policy\n if self.config_validation_handler:\n if self.config_validation_handler.allow_config_validation:\n handler = self.config_validation_handler.get_handler()\n warnings = handler(self, data)\n if warnings:\n # There are some warnings. Notify responsible persons\n self.event(\n self.EV_CONFIG_POLICY_VIOLATION, {\"object\": self, \"warnings\": warnings}\n )\n else:\n logger.warning(\"Handler is not allowed for config validation\")\n # Calculate diff\n old_data = self.config.read()\n is_new = not bool(old_data)\n diff = None\n if is_new:\n changed = True\n else:\n # Calculate diff\n if self.config_diff_filter_handler:\n if self.config_diff_filter_handler.allow_config_diff_filter:\n handler = self.config_diff_filter_handler.get_handler()\n # Pass through filters\n old_data = handler(self, old_data)\n new_data = handler(self, data)\n if not old_data and not new_data:\n logger.error(\n \"[%s] broken config_diff_filter: Returns empty result\", self.name\n )\n else:\n self.logger.warning(\"Handler is not allowed for config diff filter\")\n new_data = data\n else:\n new_data = data\n changed = old_data != new_data\n if changed:\n diff = \"\".join(\n difflib.unified_diff(\n old_data.splitlines(True),\n new_data.splitlines(True),\n fromfile=os.path.join(\"a\", self.name.encode(\"utf8\")),\n tofile=os.path.join(\"b\", self.name.encode(\"utf8\")),\n )\n )\n if changed:\n # Notify changes\n self.notify_config_changes(is_new=is_new, data=data, diff=diff)\n # Save config\n self.write_config(data)\n # Apply mirroring settings\n self.mirror_config(data, changed)\n # Run config validation\n if validate:\n self.validate_config(changed)\n return changed","def process_data():\n with open('configClear_v2.json') as config:\n json_config = json.load(config)\n cisco_ios_xe_native = json_config.get('frinx-uniconfig-topology:configuration').get('Cisco-IOS-XE-native:native')\n\n config_container = {\n \"BDI\" : cisco_ios_xe_native.get('interface').get('BDI'),\n \"Loopback\" : cisco_ios_xe_native.get('interface').get('Loopback'),\n \"Port-channel\" : cisco_ios_xe_native.get('interface').get('Port-channel'),\n \"TenGigabitEthernet\" : cisco_ios_xe_native.get('interface').get('TenGigabitEthernet'),\n \"GigabitEthernet\" : cisco_ios_xe_native.get( 'interface' ).get( 'GigabitEthernet' )\n }\n\n\n with create_connection() as conn:\n for k,v in config_container.items():\n for i in v:\n cur = conn.cursor()\n cur.execute(\"\"\"\n INSERT INTO device_interface_config( name, description, config, port_channel_id, max_frame_size )\n VALUES( %s, %s, %s, %s, %s);\n \"\"\", (f\"{k}{i.get('name')}\",\n i.get('description'),\n json.dumps(i),\n i.get( 'Cisco-IOS-XE-ethernet:channel-group' ),\n i.get('mtu')\n )\n )","def check_configs(self):\n\n pass","def _validate_data(self, vms, fw_rules):\n self._validate_vms(vms)\n self._validate_fw_rules(fw_rules)\n self._validated = True","def build_configs():","def validate_config(config: Dict) -> None:\n\n # For validating with pydantic\n config_flattened = format_config_for_validation(config)\n user_defined_sets = get_all_sets(config)\n\n errors = []\n for input_data in config_flattened:\n try:\n if \"type\" not in input_data:\n UserDefinedValue(**input_data)\n elif input_data[\"type\"] == \"param\":\n input_data[\"defined_sets\"] = user_defined_sets\n UserDefinedParameter(**input_data)\n elif input_data[\"type\"] == \"result\":\n input_data[\"defined_sets\"] = user_defined_sets\n UserDefinedResult(**input_data)\n elif input_data[\"type\"] == \"set\":\n UserDefinedSet(**input_data)\n else:\n # have pydantic raise an error\n UserDefinedValue(\n name=input_data[\"name\"],\n type=input_data[\"type\"],\n dtype=input_data[\"dtype\"],\n )\n except ValidationError as ex:\n errors_caught = [x[\"msg\"] for x in ex.errors()]\n errors.extend(errors_caught)\n\n if errors:\n error_message = \"\\n\".join(errors)\n raise OtooleConfigFileError(message=f\"\\n{error_message}\")","def validate_config(self):\n log.msg('Validating config')\n # Map message types to callbacks that handle that message type\n self.dispatch_map = {\n 'Deliver': self.receive_message,\n 'Status_Report': self.receive_delivery_report,\n }\n\n self.redis_config = self.config.get('redis', {})\n self.gammu_config = self.config.get('gammu')\n self.connect_retry_interval = int(self.config.get(\n 'connect_retry_interval', 15))\n self.poll_interval = int(self.config.get('poll_interval', 60))\n self.country_code = str(self.config.get('country_code'))\n self.phone_number = str(self.config.get('phone_number'))\n self.phone = None","def __setup(self):\n\n # Create empty config json file if not there.\n if not self.config_file:\n self.config_file = \"./default.config\"\n if not os.path.isfile(self.config_file):\n with open(self.config_file, 'w') as f:\n json.dump({}, f)\n\n # Recycle and replace values in the config file\n with open(self.config_file, 'r') as json_file:\n data = json.load(json_file)\n\n # Records the `server`, `license_key`, and `user_email` if they don't exist.\n # Server\n if (self.server not in data.keys() or data[self.server] == {}):\n data[self.server] = {}\n\n # License key\n if (self.license_key not in data[self.server].keys() or data[self.server][self.license_key] == {}):\n data[self.server][self.license_key] = {}\n\n # User email\n if self.user.email not in data[self.server][self.license_key].keys():\n data[self.server][self.license_key][self.user.email] = {}\n\n # Next, if a `device_token` doesn't exist for this server and\n # license, call the `Organization.registerLicense()` endpoint to\n # obtain a device token. On the other hand, if the device token\n # already exists, it takes the existing token to prevent\n # redundantly registering the same license.\n\n # Device token\n if (\"device_token\" not in data[self.server][self.license_key].keys()\n or data[self.server][self.license_key][\"device_token\"] == ''):\n out = self.organization.registerLicense(self.device_name)\n if 'Token' not in out:\n self.__record(data=data) # Save current state\n raise PermissionError(\n \"Registration error. Make sure your license key is valid for the selected server.\")\n\n self.device_token = out['Token']\n data[self.server][self.license_key][\"device_token\"] = self.device_token\n\n elif (self.device_token == '' and data[self.server][self.license_key][\"device_token\"] != ''):\n self.device_token = data[self.server][self.license_key][\"device_token\"]\n\n # Next, if a `user_token` does not exist for the current user on\n # this license and server, it tries to log in (`User.login()`) the\n # user first using the device token. If cannot be logged in, it\n # needs to create a new user (`User.create()`) before logging in.\n # The user information and credentials are already handled in the\n # `User` class, so it only needs to pass in the `device_token`.\n\n # User token\n if (\"user_token\" not in data[self.server][self.license_key][self.user.email].keys()\n or data[self.server][self.license_key][self.user.email][\"user_token\"] == ''):\n res = self.user.login(self.device_token)\n\n if res == \"INVALID_USER\":\n res = self.user.create(self.device_token)\n if res == 'INTERNAL_ERROR':\n self.__record(data=data)\n raise PermissionError(\"Cannot create new user. Check your license permissions.\")\n\n self.user_id = res\n res = self.user.login(self.device_token)\n\n elif res == \"INVALID_PASSWORD\":\n self.__record(data=data)\n raise PermissionError(\"Incorrect login password.\")\n\n self.user_token = self.user.user_token\n if self.user_token != '':\n data[self.server][self.license_key][self.user.email][\"user_token\"] = self.user_token\n else:\n self.user_token = data[self.server][self.license_key][self.user.email][\"user_token\"]\n self.user.user_token = self.user_token\n\n # Record updated data into the config file.\n self.__record(data=data)","def validate(self):\n if self.tba_key is None:\n self.log.error(\n \"You are missing the TBA-Key field. Please check https://github.com/team4099/scouting-data-ingest#tba for more information.\"\n )\n return False\n\n self.check_internet_connection()\n\n if self.year is None:\n self.log.error(\n \"You are missing the Year field. Please add one in the style shown below.\"\n )\n year_example = \"\"\"\n {\n \"Year\": \"2020\"\n }\n \"\"\"\n console.print(Syntax(year_example, \"json\"))\n console.print(\n \"Reference https://github.com/team4099/scouting-data-ingest#configuration for more information.\"\n )\n return False\n\n if self.google_credentials is None:\n self.log.error(\n \"You are missing the Google-Credentials field. Please check https://github.com/team4099/scouting-data-ingest#google-service-account-credentials-file for more information.\"\n )\n return False\n elif not os.path.isfile(f\"config/{self.google_credentials}\"):\n self.log.error(\n \"The file listed in the Google-Credentials field does not exist in the config folder. Please place it inside the config folder.\"\n )\n return False\n else:\n try:\n gc = gspread.service_account(f\"./config/{self.google_credentials}\")\n except ValueError as e:\n self.log.error(\n \"The file listed in the Google-Credentials Field is improper. See below for details.\"\n )\n self.log.error(e)\n return False\n\n if self.spreadsheet is None:\n self.log.error(\n \"You are missing the Spreadsheet field. Please check https://github.com/team4099/scouting-data-ingest#spreadsheet for more information.\"\n )\n return False\n else:\n try:\n gc.open(f\"{self.spreadsheet}\").get_worksheet(0)\n except gspread.exceptions.SpreadsheetNotFound:\n self.log.error(\n \"The file listed in the Spreadsheets field has not been shared with the service account. Please make sure it is.\"\n )\n return False\n\n if self.db_user is None:\n self.log.error(\n \"You are missing the Database User field. Please check https://github.com/team4099/scouting-data-ingest#mysql for more information.\"\n )\n return False\n\n if self.db_pwd is None:\n self.log.error(\n \"You are missing the Database Password field. Please check https://github.com/team4099/scouting-data-ingest#mysql for more information.\"\n )\n return False\n\n try:\n create_engine(\n f\"mysql+pymysql://{self.db_user}:{self.db_pwd}@{self.db_host}/scouting\"\n )\n except pymysql.err.OperationalError:\n self.log.error(\n \"Your Database user name and/or password is not correct. Please verify them.\"\n )\n\n if self.event is None:\n self.log.error(\n \"You are missing the Event field. Please check https://github.com/team4099/scouting-data-ingest#event for more information.\"\n )\n return False\n\n if (\n requests.get(\n f\"https://www.thebluealliance.com/api/v3/event/{self.year}{self.event}\",\n headers={\"X-TBA-Auth-Key\": self.tba_key},\n ).status_code\n == 404\n ):\n self.log.error(\n \"The event listed in the TBA-Key field is not valid. Please ensure the event key and year are correct.\"\n )\n return False\n\n if self.simulation:\n if self.simulator_url is None:\n self.log.error(\n \"You are missing the Simulator URL field. Please check https://github.com/team4099/scouting-data-ingest#tba for more information.\"\n )\n return False\n\n try:\n simulator_status = requests.get(\n f\"{self.simulator_url}/matches\"\n ).status_code\n except (\n ConnectionRefusedError,\n urllib3.exceptions.NewConnectionError,\n requests.exceptions.ConnectionError,\n ):\n self.log.error(\n \"The simulator may not be running or it's at a different url than the one provided.\"\n )\n return False\n\n if simulator_status == 401:\n self.log.error(\n \"The simulator may not be running. Please make sure it is and that it is up-to-date.\"\n )\n return False\n\n if self.simulator_spreadsheet is None:\n self.log.error(\n \"You are missing the Simulator Spreadsheet field. Please check https://github.com/team4099/scouting-data-ingest#spreadsheet for more information.\"\n )\n return False\n else:\n try:\n gc.open(f\"{self.simulator_spreadsheet}\").get_worksheet(0)\n except gspread.exceptions.SpreadsheetNotFound:\n self.log.error(\n \"The file listed in the Simulator Spreadsheet field has not been shared with the service account. Please make sure it is. Please also make sure the name entered is correct.\"\n )\n return False\n\n return True","def _prepare_and_validate_data(self,data_list):\n pos=0\n list_pos=0\n format=\"\"\n length=0\n value=\"\"\n\n #check number of items in data_list is as expected\n if(self.data_lookup.count()['type']!=len(data_list)):\n raise NumItemsError(\"Wrong number of items for the data type\")\n\n #loop over data from data_types.csv and populate\n for index,row in self.data_lookup.iterrows():\n length=int(row['Bytes'])\n\n #obtain format type\n if (row['Format']=='byte'):\n format=int\n elif (row['Format']=='string'):\n format=str\n\n #obtain limits\n try:\n min=int(row['Min'],16)\n max=int(row['Max'],16)\n except:\n min='*'\n max='*'\n\n #check format type\n if (isinstance(data_list[list_pos],format)):\n #correct format type\n if format==str:\n value=data_list[list_pos].encode()\n elif format==int:\n value=data_list[list_pos].to_bytes(length,'little')\n\n #check limits if int type\n if min=='*' or max == '*':\n pass\n elif int(data_list[list_pos]) >= min and int(data_list[list_pos]) <= max:\n pass\n else:\n raise ValueError(\"value\",int(value),\"is out of range, min:\",min,\"max:\",max)\n else:\n raise TypeError(\"Unknown type, can currently only handle string or integer types\")\n #populate data\n for n in range(0,length):\n self.data[pos+n]=value[n]\n pos=pos+length\n list_pos=list_pos+1\n else:\n raise TypeError(\"expected\",format,\"got\",type(data_list[list_pos]),\"at position\",list_pos)\n return True","def init_configs(self):\n\n # get current location\n self.script_dir = os.path.dirname(__file__)\n\n # load configuration file\n with open(os.path.join(self.script_dir, \"config.json\")) as f:\n self.configs = json.load(f)\n \n # load some configs as attributes\n self.resource_folder = os.path.join(self.script_dir, self.configs[\"resource_path\"], self.resource_type, self.language)\n self.pre_processed_folder = os.path.join(self.resource_folder, self.configs[\"pre_processed_path\"])\n self.results_folder = os.path.join(self.resource_folder, self.configs[\"results_path\"])\n self.chunk_size = self.configs[\"resources\"][self.resource_type][\"chunk_size\"]","async def _process_create_data(self, data: dict) -> dict:\n return self.SCHEMA(data)","def check(self) -> None:\n # check existence\n self.check_key_exists()\n\n # check valid range and type\n assert 0 <= self.config[\"MOMENTUM\"] <= 1\n assert isinstance(self.config[\"MOMENTUM\"], float)\n\n assert self.config[\"WEIGHT_DECAY\"] >= 0\n assert isinstance(self.config[\"WEIGHT_DECAY\"], float)\n\n assert self.config[\"SEED\"] >= 0\n assert isinstance(self.config[\"SEED\"], int)\n\n assert self.config[\"BATCH_SIZE\"] > 0\n assert isinstance(self.config[\"BATCH_SIZE\"], int)\n\n assert self.config[\"EPOCHS\"] > 0\n assert isinstance(self.config[\"EPOCHS\"], int)\n\n assert self.config[\"LR\"] > 0\n assert isinstance(self.config[\"LR\"], float)\n\n if \"NESTEROV\" in self.config:\n assert type(self.config[\"NESTEROV\"]) is bool\n else:\n self.config[\"NESTEROV\"] = False # default\n\n if \"CUTMIX\" in self.config:\n cutmix_config = self.config[\"CUTMIX\"]\n assert \"beta\" in cutmix_config\n assert cutmix_config[\"beta\"] > 0\n assert \"prob\" in cutmix_config\n assert 0 < cutmix_config[\"prob\"] <= 1\n\n if \"AUG_TRAIN_PARAMS\" in self.config:\n assert isinstance(self.config[\"AUG_TRAIN_PARAMS\"], dict)\n else:\n self.config[\"AUG_TRAIN_PARAMS\"] = dict()\n\n if \"AUG_TEST_PARAMS\" in self.config:\n assert isinstance(self.config[\"AUG_TEST_PARAMS\"], dict)\n else:\n self.config[\"AUG_TEST_PARAMS\"] = dict()\n\n self.check_criterion()\n self.check_lr_schedulers()\n self.check_regularizer()","async def _process_create_data(self, data: dict) -> dict:\n validated_data: dict = validate_language(data)\n return validated_data","def initialize_from_config(self):","def validate_data(self):\n if self.type == 'grid':\n for layout in self.data:\n grid = layout.get('grid')\n if not grid:\n raise ChartError(\n \"Layout grid setting must be set \"\n \"if layout type is 'grid'\")\n\n if not grid.get('location'):\n raise ChartError(\n \"Layout grid location must be set \"\n \"if layout type is 'grid'\")\n\n if len(grid['location']) != 2:\n raise ChartError(\"Layout grid location length must be 2\")","def create(self, validated_data):","def make_config():\n # find date of data obtained\n current_pathname = os.path.basename(os.getcwd())\n guess_date = extract_date(current_pathname)\n\n while(True):\n if guess_date is None:\n prompt = 'YYYYMMDD'\n else:\n prompt = guess_date\n\n string = input('Date of observation [{}]: '.format(prompt))\n input_date = extract_date(string)\n if input_date is None:\n if guess_date is None:\n continue\n else:\n input_date = guess_date\n break\n else:\n break\n \n input_datetime = datetime.datetime.strptime(input_date, '%Y-%m-%d')\n\n # create config object\n config = configparser.ConfigParser()\n\n config.add_section('data')\n\n config.set('data', 'telescope', 'Keck-I')\n config.set('data', 'instrument', 'HIRES')\n config.set('data', 'rawpath', 'rawdata')\n #config.set('data', 'statime_key', statime_key)\n #config.set('data', 'exptime_key', exptime_key)\n\n config.add_section('reduce')\n config.set('reduce', 'midpath', 'midproc')\n config.set('reduce', 'figpath', 'images')\n config.set('reduce', 'odspath', 'onedspec')\n config.set('reduce', 'mode', 'normal')\n config.set('reduce', 'oned_suffix', 'ods')\n config.set('reduce', 'fig_format', 'png')\n \n config.add_section('reduce.bias')\n config.set('reduce.bias', 'bias_file', '${reduce:midpath}/bias.fits')\n config.set('reduce.bias', 'cosmic_clip', str(10))\n config.set('reduce.bias', 'maxiter', str(5))\n config.set('reduce.bias', 'smooth', 'yes')\n config.set('reduce.bias', 'smooth_method', 'gaussian')\n config.set('reduce.bias', 'smooth_sigma', str(3))\n config.set('reduce.bias', 'smooth_mode', 'nearest')\n\n config.add_section('reduce.trace')\n config.set('reduce.trace', 'minimum', str(1e-3))\n config.set('reduce.trace', 'scan_step', str(100))\n config.set('reduce.trace', 'separation', '100:84, 1500:45, 3000:14')\n config.set('reduce.trace', 'filling', str(0.2))\n config.set('reduce.trace', 'align_deg', str(2))\n config.set('reduce.trace', 'display', 'no')\n config.set('reduce.trace', 'degree', str(4))\n config.set('reduce.trace', 'file', '${reduce:midpath}/trace.fits')\n\n config.add_section('reduce.flat')\n config.set('reduce.flat', 'file', '${reduce:midpath}/flat.fits')\n\n # write to config file\n filename = 'HIRES.{}.cfg'.format(input_date)\n outfile = open(filename, 'w')\n for section in config.sections():\n maxkeylen = max([len(key) for key in config[section].keys()])\n outfile.write('[{}]'.format(section)+os.linesep)\n fmt = '{{:{}s}} = {{}}'.format(maxkeylen)\n for key, value in config[section].items():\n outfile.write(fmt.format(key, value)+os.linesep)\n outfile.write(os.linesep)\n outfile.close()\n\n print('Config file written to {}'.format(filename))","def prepare_data(self):\n try:\n self.train_dataset = self.datasets['train']\n self.val_dataset = self.datasets['val']\n try:\n self.test_dataset = self.datasets['test']\n except:\n pass\n except Exception as e:\n print('Data was not succesfully prepared:', e)","def from_data(cls, app, configuration):","def __init__(self, data_config):\n self._brands = self._load_from_directory(data_config['targeted_brands_dir'])\n self._keywords = self._load_from_directory(data_config['keywords_dir'])\n self._fqdn_keywords = self._load_from_directory(data_config['fqdn_keywords_dir'])\n self._similarity_words = self._load_from_directory(data_config['similarity_words_dir'])\n self._tlds = self._load_from_directory(data_config['tld_dir'])","def check_config(self):\n cfgs = self.__get() \n \n for option in Config.FILE_OPTIONS.keys():\n _default = Config.FILE_OPTIONS[option]\n \n if not cfgs.has_key(option):\n self.log.warn(\"Parameter '%s' is missing in '%s', using default('%s')\" % \\\n (option, self.config_file, _default))\n _file = _default\n else:\n _file = cfgs[option]\n Config.FILE_OPTIONS[option] = _file\n\n if not os.path.exists(_file) and not os.path.isfile(_file):\n self.log.error(\"Paramenter '%s' points to non-existing file '%s')\" % \\\n (option, _file))\n raise ConfigError('File Error', \"Paramenter '%s' points to non-existing file '%s')\" % \\\n (option, _file))\n\n\n for option in Config.PATH_OPTIONS.keys():\n _default = Config.PATH_OPTIONS[option]\n \n if not cfgs.has_key(option):\n self.log.warn(\"Parameter '%s' is missing in '%s', using default('%s')\" % \\\n (option, self.config_file, _default))\n _dir = _default\n else:\n _dir = cfgs[option]\n Config.PATH_OPTIONS[option] = _dir\n\n if not os.path.exists(_dir) and not os.path.isdir(_dir):\n self.log.error(\"Paramenter '%s' points to non-existing directory '%s')\" % \\\n (option, _dir))\n raise ConfigError('File Error', \"Paramenter '%s' points to non-existing directory '%s')\" % \\\n (option, _dir))\n\n \n Config.DB_SFT_OPTIONS['sqlalchemy_sft.url'] = cfgs['sqlalchemy_sft.url']\n Config.DB_NAGIOS_OPTIONS['sqlalchemy_nagios.url'] = cfgs['sqlalchemy_nagios.url']\n\n self.log.debug(\"Configuration successfully checked\")","def _Validate(self):\n # There's some possible conflict with LABEL and ISSUE_DATE\n # If the date exists but the label isn't defined, this property\n # will be ignored\n if (\"ISSUE_DATE\" in self) != (\"LABEL\" in self):\n with IgnoreKeyError:\n del self[\"ISSUE_DATE\"]\n with IgnoreKeyError:\n del self[\"LABEL\"]\n # Also check that both disc and discs exists or neither do\n if self.discs > 1 and \"PART_NUMBER\" not in self:\n raise DiscConfigurationError(\"Number of discs is set but disc number not known\")\n if \"PART_NUMBER\" in self and self.discs < 2:\n raise DiscConfigurationError(\"Disc number is set but number of discs is not known\")\n # Ensure that the original medium is set, if it hasn't been set yet then assume CD\n if \"ORIGINAL_MEDIUM\" not in self:\n self[\"ORIGINAL_MEDIUM\"] = \"CD\"\n elif self[\"ORIGINAL_MEDIUM\"] not in arguments.MEDIUM_CHOICES:\n logging.critical(\"Invalid medium: '%s' - must be one of %s\",\n self['ORIGINAL_MEDIUM'], arguments.MEDIUM_CHOICES)\n raise ValueError(f\"Invalid medium: '{self['ORIGINAL_MEDIUM']}' - must be one of {arguments.MEDIUM_CHOICES}\")\n # At this point it is necessary to require that all the metadata is present\n # These were setup in the constructor as ``None`` so they do exist, but they\n # must have been overridden as non-``None`` values\n # ``required_tags`` holds tag keys which map onto descriptions for error output\n required_tags = {\"TITLE\": \"title\",\n \"ARTIST\": \"artist\",\n \"GENRE\": \"genre\",\n \"DATE_RECORDED\": \"year\"}\n for tag in required_tags:\n if self[tag] is None:\n raise TagNotFoundError(f\"Incomplete metadata - missing {required_tags[tag]}\")\n for key, value in self.items():\n self[key] = value.strip()","def create(self):\n ##\n datasubstructure_file = self.source\n if datasubstructure_file.endswith('.sql'):\n print('Generating the data substructure based on the SQL file')\n status = self.create_datastructure_from_sql_file()\n \n elif datasubstructure_file.endswith('.yml'):\n print('Generating the data substructure based on the YAML file')\n status = 'failed'\n raise ReadingDataFileException(\"Error: this file type is not yet supported\")\n else:\n status = 'failed'\n raise ReadingDataFileException(\"Error: this file type is not yet supported\")\n \n return(status)","def _save_config(self, data: dict[str, Any]) -> FlowResult:\n new_data = {\n k: v\n for k, v in data.items()\n if k not in [CONF_APPS, CONF_STATE_DETECTION_RULES]\n }\n if self._apps:\n new_data[CONF_APPS] = self._apps\n if self._state_det_rules:\n new_data[CONF_STATE_DETECTION_RULES] = self._state_det_rules\n\n return self.async_create_entry(title=\"\", data=new_data)","def test_validate_config_file(self):\n ingest_mgmr = IngestManager()\n ingest_mgmr.validate_config_file(self.example_config_data)\n assert(ingest_mgmr.config is not None)\n assert (ingest_mgmr.config.config_data is not None)","def validate(self):\n for key, value in self._configurations.items():\n value.validate()","def populate_initial_valid_metadata(self):\n pass","def check_record_config(config):\n\n def convert_type(item, convert_func):\n if item not in config.keys():\n raise Error(\"Config file dose not has '{0}'!\".format(item))\n try:\n record_dict[item] = convert_func(config[item])\n except Exception:\n raise Error(\"Config['{0}'] is not correct!\".format(item))\n\n def check_time_range():\n if record_dict['time_range'] not in TIME_INFOR.keys():\n raise Error(\"Time range is not {0}\".format(TIME_INFOR.keys()))\n\n def check_query():\n try:\n record_dict['query'] = [str(item) for item in config['query']]\n except Exception:\n raise Error(\"Config['query'] is not correct!\")\n\n def check_start_time():\n try:\n record_dict['start'] = convert_time_to_second(config['start_time'])\n except Exception:\n raise Error(\"Config['start_time'] pattern is not: {0}\".format(\n TIME_PATTERN))\n\n second_range = TIME_INFOR[record_dict['time_range']]['second_range']\n record_dict['end'] = record_dict['start'] + second_range\n if record_dict['end'] > time.time():\n raise Error(\"Config start time + time interval > now\")\n\n record_dict = {}\n for item_key, item_type in RECORD_CONFIG_PATTERN.items():\n convert_type(item_key, item_type)\n check_query()\n check_time_range()\n check_start_time()\n\n record_dict['metadata_path'] = \\\n create_path(record_dict['data_directory'], METADATA_FILE)\n record_dict['ts_directory'] = \\\n create_path(record_dict['data_directory'], TS_DATA_DIR)\n record_dict['record_config'] = \\\n create_path(record_dict['data_directory'], CONFIG_FILE)\n record_dict['interval'] = record_dict['data_file_interval'] * 60 * 60\n\n return record_dict","def prepare_data(self):\n import subprocess\n # Download coco data set into dir specified by config then /data/coco\n subprocess.call([f\"{get_original_cwd()}/bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\", f\"{get_original_cwd()}\"])\n # subprocess.call([f\"bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\"])\n task = \"instances\" if self.instance else \"person_keypoints\"\n register_coco_instances(\"train\", {}, f\"{self.dir}/data/coco/{task}_train2014.json\",\n f\"{self.dir}/data/coco/train2014\")\n register_coco_instances(\"val\", {}, f\"{self.dir}/data/coco/{task}_minival2014.json\",\n f\"{self.dir}/data/coco/val2014\")\n register_coco_instances(\"test\", {}, f\"{self.dir}/data/coco/{task}_valminusminival2014.json\",\n f\"{self.dir}/data/coco/val2014\")","def _validate_config(dataset_cfg: DictConfig):\n if dataset_cfg.get('hf_name') is not None:\n # Using the HuggingFace dataset codepath\n illegal_keys = ['local', 'remote']\n discovered_illegal_keys = []\n for key in illegal_keys:\n if dataset_cfg.get(key) is not None:\n discovered_illegal_keys.append('`' + key + '`')\n if discovered_illegal_keys:\n raise ValueError(\n 'The dataset config sets a value for `hf_name` as well as the ' +\\\n f'following keys: {\", \".join(discovered_illegal_keys)}.\\n' +\\\n 'Those keys are used when building from a streaming dataset, but ' +\\\n 'setting `hf_name` instructs the dataset to build from a HuggingFace dataset.'\n )\n elif dataset_cfg.get('remote') is not None:\n # Using the streaming dataset codepath\n illegal_keys = ['hf_name', 'hf_kwargs', 'preprocessing_fn']\n discovered_illegal_keys = []\n for key in illegal_keys:\n if dataset_cfg.get(key) is not None:\n discovered_illegal_keys.append('`' + key + '`')\n if discovered_illegal_keys:\n raise ValueError(\n 'The dataset config sets a value for `remote` as well as the ' +\\\n f'following keys: {\", \".join(discovered_illegal_keys)}.\\n' +\\\n 'Those keys are used when building from a HuggingFace dataset, but ' +\\\n 'setting `remote` instructs the dataset to build from a streaming dataset.'\n )\n if dataset_cfg.get('local') is None:\n raise ValueError(\n 'Using a streaming dataset requires setting both `remote` and `local`, ' +\\\n 'but dataset.local is None.'\n )\n else:\n raise ValueError(\n 'In the dataset config, you must set either `hf_name` to use a ' +\\\n 'HuggingFace dataset or set `remote` to use a streaming ' +\\\n 'dataset, but both were None.'\n )","def validate_config_dict(self):\n config_options = [\"pipeline_name\",\n \"num_processors\",\n \"num_sessions_at_once\",\n \"available_memory\",\n \"cluster_system\",\n \"output_directory\",\n \"working_directory\",\n \"template_head_for_anat\",\n \"exclude_zeros\",\n \"start_idx\",\n \"stop_idx\",\n \"write_report\",\n \"write_graph\",\n \"write_all_outputs\",\n \"upload_to_s3\",\n \"bucket_prefix\",\n \"bucket_out_prefix\",\n \"local_prefix\",\n \"bucket_name\",\n \"creds_path\"]\n invalid = []\n for param in self._config.keys():\n if param not in config_options:\n invalid.append(param)\n if len(invalid) > 0:\n err = \"\\n[!] The following parameters in your configuration \" \\\n \"file are not recognized. Double-check the pipeline \" \\\n \"configuration template.\\n\"\n err += \"\\n\".join([x for x in invalid])\n raise Exception(err)\n else:\n return 0","def __init__(self, data, schema_file=None):\n if schema_file is not None:\n if not os.path.exists(schema_file):\n logging.warning(\n 'Configuration schema file could not be found. Please check the path and try again.'\n )\n raise Exception()\n\n self.schema_file = schema_file\n else:\n self.schema_file = None\n\n if not os.path.exists(data):\n logging.warning(\n 'Configuration data could not be found. Please check the path and try again.'\n )\n raise Exception()\n\n self.datafile = data\n\n self.data = None","def _verify(self, data):\n sections = {\n \"schema\": dict,\n \"defaults\": dict,\n \"projects\": list\n }\n\n for key, type_ in sections.items():\n if key not in data:\n self._report_error(\"Missing section: {}\".format(key))\n return False\n if not isinstance(data[key], type_):\n err = \"Wrong data type for section {}, should be {}\"\n self._report_error(err.format(key, type_))\n return False\n\n for setting in data[\"defaults\"]:\n if setting not in data[\"schema\"]:\n err = \"Invalid setting {0} in default configuration\"\n self._report_error(err.format(setting))\n return False\n\n for i, project in enumerate(data[\"projects\"]):\n if not isinstance(project, dict):\n err = \"Wrong data type for project at index {}\"\n self._report_error(err.format(i))\n return False\n if \"name\" not in project:\n err = \"Missing name for project at index {}\"\n self._report_error(err.format(i))\n return False\n for setting in project:\n if setting not in data[\"schema\"]:\n err = \"Invalid setting {} for project {}\"\n self._report_error(err.format(setting, project[\"name\"]))\n return False\n\n return True","def __init__(self, configParserObject):\n section = 'settings'\n self.debug = configParserObject.getboolean(section, 'debug')\n self.application_path = configParserObject.get(section, 'application_path')\n self.log_path = configParserObject.get(section, 'log_path')\n self.chat_enabled = configParserObject.getboolean(section, 'chat_enabled')\n self.token_validation_enabled = configParserObject.getboolean(section, 'token_validation_enabled')\n if not os.path.isdir(self.application_path):\n raise ErrorLoadingData('Path %s does not exists' % self.application_path)\n if not os.path.isdir(self.log_path):\n raise ErrorLoadingData('Path %s does not exists' % self.log_path)","def setup(self):\n # Initialize key variables\n valid = True\n updated_list = []\n config = copy.deepcopy(self.config)\n directory = self.directories[0]\n\n # Update log_directory and ingest_cache_directory\n if isinstance(config, dict) is True:\n if 'main' in config:\n # Setup the log_directory to a known good default\n (updated, config) = self._create_directory_entries(\n 'log_directory', config)\n updated_list.append(updated)\n\n # Setup the ingest_cache_directory to a known good default\n (updated, config) = self._create_directory_entries(\n 'ingest_cache_directory', config)\n updated_list.append(updated)\n\n else:\n valid = False\n else:\n valid = False\n\n # Gracefully exit if things are not OK\n if valid is False:\n log_message = (\n 'Configuration files found in {} is invalid'\n ''.format(self.directories))\n log.log2die_safe(1007, log_message)\n\n # Update configuration file if required\n if len(updated_list) == updated_list.count(True):\n for next_directory in self.directories:\n # Delete all YAML files in the directory\n general.delete_yaml_files(next_directory)\n\n # Write config back to directory\n filepath = ('%s/config.yaml') % (directory)\n with open(filepath, 'w') as outfile:\n yaml.dump(config, outfile, default_flow_style=False)","def test_validate_ingest(self):\n #Validate schema and config file\n ingest_mgmr = IngestManager()\n response = ingest_mgmr.validate_config_file(self.example_config_data)\n assert (response is True)\n\n #Validate properties\n response = ingest_mgmr.validate_properties()\n assert (response is True)","def create_config(self):\n\n #FIXME: Try to do it over loops ie. self[attr].set_config()\n for attr, value in self.__dict__.items():\n if attr == \"connection\":\n self.connection.set_config(self.cfg)\n if attr == \"ipv4\":\n self.ipv4.set_config(self.cfg)\n if attr == \"ipv6\":\n self.ipv6.set_config(self.cfg)\n if attr == \"_802_3_ethernet\" and not value == \"none\":\n self._802_3_ethernet.set_config(self.cfg)\n if attr == \"_802_11_wireless\" and not value == \"none\":\n self._802_11_wireless.set_config(self.cfg)\n if attr == \"_802_11_wireless_security\" and not value == \"none\":\n self._802_11_wireless_security.set_config(self.cfg)","def configure(self):\n self.data_batch_file = self.get_value_from_config('data_batch_file')\n self.batch_meta_file = self.get_value_from_config('batch_meta_file')\n self.has_background = self.get_value_from_config('has_background')\n self.num_classes = self.get_value_from_config('num_classes')\n self.converted_images_dir = self.get_value_from_config('converted_images_dir')\n if not self.converted_images_dir:\n self.converted_images_dir = self.data_batch_file.parent / 'converted_images'\n self.convert_images = self.get_value_from_config('convert_images')\n # create directory for storing images if it is necessary\n if self.convert_images and not self.converted_images_dir.exists():\n self.converted_images_dir.mkdir(parents=True)\n self.dataset_meta = self.get_value_from_config('dataset_meta_file')","def create(self):\n datasubstructure_file = self.source\n if datasubstructure_file.endswith('.yml'):\n print('Generating the data substructure based on the YML file')\n status = self.create_datastructure_from_yaml_file()\n else:\n status = 'failed'\n raise ReadingDataFileException(\"Error: this file type is not yet supported\")\n \n return(status)","def _prepare_data(self):\n #TODO hardcoded values need to change\n print_info(\"Preprocessing the train data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"train\"),\n self.TRAIN_OUT_PATH)\n\n print_info(\"Preprocessing the test data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"test\"),\n self.TEST_OUT_PATH)\n\n print_info(\"Preprocessing the validation data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"val\"),\n self.VAL_OUT_PATH)","def __init__ (self, config_yaml):\n configdef = yaml.safe_load(io.StringIO(config_yaml)) \n\n if \"filters\" not in configdef:\n configdef = dict(filters=[configdef])\n\n self._configs = []\n\n for definition in configdef[\"filters\"]:\n config = Bunch( valid_from = None\n , volume_follows = False\n , copy_last_price = False\n , copy_last_volume = False\n , qualifier_include_filters = []\n , qualifier_exclude_filters = []\n , exclude_filters = [] )\n\n if \"filter\" in definition and definition[\"filter\"] != None:\n for exclude_filter in definition[\"filter\"]:\n parts = exclude_filter.split(\",\")\n if parts[0] == \"floor\":\n config.exclude_filters.append(FloorFilter(float(parts[1]), \"price\"))\n elif parts[0] == \"cap\":\n config.exclude_filters.append(CapFilter(float(parts[1]), \"price\")) \n elif parts[0] == \"step\":\n config.exclude_filters.append(StepFilter(int(parts[1]), float(parts[2]), float(parts[3]), \"price\"))\n else:\n raise Exception(\"Unknown filter (%s)\" % (parts[0])) \n \n if \"remove\" in definition and definition[\"remove\"] != None:\n for exclude_filter in definition[\"remove\"]:\n config.qualifier_exclude_filters.append(QualifierFilter(exclude_filter))\n \n if \"allow\" in definition and definition[\"allow\"] != None:\n for include_filter in definition[\"allow\"]:\n config.qualifier_include_filters.append(QualifierFilter(include_filter))\n\n if \"volFollows\" in definition: config.volume_follows = definition[\"volFollows\"] \n if \"copyLast\" in definition and definition[\"copyLast\"] != None:\n config.copy_last_price = definition[\"copyLast\"] \n config.copy_last_volume = definition[\"copyLast\"] \n if \"volumeLimit\" in definition and definition[\"volumeLimit\"] != None:\n config.exclude_filters.append(CapFilter(definition[\"volumeLimit\"], \"volume\"))\n if \"validFrom\" in definition and definition[\"validFrom\"] != None:\n valid_from = datetime.datetime.strptime(definition[\"validFrom\"], \"%Y-%m-%d %H:%M:%S\")\n valid_from.replace(tzinfo=pytz.utc)\n config.valid_from = common.Time.tick(valid_from)\n if \"weekTimezone\" in definition and definition[\"weekTimezone\"] != None:\n config.exclude_filters.append(WeekendFilter(definition[\"weekTimezone\"], definition[\"weekEnd\"], definition[\"weekStart\"]))\n\n self._configs.append(config)\n \n self._config_index = 0\n self._config_count = len(self._configs)","def validateData(self, ):\n count = 0\n while count < len(self.RAD_sequences_validate):\n RAD_filename = self.RAD_sequences_validate[count] \n RAD_complex = loader.readRAD(RAD_filename)\n if RAD_complex is None:\n raise ValueError(\"RAD file not found, please double check the path\")\n ### NOTE: Gloabl Normalization ###\n RAD_data = helper.complexTo2Channels(RAD_complex)\n RAD_data = (RAD_data - self.config_data[\"global_mean_log\"]) / \\\n self.config_data[\"global_variance_log\"]\n ### load ground truth instances ###\n gt_filename = loader.gtfileFromRADfile(RAD_filename, \\\n self.config_data[\"train_set_dir\"])\n gt_instances = loader.readRadarInstances(gt_filename)\n if gt_instances is None:\n raise ValueError(\"gt file not found, please double check the path\")\n\n ### NOTE: decode ground truth boxes to YOLO format ###\n gt_labels, has_label, raw_boxes = self.encodeToLabels(gt_instances)\n\n if has_label:\n yield (RAD_data, gt_labels, raw_boxes)\n count += 1","def _check_config(self):","def load_data(self, data):\n self.data = data\n self.validate()","def _check_loaded_conf(self, config_dict):\n expected_fields = set(self.data_types.keys())\n\n expected_missing = []\n for name in expected_fields:\n if name not in self.defaults and name not in config_dict:\n expected_missing.append(name)\n if expected_missing:\n raise Exception(\"Missing mandatory fileds: {}\"\n .format(\", \".join(expected_missing)))\n\n unexpected = []\n for name in config_dict:\n if name not in expected_fields:\n unexpected.append(name)\n if unexpected:\n raise Exception(\"Unexpected fields: {}\"\n .format(\", \".join(unexpected)))\n\n \"\"\" Check data types method \"\"\"\n for name in config_dict:\n if not isinstance(config_dict[name], self.data_types[name]):\n raise Exception(\"Bad data type: param {}, expected {}\"\n . format(name, self.data_types[name]))\n\n self.inmodule.validcheck(config_dict)","def _validate_main_config(self):\n # check for required top-level parameters in main config\n required_params = {\"name\": str, \"version\": str, \"datasets\": list}\n\n for param, expected_type in required_params.items():\n if param not in self.config:\n msg = (\n \"[ERROR] Config error: missing required configuration parameter in {}: '{}'\"\n )\n config_file = os.path.basename(self.config[\"config_file\"])\n sys.exit(msg.format(config_file, param))\n elif not isinstance(self.config[param], expected_type):\n msg = \"[ERROR] Config error: parameter is of unexpected type {}: '{}' (expected: '{}')\"\n config_file = os.path.basename(self.config[\"config_file\"])\n sys.exit(msg.format(config_file, param, expected_type))","def build_validation_data_loader(self) -> DataLoader:\n pass","def validate(cls, data, errors):","def validate_config():\n\n # diff/sync settings, not including templates (see below)\n nori.setting_check_list('action', ['diff', 'sync'])\n nori.setting_check_type('reverse', bool)\n nori.setting_check_type('bidir', bool)\n nori.setting_check_callbacks('pre_action_callbacks')\n nori.setting_check_callbacks('post_action_callbacks', 1, 1)\n for i, cb_t in enumerate(nori.core.cfg['post_action_callbacks']):\n nori.setting_check_type(('post_action_callbacks', i, 3), bool)\n nori.setting_check_list('source_type', ['generic', 'drupal'])\n nori.setting_check_callable('source_query_func', may_be_none=False)\n nori.setting_check_callable('source_query_defaulter', may_be_none=True)\n nori.setting_check_callable('source_query_validator', may_be_none=False)\n nori.setting_check_callbacks('source_template_change_callbacks')\n nori.setting_check_callbacks('source_global_change_callbacks')\n nori.setting_check_list('dest_type', ['generic', 'drupal'])\n nori.setting_check_callable('dest_query_func', may_be_none=False)\n nori.setting_check_callable('dest_query_defaulter', may_be_none=True)\n nori.setting_check_callable('dest_query_validator', may_be_none=False)\n nori.setting_check_callbacks('dest_template_change_callbacks')\n nori.setting_check_callbacks('dest_global_change_callbacks')\n nori.setting_check_list('template_mode', ['all', 'include', 'exclude'])\n if nori.core.cfg['template_mode'] != 'all':\n nori.setting_check_not_empty('template_list')\n for i, t_name in enumerate(nori.core.cfg['template_list']):\n nori.setting_check_type(('template_list', i),\n nori.core.STRING_TYPES)\n nori.setting_check_list('key_mode', ['all', 'include', 'exclude'])\n if nori.core.cfg['key_mode'] != 'all':\n nori.setting_check_not_empty('key_list')\n\n # templates: general\n nori.setting_check_not_empty(\n 'templates', types=nori.core.MAIN_SEQUENCE_TYPES\n )\n for i, template in enumerate(nori.core.cfg['templates']):\n nori.setting_check_type(('templates', i), nori.core.MAPPING_TYPES)\n # bogus elements\n for k in template:\n if k not in T_KEYS:\n nori.err_exit(\n \"Warning: cfg['templates'][{0}][{1}] is set\\n\"\n \"(to {2}), but there is no such setting.\" .\n format(i, *map(nori.pps, [k, template[k]])),\n nori.core.exitvals['startup']['num']\n )\n # template name\n nori.setting_check_type(('templates', i, T_NAME_KEY),\n nori.core.STRING_TYPES)\n # multiple-valued value columns?\n nori.setting_check_type(('templates', i, T_MULTIPLE_KEY), bool)\n # source-DB query function arguments\n nori.setting_check_arg_tuple(('templates', i, T_S_QUERY_ARGS_KEY))\n # to-dest transform function\n nori.setting_check_callable(('templates', i, T_TO_D_FUNC_KEY),\n may_be_none=True)\n # source-DB don't-replicate flag\n nori.setting_check_type(('templates', i, T_S_NO_REPL_KEY), bool)\n # source-DB change callbacks\n nori.setting_check_callbacks(('templates', i, T_S_CHANGE_CB_KEY))\n # dest-DB query function arguments\n nori.setting_check_arg_tuple(('templates', i, T_D_QUERY_ARGS_KEY))\n # to-source transform function\n nori.setting_check_callable(('templates', i, T_TO_S_FUNC_KEY),\n may_be_none=True)\n # dest-DB don't-replicate flag\n nori.setting_check_type(('templates', i, T_D_NO_REPL_KEY), bool)\n # dest-DB change callbacks\n nori.setting_check_callbacks(('templates', i, T_D_CHANGE_CB_KEY))\n # key mode\n nori.setting_check_list(('templates', i, T_KEY_MODE_KEY),\n ['all', 'include', 'exclude'])\n if template[T_KEY_MODE_KEY] != 'all':\n # key list\n nori.setting_check_not_empty(('templates', i, T_KEY_LIST_KEY))\n\n # templates: query-function arguments\n for (sd, t_key, validator_key) in [\n ('s', T_S_QUERY_ARGS_KEY, 'source_query_validator'),\n ('d', T_D_QUERY_ARGS_KEY, 'dest_query_validator')\n ]:\n # args tuple\n args_idx = ('templates', i, t_key)\n args_t = template[t_key]\n # key_cv, value_cv (somewhat)\n for cv_str in ['key_cv', 'value_cv']:\n cv_idx = args_idx + (1, cv_str)\n nori.setting_check_not_empty(\n cv_idx, types=nori.core.MAIN_SEQUENCE_TYPES\n )\n cv_seq = args_t[1][cv_str]\n for j, cv in enumerate(cv_seq):\n nori.setting_check_length(cv_idx + (j, ), 2, 3,\n types=tuple)\n # the rest of the arguments\n nori.core.cfg[validator_key](sd, args_idx, args_t, i)\n\n # reporting settings\n nori.setting_check_list('report_order', ['template', 'keys'])\n # the rest are handled by nori.validate_email_config()","def __init__(self, configfile):\n\n self.all_sqs = {}\n self.all_dynamodb = {}\n self.all_s3 = {}\n self.all_sites = []\n\n with open(configfile, 'r') as stream:\n try: \n self.config = yaml.safe_load(stream)\n self.all_sites = list(self.config['Sites'].keys())\n\n for site in self.all_sites:\n self.all_sqs[site] = self.make_sqs(site)\n self.all_dynamodb[site] = self.make_dynamodb(site)\n self.all_s3[site] = self.make_s3(site)\n \n except Exception as e:\n print(f\"Exception: {e}\")","def _verify_map(self):\n # ---- verify self.info ----\n if self.info['contype'] == NotImplemented:\n # 'contype' must be defined\n errstr = \"self.info['contype'] must be defined as:\\n\" \\\n \" 'motion', 'waveform', or 'power'\"\n raise NotImplementedError(errstr)\n elif self.info['contype'] not in ['motion',\n 'waveform',\n 'power']:\n # 'contype' must be one of specified type\n errstr = \"self.info['contype'] must be defined as:\\n\" \\\n \" 'motion', 'waveform', or 'power'\"\n raise NotImplementedError(errstr)\n\n # ---- verity self.configs ----\n # 'dataset fields' must be defined\n if 'dataset fields' not in self.configs:\n errstr = \"self.configs['dataset fields'] must be defined \" \\\n \"as:\\n [('field name', dtype), ]\"\n raise NotImplementedError(errstr)\n elif self.configs['dataset fields'] == NotImplemented:\n errstr = \"self.configs['dataset fields'] must be defined \" \\\n \"as:\\n [('field name', dtype), ]\"\n raise NotImplementedError(errstr)\n\n # 'dset field to numpy field' must be defined\n # - each 'dataset field' needs a mapping to a structured numpy\n # field for hdfReadControl\n # - 'dset field to numpy field' is a list of 3-element tuples\n # where each entry in the list corresponds to a dataset field\n # name\n # - the 3-element tuple must follow the format:\n #\n # self.configs['dset field to numpy field'][i] = (\n # str, # dataset field name\n # str, # corresponding structured numpy field name\n # int) # index of structured numpy field\n #\n # For example, the '6K Compumotor would look like...\n # self.configs['dset field to numpy'] = [\n # ('x', 'xyz', 0),\n # ('y', 'xyz', 1),\n # ('z', 'xyz', 2)]\n #\n key = 'dset field to numpy field'\n if key not in self.configs:\n raise NotImplementedError\n elif self.configs[key] == NotImplemented:\n raise NotImplementedError\n elif type(self.configs[key]) is not list:\n errstr = \"self.configs['dset field to numpy field] must \" \\\n + \"be a list of 3-element tuples\"\n raise Exception(errstr)\n elif not all(isinstance(val, tuple)\n for val in self.configs[key]):\n errstr = \"self.configs['dset field to numpy field] must \" \\\n + \"be a list of 3-element tuples\"\n raise Exception(errstr)\n elif not all(len(val) == 3 for val in self.configs[key]):\n errstr = \"self.configs['dset field to numpy field] must \" \\\n + \"be a list of 3-element tuples\"\n raise Exception(errstr)\n else:\n err = False\n dset_fields = [name\n for name, dftype\n in self.configs['dataset fields']]\n for dfname, npfname, npi in self.configs[key]:\n if dfname not in dset_fields:\n err = True\n break\n elif type(npfname) is not str:\n err = True\n break\n elif type(npi) is not int:\n err = True\n break\n if err:\n errstr = \"self.configs['dset field to numpy field] \" \\\n + \"must be a list of 3-element tuples\"\n raise Exception(errstr)\n\n # contype == 'motion' specific verification\n if self.contype == 'motion':\n # verify 'motion list'\n if 'motion list' not in self.configs:\n # 'motion list' exists\n errstr = \"self.configs['motion list'] must be defined\"\n raise NotImplementedError(errstr)\n elif self.configs['motion list'] == NotImplemented:\n # 'motion list' is defined\n errstr = \"self.configs['motion list'] must be defined\"\n raise NotImplementedError(errstr)\n else:\n # each 'motion list' must have its own config\n for name in self.configs['motion list']:\n if name not in self.configs:\n errstr = \"must defined self.configs['motion \" \\\n \"name'] for each motion list in \" \\\n \"self.configs['motion list'] = \" \\\n \"[motion name, ]\"\n raise NotImplementedError(errstr)\n\n # verify 'probe list'\n if 'probe list' not in self.configs:\n # 'probe list' exists\n errstr = \"self.configs['probe list'] must be defined\"\n raise NotImplementedError(errstr)\n elif self.configs['probe list'] == NotImplemented:\n # 'probe list' is defined\n errstr = \"self.configs['probe list'] must be defined\"\n raise NotImplementedError(errstr)\n else:\n # each 'probe list' must have its own config\n for name in self.configs['probe list']:\n if name not in self.configs:\n errstr = \"must defined self.configs['probe \" \\\n \"name'] for each probe in \" \\\n \"self.configs['probe list'] = \" \\\n \"[probe name, ]\"\n raise NotImplementedError(errstr)\n\n # delete 'config names' if present\n if 'config names' in self.configs:\n del self.configs['config names']\n\n # verify all other contypes\n if self.contype != 'motion':\n # remove 'motion list'\n if 'motion list' in self.configs:\n # remove 'motion list' children\n for name in self.configs['motion list']:\n if name in self.configs:\n del(self.configs[name])\n\n # remove 'motion list'\n del(self.configs['motion list'])\n\n # remove 'probe list'\n if 'probe list' in self.configs:\n # remove 'probe list' children\n for name in self.configs['probe list']:\n if name in self.configs:\n del (self.configs[name])\n\n # remove 'motion list'\n del (self.configs['probe list'])\n\n # verify 'command list'\n # if 'command list' not in self.configs:\n # # 'command list' exists\n # errstr = \"self.configs['command list'] must be \" \\\n # \"defined\"\n # raise NotImplementedError(errstr)\n # elif self.configs['command list'] == NotImplemented:\n # # 'motion list' is defined\n # errstr = \"self.configs['command list'] must be \" \\\n # \"defined\"\n # raise NotImplementedError(errstr)","def create_dicts():\n load_data_for_dict('data/atis/train/seq.in', 'data/atis/voc/vocabulary.json')\n load_data_for_dict('data/atis/valid/seq.in', 'data/atis/voc/vocabulary.json')\n load_data_for_dict('data/atis/test/seq.in', 'data/atis/voc/vocabulary.json') \n load_data_for_dict('data/atis/train/seq.out', 'data/atis/voc/slot_vocabulary.json')","def test_creates_data(self, config_filename, expected_class):\n data = create_data(read_config_file(config_filename))\n self.assertIsInstance(data, expected_class)","def mk_data(self):\n self.data = self.DEFAULTS.copy()\n\n for template in self.raw_data.get('extends', []):\n template_data = self.load_template(template)\n self.data.update(template_data)\n\n self.data.update(self.raw_data)\n\n str_replace(self.data)\n\n if self.data.get('redirect_stderr'):\n self.data.pop('stderr')","def check(self):\n if not os.path.exists(config.configured_root_path):\n raise c8e('root path of data set not exist' + config.configured_root_path)\n \n for it in config.configured_dirs:\n self.__path[it] = os.path.join(config.configured_root_path, it)\n \n for l1 in os.listdir(config.configured_root_path): #1st level directory: train/valid/test\n l1path = os.path.join(config.configured_root_path, l1)\n if not os.path.isdir(l1path):\n raise c8e('regular file exists in data set' + l1)\n \n if l1 not in config.configured_dirs:\n raise c8e('wrong dir in data set' + l1)\n \n for l2 in os.listdir(l1path): #2nd level directory, red/yellow/green\n l2path = os.path.join(l1path, l2)\n if not os.path.isdir(l2path):\n raise c8e('regular file exists in data set' + l2path)\n \n if l2 not in config.configured_classes:\n raise c8e('wrong dir in data set' + l2path)\n \n for l3 in os.listdir(l2path): #3rd level files \n self._check_image(l2path, l3)\n \n #statistic\n self.__phase_sample_count[l1] += 1\n self.__area_sample_count[l2] += 1\n if l1 == config.configured_train_dir:\n self.__train_sample_count[l2] += 1\n \n #process weight of each class of train directory\n total = np.sum(list(self.__train_sample_count.values())) \n max_samples = np.max(list(self.__train_sample_count.values())) #Max\n mu = 1. / (total / float(max_samples)) #\n keys = self.__train_sample_count.keys()\n for key in keys:\n score = math.log(mu * total / float(self.__train_sample_count[key]))\n self.__class_weight[int(key)] = score if score > 1. else 1.","def prepare_data(self):\n # Set up the path\n self.path_target_train = os.path.join(self.data_dir, self.train_path_file_target + \".pkl\")\n self.path_target_test = os.path.join(self.data_dir, self.test_path_file_target + \".pkl\")\n\n if not os.path.exists(self.path_target_train) or not os.path.exists(self.path_target_test):\n # Create vocabularies of the appropriate sizes.\n self.create_vocabulary(self.train_path_file)\n\n # Create token ids for the training data.\n input_train_path = self.train_path_file\n target_train_path = self.train_path_file_target\n train_input, train_input_length, train_labels = self.data_to_token_ids(input_train_path, target_train_path)\n\n # Create token ids for the validation data.\n input_test_path = self.test_path_file\n target_test_path = self.test_path_file_target\n test_input, test_input_length, _ = self.data_to_token_ids(input_test_path, target_test_path, train=False)\n\n # Collect data into a list\n training_data = [train_input, train_input_length, train_labels]\n test_data = [test_input, test_input_length]\n\n # Save all the data\n with open(self.path_target_train, 'wb') as f:\n pickle.dump(training_data,f)\n with open(self.path_target_test, 'wb') as f:\n pickle.dump(test_data, f)\n else:\n # Load data\n with open(self.path_target_train, 'rb') as f:\n training_data = pickle.load(f)\n with open(self.path_target_test, 'rb') as f:\n test_data = pickle.load(f)\n\n # Initialize vocabulary\n self.initialize_vocabulary()\n\n # Convert list into a numpy array - train data\n train_input = pd.DataFrame(training_data[0]).fillna(value=0).astype(int).values\n train_length_input = np.array(training_data[1], dtype=int)\n train_labels = np.array(training_data[2], dtype=int)\n\n # Convert list into a numpy array - test data\n test_input = pd.DataFrame(test_data[0]).fillna(value=0).astype(int).values\n test_length_input = pd.DataFrame(test_data[1]).fillna(value=0).astype(int).values\n\n # Printing maximum length\n print(\"Shape of the input training matrix {}\".format(str(train_input.shape)))\n print(\"Shape of the input test matrix {}\".format(str(test_input.shape)))\n\n # Copy the files\n self.copy_files()\n\n # Return output\n return train_input, train_length_input, train_labels, test_input, test_length_input","def build_data_set(self):\n if not self.assert_data_correct():\n self.download_all_data()\n self.unpack_rename_data()\n self.split_data_characters()\n self.clean_data_fragments()\n self.create_font_data()\n if not self.assert_train_augmented():\n self.augment_train_data()\n if not self.assert_style_data_correct():\n self.download_style_data()\n self.unpack_rename_data()","def validate_config(config):\n # check if paths are valid\n check_paths = {\n 'data_path': r'data$',\n 'master_list_path': r'master_list\\.csv$',\n 'duplicate_list_path': r'duplicate_list\\.csv$',\n 'log_path': r'data[\\\\\\/]jobfunnel.log$',\n 'filter_list_path': r'data[\\\\\\/]filter_list\\.json$',\n }\n\n for path, pattern in check_paths.items():\n if not re.search(pattern, config[path]):\n raise ConfigError(path)\n # check if the provider list only consists of supported providers\n if not set(config['providers']).issubset(PROVIDERS):\n raise ConfigError('providers')\n\n # check validity of region settings\n validate_region(config['search_terms']['region'])\n\n # check validity of delay settings\n validate_delay(config['delay_config'])\n\n # check the validity of max_listing_days settings\n if(config['max_listing_days'] is not None and config['max_listing_days'] < 0):\n raise ConfigError('max_listing_days')","def get_valid_config_data():\n\t# Valid JSON config for testing\n\tJSON_config = '''{\n\t\t\"1\": {\n\t\t\t\"type\": \"custom\",\n\t\t\t\"faces\": \"right\"\n\t\t},\n\t\t\"3\": {\n\t\t\t\"type\": \"custom2\"\n\t\t},\n\t\t\"5\": {\n\t\t\t\"x\": 32,\n\t\t\t\"y\": 128\n\t\t},\n\t\t\"7\": {\n\t\t\t\"is_collidable\": false\n\t\t}\n\t}'''\n\n\t# Expected values for the parsed tileset config\n\texpected_config = {\n\t\t1: {\n\t\t\t'type': 'custom',\n\t\t\t'faces': 'right',\n\t\t},\n\t\t2: {},\n\t\t3: {\n\t\t\t'type': 'custom2',\n\t\t},\n\t\t4: {},\n\t\t5: {\n\t\t\t'x': 32,\n\t\t\t'y': 128,\n\t\t},\n\t\t6: {},\n\t\t7: {\n\t\t\t'is_collidable': False,\n\t\t},\n\t\t8: {},\n\t}\n\n\treturn {\n\t\t'JSON': JSON_config,\n\t\t'expected': expected_config\n\t}","def configure(self, config_json):\n log.info(\"Configuring EDD backend for processing\")\n log.debug(\"Configuration string: '{}'\".format(config_json))\n\n yield self.set(config_json)\n\n cfs = json.dumps(self._config, indent=4)\n log.info(\"Final configuration:\\n\" + cfs)\n\n\n\n self.__numa_node_pool = []\n # remove numa nodes with missing capabilities\n for node in numa.getInfo():\n if len(numa.getInfo()[node]['gpus']) < 1:\n log.debug(\"Not enough gpus on numa node {} - removing from pool.\".format(node))\n continue\n elif len(numa.getInfo()[node]['net_devices']) < 1:\n log.debug(\"Not enough nics on numa node {} - removing from pool.\".format(node))\n continue\n else:\n self.__numa_node_pool.append(node)\n\n log.debug(\"{} numa nodes remaining in pool after cosntraints.\".format(len(self.__numa_node_pool)))\n\n if len(self._config['input_data_streams']) > len(self.__numa_node_pool):\n raise FailReply(\"Not enough numa nodes to process {} polarizations!\".format(len(self._config['input_data_streams'])))\n\n self._subprocessMonitor = SubprocessMonitor()\n #ToDo: Check that all input data streams have the same format, or allow different formats\n for i, streamid in enumerate(self._config['input_data_streams']):\n # calculate input buffer parameters\n stream_description = self._config['input_data_streams'][streamid]\n stream_description[\"dada_key\"] = DADABUFFERS[i]\n self.add_input_stream_sensor(streamid)\n self.input_heapSize = stream_description[\"samples_per_heap\"] * stream_description['bit_depth'] / 8\n\n nHeaps = self._config[\"samples_per_block\"] / stream_description[\"samples_per_heap\"]\n input_bufferSize = nHeaps * (self.input_heapSize)\n log.info('Input dada parameters created from configuration:\\n\\\n heap size: {} byte\\n\\\n heaps per block: {}\\n\\\n buffer size: {} byte'.format(self.input_heapSize, nHeaps, input_bufferSize))\n\n\n final_payloads, final_fpss, final_framens = EDD_VDIF_Frame_Size(stream_description['sample_rate'])\n\n if self._config['payload_size'] == 'auto':\n payload_size = final_payloads[-1]\n else:\n payload_size = int(self._config['payload_size'])\n\n log.info('Possible frame payload sizes (add 32 for framesize):')\n for k in range(final_payloads.size):\n if payload_size == final_payloads[k]:\n M = \"*\"\n else:\n M = \" \"\n log.info(' {}{:5.0f} byte {:8.0f} frames per sec {:6.3f} nsec/frame'.format(M, final_payloads[k], final_fpss[k], final_framens[k]))\n\n if payload_size not in final_payloads:\n log.warning(\"Payload size {} possibly not conform with VDIF format!\".format(payload_size))\n\n # calculate output buffer parameters\n size_of_samples = ceil(1. * self._config[\"samples_per_block\"] * 2 / 8.) # byte for two bit mode\n number_of_packages = ceil(size_of_samples / float(payload_size))\n\n output_buffer_size = number_of_packages * (payload_size + self._config['vdif_header_size'])\n\n integration_time = self._config[\"samples_per_block\"] / float(stream_description[\"sample_rate\"])\n self._integration_time_status.set_value(integration_time)\n\n rate = output_buffer_size/ integration_time # in spead documentation BYTE per second and not bit!\n rate *= self._config[\"output_rate_factor\"] # set rate to (100+X)% of expected rate\n self._output_rate_status.set_value(rate / 1E9)\n\n log.info('Output parameters calculated from configuration:\\n\\\n total size of data samples: {} byte\\n\\\n number_of_packages: {}\\n\\\n size of output buffer: {} byte\\n\\\n rate ({:.0f}%): {} Gbps'.format(size_of_samples,\n number_of_packages, output_buffer_size,\n self._config[\"output_rate_factor\"]*100, rate / 1E9))\n\n numa_node = self.__numa_node_pool[i]\n log.debug(\"Associating {} with numa node {}\".format(streamid, numa_node))\n\n # configure dada buffer\n bufferName = stream_description['dada_key']\n yield self._create_ring_buffer(input_bufferSize, 64, bufferName, numa_node)\n\n ofname = bufferName[::-1]\n # we write nSlice blocks on each go\n yield self._create_ring_buffer(output_buffer_size, 8, ofname, numa_node)\n\n # Configure + launch \n physcpu = numa.getInfo()[numa_node]['cores'][0]\n thread_id = self._config['thread_id'][streamid]\n station_id = self._config['thread_id'][streamid]\n cmd = \"taskset -c {physcpu} VLBI --input_key={dada_key} --speadheap_size={heapSize} --thread_id={thread_id} --station_id={station_id} --payload_size={payload_size} --sample_rate={sample_rate} --nbits={bit_depth} -o {ofname} --log_level={log_level} --output_type=dada\".format(ofname=ofname, heapSize=self.input_heapSize, numa_node=numa_node, physcpu=physcpu, thread_id=thread_id, station_id=station_id, payload_size=payload_size, log_level=self._config['log_level'], **stream_description)\n log.debug(\"Command to run: {}\".format(cmd))\n\n cudaDevice = numa.getInfo()[numa_node]['gpus'][0]\n cli = ManagedProcess(cmd, env={\"CUDA_VISIBLE_DEVICES\": cudaDevice})\n self._subprocessMonitor.add(cli, self._subprocess_error)\n self._subprocesses.append(cli)\n\n cfg = self._config.copy()\n cfg.update(stream_description)\n\n ip_range = []\n port = set()\n for key in self._config[\"output_data_streams\"]:\n if streamid in key:\n ip_range.append(self._config[\"output_data_streams\"][key]['ip'])\n port.add(self._config[\"output_data_streams\"][key]['port'])\n if len(port)!=1:\n raise FailReply(\"Output data for one plarization has to be on the same port! \")\n\n if self._config[\"output_type\"] == 'network':\n physcpu = \",\".join(numa.getInfo()[numa_node]['cores'][1:2])\n fastest_nic, nic_params = numa.getFastestNic(numa_node)\n log.info(\"Sending data for {} on NIC {} [ {} ] @ {} Mbit/s\".format(streamid, fastest_nic, nic_params['ip'], nic_params['speed']))\n\n cmd = \"taskset -c {physcpu} vdif_send --input_key {ofname} --if_ip {ibv_if} --dest_ip {mcast_dest} --port {port_tx} --max_rate {rate}\".format(ofname=ofname, \n physcpu=physcpu, ibv_if=nic_params['ip'], mcast_dest=\" \".join(ip_range), port_tx=port.pop(), rate=rate)\n log.debug(\"Command to run: {}\".format(cmd))\n\n elif self._config[\"output_type\"] == 'disk':\n ofpath = os.path.join(cfg[\"output_directory\"], ofname)\n log.debug(\"Writing output to {}\".format(ofpath))\n if not os.path.isdir(ofpath):\n os.makedirs(ofpath)\n cmd = \"dada_dbdisk -k {ofname} -D {ofpath} -W\".format(ofname=ofname, ofpath=ofpath, **cfg)\n else:\n log.warning(\"Selected null output. Not sending data!\")\n cmd = \"dada_dbnull -z -k {}\".format(ofname)\n\n log.debug(\"Command to run: {}\".format(cmd))\n mks = ManagedProcess(cmd, env={\"CUDA_VISIBLE_DEVICES\": cudaDevice})\n self._subprocessMonitor.add(mks, self._subprocess_error)\n self._subprocesses.append(mks)\n\n self._subprocessMonitor.start()","def test_set_config__schema_validation(self):\n\n test_datafile = json.dumps(self.config_dict_with_features)\n mock_logger = mock.Mock()\n\n # Test that schema is validated.\n # Note: set_config is called in __init__ itself.\n with mock.patch('optimizely.helpers.validator.is_datafile_valid', return_value=True) as mock_validate_datafile:\n config_manager.StaticConfigManager(datafile=test_datafile, logger=mock_logger)\n mock_validate_datafile.assert_called_once_with(test_datafile)\n\n # Test that schema is not validated if skip_json_validation option is set to True.\n with mock.patch('optimizely.helpers.validator.is_datafile_valid', return_value=True) as mock_validate_datafile:\n config_manager.StaticConfigManager(datafile=test_datafile, logger=mock_logger, skip_json_validation=True)\n mock_validate_datafile.assert_not_called()","def create(self):\n # TODO: Properly validate data\n self._proj()\n if self.cfg.align_heading:\n self._align()\n self._griddata()\n if self.cfg.gap_filter[\"algorithm\"] != \"none\":\n self._gap_filter()","def _build_config(data):\n defaults = data['defaults']\n clusters = data['clusters']\n\n # set each cluster settings\n for cluster in clusters:\n\n # set each setting for each group if not present\n for group_key, group_val in defaults.items():\n if group_key in cluster:\n for key, val in group_val.items():\n cluster[group_key].setdefault(key, val)\n else:\n cluster[group_key] = copy.deepcopy(group_val)\n\n # set default endpoint if nothing else is set for kibana\n cluster['kibana'].setdefault('url', cluster['es']['url'])\n\n # by default, exclude nothing!\n cluster.setdefault('exclude', [])\n cluster['exclude'] = set(cluster['exclude'])\n\n return data","def create_new_config():\n\n print (\"\")\n log_app.debug(\"create_new_config\")\n log_app.debug(\"create_new_config / method : %s\", request.method )\n\n req_json = request.get_json()\n log_app.debug(\"create_new_config / req_json : \\n%s\", pformat(req_json) )\n\n new_uuid = req_json['model_uuid']\n new_admin_email = req_json['model_admin_email']\n new_admin_name = req_json['model_admin_name']\n new_admin_surname = req_json['model_admin_surname']\n\n new_endpoint_data = req_json.get('new_endpoint_data', None)\n\n ### target right config collection\n allowedCollections = [\"global\" , \"footer\", \"navbar\", \"tabs\", \"endpoints\" , \"styles\" , \"routes\", \"socials\" ]\n \n if request.method == 'POST':\n\n log_app.debug(\"config app route / POST\" )\n \n ### check if model can be used\n modelCheck = get_config_model(new_uuid, returnDict=True, noRemap=True)\n log_app.debug(\"create_new_config / modelCheck : \\n%s\", pformat(modelCheck) )\n\n ### check if uuid is new and not already used\n globalColl = mongoConfigColls['global']\n usedUuids = globalColl.distinct('apiviz_front_uuid')\n log_app.debug(\"create_new_config / usedUuids : \\n%s\", pformat(usedUuids) )\n \n modelIsUsed = new_uuid in usedUuids\n # modelIsUsed = False ### only for debugging\n log_app.debug(\"create_new_config / modelIsUsed : %s\", modelIsUsed )\n\n canUseModel = modelIsUsed == False and modelCheck != None \n log_app.debug(\"create_new_config / canUseModel : %s\", canUseModel )\n\n ### start copying documents if allowed\n if canUseModel : \n\n query = {'apiviz_front_uuid' : new_uuid}\n \n # loop collections and copy paste docs\n for coll in allowedCollections : \n \n # get corresponding documents without _id\n mongoColl = mongoConfigColls[coll]\n results = list(mongoColl.find(query, { '_id' : 0 } ))\n \n # replace 'apiviz_front_uuid' field's value by new_uuid\n # set 'is_default' field's value as False\n for doc in results :\n\n log_app.debug(\"create_new_config / coll-doc['field'] : %s-%s\" %(coll,doc['field']) )\n \n doc['apiviz_front_uuid'] = new_uuid\n doc['is_default'] = False\n\n # specific cases\n if doc['field'] == 'app_title' : \n doc['content'] = req_json['new_title']\n\n if doc['field'] == 'app_logo' : \n doc['url'] = req_json['new_logoUrl']\n\n # save documents list back in collection\n mongoColl.insert(results)\n\n print()\n\n msg = 'your new website is ready'\n resp_code = 200\n resp_msgCode = 'instane_created_1a'\n \n # create new default uuid_auth\n new_uuid_auth_doc = uuid_auth_model.copy()\n\n new_uuid_auth_doc[\"apiviz_front_uuid\"] = new_uuid\n new_uuid_auth_doc[\"apiviz_front_name\"] = req_json['new_title']\n\n new_uuid_auth_doc[\"date_added\"] = datetime.datetime.now()\n new_uuid_auth_doc[\"added_by\"][\"name\"] = new_admin_name\n new_uuid_auth_doc[\"added_by\"][\"surname\"] = new_admin_surname\n new_uuid_auth_doc[\"added_by\"][\"email\"] = new_admin_email\n\n ### setting admin list\n new_uuid_auth_doc[\"auth_role_users\"][\"admin_list\"] = [new_admin_email]\n \n uuidsAuthColl = mongoConfigColls['uuids_auth']\n uuidsAuthColl.insert(new_uuid_auth_doc)\n\n\n else : \n msg = 'errors : '\n if modelIsUsed :\n msg += 'your current uuid is already used... '\n resp_msgCode = 'uuid_is_current_1a'\n if modelCheck == None : \n msg += \"you can't use this model.. \"\n resp_msgCode = 'instance_used_1a'\n resp_code = 400\n log_app.debug(\"create_new_config / msg : %s\", msg )\n\n return jsonify({\n 'msg' : msg,\n 'status' : resp_code,\n 'msg_code' : resp_msgCode,\n 'uuid' : new_uuid,\n 'request' : req_json,\n })\n\n\n\n\n ### TO DO \n elif request.method == 'DELETE' : \n\n log_app.debug(\"config app route / DELETE\" )\n \n return jsonify({\n 'msg' : 'your apiviz instance has been deleted',\n 'status' : 200,\n 'msg_code' : 'instane_deleted_1a',\n 'uuid' : new_uuid,\n 'request' : req_json,\n })\n\n\n # not a POST nor a DELETE request\n else : \n return jsonify({\n 'msg' : 'there was an error during the process (method not allowed)',\n 'status' : 500,\n 'msg_code' : 'error_1a',\n 'uuid' : new_uuid,\n 'request' : req_json,\n }), 500","def parse(self):\n\t\tself.maincfg_values = self._load_static_file(self.cfg_file)\n\t\t\n\t\tself.cfg_files = self.get_cfg_files()\n\t\t\n\t\tself.resource_values = self.get_resources()\n\t\t\n\t\tself.timestamps = self.get_timestamps()\n\t\t\n\t\t## This loads everything into\n\t\tfor cfg_file in self.cfg_files:\n\t\t\tself._load_file(cfg_file)\n\n\t\tself._post_parse()","def main():\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')\n get_user_config()","def set_up(self):\n self.keywords = (\"DATES\", \"COMPDAT\", \"COMPDATL\")\n self.parameters = (\"Date\", \"Well name\", \"Local grid name\", \"I\", \"J\", \"K upper\", \"K lower\", \"Flag on connection\",\n \"Saturation table\", \"Transmissibility factor\", \"Well bore diameter\", \"Effective Kh\",\n \"Skin factor\", \"D-factor\", \"Dir_well_penetrates_grid_block\", \"Press_eq_radius\")\n\n # TODO: с названиями стоит подумать\n self.input_file_reference = \"data/test_schedule_input_reference.inc\"\n self.output_csv_reference = \"data/schedule_output_reference.csv\"\n\n self.clean_file = \"data/handled_schedule.inc\"\n self.output_csv = \"data/schedule_output.csv\"\n\n with open(self.clean_file, \"r\", encoding=\"utf-8\") as file:\n self.clean_file_text = file.read()\n\n self.parse_list_output_reference = [\n [np.nan, 'W1', np.nan, '10', '10', '1', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '1.0'],\n [np.nan, 'W2', np.nan, '32', '10', '1', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '2.0'],\n [np.nan, 'W3', np.nan, '5', '36', '2', '2', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '3.0'],\n [np.nan, 'W4', np.nan, '40', '30', '1', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '4.0'],\n [np.nan, 'W5', np.nan, '21', '21', '4', '4', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '5.0'],\n ['01 JUN 2018', np.nan],\n ['01 JUL 2018', 'W3', np.nan, '32', '10', '1', '1', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '1.0718'],\n ['01 JUL 2018', 'W5', np.nan, '21', '21', '1', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '5.0'],\n ['01 AUG 2018', np.nan],\n ['01 SEP 2018', 'W1', np.nan, '10', '10', '2', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '1.0918'],\n ['01 SEP 2018', 'W2', np.nan, '32', '10', '1', '2', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '2.0'],\n ['01 SEP 2018', 'W3', 'LGR1', '10', '10', '2', '2', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '1.0918'],\n ['01 OCT 2018', np.nan],\n ['01 NOV 2018', np.nan],\n ['01 DEC 2018', np.nan]]","def preprocess_valid_data(self):\r\n print(\"* Preprocessing validation data.\", flush=True)\r\n prep.create_HDF_file(self.C.validation_set)\r\n\r\n self.print_time_elapsed()","def __init__(self, cfg_index, conditions, pars_dir, step_title, use_defaults, input_cfg_json_data):\n super().__init__(cfg_index, conditions, pars_dir, step_title, use_defaults, input_cfg_json_data)\n if input_cfg_json_data:\n self._read_custom_pars()\n else:\n self._combine_conditions()\n\n # Mike's new stuff\n self.outpars = self._flatten_dict(self.outpars, '', {})","def save_data(self):\n # Validate\n try:\n self._data = self._schema(self._data)\n except vol.Invalid as ex:\n _LOGGER.error(\"Can't parse data: %s\",\n humanize_error(self._data, ex))\n\n # Load last valid data\n _LOGGER.warning(\"Reset %s to last version\", self._file)\n self.read_data()\n return\n\n # write\n try:\n write_json_file(self._file, self._data)\n except (OSError, json.JSONDecodeError) as err:\n _LOGGER.error(\"Can't store config in %s: %s\", self._file, err)","def __build_empty_config(self):\n\n self.__config.add_section('IN_OUT')\n self.__config['IN_OUT']['source'] = 'Set Source Directory'\n self.__config['IN_OUT']['destination'] = 'Set Destination Directory'\n self.__save_config()\n\n self.__is_dirty = False\n self.__default = True","def setUp(self):\n with open(os.path.join(os.path.dirname(__file__), 'valid_resume.json')) as schema:\n self.valid_resume = json.load(schema)\n\n with open(os.path.join(os.path.dirname(__file__), 'invalid_resume.json')) as schema:\n self.invalid_resume = json.load(schema)","def prepare(self):\n bcolz.set_nthreads(2)\n\n # step 0: load only when not loaded yet\n if TRAINING in self.data and VALIDATION in self.data: return\n\n # step 1: load the file names\n patients = sorted(glob.glob(self.location+'/*.*/'))\n print len(patients), \"patients\"\n\n # step 1: load the file names\n # make a stratified validation set\n # note, the seed decides the validation set, but it is deterministic in the names\n random.seed(317070)\n patient_names = [self.patient_name_from_file_name(f) for f in patients]\n validation_patients = random.sample(patient_names, int(VALIDATION_SET_SIZE*len(patient_names)))\n\n labels_as_dict = defaultdict(list)\n\n with open(paths.LUNA_LABELS_PATH, 'rb') as csvfile:\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\n next(reader) # skip the header\n for row in reader:\n label = (float(row[1]), float(row[2]), float(row[3]), float(row[4]))\n labels_as_dict[str(row[0])].append(label)\n\n # make the static data empty\n for s in self.datasets:\n self.data[s] = []\n self.labels[s] = []\n self.names[s] = []\n self.spacings[s] = []\n self.origins[s] = []\n\n with gzip.open(paths.INTERMEDIATE_DATA_PATH + 'spacings.pkl.gz') as f:\n spacings = cPickle.load(f)\n\n with gzip.open(paths.INTERMEDIATE_DATA_PATH + 'origins.pkl.gz') as f:\n origins = cPickle.load(f)\n\n # load the filenames and put into the right dataset\n for i, patient_folder in enumerate(patients):\n patient_id = str(patient_folder.split(path.sep)[-2])\n if patient_id in validation_patients:\n dataset = VALIDATION\n else:\n dataset = TRAIN\n\n\n label = labels_as_dict[patient_id]\n if self.only_positive and not label:\n continue\n\n self.data[dataset].append(patient_folder)\n self.labels[dataset].append(label)\n self.names[dataset].append(patient_id)\n self.spacings[dataset].append(spacings[patient_id])\n self.origins[dataset].append(origins[patient_id])\n\n # give every patient a unique number\n last_index = -1\n for set in self.datasets:\n self.indices[set] = range(last_index+1,last_index+1+len(self.data[set]))\n if len(self.indices[set]) > 0:\n last_index = self.indices[set][-1]\n print set, len(self.indices[set]), \"samples\"","def validate_parameters(self):\n\n # env and fixed_env\n self._validate_envs()\n # checking optional data and scripts\n self._validate_download_data()\n self.data_path = self.params[\"data\"][\"location\"]\n self._validate_scripts()\n # checking optional data_ref (if not data_ref provided, path is the same as data path)\n if \"data_ref\" in self.params:\n self._validate_download_data(data_nm=\"data_ref\")\n# self.data_ref_path = self.params[\"data_ref\"][\"location\"]\n# else:\n# self.data_ref_path = self.data_path\n # checking analysis\n self._validate_analysis()\n # checking tests\n self._validate_tests()\n\n self.params.setdefault(\"post_build\", None)\n # if copy in post_build part that I'm changing the build_context\n if self.params[\"post_build\"] and \"copy\" in self.params[\"post_build\"]:\n self.build_context = self.workflow_path\n else:\n self.build_context = self.working_dir\n\n self.params.setdefault(\"plots\", [])\n if self.params[\"plots\"]:\n if not isinstance(self.params[\"plots\"], (list, tuple)):\n raise SpecificationError(\n \"Value of key 'plots' must be a list or a tuple\"\n )\n else:\n if any(not isinstance(j, dict) for j in self.params[\"plots\"]):\n raise SpecificationError(\n \"Every item in 'plots' must be a dictionary.\"\n )","def _init_config_(self):\n self._config= {}","def __init__(self, data):\n\n self.produce_csv = data['produce_csv']\n self.produce_graphics = data['produce_graphics']\n self.report_name = data['report_name']\n self.file_name = self.report_name + '.csv'\n self.annual_file_name = self.report_name + '_annual.csv'\n self.csv_dir = ''\n self.diagnostic_dir = ''\n\n self.daily_variables = {\n 'year': ['time.cal_year', '', []],\n 'j_day': ['time.day', '', []]\n }\n\n self.annual_variables = {\n 'year': ['time.cal_year', '', 0]\n }","def load_data(self):\n super(MudderyObjectCreater, self).load_data()\n \n data = self.get_data_record()\n if not data:\n return\n \n # set common object's info\n self.obj_list = {}\n\n for obj in data.obj_list.split(\",\"):\n obj_key = \"\"\n number = 0\n arg = obj.split(\":\", 1)\n if len(arg) == 1:\n obj_key = arg[0]\n number = 1\n elif len(arg) >= 2:\n obj_key = arg[0]\n number = int(arg[1])\n\n self.obj_list[obj_key] = number","def load_data_from_config(self):\n\n config_file_name = \"cicada/config/config.yaml\"\n config_dict = None\n self.labels = []\n self.to_add_labels = []\n if os.path.isfile(config_file_name):\n with open(config_file_name, 'r') as stream:\n config_dict = yaml.safe_load(stream)\n print(f\"config_dict {config_dict}\")\n if (config_dict is not None) and config_dict.get(\"dir_name\"):\n self.load_data_from_dir(dir_name=config_dict[\"dir_name\"], method='clear')","def extract_data(\n self, config_data, pre_name=None, action=None, post_name=None, local=False):\n val =[]\n if os.path.isfile(config_data):\n data = open(config_data, 'r')\n config_data = yaml.load(data)\n elif isinstance(config_data, str):\n config_data = yaml.load(config_data)\n else:\n self.logger.info(\n colorama.Fore.RED +\n \"Incorrect config file or data, please chk !!!!\", extra=self.log_detail)\n exit(1)\n try:\n host = config_data.get('hosts')[0]\n except Exception as ex:\n self.logger.error(\n colorama.Fore.RED +\n \"ERROR!! config file %s is not present\" %\n ex,\n extra=self.log_detail)\n raise Exception(\"config file is not present \", ex)\n else:\n self.args.local = local\n if config_data.__contains__(\n 'sqlite') and config_data['sqlite'] and config_data['sqlite'][0]:\n self.chk_database(\n config_data,\n pre_name,\n post_name,\n None,\n None,\n action)\n if host.__contains__('include') or len(config_data.get('hosts'))>1:\n res_obj = self.multiple_device_details(\n config_data.get('hosts'),\n config_data,\n pre_name,\n action,\n post_name)\n return res_obj\n else:\n hostname = host.get('device')\n self.log_detail = {'hostname': hostname}\n username = host.get('username')\n password = host.get('passwd')\n key_value = host\n key_value= self.get_values(key_value)\n #pre_name = hostname + '_' + pre_name if not os.path.isfile(pre_name) else pre_name\n # if action is \"check\":\n # post_name= hostname + '_' + post_name if not os.path.isfile(post_name) else post_name\n val.append(self.connect(\n hostname,\n username,\n password,\n pre_name,\n config_data,\n action,\n post_name,\n **key_value))\n return val","def generate_data(self):\n\n # cfg.d_sour_num = 20 # number of source domains\n self.d_sour_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_sour_num)]\n self.d_sour_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_sour_num)]\n # cfg.d_targ_num = 1 # number of target domain\n self.d_targ_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_targ_num)]\n self.d_targ_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_targ_num)]\n\n\n # cfg.train_num = 100 # number of training point in each domain\n self.train_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.train_num)], dtype=np.float32).reshape(-1,1)\n self.train_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.train_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.train_num, 1)\n\n # cfg.val_num = 100\n self.val_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.val_num)], dtype=np.float32).reshape(-1,1)\n self.val_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.val_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.val_num, 1)\n\n # cfg.support_num = 10\n self.support_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.support_num)], dtype=np.float32).reshape(-1,1)\n self.support_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.support_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.support_num, 1)\n\n # cfg.test_num = 100\n self.test_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\n self.test_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.test_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.test_num, 1)\n\n self.test_x_old = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\n self.test_y_old = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.test_x_old] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.test_num, 1)"],"string":"[\n \"def validate_config(self):\\r\\n c = self.config\\r\\n \\r\\n # Make sure that we have a database_path, and an image_path...\\r\\n assert 'database_path' in c\\r\\n assert 'image_path' in c\\r\\n # We should probably check if these paths exist and make them as well...\\r\\n \\r\\n # Set the default values.\\r\\n graph_draw_frequency = c['graph_draw_frequency']\\r\\n for period, interval in self.default_config['graph_draw_frequency'].iteritems():\\r\\n graph_draw_frequency.setdefault(period, interval)\\r\\n \\r\\n # A quick check to make sure that our port is an integer.\\r\\n c['httpd_port'] = int(c['httpd_port'])\\r\\n \\r\\n # Make sure that no duplicate IDs exist, and that the template exists as well.\\r\\n ids = set()\\r\\n for graph in c['graphs']:\\r\\n graph.setdefault('config', {})\\r\\n graph['config'].setdefault('periods', [])\\r\\n assert graph['id'] not in ids\\r\\n ids.add(graph['id'])\\r\\n assert(template_exists(graph['template']))\",\n \"def _validate_config(self):\\n pass\",\n \"def validate_config(self):\\n pass\",\n \"def validate_config(self):\\n pass\",\n \"def prepare_data(self, config: TreeConfigParser) -> None:\\n self.data = Data(config)\\n self.data.prepare_input()\\n self.data.prepare_output()\",\n \"def _validate_create_data(self, data):\\n return\",\n \"def _further_validate_and_setup(self) -> None:\\n\\n # Make sure parameters make sense/are valid\\n if len(self.validated['learners']) != len(self.validated['param_grids']):\\n raise SchemaError(autos=None,\\n errors='The lists of of learners and parameter '\\n 'grids must be the same size.')\\n if (self.validated['hashed_features'] is not None\\n and self.validated['hashed_features'] == 0):\\n self.validated['hashed_features'] = self._n_features_feature_hashing\\n if self.validated['lognormal'] and self.validated['power_transform']:\\n raise SchemaError(autos=None,\\n errors='Both \\\"lognormal\\\" and \\\"power_transform\\\" '\\n 'were set simultaneously.')\\n if len(self.validated['learners']) != len(self.validated['param_grids']):\\n raise SchemaError(autos=None,\\n errors='The \\\"learners\\\" and \\\"param_grids\\\" '\\n 'parameters were both set and the '\\n 'lengths of the lists are unequal.')\",\n \"def __record(self, data={}):\\n # Create a config file\\n if not self.config_file:\\n self.config_file = \\\"./default.config\\\"\\n\\n # Create empty config json file if not there\\n if not os.path.isfile(self.config_file):\\n with open(self.config_file, 'w') as f:\\n d = json.dumps({})\\n f.write(d)\\n\\n # This structure ensures that for different servers, there can exist\\n # multiple licenses (`license_key`), which contains one `device_token`\\n # each and multiple users (identified by `user_email`), each with its\\n # own `user_token`.\\n\\n # Overwrite values with current values\\n if not data or data == {}:\\n with open(self.config_file, 'r') as f:\\n data = json.load(f)\\n data[self.server] = {}\\n if self.license_key != '':\\n data[self.server][self.license_key] = {}\\n if self.device_token != '':\\n data[self.server][self.license_key][\\\"device_token\\\"] = self.device_token\\n if self.user.email != '':\\n data[self.server][self.license_key][self.user.email] = {}\\n if self.user_token != '':\\n data[self.server][self.license_key][self.user.email][\\\"user_token\\\"] = self.user_token\\n else:\\n data = data\\n\\n # Clean up the remaining values (i.e. get rid of it if it's empty)\\n copied = copy.deepcopy(data)\\n for server in copied.keys():\\n if server not in self.__valid_servers.keys():\\n data.pop(server, None)\\n\\n for key in copied[server].keys():\\n data[server].pop('', None)\\n data[server].pop(' ', None)\\n if copied[server][key] == {}:\\n data[server].pop(key, None)\\n\\n for k in copied[server][key].keys():\\n if k != \\\"device_token\\\":\\n data[server][key].pop('', None)\\n data[server][key].pop(' ', None)\\n if copied[server][key][k] == {} or copied[server][key][k] == \\\"\\\":\\n data[server][key].pop(k, None)\\n\\n with open(self.config_file, 'w') as f:\\n d = json.dumps(data)\\n f.write(d)\",\n \"def _validate_configurations(self) -> None:\\n if self.__exception:\\n raise self.__exception\",\n \"def validate_config(self):\\n reference = data_file(\\\"../config/template/minimum_aiscalator.conf\\\")\\n ref = pyhocon.ConfigFactory.parse_file(reference)\\n msg = \\\"In Global Application Configuration file \\\"\\n _validate_configs(self._app_conf, ref, msg,\\n missing_exception=True,\\n type_mismatch_exception=True)\\n reference = data_file(\\\"../config/template/aiscalator.conf\\\")\\n ref = pyhocon.ConfigFactory.parse_file(reference)\\n msg = \\\"In Global Application Configuration file \\\"\\n _validate_configs(self._app_conf, ref, msg,\\n missing_exception=False,\\n type_mismatch_exception=True)\\n if self._step_name:\\n reference = data_file(\\\"../config/template/minimum_step.conf\\\")\\n ref = pyhocon.ConfigFactory.parse_file(reference)\\n msg = \\\"in step named \\\" + self._step_name\\n _validate_configs(self._step,\\n ref[\\\"steps\\\"][\\\"Untitled\\\"],\\n msg,\\n missing_exception=True,\\n type_mismatch_exception=True)\\n reference = data_file(\\\"../config/template/step.conf\\\")\\n ref = pyhocon.ConfigFactory.parse_file(reference)\\n msg = \\\"in step named \\\" + self._step_name\\n _validate_configs(self._step,\\n ref[\\\"steps\\\"][\\\"Untitled\\\"],\\n msg,\\n missing_exception=False,\\n type_mismatch_exception=True)\\n if self._dag_name:\\n reference = data_file(\\\"../config/template/minimum_dag.conf\\\")\\n ref = pyhocon.ConfigFactory.parse_file(reference)\\n msg = \\\"in dag named \\\" + self._dag_name\\n _validate_configs(self._dag,\\n ref[\\\"dags\\\"][\\\"Untitled\\\"],\\n msg,\\n missing_exception=True,\\n type_mismatch_exception=True)\\n reference = data_file(\\\"../config/template/step.conf\\\")\\n ref = pyhocon.ConfigFactory.parse_file(reference)\\n msg = \\\"in dag named \\\" + self._dag_name\\n _validate_configs(self._dag,\\n ref[\\\"dags\\\"][\\\"Untitled\\\"],\\n msg,\\n missing_exception=False,\\n type_mismatch_exception=True)\",\n \"def validate(self, data):\\n logger.debug(data)\\n upload = data['upload']\\n config_type = data['config_type']\\n content_type = validators.validate_content_type(upload, config_type)\\n if config_type == 'PRESET':\\n validators.validate_preset(upload)\\n data['content_type'] = content_type\\n fname = data['upload'].name\\n data['filename'] = fname.replace(' ', '_').lower()\\n return data\",\n \"def initiate(self, data):\\n self._parse_config()\",\n \"def validate(self, config_json):\\n pass\",\n \"def defaultconfig(self):\\r\\n\\r\\n config_data = {\\r\\n \\\"path_to_database\\\": \\\"FUDB/FOLLOWUP.DB\\\",\\r\\n \\\"path_to_frontend\\\": \\\"FUDB/\\\",\\r\\n \\\"path_to_dcs_info\\\": \\\"FUDB/\\\",\\r\\n \\\"path_to_bin\\\": \\\"bin/\\\",\\r\\n \\\"path_to_excels_exported_from_database\\\": \\\"excels exported/\\\",\\r\\n \\\"path_to_excels_to_be_imported_in_database\\\": \\\"excels to be imported/\\\",\\r\\n \\\"path_to_new_opfiles\\\": \\\"DC BATCHES IN WORK/0 NEW/\\\",\\r\\n \\\"path_to_batches_unassigned\\\": \\\"DC BATCHES IN WORK/1 UNASSIGNED/\\\",\\r\\n \\\"path_to_batches_prepfiles\\\": \\\"DC BATCHES IN WORK/2 PREPARED FILES/\\\",\\r\\n \\\"path_to_batches_assigned\\\": \\\"DC BATCHES IN WORK/3 ASSIGNED/\\\",\\r\\n \\\"path_to_batches_tobechecked\\\": \\\"DC BATCHES IN WORK/4 TO BE CHECKED/\\\",\\r\\n \\\"path_to_batches_tbimported\\\": \\\"DC BATCHES IN WORK/5 TO BE IMPORTED/\\\",\\r\\n \\\"path_to_batches_finished\\\": \\\"DC BATCHES IN WORK/6 FINISHED/\\\",\\r\\n \\\"path_to_batches_instandby\\\": \\\"DC BATCHES IN WORK/7 IN STANDBY/\\\",\\r\\n \\\"path_to_batches_unrecordable\\\": \\\"DC BATCHES IN WORK/8 UNRECORDABLE/\\\",\\r\\n \\\"batch_status_options_responsible\\\": \\\"PREP. OP FILE, IMPORTATION & SPLIT FILE, RELIABILITY & DATA UPGRADE, CHECK OP FILE, CHECK SPLIT FILE, CHECK FRONT END, **TO BE CHECKED\\\",\\r\\n \\\"batch_status_options_proofreader\\\": \\\"OP FILE OK, SPLIT FILE OK, FRONT END OK, **TO BE IMPORTED, **FINISHED, **REWORK, **STANDBY, **UNRECORDABLE\\\",\\r\\n \\\"batch_status_options_overall\\\": \\\"ONGOING, STANDBY, FINISHED, UNRECORDABLE\\\",\\r\\n \\\"aircrafts\\\": \\\"A300, A300-600, A310, A320, A330, A340, A350, A380\\\",\\r\\n \\\"split_batch_factor\\\": \\\"2, 3, 4, 5, 6, 7, 8, 9\\\",\\r\\n \\\"IDlentgh\\\": \\\"6\\\",\\r\\n \\\"port\\\": \\\"5000\\\"\\r\\n }\\r\\n \\r\\n if not os.path.isfile(os.path.join(self.cwd, \\\"config.json\\\")):\\r\\n self.func.write_json(config_data, self.cwd, fname=\\\"config.json\\\")\",\n \"def _validate_config(self):\\n # Simulation ID\\n empty_string_check(self._config_dict['@id'])\\n \\n # Output\\n empty_string_check(self._config_dict['output']['@baseDirectory'])\\n self._config_dict['output']['@saveInteractionLog'] = parse_boolean(self._config_dict['output']['@saveInteractionLog'])\\n self._config_dict['output']['@saveRelevanceJudgments'] = parse_boolean(self._config_dict['output']['@saveRelevanceJudgments'])\\n self._config_dict['output']['@trec_eval'] = parse_boolean(self._config_dict['output']['@trec_eval'])\\n \\n # Topics\\n def check_topic(t):\\n \\\"\\\"\\\"\\n Checks a given topic, t. Looks for a topic ID and a valid topic description file.\\n \\\"\\\"\\\"\\n empty_string_check(t['@id'])\\n filesystem_exists_check(t['@filename'])\\n filesystem_exists_check(t['@qrelsFilename'])\\n \\n if '@backgroundFilename' in t: # A background file was specified.\\n filesystem_exists_check(t['@backgroundFilename'])\\n else:\\n t['@backgroundFilename'] = None # No background file was specified.\\n \\n topics = self._config_dict['topics']['topic']\\n \\n if type(topics) == list:\\n for topic in topics:\\n check_topic(topic)\\n else:\\n check_topic(topics)\\n \\n # Users\\n users = self._config_dict['users']['user']\\n \\n if type(users) == list:\\n for user in users:\\n filesystem_exists_check(user['@configurationFile'])\\n else:\\n filesystem_exists_check(users['@configurationFile'])\\n \\n # Search Interface\\n empty_string_check(self._config_dict['searchInterface']['@class'])\\n check_attributes(self._config_dict['searchInterface'])\",\n \"def create(self, validated_data):\\n return ExportConfig.objects.create(**validated_data)\",\n \"def create_config(self) -> None:\\n pass\",\n \"def create_config(self) -> None:\\n pass\",\n \"def test_valid_configurations_create(self):\\n expected_configs = self.expected_default_datastore_configs()\\n values = json.dumps(expected_configs.get('valid_values'))\\n expected_values = json.loads(values)\\n result = instance_info.dbaas.configurations.create(\\n CONFIG_NAME,\\n values,\\n CONFIG_DESC,\\n datastore=instance_info.dbaas_datastore,\\n datastore_version=instance_info.dbaas_datastore_version)\\n resp, body = instance_info.dbaas.client.last_response\\n assert_equal(resp.status, 200)\\n with TypeCheck('Configuration', result) as configuration:\\n configuration.has_field('name', str)\\n configuration.has_field('description', str)\\n configuration.has_field('values', dict)\\n configuration.has_field('datastore_name', str)\\n configuration.has_field('datastore_version_id', str)\\n configuration.has_field('datastore_version_name', str)\\n global configuration_info\\n configuration_info = result\\n assert_equal(configuration_info.name, CONFIG_NAME)\\n assert_equal(configuration_info.description, CONFIG_DESC)\\n assert_equal(configuration_info.values, expected_values)\",\n \"def save_config(self, data, validate=True):\\n if isinstance(data, list):\\n # Convert list to plain text\\n r = []\\n for d in sorted(data, key=operator.itemgetter(\\\"name\\\")):\\n r += [\\n \\\"==[ %s ]========================================\\\\n%s\\\"\\n % (d[\\\"name\\\"], d[\\\"config\\\"])\\n ]\\n data = \\\"\\\\n\\\".join(r)\\n # Wipe out unnecessary parts\\n if self.config_filter_handler:\\n if self.config_filter_handler.allow_config_filter:\\n handler = self.config_filter_handler.get_handler()\\n data = handler(self, data) or \\\"\\\"\\n else:\\n logger.warning(\\\"Handler is not allowed for config filter\\\")\\n # Pass data through config filter, if given\\n if self.config_diff_filter_handler:\\n if self.config_diff_filter_handler.allow_config_diff_filter:\\n handler = self.config_diff_filter_handler.get_handler()\\n data = handler(self, data) or \\\"\\\"\\n else:\\n logger.warning(\\\"Handler is not allowed for config diff filter\\\")\\n # Pass data through the validation filter, if given\\n # @todo: Replace with config validation policy\\n if self.config_validation_handler:\\n if self.config_validation_handler.allow_config_validation:\\n handler = self.config_validation_handler.get_handler()\\n warnings = handler(self, data)\\n if warnings:\\n # There are some warnings. Notify responsible persons\\n self.event(\\n self.EV_CONFIG_POLICY_VIOLATION, {\\\"object\\\": self, \\\"warnings\\\": warnings}\\n )\\n else:\\n logger.warning(\\\"Handler is not allowed for config validation\\\")\\n # Calculate diff\\n old_data = self.config.read()\\n is_new = not bool(old_data)\\n diff = None\\n if is_new:\\n changed = True\\n else:\\n # Calculate diff\\n if self.config_diff_filter_handler:\\n if self.config_diff_filter_handler.allow_config_diff_filter:\\n handler = self.config_diff_filter_handler.get_handler()\\n # Pass through filters\\n old_data = handler(self, old_data)\\n new_data = handler(self, data)\\n if not old_data and not new_data:\\n logger.error(\\n \\\"[%s] broken config_diff_filter: Returns empty result\\\", self.name\\n )\\n else:\\n self.logger.warning(\\\"Handler is not allowed for config diff filter\\\")\\n new_data = data\\n else:\\n new_data = data\\n changed = old_data != new_data\\n if changed:\\n diff = \\\"\\\".join(\\n difflib.unified_diff(\\n old_data.splitlines(True),\\n new_data.splitlines(True),\\n fromfile=os.path.join(\\\"a\\\", self.name.encode(\\\"utf8\\\")),\\n tofile=os.path.join(\\\"b\\\", self.name.encode(\\\"utf8\\\")),\\n )\\n )\\n if changed:\\n # Notify changes\\n self.notify_config_changes(is_new=is_new, data=data, diff=diff)\\n # Save config\\n self.write_config(data)\\n # Apply mirroring settings\\n self.mirror_config(data, changed)\\n # Run config validation\\n if validate:\\n self.validate_config(changed)\\n return changed\",\n \"def process_data():\\n with open('configClear_v2.json') as config:\\n json_config = json.load(config)\\n cisco_ios_xe_native = json_config.get('frinx-uniconfig-topology:configuration').get('Cisco-IOS-XE-native:native')\\n\\n config_container = {\\n \\\"BDI\\\" : cisco_ios_xe_native.get('interface').get('BDI'),\\n \\\"Loopback\\\" : cisco_ios_xe_native.get('interface').get('Loopback'),\\n \\\"Port-channel\\\" : cisco_ios_xe_native.get('interface').get('Port-channel'),\\n \\\"TenGigabitEthernet\\\" : cisco_ios_xe_native.get('interface').get('TenGigabitEthernet'),\\n \\\"GigabitEthernet\\\" : cisco_ios_xe_native.get( 'interface' ).get( 'GigabitEthernet' )\\n }\\n\\n\\n with create_connection() as conn:\\n for k,v in config_container.items():\\n for i in v:\\n cur = conn.cursor()\\n cur.execute(\\\"\\\"\\\"\\n INSERT INTO device_interface_config( name, description, config, port_channel_id, max_frame_size )\\n VALUES( %s, %s, %s, %s, %s);\\n \\\"\\\"\\\", (f\\\"{k}{i.get('name')}\\\",\\n i.get('description'),\\n json.dumps(i),\\n i.get( 'Cisco-IOS-XE-ethernet:channel-group' ),\\n i.get('mtu')\\n )\\n )\",\n \"def check_configs(self):\\n\\n pass\",\n \"def _validate_data(self, vms, fw_rules):\\n self._validate_vms(vms)\\n self._validate_fw_rules(fw_rules)\\n self._validated = True\",\n \"def build_configs():\",\n \"def validate_config(config: Dict) -> None:\\n\\n # For validating with pydantic\\n config_flattened = format_config_for_validation(config)\\n user_defined_sets = get_all_sets(config)\\n\\n errors = []\\n for input_data in config_flattened:\\n try:\\n if \\\"type\\\" not in input_data:\\n UserDefinedValue(**input_data)\\n elif input_data[\\\"type\\\"] == \\\"param\\\":\\n input_data[\\\"defined_sets\\\"] = user_defined_sets\\n UserDefinedParameter(**input_data)\\n elif input_data[\\\"type\\\"] == \\\"result\\\":\\n input_data[\\\"defined_sets\\\"] = user_defined_sets\\n UserDefinedResult(**input_data)\\n elif input_data[\\\"type\\\"] == \\\"set\\\":\\n UserDefinedSet(**input_data)\\n else:\\n # have pydantic raise an error\\n UserDefinedValue(\\n name=input_data[\\\"name\\\"],\\n type=input_data[\\\"type\\\"],\\n dtype=input_data[\\\"dtype\\\"],\\n )\\n except ValidationError as ex:\\n errors_caught = [x[\\\"msg\\\"] for x in ex.errors()]\\n errors.extend(errors_caught)\\n\\n if errors:\\n error_message = \\\"\\\\n\\\".join(errors)\\n raise OtooleConfigFileError(message=f\\\"\\\\n{error_message}\\\")\",\n \"def validate_config(self):\\n log.msg('Validating config')\\n # Map message types to callbacks that handle that message type\\n self.dispatch_map = {\\n 'Deliver': self.receive_message,\\n 'Status_Report': self.receive_delivery_report,\\n }\\n\\n self.redis_config = self.config.get('redis', {})\\n self.gammu_config = self.config.get('gammu')\\n self.connect_retry_interval = int(self.config.get(\\n 'connect_retry_interval', 15))\\n self.poll_interval = int(self.config.get('poll_interval', 60))\\n self.country_code = str(self.config.get('country_code'))\\n self.phone_number = str(self.config.get('phone_number'))\\n self.phone = None\",\n \"def __setup(self):\\n\\n # Create empty config json file if not there.\\n if not self.config_file:\\n self.config_file = \\\"./default.config\\\"\\n if not os.path.isfile(self.config_file):\\n with open(self.config_file, 'w') as f:\\n json.dump({}, f)\\n\\n # Recycle and replace values in the config file\\n with open(self.config_file, 'r') as json_file:\\n data = json.load(json_file)\\n\\n # Records the `server`, `license_key`, and `user_email` if they don't exist.\\n # Server\\n if (self.server not in data.keys() or data[self.server] == {}):\\n data[self.server] = {}\\n\\n # License key\\n if (self.license_key not in data[self.server].keys() or data[self.server][self.license_key] == {}):\\n data[self.server][self.license_key] = {}\\n\\n # User email\\n if self.user.email not in data[self.server][self.license_key].keys():\\n data[self.server][self.license_key][self.user.email] = {}\\n\\n # Next, if a `device_token` doesn't exist for this server and\\n # license, call the `Organization.registerLicense()` endpoint to\\n # obtain a device token. On the other hand, if the device token\\n # already exists, it takes the existing token to prevent\\n # redundantly registering the same license.\\n\\n # Device token\\n if (\\\"device_token\\\" not in data[self.server][self.license_key].keys()\\n or data[self.server][self.license_key][\\\"device_token\\\"] == ''):\\n out = self.organization.registerLicense(self.device_name)\\n if 'Token' not in out:\\n self.__record(data=data) # Save current state\\n raise PermissionError(\\n \\\"Registration error. Make sure your license key is valid for the selected server.\\\")\\n\\n self.device_token = out['Token']\\n data[self.server][self.license_key][\\\"device_token\\\"] = self.device_token\\n\\n elif (self.device_token == '' and data[self.server][self.license_key][\\\"device_token\\\"] != ''):\\n self.device_token = data[self.server][self.license_key][\\\"device_token\\\"]\\n\\n # Next, if a `user_token` does not exist for the current user on\\n # this license and server, it tries to log in (`User.login()`) the\\n # user first using the device token. If cannot be logged in, it\\n # needs to create a new user (`User.create()`) before logging in.\\n # The user information and credentials are already handled in the\\n # `User` class, so it only needs to pass in the `device_token`.\\n\\n # User token\\n if (\\\"user_token\\\" not in data[self.server][self.license_key][self.user.email].keys()\\n or data[self.server][self.license_key][self.user.email][\\\"user_token\\\"] == ''):\\n res = self.user.login(self.device_token)\\n\\n if res == \\\"INVALID_USER\\\":\\n res = self.user.create(self.device_token)\\n if res == 'INTERNAL_ERROR':\\n self.__record(data=data)\\n raise PermissionError(\\\"Cannot create new user. Check your license permissions.\\\")\\n\\n self.user_id = res\\n res = self.user.login(self.device_token)\\n\\n elif res == \\\"INVALID_PASSWORD\\\":\\n self.__record(data=data)\\n raise PermissionError(\\\"Incorrect login password.\\\")\\n\\n self.user_token = self.user.user_token\\n if self.user_token != '':\\n data[self.server][self.license_key][self.user.email][\\\"user_token\\\"] = self.user_token\\n else:\\n self.user_token = data[self.server][self.license_key][self.user.email][\\\"user_token\\\"]\\n self.user.user_token = self.user_token\\n\\n # Record updated data into the config file.\\n self.__record(data=data)\",\n \"def validate(self):\\n if self.tba_key is None:\\n self.log.error(\\n \\\"You are missing the TBA-Key field. Please check https://github.com/team4099/scouting-data-ingest#tba for more information.\\\"\\n )\\n return False\\n\\n self.check_internet_connection()\\n\\n if self.year is None:\\n self.log.error(\\n \\\"You are missing the Year field. Please add one in the style shown below.\\\"\\n )\\n year_example = \\\"\\\"\\\"\\n {\\n \\\"Year\\\": \\\"2020\\\"\\n }\\n \\\"\\\"\\\"\\n console.print(Syntax(year_example, \\\"json\\\"))\\n console.print(\\n \\\"Reference https://github.com/team4099/scouting-data-ingest#configuration for more information.\\\"\\n )\\n return False\\n\\n if self.google_credentials is None:\\n self.log.error(\\n \\\"You are missing the Google-Credentials field. Please check https://github.com/team4099/scouting-data-ingest#google-service-account-credentials-file for more information.\\\"\\n )\\n return False\\n elif not os.path.isfile(f\\\"config/{self.google_credentials}\\\"):\\n self.log.error(\\n \\\"The file listed in the Google-Credentials field does not exist in the config folder. Please place it inside the config folder.\\\"\\n )\\n return False\\n else:\\n try:\\n gc = gspread.service_account(f\\\"./config/{self.google_credentials}\\\")\\n except ValueError as e:\\n self.log.error(\\n \\\"The file listed in the Google-Credentials Field is improper. See below for details.\\\"\\n )\\n self.log.error(e)\\n return False\\n\\n if self.spreadsheet is None:\\n self.log.error(\\n \\\"You are missing the Spreadsheet field. Please check https://github.com/team4099/scouting-data-ingest#spreadsheet for more information.\\\"\\n )\\n return False\\n else:\\n try:\\n gc.open(f\\\"{self.spreadsheet}\\\").get_worksheet(0)\\n except gspread.exceptions.SpreadsheetNotFound:\\n self.log.error(\\n \\\"The file listed in the Spreadsheets field has not been shared with the service account. Please make sure it is.\\\"\\n )\\n return False\\n\\n if self.db_user is None:\\n self.log.error(\\n \\\"You are missing the Database User field. Please check https://github.com/team4099/scouting-data-ingest#mysql for more information.\\\"\\n )\\n return False\\n\\n if self.db_pwd is None:\\n self.log.error(\\n \\\"You are missing the Database Password field. Please check https://github.com/team4099/scouting-data-ingest#mysql for more information.\\\"\\n )\\n return False\\n\\n try:\\n create_engine(\\n f\\\"mysql+pymysql://{self.db_user}:{self.db_pwd}@{self.db_host}/scouting\\\"\\n )\\n except pymysql.err.OperationalError:\\n self.log.error(\\n \\\"Your Database user name and/or password is not correct. Please verify them.\\\"\\n )\\n\\n if self.event is None:\\n self.log.error(\\n \\\"You are missing the Event field. Please check https://github.com/team4099/scouting-data-ingest#event for more information.\\\"\\n )\\n return False\\n\\n if (\\n requests.get(\\n f\\\"https://www.thebluealliance.com/api/v3/event/{self.year}{self.event}\\\",\\n headers={\\\"X-TBA-Auth-Key\\\": self.tba_key},\\n ).status_code\\n == 404\\n ):\\n self.log.error(\\n \\\"The event listed in the TBA-Key field is not valid. Please ensure the event key and year are correct.\\\"\\n )\\n return False\\n\\n if self.simulation:\\n if self.simulator_url is None:\\n self.log.error(\\n \\\"You are missing the Simulator URL field. Please check https://github.com/team4099/scouting-data-ingest#tba for more information.\\\"\\n )\\n return False\\n\\n try:\\n simulator_status = requests.get(\\n f\\\"{self.simulator_url}/matches\\\"\\n ).status_code\\n except (\\n ConnectionRefusedError,\\n urllib3.exceptions.NewConnectionError,\\n requests.exceptions.ConnectionError,\\n ):\\n self.log.error(\\n \\\"The simulator may not be running or it's at a different url than the one provided.\\\"\\n )\\n return False\\n\\n if simulator_status == 401:\\n self.log.error(\\n \\\"The simulator may not be running. Please make sure it is and that it is up-to-date.\\\"\\n )\\n return False\\n\\n if self.simulator_spreadsheet is None:\\n self.log.error(\\n \\\"You are missing the Simulator Spreadsheet field. Please check https://github.com/team4099/scouting-data-ingest#spreadsheet for more information.\\\"\\n )\\n return False\\n else:\\n try:\\n gc.open(f\\\"{self.simulator_spreadsheet}\\\").get_worksheet(0)\\n except gspread.exceptions.SpreadsheetNotFound:\\n self.log.error(\\n \\\"The file listed in the Simulator Spreadsheet field has not been shared with the service account. Please make sure it is. Please also make sure the name entered is correct.\\\"\\n )\\n return False\\n\\n return True\",\n \"def _prepare_and_validate_data(self,data_list):\\n pos=0\\n list_pos=0\\n format=\\\"\\\"\\n length=0\\n value=\\\"\\\"\\n\\n #check number of items in data_list is as expected\\n if(self.data_lookup.count()['type']!=len(data_list)):\\n raise NumItemsError(\\\"Wrong number of items for the data type\\\")\\n\\n #loop over data from data_types.csv and populate\\n for index,row in self.data_lookup.iterrows():\\n length=int(row['Bytes'])\\n\\n #obtain format type\\n if (row['Format']=='byte'):\\n format=int\\n elif (row['Format']=='string'):\\n format=str\\n\\n #obtain limits\\n try:\\n min=int(row['Min'],16)\\n max=int(row['Max'],16)\\n except:\\n min='*'\\n max='*'\\n\\n #check format type\\n if (isinstance(data_list[list_pos],format)):\\n #correct format type\\n if format==str:\\n value=data_list[list_pos].encode()\\n elif format==int:\\n value=data_list[list_pos].to_bytes(length,'little')\\n\\n #check limits if int type\\n if min=='*' or max == '*':\\n pass\\n elif int(data_list[list_pos]) >= min and int(data_list[list_pos]) <= max:\\n pass\\n else:\\n raise ValueError(\\\"value\\\",int(value),\\\"is out of range, min:\\\",min,\\\"max:\\\",max)\\n else:\\n raise TypeError(\\\"Unknown type, can currently only handle string or integer types\\\")\\n #populate data\\n for n in range(0,length):\\n self.data[pos+n]=value[n]\\n pos=pos+length\\n list_pos=list_pos+1\\n else:\\n raise TypeError(\\\"expected\\\",format,\\\"got\\\",type(data_list[list_pos]),\\\"at position\\\",list_pos)\\n return True\",\n \"def init_configs(self):\\n\\n # get current location\\n self.script_dir = os.path.dirname(__file__)\\n\\n # load configuration file\\n with open(os.path.join(self.script_dir, \\\"config.json\\\")) as f:\\n self.configs = json.load(f)\\n \\n # load some configs as attributes\\n self.resource_folder = os.path.join(self.script_dir, self.configs[\\\"resource_path\\\"], self.resource_type, self.language)\\n self.pre_processed_folder = os.path.join(self.resource_folder, self.configs[\\\"pre_processed_path\\\"])\\n self.results_folder = os.path.join(self.resource_folder, self.configs[\\\"results_path\\\"])\\n self.chunk_size = self.configs[\\\"resources\\\"][self.resource_type][\\\"chunk_size\\\"]\",\n \"async def _process_create_data(self, data: dict) -> dict:\\n return self.SCHEMA(data)\",\n \"def check(self) -> None:\\n # check existence\\n self.check_key_exists()\\n\\n # check valid range and type\\n assert 0 <= self.config[\\\"MOMENTUM\\\"] <= 1\\n assert isinstance(self.config[\\\"MOMENTUM\\\"], float)\\n\\n assert self.config[\\\"WEIGHT_DECAY\\\"] >= 0\\n assert isinstance(self.config[\\\"WEIGHT_DECAY\\\"], float)\\n\\n assert self.config[\\\"SEED\\\"] >= 0\\n assert isinstance(self.config[\\\"SEED\\\"], int)\\n\\n assert self.config[\\\"BATCH_SIZE\\\"] > 0\\n assert isinstance(self.config[\\\"BATCH_SIZE\\\"], int)\\n\\n assert self.config[\\\"EPOCHS\\\"] > 0\\n assert isinstance(self.config[\\\"EPOCHS\\\"], int)\\n\\n assert self.config[\\\"LR\\\"] > 0\\n assert isinstance(self.config[\\\"LR\\\"], float)\\n\\n if \\\"NESTEROV\\\" in self.config:\\n assert type(self.config[\\\"NESTEROV\\\"]) is bool\\n else:\\n self.config[\\\"NESTEROV\\\"] = False # default\\n\\n if \\\"CUTMIX\\\" in self.config:\\n cutmix_config = self.config[\\\"CUTMIX\\\"]\\n assert \\\"beta\\\" in cutmix_config\\n assert cutmix_config[\\\"beta\\\"] > 0\\n assert \\\"prob\\\" in cutmix_config\\n assert 0 < cutmix_config[\\\"prob\\\"] <= 1\\n\\n if \\\"AUG_TRAIN_PARAMS\\\" in self.config:\\n assert isinstance(self.config[\\\"AUG_TRAIN_PARAMS\\\"], dict)\\n else:\\n self.config[\\\"AUG_TRAIN_PARAMS\\\"] = dict()\\n\\n if \\\"AUG_TEST_PARAMS\\\" in self.config:\\n assert isinstance(self.config[\\\"AUG_TEST_PARAMS\\\"], dict)\\n else:\\n self.config[\\\"AUG_TEST_PARAMS\\\"] = dict()\\n\\n self.check_criterion()\\n self.check_lr_schedulers()\\n self.check_regularizer()\",\n \"async def _process_create_data(self, data: dict) -> dict:\\n validated_data: dict = validate_language(data)\\n return validated_data\",\n \"def initialize_from_config(self):\",\n \"def validate_data(self):\\n if self.type == 'grid':\\n for layout in self.data:\\n grid = layout.get('grid')\\n if not grid:\\n raise ChartError(\\n \\\"Layout grid setting must be set \\\"\\n \\\"if layout type is 'grid'\\\")\\n\\n if not grid.get('location'):\\n raise ChartError(\\n \\\"Layout grid location must be set \\\"\\n \\\"if layout type is 'grid'\\\")\\n\\n if len(grid['location']) != 2:\\n raise ChartError(\\\"Layout grid location length must be 2\\\")\",\n \"def create(self, validated_data):\",\n \"def make_config():\\n # find date of data obtained\\n current_pathname = os.path.basename(os.getcwd())\\n guess_date = extract_date(current_pathname)\\n\\n while(True):\\n if guess_date is None:\\n prompt = 'YYYYMMDD'\\n else:\\n prompt = guess_date\\n\\n string = input('Date of observation [{}]: '.format(prompt))\\n input_date = extract_date(string)\\n if input_date is None:\\n if guess_date is None:\\n continue\\n else:\\n input_date = guess_date\\n break\\n else:\\n break\\n \\n input_datetime = datetime.datetime.strptime(input_date, '%Y-%m-%d')\\n\\n # create config object\\n config = configparser.ConfigParser()\\n\\n config.add_section('data')\\n\\n config.set('data', 'telescope', 'Keck-I')\\n config.set('data', 'instrument', 'HIRES')\\n config.set('data', 'rawpath', 'rawdata')\\n #config.set('data', 'statime_key', statime_key)\\n #config.set('data', 'exptime_key', exptime_key)\\n\\n config.add_section('reduce')\\n config.set('reduce', 'midpath', 'midproc')\\n config.set('reduce', 'figpath', 'images')\\n config.set('reduce', 'odspath', 'onedspec')\\n config.set('reduce', 'mode', 'normal')\\n config.set('reduce', 'oned_suffix', 'ods')\\n config.set('reduce', 'fig_format', 'png')\\n \\n config.add_section('reduce.bias')\\n config.set('reduce.bias', 'bias_file', '${reduce:midpath}/bias.fits')\\n config.set('reduce.bias', 'cosmic_clip', str(10))\\n config.set('reduce.bias', 'maxiter', str(5))\\n config.set('reduce.bias', 'smooth', 'yes')\\n config.set('reduce.bias', 'smooth_method', 'gaussian')\\n config.set('reduce.bias', 'smooth_sigma', str(3))\\n config.set('reduce.bias', 'smooth_mode', 'nearest')\\n\\n config.add_section('reduce.trace')\\n config.set('reduce.trace', 'minimum', str(1e-3))\\n config.set('reduce.trace', 'scan_step', str(100))\\n config.set('reduce.trace', 'separation', '100:84, 1500:45, 3000:14')\\n config.set('reduce.trace', 'filling', str(0.2))\\n config.set('reduce.trace', 'align_deg', str(2))\\n config.set('reduce.trace', 'display', 'no')\\n config.set('reduce.trace', 'degree', str(4))\\n config.set('reduce.trace', 'file', '${reduce:midpath}/trace.fits')\\n\\n config.add_section('reduce.flat')\\n config.set('reduce.flat', 'file', '${reduce:midpath}/flat.fits')\\n\\n # write to config file\\n filename = 'HIRES.{}.cfg'.format(input_date)\\n outfile = open(filename, 'w')\\n for section in config.sections():\\n maxkeylen = max([len(key) for key in config[section].keys()])\\n outfile.write('[{}]'.format(section)+os.linesep)\\n fmt = '{{:{}s}} = {{}}'.format(maxkeylen)\\n for key, value in config[section].items():\\n outfile.write(fmt.format(key, value)+os.linesep)\\n outfile.write(os.linesep)\\n outfile.close()\\n\\n print('Config file written to {}'.format(filename))\",\n \"def prepare_data(self):\\n try:\\n self.train_dataset = self.datasets['train']\\n self.val_dataset = self.datasets['val']\\n try:\\n self.test_dataset = self.datasets['test']\\n except:\\n pass\\n except Exception as e:\\n print('Data was not succesfully prepared:', e)\",\n \"def from_data(cls, app, configuration):\",\n \"def __init__(self, data_config):\\n self._brands = self._load_from_directory(data_config['targeted_brands_dir'])\\n self._keywords = self._load_from_directory(data_config['keywords_dir'])\\n self._fqdn_keywords = self._load_from_directory(data_config['fqdn_keywords_dir'])\\n self._similarity_words = self._load_from_directory(data_config['similarity_words_dir'])\\n self._tlds = self._load_from_directory(data_config['tld_dir'])\",\n \"def check_config(self):\\n cfgs = self.__get() \\n \\n for option in Config.FILE_OPTIONS.keys():\\n _default = Config.FILE_OPTIONS[option]\\n \\n if not cfgs.has_key(option):\\n self.log.warn(\\\"Parameter '%s' is missing in '%s', using default('%s')\\\" % \\\\\\n (option, self.config_file, _default))\\n _file = _default\\n else:\\n _file = cfgs[option]\\n Config.FILE_OPTIONS[option] = _file\\n\\n if not os.path.exists(_file) and not os.path.isfile(_file):\\n self.log.error(\\\"Paramenter '%s' points to non-existing file '%s')\\\" % \\\\\\n (option, _file))\\n raise ConfigError('File Error', \\\"Paramenter '%s' points to non-existing file '%s')\\\" % \\\\\\n (option, _file))\\n\\n\\n for option in Config.PATH_OPTIONS.keys():\\n _default = Config.PATH_OPTIONS[option]\\n \\n if not cfgs.has_key(option):\\n self.log.warn(\\\"Parameter '%s' is missing in '%s', using default('%s')\\\" % \\\\\\n (option, self.config_file, _default))\\n _dir = _default\\n else:\\n _dir = cfgs[option]\\n Config.PATH_OPTIONS[option] = _dir\\n\\n if not os.path.exists(_dir) and not os.path.isdir(_dir):\\n self.log.error(\\\"Paramenter '%s' points to non-existing directory '%s')\\\" % \\\\\\n (option, _dir))\\n raise ConfigError('File Error', \\\"Paramenter '%s' points to non-existing directory '%s')\\\" % \\\\\\n (option, _dir))\\n\\n \\n Config.DB_SFT_OPTIONS['sqlalchemy_sft.url'] = cfgs['sqlalchemy_sft.url']\\n Config.DB_NAGIOS_OPTIONS['sqlalchemy_nagios.url'] = cfgs['sqlalchemy_nagios.url']\\n\\n self.log.debug(\\\"Configuration successfully checked\\\")\",\n \"def _Validate(self):\\n # There's some possible conflict with LABEL and ISSUE_DATE\\n # If the date exists but the label isn't defined, this property\\n # will be ignored\\n if (\\\"ISSUE_DATE\\\" in self) != (\\\"LABEL\\\" in self):\\n with IgnoreKeyError:\\n del self[\\\"ISSUE_DATE\\\"]\\n with IgnoreKeyError:\\n del self[\\\"LABEL\\\"]\\n # Also check that both disc and discs exists or neither do\\n if self.discs > 1 and \\\"PART_NUMBER\\\" not in self:\\n raise DiscConfigurationError(\\\"Number of discs is set but disc number not known\\\")\\n if \\\"PART_NUMBER\\\" in self and self.discs < 2:\\n raise DiscConfigurationError(\\\"Disc number is set but number of discs is not known\\\")\\n # Ensure that the original medium is set, if it hasn't been set yet then assume CD\\n if \\\"ORIGINAL_MEDIUM\\\" not in self:\\n self[\\\"ORIGINAL_MEDIUM\\\"] = \\\"CD\\\"\\n elif self[\\\"ORIGINAL_MEDIUM\\\"] not in arguments.MEDIUM_CHOICES:\\n logging.critical(\\\"Invalid medium: '%s' - must be one of %s\\\",\\n self['ORIGINAL_MEDIUM'], arguments.MEDIUM_CHOICES)\\n raise ValueError(f\\\"Invalid medium: '{self['ORIGINAL_MEDIUM']}' - must be one of {arguments.MEDIUM_CHOICES}\\\")\\n # At this point it is necessary to require that all the metadata is present\\n # These were setup in the constructor as ``None`` so they do exist, but they\\n # must have been overridden as non-``None`` values\\n # ``required_tags`` holds tag keys which map onto descriptions for error output\\n required_tags = {\\\"TITLE\\\": \\\"title\\\",\\n \\\"ARTIST\\\": \\\"artist\\\",\\n \\\"GENRE\\\": \\\"genre\\\",\\n \\\"DATE_RECORDED\\\": \\\"year\\\"}\\n for tag in required_tags:\\n if self[tag] is None:\\n raise TagNotFoundError(f\\\"Incomplete metadata - missing {required_tags[tag]}\\\")\\n for key, value in self.items():\\n self[key] = value.strip()\",\n \"def create(self):\\n ##\\n datasubstructure_file = self.source\\n if datasubstructure_file.endswith('.sql'):\\n print('Generating the data substructure based on the SQL file')\\n status = self.create_datastructure_from_sql_file()\\n \\n elif datasubstructure_file.endswith('.yml'):\\n print('Generating the data substructure based on the YAML file')\\n status = 'failed'\\n raise ReadingDataFileException(\\\"Error: this file type is not yet supported\\\")\\n else:\\n status = 'failed'\\n raise ReadingDataFileException(\\\"Error: this file type is not yet supported\\\")\\n \\n return(status)\",\n \"def _save_config(self, data: dict[str, Any]) -> FlowResult:\\n new_data = {\\n k: v\\n for k, v in data.items()\\n if k not in [CONF_APPS, CONF_STATE_DETECTION_RULES]\\n }\\n if self._apps:\\n new_data[CONF_APPS] = self._apps\\n if self._state_det_rules:\\n new_data[CONF_STATE_DETECTION_RULES] = self._state_det_rules\\n\\n return self.async_create_entry(title=\\\"\\\", data=new_data)\",\n \"def test_validate_config_file(self):\\n ingest_mgmr = IngestManager()\\n ingest_mgmr.validate_config_file(self.example_config_data)\\n assert(ingest_mgmr.config is not None)\\n assert (ingest_mgmr.config.config_data is not None)\",\n \"def validate(self):\\n for key, value in self._configurations.items():\\n value.validate()\",\n \"def populate_initial_valid_metadata(self):\\n pass\",\n \"def check_record_config(config):\\n\\n def convert_type(item, convert_func):\\n if item not in config.keys():\\n raise Error(\\\"Config file dose not has '{0}'!\\\".format(item))\\n try:\\n record_dict[item] = convert_func(config[item])\\n except Exception:\\n raise Error(\\\"Config['{0}'] is not correct!\\\".format(item))\\n\\n def check_time_range():\\n if record_dict['time_range'] not in TIME_INFOR.keys():\\n raise Error(\\\"Time range is not {0}\\\".format(TIME_INFOR.keys()))\\n\\n def check_query():\\n try:\\n record_dict['query'] = [str(item) for item in config['query']]\\n except Exception:\\n raise Error(\\\"Config['query'] is not correct!\\\")\\n\\n def check_start_time():\\n try:\\n record_dict['start'] = convert_time_to_second(config['start_time'])\\n except Exception:\\n raise Error(\\\"Config['start_time'] pattern is not: {0}\\\".format(\\n TIME_PATTERN))\\n\\n second_range = TIME_INFOR[record_dict['time_range']]['second_range']\\n record_dict['end'] = record_dict['start'] + second_range\\n if record_dict['end'] > time.time():\\n raise Error(\\\"Config start time + time interval > now\\\")\\n\\n record_dict = {}\\n for item_key, item_type in RECORD_CONFIG_PATTERN.items():\\n convert_type(item_key, item_type)\\n check_query()\\n check_time_range()\\n check_start_time()\\n\\n record_dict['metadata_path'] = \\\\\\n create_path(record_dict['data_directory'], METADATA_FILE)\\n record_dict['ts_directory'] = \\\\\\n create_path(record_dict['data_directory'], TS_DATA_DIR)\\n record_dict['record_config'] = \\\\\\n create_path(record_dict['data_directory'], CONFIG_FILE)\\n record_dict['interval'] = record_dict['data_file_interval'] * 60 * 60\\n\\n return record_dict\",\n \"def prepare_data(self):\\n import subprocess\\n # Download coco data set into dir specified by config then /data/coco\\n subprocess.call([f\\\"{get_original_cwd()}/bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\", f\\\"{get_original_cwd()}\\\"])\\n # subprocess.call([f\\\"bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\"])\\n task = \\\"instances\\\" if self.instance else \\\"person_keypoints\\\"\\n register_coco_instances(\\\"train\\\", {}, f\\\"{self.dir}/data/coco/{task}_train2014.json\\\",\\n f\\\"{self.dir}/data/coco/train2014\\\")\\n register_coco_instances(\\\"val\\\", {}, f\\\"{self.dir}/data/coco/{task}_minival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\\n register_coco_instances(\\\"test\\\", {}, f\\\"{self.dir}/data/coco/{task}_valminusminival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\",\n \"def _validate_config(dataset_cfg: DictConfig):\\n if dataset_cfg.get('hf_name') is not None:\\n # Using the HuggingFace dataset codepath\\n illegal_keys = ['local', 'remote']\\n discovered_illegal_keys = []\\n for key in illegal_keys:\\n if dataset_cfg.get(key) is not None:\\n discovered_illegal_keys.append('`' + key + '`')\\n if discovered_illegal_keys:\\n raise ValueError(\\n 'The dataset config sets a value for `hf_name` as well as the ' +\\\\\\n f'following keys: {\\\", \\\".join(discovered_illegal_keys)}.\\\\n' +\\\\\\n 'Those keys are used when building from a streaming dataset, but ' +\\\\\\n 'setting `hf_name` instructs the dataset to build from a HuggingFace dataset.'\\n )\\n elif dataset_cfg.get('remote') is not None:\\n # Using the streaming dataset codepath\\n illegal_keys = ['hf_name', 'hf_kwargs', 'preprocessing_fn']\\n discovered_illegal_keys = []\\n for key in illegal_keys:\\n if dataset_cfg.get(key) is not None:\\n discovered_illegal_keys.append('`' + key + '`')\\n if discovered_illegal_keys:\\n raise ValueError(\\n 'The dataset config sets a value for `remote` as well as the ' +\\\\\\n f'following keys: {\\\", \\\".join(discovered_illegal_keys)}.\\\\n' +\\\\\\n 'Those keys are used when building from a HuggingFace dataset, but ' +\\\\\\n 'setting `remote` instructs the dataset to build from a streaming dataset.'\\n )\\n if dataset_cfg.get('local') is None:\\n raise ValueError(\\n 'Using a streaming dataset requires setting both `remote` and `local`, ' +\\\\\\n 'but dataset.local is None.'\\n )\\n else:\\n raise ValueError(\\n 'In the dataset config, you must set either `hf_name` to use a ' +\\\\\\n 'HuggingFace dataset or set `remote` to use a streaming ' +\\\\\\n 'dataset, but both were None.'\\n )\",\n \"def validate_config_dict(self):\\n config_options = [\\\"pipeline_name\\\",\\n \\\"num_processors\\\",\\n \\\"num_sessions_at_once\\\",\\n \\\"available_memory\\\",\\n \\\"cluster_system\\\",\\n \\\"output_directory\\\",\\n \\\"working_directory\\\",\\n \\\"template_head_for_anat\\\",\\n \\\"exclude_zeros\\\",\\n \\\"start_idx\\\",\\n \\\"stop_idx\\\",\\n \\\"write_report\\\",\\n \\\"write_graph\\\",\\n \\\"write_all_outputs\\\",\\n \\\"upload_to_s3\\\",\\n \\\"bucket_prefix\\\",\\n \\\"bucket_out_prefix\\\",\\n \\\"local_prefix\\\",\\n \\\"bucket_name\\\",\\n \\\"creds_path\\\"]\\n invalid = []\\n for param in self._config.keys():\\n if param not in config_options:\\n invalid.append(param)\\n if len(invalid) > 0:\\n err = \\\"\\\\n[!] The following parameters in your configuration \\\" \\\\\\n \\\"file are not recognized. Double-check the pipeline \\\" \\\\\\n \\\"configuration template.\\\\n\\\"\\n err += \\\"\\\\n\\\".join([x for x in invalid])\\n raise Exception(err)\\n else:\\n return 0\",\n \"def __init__(self, data, schema_file=None):\\n if schema_file is not None:\\n if not os.path.exists(schema_file):\\n logging.warning(\\n 'Configuration schema file could not be found. Please check the path and try again.'\\n )\\n raise Exception()\\n\\n self.schema_file = schema_file\\n else:\\n self.schema_file = None\\n\\n if not os.path.exists(data):\\n logging.warning(\\n 'Configuration data could not be found. Please check the path and try again.'\\n )\\n raise Exception()\\n\\n self.datafile = data\\n\\n self.data = None\",\n \"def _verify(self, data):\\n sections = {\\n \\\"schema\\\": dict,\\n \\\"defaults\\\": dict,\\n \\\"projects\\\": list\\n }\\n\\n for key, type_ in sections.items():\\n if key not in data:\\n self._report_error(\\\"Missing section: {}\\\".format(key))\\n return False\\n if not isinstance(data[key], type_):\\n err = \\\"Wrong data type for section {}, should be {}\\\"\\n self._report_error(err.format(key, type_))\\n return False\\n\\n for setting in data[\\\"defaults\\\"]:\\n if setting not in data[\\\"schema\\\"]:\\n err = \\\"Invalid setting {0} in default configuration\\\"\\n self._report_error(err.format(setting))\\n return False\\n\\n for i, project in enumerate(data[\\\"projects\\\"]):\\n if not isinstance(project, dict):\\n err = \\\"Wrong data type for project at index {}\\\"\\n self._report_error(err.format(i))\\n return False\\n if \\\"name\\\" not in project:\\n err = \\\"Missing name for project at index {}\\\"\\n self._report_error(err.format(i))\\n return False\\n for setting in project:\\n if setting not in data[\\\"schema\\\"]:\\n err = \\\"Invalid setting {} for project {}\\\"\\n self._report_error(err.format(setting, project[\\\"name\\\"]))\\n return False\\n\\n return True\",\n \"def __init__(self, configParserObject):\\n section = 'settings'\\n self.debug = configParserObject.getboolean(section, 'debug')\\n self.application_path = configParserObject.get(section, 'application_path')\\n self.log_path = configParserObject.get(section, 'log_path')\\n self.chat_enabled = configParserObject.getboolean(section, 'chat_enabled')\\n self.token_validation_enabled = configParserObject.getboolean(section, 'token_validation_enabled')\\n if not os.path.isdir(self.application_path):\\n raise ErrorLoadingData('Path %s does not exists' % self.application_path)\\n if not os.path.isdir(self.log_path):\\n raise ErrorLoadingData('Path %s does not exists' % self.log_path)\",\n \"def setup(self):\\n # Initialize key variables\\n valid = True\\n updated_list = []\\n config = copy.deepcopy(self.config)\\n directory = self.directories[0]\\n\\n # Update log_directory and ingest_cache_directory\\n if isinstance(config, dict) is True:\\n if 'main' in config:\\n # Setup the log_directory to a known good default\\n (updated, config) = self._create_directory_entries(\\n 'log_directory', config)\\n updated_list.append(updated)\\n\\n # Setup the ingest_cache_directory to a known good default\\n (updated, config) = self._create_directory_entries(\\n 'ingest_cache_directory', config)\\n updated_list.append(updated)\\n\\n else:\\n valid = False\\n else:\\n valid = False\\n\\n # Gracefully exit if things are not OK\\n if valid is False:\\n log_message = (\\n 'Configuration files found in {} is invalid'\\n ''.format(self.directories))\\n log.log2die_safe(1007, log_message)\\n\\n # Update configuration file if required\\n if len(updated_list) == updated_list.count(True):\\n for next_directory in self.directories:\\n # Delete all YAML files in the directory\\n general.delete_yaml_files(next_directory)\\n\\n # Write config back to directory\\n filepath = ('%s/config.yaml') % (directory)\\n with open(filepath, 'w') as outfile:\\n yaml.dump(config, outfile, default_flow_style=False)\",\n \"def test_validate_ingest(self):\\n #Validate schema and config file\\n ingest_mgmr = IngestManager()\\n response = ingest_mgmr.validate_config_file(self.example_config_data)\\n assert (response is True)\\n\\n #Validate properties\\n response = ingest_mgmr.validate_properties()\\n assert (response is True)\",\n \"def create_config(self):\\n\\n #FIXME: Try to do it over loops ie. self[attr].set_config()\\n for attr, value in self.__dict__.items():\\n if attr == \\\"connection\\\":\\n self.connection.set_config(self.cfg)\\n if attr == \\\"ipv4\\\":\\n self.ipv4.set_config(self.cfg)\\n if attr == \\\"ipv6\\\":\\n self.ipv6.set_config(self.cfg)\\n if attr == \\\"_802_3_ethernet\\\" and not value == \\\"none\\\":\\n self._802_3_ethernet.set_config(self.cfg)\\n if attr == \\\"_802_11_wireless\\\" and not value == \\\"none\\\":\\n self._802_11_wireless.set_config(self.cfg)\\n if attr == \\\"_802_11_wireless_security\\\" and not value == \\\"none\\\":\\n self._802_11_wireless_security.set_config(self.cfg)\",\n \"def configure(self):\\n self.data_batch_file = self.get_value_from_config('data_batch_file')\\n self.batch_meta_file = self.get_value_from_config('batch_meta_file')\\n self.has_background = self.get_value_from_config('has_background')\\n self.num_classes = self.get_value_from_config('num_classes')\\n self.converted_images_dir = self.get_value_from_config('converted_images_dir')\\n if not self.converted_images_dir:\\n self.converted_images_dir = self.data_batch_file.parent / 'converted_images'\\n self.convert_images = self.get_value_from_config('convert_images')\\n # create directory for storing images if it is necessary\\n if self.convert_images and not self.converted_images_dir.exists():\\n self.converted_images_dir.mkdir(parents=True)\\n self.dataset_meta = self.get_value_from_config('dataset_meta_file')\",\n \"def create(self):\\n datasubstructure_file = self.source\\n if datasubstructure_file.endswith('.yml'):\\n print('Generating the data substructure based on the YML file')\\n status = self.create_datastructure_from_yaml_file()\\n else:\\n status = 'failed'\\n raise ReadingDataFileException(\\\"Error: this file type is not yet supported\\\")\\n \\n return(status)\",\n \"def _prepare_data(self):\\n #TODO hardcoded values need to change\\n print_info(\\\"Preprocessing the train data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"train\\\"),\\n self.TRAIN_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the test data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"test\\\"),\\n self.TEST_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the validation data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"val\\\"),\\n self.VAL_OUT_PATH)\",\n \"def __init__ (self, config_yaml):\\n configdef = yaml.safe_load(io.StringIO(config_yaml)) \\n\\n if \\\"filters\\\" not in configdef:\\n configdef = dict(filters=[configdef])\\n\\n self._configs = []\\n\\n for definition in configdef[\\\"filters\\\"]:\\n config = Bunch( valid_from = None\\n , volume_follows = False\\n , copy_last_price = False\\n , copy_last_volume = False\\n , qualifier_include_filters = []\\n , qualifier_exclude_filters = []\\n , exclude_filters = [] )\\n\\n if \\\"filter\\\" in definition and definition[\\\"filter\\\"] != None:\\n for exclude_filter in definition[\\\"filter\\\"]:\\n parts = exclude_filter.split(\\\",\\\")\\n if parts[0] == \\\"floor\\\":\\n config.exclude_filters.append(FloorFilter(float(parts[1]), \\\"price\\\"))\\n elif parts[0] == \\\"cap\\\":\\n config.exclude_filters.append(CapFilter(float(parts[1]), \\\"price\\\")) \\n elif parts[0] == \\\"step\\\":\\n config.exclude_filters.append(StepFilter(int(parts[1]), float(parts[2]), float(parts[3]), \\\"price\\\"))\\n else:\\n raise Exception(\\\"Unknown filter (%s)\\\" % (parts[0])) \\n \\n if \\\"remove\\\" in definition and definition[\\\"remove\\\"] != None:\\n for exclude_filter in definition[\\\"remove\\\"]:\\n config.qualifier_exclude_filters.append(QualifierFilter(exclude_filter))\\n \\n if \\\"allow\\\" in definition and definition[\\\"allow\\\"] != None:\\n for include_filter in definition[\\\"allow\\\"]:\\n config.qualifier_include_filters.append(QualifierFilter(include_filter))\\n\\n if \\\"volFollows\\\" in definition: config.volume_follows = definition[\\\"volFollows\\\"] \\n if \\\"copyLast\\\" in definition and definition[\\\"copyLast\\\"] != None:\\n config.copy_last_price = definition[\\\"copyLast\\\"] \\n config.copy_last_volume = definition[\\\"copyLast\\\"] \\n if \\\"volumeLimit\\\" in definition and definition[\\\"volumeLimit\\\"] != None:\\n config.exclude_filters.append(CapFilter(definition[\\\"volumeLimit\\\"], \\\"volume\\\"))\\n if \\\"validFrom\\\" in definition and definition[\\\"validFrom\\\"] != None:\\n valid_from = datetime.datetime.strptime(definition[\\\"validFrom\\\"], \\\"%Y-%m-%d %H:%M:%S\\\")\\n valid_from.replace(tzinfo=pytz.utc)\\n config.valid_from = common.Time.tick(valid_from)\\n if \\\"weekTimezone\\\" in definition and definition[\\\"weekTimezone\\\"] != None:\\n config.exclude_filters.append(WeekendFilter(definition[\\\"weekTimezone\\\"], definition[\\\"weekEnd\\\"], definition[\\\"weekStart\\\"]))\\n\\n self._configs.append(config)\\n \\n self._config_index = 0\\n self._config_count = len(self._configs)\",\n \"def validateData(self, ):\\n count = 0\\n while count < len(self.RAD_sequences_validate):\\n RAD_filename = self.RAD_sequences_validate[count] \\n RAD_complex = loader.readRAD(RAD_filename)\\n if RAD_complex is None:\\n raise ValueError(\\\"RAD file not found, please double check the path\\\")\\n ### NOTE: Gloabl Normalization ###\\n RAD_data = helper.complexTo2Channels(RAD_complex)\\n RAD_data = (RAD_data - self.config_data[\\\"global_mean_log\\\"]) / \\\\\\n self.config_data[\\\"global_variance_log\\\"]\\n ### load ground truth instances ###\\n gt_filename = loader.gtfileFromRADfile(RAD_filename, \\\\\\n self.config_data[\\\"train_set_dir\\\"])\\n gt_instances = loader.readRadarInstances(gt_filename)\\n if gt_instances is None:\\n raise ValueError(\\\"gt file not found, please double check the path\\\")\\n\\n ### NOTE: decode ground truth boxes to YOLO format ###\\n gt_labels, has_label, raw_boxes = self.encodeToLabels(gt_instances)\\n\\n if has_label:\\n yield (RAD_data, gt_labels, raw_boxes)\\n count += 1\",\n \"def _check_config(self):\",\n \"def load_data(self, data):\\n self.data = data\\n self.validate()\",\n \"def _check_loaded_conf(self, config_dict):\\n expected_fields = set(self.data_types.keys())\\n\\n expected_missing = []\\n for name in expected_fields:\\n if name not in self.defaults and name not in config_dict:\\n expected_missing.append(name)\\n if expected_missing:\\n raise Exception(\\\"Missing mandatory fileds: {}\\\"\\n .format(\\\", \\\".join(expected_missing)))\\n\\n unexpected = []\\n for name in config_dict:\\n if name not in expected_fields:\\n unexpected.append(name)\\n if unexpected:\\n raise Exception(\\\"Unexpected fields: {}\\\"\\n .format(\\\", \\\".join(unexpected)))\\n\\n \\\"\\\"\\\" Check data types method \\\"\\\"\\\"\\n for name in config_dict:\\n if not isinstance(config_dict[name], self.data_types[name]):\\n raise Exception(\\\"Bad data type: param {}, expected {}\\\"\\n . format(name, self.data_types[name]))\\n\\n self.inmodule.validcheck(config_dict)\",\n \"def _validate_main_config(self):\\n # check for required top-level parameters in main config\\n required_params = {\\\"name\\\": str, \\\"version\\\": str, \\\"datasets\\\": list}\\n\\n for param, expected_type in required_params.items():\\n if param not in self.config:\\n msg = (\\n \\\"[ERROR] Config error: missing required configuration parameter in {}: '{}'\\\"\\n )\\n config_file = os.path.basename(self.config[\\\"config_file\\\"])\\n sys.exit(msg.format(config_file, param))\\n elif not isinstance(self.config[param], expected_type):\\n msg = \\\"[ERROR] Config error: parameter is of unexpected type {}: '{}' (expected: '{}')\\\"\\n config_file = os.path.basename(self.config[\\\"config_file\\\"])\\n sys.exit(msg.format(config_file, param, expected_type))\",\n \"def build_validation_data_loader(self) -> DataLoader:\\n pass\",\n \"def validate(cls, data, errors):\",\n \"def validate_config():\\n\\n # diff/sync settings, not including templates (see below)\\n nori.setting_check_list('action', ['diff', 'sync'])\\n nori.setting_check_type('reverse', bool)\\n nori.setting_check_type('bidir', bool)\\n nori.setting_check_callbacks('pre_action_callbacks')\\n nori.setting_check_callbacks('post_action_callbacks', 1, 1)\\n for i, cb_t in enumerate(nori.core.cfg['post_action_callbacks']):\\n nori.setting_check_type(('post_action_callbacks', i, 3), bool)\\n nori.setting_check_list('source_type', ['generic', 'drupal'])\\n nori.setting_check_callable('source_query_func', may_be_none=False)\\n nori.setting_check_callable('source_query_defaulter', may_be_none=True)\\n nori.setting_check_callable('source_query_validator', may_be_none=False)\\n nori.setting_check_callbacks('source_template_change_callbacks')\\n nori.setting_check_callbacks('source_global_change_callbacks')\\n nori.setting_check_list('dest_type', ['generic', 'drupal'])\\n nori.setting_check_callable('dest_query_func', may_be_none=False)\\n nori.setting_check_callable('dest_query_defaulter', may_be_none=True)\\n nori.setting_check_callable('dest_query_validator', may_be_none=False)\\n nori.setting_check_callbacks('dest_template_change_callbacks')\\n nori.setting_check_callbacks('dest_global_change_callbacks')\\n nori.setting_check_list('template_mode', ['all', 'include', 'exclude'])\\n if nori.core.cfg['template_mode'] != 'all':\\n nori.setting_check_not_empty('template_list')\\n for i, t_name in enumerate(nori.core.cfg['template_list']):\\n nori.setting_check_type(('template_list', i),\\n nori.core.STRING_TYPES)\\n nori.setting_check_list('key_mode', ['all', 'include', 'exclude'])\\n if nori.core.cfg['key_mode'] != 'all':\\n nori.setting_check_not_empty('key_list')\\n\\n # templates: general\\n nori.setting_check_not_empty(\\n 'templates', types=nori.core.MAIN_SEQUENCE_TYPES\\n )\\n for i, template in enumerate(nori.core.cfg['templates']):\\n nori.setting_check_type(('templates', i), nori.core.MAPPING_TYPES)\\n # bogus elements\\n for k in template:\\n if k not in T_KEYS:\\n nori.err_exit(\\n \\\"Warning: cfg['templates'][{0}][{1}] is set\\\\n\\\"\\n \\\"(to {2}), but there is no such setting.\\\" .\\n format(i, *map(nori.pps, [k, template[k]])),\\n nori.core.exitvals['startup']['num']\\n )\\n # template name\\n nori.setting_check_type(('templates', i, T_NAME_KEY),\\n nori.core.STRING_TYPES)\\n # multiple-valued value columns?\\n nori.setting_check_type(('templates', i, T_MULTIPLE_KEY), bool)\\n # source-DB query function arguments\\n nori.setting_check_arg_tuple(('templates', i, T_S_QUERY_ARGS_KEY))\\n # to-dest transform function\\n nori.setting_check_callable(('templates', i, T_TO_D_FUNC_KEY),\\n may_be_none=True)\\n # source-DB don't-replicate flag\\n nori.setting_check_type(('templates', i, T_S_NO_REPL_KEY), bool)\\n # source-DB change callbacks\\n nori.setting_check_callbacks(('templates', i, T_S_CHANGE_CB_KEY))\\n # dest-DB query function arguments\\n nori.setting_check_arg_tuple(('templates', i, T_D_QUERY_ARGS_KEY))\\n # to-source transform function\\n nori.setting_check_callable(('templates', i, T_TO_S_FUNC_KEY),\\n may_be_none=True)\\n # dest-DB don't-replicate flag\\n nori.setting_check_type(('templates', i, T_D_NO_REPL_KEY), bool)\\n # dest-DB change callbacks\\n nori.setting_check_callbacks(('templates', i, T_D_CHANGE_CB_KEY))\\n # key mode\\n nori.setting_check_list(('templates', i, T_KEY_MODE_KEY),\\n ['all', 'include', 'exclude'])\\n if template[T_KEY_MODE_KEY] != 'all':\\n # key list\\n nori.setting_check_not_empty(('templates', i, T_KEY_LIST_KEY))\\n\\n # templates: query-function arguments\\n for (sd, t_key, validator_key) in [\\n ('s', T_S_QUERY_ARGS_KEY, 'source_query_validator'),\\n ('d', T_D_QUERY_ARGS_KEY, 'dest_query_validator')\\n ]:\\n # args tuple\\n args_idx = ('templates', i, t_key)\\n args_t = template[t_key]\\n # key_cv, value_cv (somewhat)\\n for cv_str in ['key_cv', 'value_cv']:\\n cv_idx = args_idx + (1, cv_str)\\n nori.setting_check_not_empty(\\n cv_idx, types=nori.core.MAIN_SEQUENCE_TYPES\\n )\\n cv_seq = args_t[1][cv_str]\\n for j, cv in enumerate(cv_seq):\\n nori.setting_check_length(cv_idx + (j, ), 2, 3,\\n types=tuple)\\n # the rest of the arguments\\n nori.core.cfg[validator_key](sd, args_idx, args_t, i)\\n\\n # reporting settings\\n nori.setting_check_list('report_order', ['template', 'keys'])\\n # the rest are handled by nori.validate_email_config()\",\n \"def __init__(self, configfile):\\n\\n self.all_sqs = {}\\n self.all_dynamodb = {}\\n self.all_s3 = {}\\n self.all_sites = []\\n\\n with open(configfile, 'r') as stream:\\n try: \\n self.config = yaml.safe_load(stream)\\n self.all_sites = list(self.config['Sites'].keys())\\n\\n for site in self.all_sites:\\n self.all_sqs[site] = self.make_sqs(site)\\n self.all_dynamodb[site] = self.make_dynamodb(site)\\n self.all_s3[site] = self.make_s3(site)\\n \\n except Exception as e:\\n print(f\\\"Exception: {e}\\\")\",\n \"def _verify_map(self):\\n # ---- verify self.info ----\\n if self.info['contype'] == NotImplemented:\\n # 'contype' must be defined\\n errstr = \\\"self.info['contype'] must be defined as:\\\\n\\\" \\\\\\n \\\" 'motion', 'waveform', or 'power'\\\"\\n raise NotImplementedError(errstr)\\n elif self.info['contype'] not in ['motion',\\n 'waveform',\\n 'power']:\\n # 'contype' must be one of specified type\\n errstr = \\\"self.info['contype'] must be defined as:\\\\n\\\" \\\\\\n \\\" 'motion', 'waveform', or 'power'\\\"\\n raise NotImplementedError(errstr)\\n\\n # ---- verity self.configs ----\\n # 'dataset fields' must be defined\\n if 'dataset fields' not in self.configs:\\n errstr = \\\"self.configs['dataset fields'] must be defined \\\" \\\\\\n \\\"as:\\\\n [('field name', dtype), ]\\\"\\n raise NotImplementedError(errstr)\\n elif self.configs['dataset fields'] == NotImplemented:\\n errstr = \\\"self.configs['dataset fields'] must be defined \\\" \\\\\\n \\\"as:\\\\n [('field name', dtype), ]\\\"\\n raise NotImplementedError(errstr)\\n\\n # 'dset field to numpy field' must be defined\\n # - each 'dataset field' needs a mapping to a structured numpy\\n # field for hdfReadControl\\n # - 'dset field to numpy field' is a list of 3-element tuples\\n # where each entry in the list corresponds to a dataset field\\n # name\\n # - the 3-element tuple must follow the format:\\n #\\n # self.configs['dset field to numpy field'][i] = (\\n # str, # dataset field name\\n # str, # corresponding structured numpy field name\\n # int) # index of structured numpy field\\n #\\n # For example, the '6K Compumotor would look like...\\n # self.configs['dset field to numpy'] = [\\n # ('x', 'xyz', 0),\\n # ('y', 'xyz', 1),\\n # ('z', 'xyz', 2)]\\n #\\n key = 'dset field to numpy field'\\n if key not in self.configs:\\n raise NotImplementedError\\n elif self.configs[key] == NotImplemented:\\n raise NotImplementedError\\n elif type(self.configs[key]) is not list:\\n errstr = \\\"self.configs['dset field to numpy field] must \\\" \\\\\\n + \\\"be a list of 3-element tuples\\\"\\n raise Exception(errstr)\\n elif not all(isinstance(val, tuple)\\n for val in self.configs[key]):\\n errstr = \\\"self.configs['dset field to numpy field] must \\\" \\\\\\n + \\\"be a list of 3-element tuples\\\"\\n raise Exception(errstr)\\n elif not all(len(val) == 3 for val in self.configs[key]):\\n errstr = \\\"self.configs['dset field to numpy field] must \\\" \\\\\\n + \\\"be a list of 3-element tuples\\\"\\n raise Exception(errstr)\\n else:\\n err = False\\n dset_fields = [name\\n for name, dftype\\n in self.configs['dataset fields']]\\n for dfname, npfname, npi in self.configs[key]:\\n if dfname not in dset_fields:\\n err = True\\n break\\n elif type(npfname) is not str:\\n err = True\\n break\\n elif type(npi) is not int:\\n err = True\\n break\\n if err:\\n errstr = \\\"self.configs['dset field to numpy field] \\\" \\\\\\n + \\\"must be a list of 3-element tuples\\\"\\n raise Exception(errstr)\\n\\n # contype == 'motion' specific verification\\n if self.contype == 'motion':\\n # verify 'motion list'\\n if 'motion list' not in self.configs:\\n # 'motion list' exists\\n errstr = \\\"self.configs['motion list'] must be defined\\\"\\n raise NotImplementedError(errstr)\\n elif self.configs['motion list'] == NotImplemented:\\n # 'motion list' is defined\\n errstr = \\\"self.configs['motion list'] must be defined\\\"\\n raise NotImplementedError(errstr)\\n else:\\n # each 'motion list' must have its own config\\n for name in self.configs['motion list']:\\n if name not in self.configs:\\n errstr = \\\"must defined self.configs['motion \\\" \\\\\\n \\\"name'] for each motion list in \\\" \\\\\\n \\\"self.configs['motion list'] = \\\" \\\\\\n \\\"[motion name, ]\\\"\\n raise NotImplementedError(errstr)\\n\\n # verify 'probe list'\\n if 'probe list' not in self.configs:\\n # 'probe list' exists\\n errstr = \\\"self.configs['probe list'] must be defined\\\"\\n raise NotImplementedError(errstr)\\n elif self.configs['probe list'] == NotImplemented:\\n # 'probe list' is defined\\n errstr = \\\"self.configs['probe list'] must be defined\\\"\\n raise NotImplementedError(errstr)\\n else:\\n # each 'probe list' must have its own config\\n for name in self.configs['probe list']:\\n if name not in self.configs:\\n errstr = \\\"must defined self.configs['probe \\\" \\\\\\n \\\"name'] for each probe in \\\" \\\\\\n \\\"self.configs['probe list'] = \\\" \\\\\\n \\\"[probe name, ]\\\"\\n raise NotImplementedError(errstr)\\n\\n # delete 'config names' if present\\n if 'config names' in self.configs:\\n del self.configs['config names']\\n\\n # verify all other contypes\\n if self.contype != 'motion':\\n # remove 'motion list'\\n if 'motion list' in self.configs:\\n # remove 'motion list' children\\n for name in self.configs['motion list']:\\n if name in self.configs:\\n del(self.configs[name])\\n\\n # remove 'motion list'\\n del(self.configs['motion list'])\\n\\n # remove 'probe list'\\n if 'probe list' in self.configs:\\n # remove 'probe list' children\\n for name in self.configs['probe list']:\\n if name in self.configs:\\n del (self.configs[name])\\n\\n # remove 'motion list'\\n del (self.configs['probe list'])\\n\\n # verify 'command list'\\n # if 'command list' not in self.configs:\\n # # 'command list' exists\\n # errstr = \\\"self.configs['command list'] must be \\\" \\\\\\n # \\\"defined\\\"\\n # raise NotImplementedError(errstr)\\n # elif self.configs['command list'] == NotImplemented:\\n # # 'motion list' is defined\\n # errstr = \\\"self.configs['command list'] must be \\\" \\\\\\n # \\\"defined\\\"\\n # raise NotImplementedError(errstr)\",\n \"def create_dicts():\\n load_data_for_dict('data/atis/train/seq.in', 'data/atis/voc/vocabulary.json')\\n load_data_for_dict('data/atis/valid/seq.in', 'data/atis/voc/vocabulary.json')\\n load_data_for_dict('data/atis/test/seq.in', 'data/atis/voc/vocabulary.json') \\n load_data_for_dict('data/atis/train/seq.out', 'data/atis/voc/slot_vocabulary.json')\",\n \"def test_creates_data(self, config_filename, expected_class):\\n data = create_data(read_config_file(config_filename))\\n self.assertIsInstance(data, expected_class)\",\n \"def mk_data(self):\\n self.data = self.DEFAULTS.copy()\\n\\n for template in self.raw_data.get('extends', []):\\n template_data = self.load_template(template)\\n self.data.update(template_data)\\n\\n self.data.update(self.raw_data)\\n\\n str_replace(self.data)\\n\\n if self.data.get('redirect_stderr'):\\n self.data.pop('stderr')\",\n \"def check(self):\\n if not os.path.exists(config.configured_root_path):\\n raise c8e('root path of data set not exist' + config.configured_root_path)\\n \\n for it in config.configured_dirs:\\n self.__path[it] = os.path.join(config.configured_root_path, it)\\n \\n for l1 in os.listdir(config.configured_root_path): #1st level directory: train/valid/test\\n l1path = os.path.join(config.configured_root_path, l1)\\n if not os.path.isdir(l1path):\\n raise c8e('regular file exists in data set' + l1)\\n \\n if l1 not in config.configured_dirs:\\n raise c8e('wrong dir in data set' + l1)\\n \\n for l2 in os.listdir(l1path): #2nd level directory, red/yellow/green\\n l2path = os.path.join(l1path, l2)\\n if not os.path.isdir(l2path):\\n raise c8e('regular file exists in data set' + l2path)\\n \\n if l2 not in config.configured_classes:\\n raise c8e('wrong dir in data set' + l2path)\\n \\n for l3 in os.listdir(l2path): #3rd level files \\n self._check_image(l2path, l3)\\n \\n #statistic\\n self.__phase_sample_count[l1] += 1\\n self.__area_sample_count[l2] += 1\\n if l1 == config.configured_train_dir:\\n self.__train_sample_count[l2] += 1\\n \\n #process weight of each class of train directory\\n total = np.sum(list(self.__train_sample_count.values())) \\n max_samples = np.max(list(self.__train_sample_count.values())) #Max\\n mu = 1. / (total / float(max_samples)) #\\n keys = self.__train_sample_count.keys()\\n for key in keys:\\n score = math.log(mu * total / float(self.__train_sample_count[key]))\\n self.__class_weight[int(key)] = score if score > 1. else 1.\",\n \"def prepare_data(self):\\n # Set up the path\\n self.path_target_train = os.path.join(self.data_dir, self.train_path_file_target + \\\".pkl\\\")\\n self.path_target_test = os.path.join(self.data_dir, self.test_path_file_target + \\\".pkl\\\")\\n\\n if not os.path.exists(self.path_target_train) or not os.path.exists(self.path_target_test):\\n # Create vocabularies of the appropriate sizes.\\n self.create_vocabulary(self.train_path_file)\\n\\n # Create token ids for the training data.\\n input_train_path = self.train_path_file\\n target_train_path = self.train_path_file_target\\n train_input, train_input_length, train_labels = self.data_to_token_ids(input_train_path, target_train_path)\\n\\n # Create token ids for the validation data.\\n input_test_path = self.test_path_file\\n target_test_path = self.test_path_file_target\\n test_input, test_input_length, _ = self.data_to_token_ids(input_test_path, target_test_path, train=False)\\n\\n # Collect data into a list\\n training_data = [train_input, train_input_length, train_labels]\\n test_data = [test_input, test_input_length]\\n\\n # Save all the data\\n with open(self.path_target_train, 'wb') as f:\\n pickle.dump(training_data,f)\\n with open(self.path_target_test, 'wb') as f:\\n pickle.dump(test_data, f)\\n else:\\n # Load data\\n with open(self.path_target_train, 'rb') as f:\\n training_data = pickle.load(f)\\n with open(self.path_target_test, 'rb') as f:\\n test_data = pickle.load(f)\\n\\n # Initialize vocabulary\\n self.initialize_vocabulary()\\n\\n # Convert list into a numpy array - train data\\n train_input = pd.DataFrame(training_data[0]).fillna(value=0).astype(int).values\\n train_length_input = np.array(training_data[1], dtype=int)\\n train_labels = np.array(training_data[2], dtype=int)\\n\\n # Convert list into a numpy array - test data\\n test_input = pd.DataFrame(test_data[0]).fillna(value=0).astype(int).values\\n test_length_input = pd.DataFrame(test_data[1]).fillna(value=0).astype(int).values\\n\\n # Printing maximum length\\n print(\\\"Shape of the input training matrix {}\\\".format(str(train_input.shape)))\\n print(\\\"Shape of the input test matrix {}\\\".format(str(test_input.shape)))\\n\\n # Copy the files\\n self.copy_files()\\n\\n # Return output\\n return train_input, train_length_input, train_labels, test_input, test_length_input\",\n \"def build_data_set(self):\\n if not self.assert_data_correct():\\n self.download_all_data()\\n self.unpack_rename_data()\\n self.split_data_characters()\\n self.clean_data_fragments()\\n self.create_font_data()\\n if not self.assert_train_augmented():\\n self.augment_train_data()\\n if not self.assert_style_data_correct():\\n self.download_style_data()\\n self.unpack_rename_data()\",\n \"def validate_config(config):\\n # check if paths are valid\\n check_paths = {\\n 'data_path': r'data$',\\n 'master_list_path': r'master_list\\\\.csv$',\\n 'duplicate_list_path': r'duplicate_list\\\\.csv$',\\n 'log_path': r'data[\\\\\\\\\\\\/]jobfunnel.log$',\\n 'filter_list_path': r'data[\\\\\\\\\\\\/]filter_list\\\\.json$',\\n }\\n\\n for path, pattern in check_paths.items():\\n if not re.search(pattern, config[path]):\\n raise ConfigError(path)\\n # check if the provider list only consists of supported providers\\n if not set(config['providers']).issubset(PROVIDERS):\\n raise ConfigError('providers')\\n\\n # check validity of region settings\\n validate_region(config['search_terms']['region'])\\n\\n # check validity of delay settings\\n validate_delay(config['delay_config'])\\n\\n # check the validity of max_listing_days settings\\n if(config['max_listing_days'] is not None and config['max_listing_days'] < 0):\\n raise ConfigError('max_listing_days')\",\n \"def get_valid_config_data():\\n\\t# Valid JSON config for testing\\n\\tJSON_config = '''{\\n\\t\\t\\\"1\\\": {\\n\\t\\t\\t\\\"type\\\": \\\"custom\\\",\\n\\t\\t\\t\\\"faces\\\": \\\"right\\\"\\n\\t\\t},\\n\\t\\t\\\"3\\\": {\\n\\t\\t\\t\\\"type\\\": \\\"custom2\\\"\\n\\t\\t},\\n\\t\\t\\\"5\\\": {\\n\\t\\t\\t\\\"x\\\": 32,\\n\\t\\t\\t\\\"y\\\": 128\\n\\t\\t},\\n\\t\\t\\\"7\\\": {\\n\\t\\t\\t\\\"is_collidable\\\": false\\n\\t\\t}\\n\\t}'''\\n\\n\\t# Expected values for the parsed tileset config\\n\\texpected_config = {\\n\\t\\t1: {\\n\\t\\t\\t'type': 'custom',\\n\\t\\t\\t'faces': 'right',\\n\\t\\t},\\n\\t\\t2: {},\\n\\t\\t3: {\\n\\t\\t\\t'type': 'custom2',\\n\\t\\t},\\n\\t\\t4: {},\\n\\t\\t5: {\\n\\t\\t\\t'x': 32,\\n\\t\\t\\t'y': 128,\\n\\t\\t},\\n\\t\\t6: {},\\n\\t\\t7: {\\n\\t\\t\\t'is_collidable': False,\\n\\t\\t},\\n\\t\\t8: {},\\n\\t}\\n\\n\\treturn {\\n\\t\\t'JSON': JSON_config,\\n\\t\\t'expected': expected_config\\n\\t}\",\n \"def configure(self, config_json):\\n log.info(\\\"Configuring EDD backend for processing\\\")\\n log.debug(\\\"Configuration string: '{}'\\\".format(config_json))\\n\\n yield self.set(config_json)\\n\\n cfs = json.dumps(self._config, indent=4)\\n log.info(\\\"Final configuration:\\\\n\\\" + cfs)\\n\\n\\n\\n self.__numa_node_pool = []\\n # remove numa nodes with missing capabilities\\n for node in numa.getInfo():\\n if len(numa.getInfo()[node]['gpus']) < 1:\\n log.debug(\\\"Not enough gpus on numa node {} - removing from pool.\\\".format(node))\\n continue\\n elif len(numa.getInfo()[node]['net_devices']) < 1:\\n log.debug(\\\"Not enough nics on numa node {} - removing from pool.\\\".format(node))\\n continue\\n else:\\n self.__numa_node_pool.append(node)\\n\\n log.debug(\\\"{} numa nodes remaining in pool after cosntraints.\\\".format(len(self.__numa_node_pool)))\\n\\n if len(self._config['input_data_streams']) > len(self.__numa_node_pool):\\n raise FailReply(\\\"Not enough numa nodes to process {} polarizations!\\\".format(len(self._config['input_data_streams'])))\\n\\n self._subprocessMonitor = SubprocessMonitor()\\n #ToDo: Check that all input data streams have the same format, or allow different formats\\n for i, streamid in enumerate(self._config['input_data_streams']):\\n # calculate input buffer parameters\\n stream_description = self._config['input_data_streams'][streamid]\\n stream_description[\\\"dada_key\\\"] = DADABUFFERS[i]\\n self.add_input_stream_sensor(streamid)\\n self.input_heapSize = stream_description[\\\"samples_per_heap\\\"] * stream_description['bit_depth'] / 8\\n\\n nHeaps = self._config[\\\"samples_per_block\\\"] / stream_description[\\\"samples_per_heap\\\"]\\n input_bufferSize = nHeaps * (self.input_heapSize)\\n log.info('Input dada parameters created from configuration:\\\\n\\\\\\n heap size: {} byte\\\\n\\\\\\n heaps per block: {}\\\\n\\\\\\n buffer size: {} byte'.format(self.input_heapSize, nHeaps, input_bufferSize))\\n\\n\\n final_payloads, final_fpss, final_framens = EDD_VDIF_Frame_Size(stream_description['sample_rate'])\\n\\n if self._config['payload_size'] == 'auto':\\n payload_size = final_payloads[-1]\\n else:\\n payload_size = int(self._config['payload_size'])\\n\\n log.info('Possible frame payload sizes (add 32 for framesize):')\\n for k in range(final_payloads.size):\\n if payload_size == final_payloads[k]:\\n M = \\\"*\\\"\\n else:\\n M = \\\" \\\"\\n log.info(' {}{:5.0f} byte {:8.0f} frames per sec {:6.3f} nsec/frame'.format(M, final_payloads[k], final_fpss[k], final_framens[k]))\\n\\n if payload_size not in final_payloads:\\n log.warning(\\\"Payload size {} possibly not conform with VDIF format!\\\".format(payload_size))\\n\\n # calculate output buffer parameters\\n size_of_samples = ceil(1. * self._config[\\\"samples_per_block\\\"] * 2 / 8.) # byte for two bit mode\\n number_of_packages = ceil(size_of_samples / float(payload_size))\\n\\n output_buffer_size = number_of_packages * (payload_size + self._config['vdif_header_size'])\\n\\n integration_time = self._config[\\\"samples_per_block\\\"] / float(stream_description[\\\"sample_rate\\\"])\\n self._integration_time_status.set_value(integration_time)\\n\\n rate = output_buffer_size/ integration_time # in spead documentation BYTE per second and not bit!\\n rate *= self._config[\\\"output_rate_factor\\\"] # set rate to (100+X)% of expected rate\\n self._output_rate_status.set_value(rate / 1E9)\\n\\n log.info('Output parameters calculated from configuration:\\\\n\\\\\\n total size of data samples: {} byte\\\\n\\\\\\n number_of_packages: {}\\\\n\\\\\\n size of output buffer: {} byte\\\\n\\\\\\n rate ({:.0f}%): {} Gbps'.format(size_of_samples,\\n number_of_packages, output_buffer_size,\\n self._config[\\\"output_rate_factor\\\"]*100, rate / 1E9))\\n\\n numa_node = self.__numa_node_pool[i]\\n log.debug(\\\"Associating {} with numa node {}\\\".format(streamid, numa_node))\\n\\n # configure dada buffer\\n bufferName = stream_description['dada_key']\\n yield self._create_ring_buffer(input_bufferSize, 64, bufferName, numa_node)\\n\\n ofname = bufferName[::-1]\\n # we write nSlice blocks on each go\\n yield self._create_ring_buffer(output_buffer_size, 8, ofname, numa_node)\\n\\n # Configure + launch \\n physcpu = numa.getInfo()[numa_node]['cores'][0]\\n thread_id = self._config['thread_id'][streamid]\\n station_id = self._config['thread_id'][streamid]\\n cmd = \\\"taskset -c {physcpu} VLBI --input_key={dada_key} --speadheap_size={heapSize} --thread_id={thread_id} --station_id={station_id} --payload_size={payload_size} --sample_rate={sample_rate} --nbits={bit_depth} -o {ofname} --log_level={log_level} --output_type=dada\\\".format(ofname=ofname, heapSize=self.input_heapSize, numa_node=numa_node, physcpu=physcpu, thread_id=thread_id, station_id=station_id, payload_size=payload_size, log_level=self._config['log_level'], **stream_description)\\n log.debug(\\\"Command to run: {}\\\".format(cmd))\\n\\n cudaDevice = numa.getInfo()[numa_node]['gpus'][0]\\n cli = ManagedProcess(cmd, env={\\\"CUDA_VISIBLE_DEVICES\\\": cudaDevice})\\n self._subprocessMonitor.add(cli, self._subprocess_error)\\n self._subprocesses.append(cli)\\n\\n cfg = self._config.copy()\\n cfg.update(stream_description)\\n\\n ip_range = []\\n port = set()\\n for key in self._config[\\\"output_data_streams\\\"]:\\n if streamid in key:\\n ip_range.append(self._config[\\\"output_data_streams\\\"][key]['ip'])\\n port.add(self._config[\\\"output_data_streams\\\"][key]['port'])\\n if len(port)!=1:\\n raise FailReply(\\\"Output data for one plarization has to be on the same port! \\\")\\n\\n if self._config[\\\"output_type\\\"] == 'network':\\n physcpu = \\\",\\\".join(numa.getInfo()[numa_node]['cores'][1:2])\\n fastest_nic, nic_params = numa.getFastestNic(numa_node)\\n log.info(\\\"Sending data for {} on NIC {} [ {} ] @ {} Mbit/s\\\".format(streamid, fastest_nic, nic_params['ip'], nic_params['speed']))\\n\\n cmd = \\\"taskset -c {physcpu} vdif_send --input_key {ofname} --if_ip {ibv_if} --dest_ip {mcast_dest} --port {port_tx} --max_rate {rate}\\\".format(ofname=ofname, \\n physcpu=physcpu, ibv_if=nic_params['ip'], mcast_dest=\\\" \\\".join(ip_range), port_tx=port.pop(), rate=rate)\\n log.debug(\\\"Command to run: {}\\\".format(cmd))\\n\\n elif self._config[\\\"output_type\\\"] == 'disk':\\n ofpath = os.path.join(cfg[\\\"output_directory\\\"], ofname)\\n log.debug(\\\"Writing output to {}\\\".format(ofpath))\\n if not os.path.isdir(ofpath):\\n os.makedirs(ofpath)\\n cmd = \\\"dada_dbdisk -k {ofname} -D {ofpath} -W\\\".format(ofname=ofname, ofpath=ofpath, **cfg)\\n else:\\n log.warning(\\\"Selected null output. Not sending data!\\\")\\n cmd = \\\"dada_dbnull -z -k {}\\\".format(ofname)\\n\\n log.debug(\\\"Command to run: {}\\\".format(cmd))\\n mks = ManagedProcess(cmd, env={\\\"CUDA_VISIBLE_DEVICES\\\": cudaDevice})\\n self._subprocessMonitor.add(mks, self._subprocess_error)\\n self._subprocesses.append(mks)\\n\\n self._subprocessMonitor.start()\",\n \"def test_set_config__schema_validation(self):\\n\\n test_datafile = json.dumps(self.config_dict_with_features)\\n mock_logger = mock.Mock()\\n\\n # Test that schema is validated.\\n # Note: set_config is called in __init__ itself.\\n with mock.patch('optimizely.helpers.validator.is_datafile_valid', return_value=True) as mock_validate_datafile:\\n config_manager.StaticConfigManager(datafile=test_datafile, logger=mock_logger)\\n mock_validate_datafile.assert_called_once_with(test_datafile)\\n\\n # Test that schema is not validated if skip_json_validation option is set to True.\\n with mock.patch('optimizely.helpers.validator.is_datafile_valid', return_value=True) as mock_validate_datafile:\\n config_manager.StaticConfigManager(datafile=test_datafile, logger=mock_logger, skip_json_validation=True)\\n mock_validate_datafile.assert_not_called()\",\n \"def create(self):\\n # TODO: Properly validate data\\n self._proj()\\n if self.cfg.align_heading:\\n self._align()\\n self._griddata()\\n if self.cfg.gap_filter[\\\"algorithm\\\"] != \\\"none\\\":\\n self._gap_filter()\",\n \"def _build_config(data):\\n defaults = data['defaults']\\n clusters = data['clusters']\\n\\n # set each cluster settings\\n for cluster in clusters:\\n\\n # set each setting for each group if not present\\n for group_key, group_val in defaults.items():\\n if group_key in cluster:\\n for key, val in group_val.items():\\n cluster[group_key].setdefault(key, val)\\n else:\\n cluster[group_key] = copy.deepcopy(group_val)\\n\\n # set default endpoint if nothing else is set for kibana\\n cluster['kibana'].setdefault('url', cluster['es']['url'])\\n\\n # by default, exclude nothing!\\n cluster.setdefault('exclude', [])\\n cluster['exclude'] = set(cluster['exclude'])\\n\\n return data\",\n \"def create_new_config():\\n\\n print (\\\"\\\")\\n log_app.debug(\\\"create_new_config\\\")\\n log_app.debug(\\\"create_new_config / method : %s\\\", request.method )\\n\\n req_json = request.get_json()\\n log_app.debug(\\\"create_new_config / req_json : \\\\n%s\\\", pformat(req_json) )\\n\\n new_uuid = req_json['model_uuid']\\n new_admin_email = req_json['model_admin_email']\\n new_admin_name = req_json['model_admin_name']\\n new_admin_surname = req_json['model_admin_surname']\\n\\n new_endpoint_data = req_json.get('new_endpoint_data', None)\\n\\n ### target right config collection\\n allowedCollections = [\\\"global\\\" , \\\"footer\\\", \\\"navbar\\\", \\\"tabs\\\", \\\"endpoints\\\" , \\\"styles\\\" , \\\"routes\\\", \\\"socials\\\" ]\\n \\n if request.method == 'POST':\\n\\n log_app.debug(\\\"config app route / POST\\\" )\\n \\n ### check if model can be used\\n modelCheck = get_config_model(new_uuid, returnDict=True, noRemap=True)\\n log_app.debug(\\\"create_new_config / modelCheck : \\\\n%s\\\", pformat(modelCheck) )\\n\\n ### check if uuid is new and not already used\\n globalColl = mongoConfigColls['global']\\n usedUuids = globalColl.distinct('apiviz_front_uuid')\\n log_app.debug(\\\"create_new_config / usedUuids : \\\\n%s\\\", pformat(usedUuids) )\\n \\n modelIsUsed = new_uuid in usedUuids\\n # modelIsUsed = False ### only for debugging\\n log_app.debug(\\\"create_new_config / modelIsUsed : %s\\\", modelIsUsed )\\n\\n canUseModel = modelIsUsed == False and modelCheck != None \\n log_app.debug(\\\"create_new_config / canUseModel : %s\\\", canUseModel )\\n\\n ### start copying documents if allowed\\n if canUseModel : \\n\\n query = {'apiviz_front_uuid' : new_uuid}\\n \\n # loop collections and copy paste docs\\n for coll in allowedCollections : \\n \\n # get corresponding documents without _id\\n mongoColl = mongoConfigColls[coll]\\n results = list(mongoColl.find(query, { '_id' : 0 } ))\\n \\n # replace 'apiviz_front_uuid' field's value by new_uuid\\n # set 'is_default' field's value as False\\n for doc in results :\\n\\n log_app.debug(\\\"create_new_config / coll-doc['field'] : %s-%s\\\" %(coll,doc['field']) )\\n \\n doc['apiviz_front_uuid'] = new_uuid\\n doc['is_default'] = False\\n\\n # specific cases\\n if doc['field'] == 'app_title' : \\n doc['content'] = req_json['new_title']\\n\\n if doc['field'] == 'app_logo' : \\n doc['url'] = req_json['new_logoUrl']\\n\\n # save documents list back in collection\\n mongoColl.insert(results)\\n\\n print()\\n\\n msg = 'your new website is ready'\\n resp_code = 200\\n resp_msgCode = 'instane_created_1a'\\n \\n # create new default uuid_auth\\n new_uuid_auth_doc = uuid_auth_model.copy()\\n\\n new_uuid_auth_doc[\\\"apiviz_front_uuid\\\"] = new_uuid\\n new_uuid_auth_doc[\\\"apiviz_front_name\\\"] = req_json['new_title']\\n\\n new_uuid_auth_doc[\\\"date_added\\\"] = datetime.datetime.now()\\n new_uuid_auth_doc[\\\"added_by\\\"][\\\"name\\\"] = new_admin_name\\n new_uuid_auth_doc[\\\"added_by\\\"][\\\"surname\\\"] = new_admin_surname\\n new_uuid_auth_doc[\\\"added_by\\\"][\\\"email\\\"] = new_admin_email\\n\\n ### setting admin list\\n new_uuid_auth_doc[\\\"auth_role_users\\\"][\\\"admin_list\\\"] = [new_admin_email]\\n \\n uuidsAuthColl = mongoConfigColls['uuids_auth']\\n uuidsAuthColl.insert(new_uuid_auth_doc)\\n\\n\\n else : \\n msg = 'errors : '\\n if modelIsUsed :\\n msg += 'your current uuid is already used... '\\n resp_msgCode = 'uuid_is_current_1a'\\n if modelCheck == None : \\n msg += \\\"you can't use this model.. \\\"\\n resp_msgCode = 'instance_used_1a'\\n resp_code = 400\\n log_app.debug(\\\"create_new_config / msg : %s\\\", msg )\\n\\n return jsonify({\\n 'msg' : msg,\\n 'status' : resp_code,\\n 'msg_code' : resp_msgCode,\\n 'uuid' : new_uuid,\\n 'request' : req_json,\\n })\\n\\n\\n\\n\\n ### TO DO \\n elif request.method == 'DELETE' : \\n\\n log_app.debug(\\\"config app route / DELETE\\\" )\\n \\n return jsonify({\\n 'msg' : 'your apiviz instance has been deleted',\\n 'status' : 200,\\n 'msg_code' : 'instane_deleted_1a',\\n 'uuid' : new_uuid,\\n 'request' : req_json,\\n })\\n\\n\\n # not a POST nor a DELETE request\\n else : \\n return jsonify({\\n 'msg' : 'there was an error during the process (method not allowed)',\\n 'status' : 500,\\n 'msg_code' : 'error_1a',\\n 'uuid' : new_uuid,\\n 'request' : req_json,\\n }), 500\",\n \"def parse(self):\\n\\t\\tself.maincfg_values = self._load_static_file(self.cfg_file)\\n\\t\\t\\n\\t\\tself.cfg_files = self.get_cfg_files()\\n\\t\\t\\n\\t\\tself.resource_values = self.get_resources()\\n\\t\\t\\n\\t\\tself.timestamps = self.get_timestamps()\\n\\t\\t\\n\\t\\t## This loads everything into\\n\\t\\tfor cfg_file in self.cfg_files:\\n\\t\\t\\tself._load_file(cfg_file)\\n\\n\\t\\tself._post_parse()\",\n \"def main():\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\\n get_user_config()\",\n \"def set_up(self):\\n self.keywords = (\\\"DATES\\\", \\\"COMPDAT\\\", \\\"COMPDATL\\\")\\n self.parameters = (\\\"Date\\\", \\\"Well name\\\", \\\"Local grid name\\\", \\\"I\\\", \\\"J\\\", \\\"K upper\\\", \\\"K lower\\\", \\\"Flag on connection\\\",\\n \\\"Saturation table\\\", \\\"Transmissibility factor\\\", \\\"Well bore diameter\\\", \\\"Effective Kh\\\",\\n \\\"Skin factor\\\", \\\"D-factor\\\", \\\"Dir_well_penetrates_grid_block\\\", \\\"Press_eq_radius\\\")\\n\\n # TODO: с названиями стоит подумать\\n self.input_file_reference = \\\"data/test_schedule_input_reference.inc\\\"\\n self.output_csv_reference = \\\"data/schedule_output_reference.csv\\\"\\n\\n self.clean_file = \\\"data/handled_schedule.inc\\\"\\n self.output_csv = \\\"data/schedule_output.csv\\\"\\n\\n with open(self.clean_file, \\\"r\\\", encoding=\\\"utf-8\\\") as file:\\n self.clean_file_text = file.read()\\n\\n self.parse_list_output_reference = [\\n [np.nan, 'W1', np.nan, '10', '10', '1', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '1.0'],\\n [np.nan, 'W2', np.nan, '32', '10', '1', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '2.0'],\\n [np.nan, 'W3', np.nan, '5', '36', '2', '2', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '3.0'],\\n [np.nan, 'W4', np.nan, '40', '30', '1', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '4.0'],\\n [np.nan, 'W5', np.nan, '21', '21', '4', '4', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '5.0'],\\n ['01 JUN 2018', np.nan],\\n ['01 JUL 2018', 'W3', np.nan, '32', '10', '1', '1', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '1.0718'],\\n ['01 JUL 2018', 'W5', np.nan, '21', '21', '1', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '5.0'],\\n ['01 AUG 2018', np.nan],\\n ['01 SEP 2018', 'W1', np.nan, '10', '10', '2', '3', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '1.0918'],\\n ['01 SEP 2018', 'W2', np.nan, '32', '10', '1', '2', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '2.0'],\\n ['01 SEP 2018', 'W3', 'LGR1', '10', '10', '2', '2', 'OPEN', 'DEFAULT', '1', '2', '1', 'DEFAULT', 'DEFAULT', 'DEFAULT', '1.0918'],\\n ['01 OCT 2018', np.nan],\\n ['01 NOV 2018', np.nan],\\n ['01 DEC 2018', np.nan]]\",\n \"def preprocess_valid_data(self):\\r\\n print(\\\"* Preprocessing validation data.\\\", flush=True)\\r\\n prep.create_HDF_file(self.C.validation_set)\\r\\n\\r\\n self.print_time_elapsed()\",\n \"def __init__(self, cfg_index, conditions, pars_dir, step_title, use_defaults, input_cfg_json_data):\\n super().__init__(cfg_index, conditions, pars_dir, step_title, use_defaults, input_cfg_json_data)\\n if input_cfg_json_data:\\n self._read_custom_pars()\\n else:\\n self._combine_conditions()\\n\\n # Mike's new stuff\\n self.outpars = self._flatten_dict(self.outpars, '', {})\",\n \"def save_data(self):\\n # Validate\\n try:\\n self._data = self._schema(self._data)\\n except vol.Invalid as ex:\\n _LOGGER.error(\\\"Can't parse data: %s\\\",\\n humanize_error(self._data, ex))\\n\\n # Load last valid data\\n _LOGGER.warning(\\\"Reset %s to last version\\\", self._file)\\n self.read_data()\\n return\\n\\n # write\\n try:\\n write_json_file(self._file, self._data)\\n except (OSError, json.JSONDecodeError) as err:\\n _LOGGER.error(\\\"Can't store config in %s: %s\\\", self._file, err)\",\n \"def __build_empty_config(self):\\n\\n self.__config.add_section('IN_OUT')\\n self.__config['IN_OUT']['source'] = 'Set Source Directory'\\n self.__config['IN_OUT']['destination'] = 'Set Destination Directory'\\n self.__save_config()\\n\\n self.__is_dirty = False\\n self.__default = True\",\n \"def setUp(self):\\n with open(os.path.join(os.path.dirname(__file__), 'valid_resume.json')) as schema:\\n self.valid_resume = json.load(schema)\\n\\n with open(os.path.join(os.path.dirname(__file__), 'invalid_resume.json')) as schema:\\n self.invalid_resume = json.load(schema)\",\n \"def prepare(self):\\n bcolz.set_nthreads(2)\\n\\n # step 0: load only when not loaded yet\\n if TRAINING in self.data and VALIDATION in self.data: return\\n\\n # step 1: load the file names\\n patients = sorted(glob.glob(self.location+'/*.*/'))\\n print len(patients), \\\"patients\\\"\\n\\n # step 1: load the file names\\n # make a stratified validation set\\n # note, the seed decides the validation set, but it is deterministic in the names\\n random.seed(317070)\\n patient_names = [self.patient_name_from_file_name(f) for f in patients]\\n validation_patients = random.sample(patient_names, int(VALIDATION_SET_SIZE*len(patient_names)))\\n\\n labels_as_dict = defaultdict(list)\\n\\n with open(paths.LUNA_LABELS_PATH, 'rb') as csvfile:\\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\\n next(reader) # skip the header\\n for row in reader:\\n label = (float(row[1]), float(row[2]), float(row[3]), float(row[4]))\\n labels_as_dict[str(row[0])].append(label)\\n\\n # make the static data empty\\n for s in self.datasets:\\n self.data[s] = []\\n self.labels[s] = []\\n self.names[s] = []\\n self.spacings[s] = []\\n self.origins[s] = []\\n\\n with gzip.open(paths.INTERMEDIATE_DATA_PATH + 'spacings.pkl.gz') as f:\\n spacings = cPickle.load(f)\\n\\n with gzip.open(paths.INTERMEDIATE_DATA_PATH + 'origins.pkl.gz') as f:\\n origins = cPickle.load(f)\\n\\n # load the filenames and put into the right dataset\\n for i, patient_folder in enumerate(patients):\\n patient_id = str(patient_folder.split(path.sep)[-2])\\n if patient_id in validation_patients:\\n dataset = VALIDATION\\n else:\\n dataset = TRAIN\\n\\n\\n label = labels_as_dict[patient_id]\\n if self.only_positive and not label:\\n continue\\n\\n self.data[dataset].append(patient_folder)\\n self.labels[dataset].append(label)\\n self.names[dataset].append(patient_id)\\n self.spacings[dataset].append(spacings[patient_id])\\n self.origins[dataset].append(origins[patient_id])\\n\\n # give every patient a unique number\\n last_index = -1\\n for set in self.datasets:\\n self.indices[set] = range(last_index+1,last_index+1+len(self.data[set]))\\n if len(self.indices[set]) > 0:\\n last_index = self.indices[set][-1]\\n print set, len(self.indices[set]), \\\"samples\\\"\",\n \"def validate_parameters(self):\\n\\n # env and fixed_env\\n self._validate_envs()\\n # checking optional data and scripts\\n self._validate_download_data()\\n self.data_path = self.params[\\\"data\\\"][\\\"location\\\"]\\n self._validate_scripts()\\n # checking optional data_ref (if not data_ref provided, path is the same as data path)\\n if \\\"data_ref\\\" in self.params:\\n self._validate_download_data(data_nm=\\\"data_ref\\\")\\n# self.data_ref_path = self.params[\\\"data_ref\\\"][\\\"location\\\"]\\n# else:\\n# self.data_ref_path = self.data_path\\n # checking analysis\\n self._validate_analysis()\\n # checking tests\\n self._validate_tests()\\n\\n self.params.setdefault(\\\"post_build\\\", None)\\n # if copy in post_build part that I'm changing the build_context\\n if self.params[\\\"post_build\\\"] and \\\"copy\\\" in self.params[\\\"post_build\\\"]:\\n self.build_context = self.workflow_path\\n else:\\n self.build_context = self.working_dir\\n\\n self.params.setdefault(\\\"plots\\\", [])\\n if self.params[\\\"plots\\\"]:\\n if not isinstance(self.params[\\\"plots\\\"], (list, tuple)):\\n raise SpecificationError(\\n \\\"Value of key 'plots' must be a list or a tuple\\\"\\n )\\n else:\\n if any(not isinstance(j, dict) for j in self.params[\\\"plots\\\"]):\\n raise SpecificationError(\\n \\\"Every item in 'plots' must be a dictionary.\\\"\\n )\",\n \"def _init_config_(self):\\n self._config= {}\",\n \"def __init__(self, data):\\n\\n self.produce_csv = data['produce_csv']\\n self.produce_graphics = data['produce_graphics']\\n self.report_name = data['report_name']\\n self.file_name = self.report_name + '.csv'\\n self.annual_file_name = self.report_name + '_annual.csv'\\n self.csv_dir = ''\\n self.diagnostic_dir = ''\\n\\n self.daily_variables = {\\n 'year': ['time.cal_year', '', []],\\n 'j_day': ['time.day', '', []]\\n }\\n\\n self.annual_variables = {\\n 'year': ['time.cal_year', '', 0]\\n }\",\n \"def load_data(self):\\n super(MudderyObjectCreater, self).load_data()\\n \\n data = self.get_data_record()\\n if not data:\\n return\\n \\n # set common object's info\\n self.obj_list = {}\\n\\n for obj in data.obj_list.split(\\\",\\\"):\\n obj_key = \\\"\\\"\\n number = 0\\n arg = obj.split(\\\":\\\", 1)\\n if len(arg) == 1:\\n obj_key = arg[0]\\n number = 1\\n elif len(arg) >= 2:\\n obj_key = arg[0]\\n number = int(arg[1])\\n\\n self.obj_list[obj_key] = number\",\n \"def load_data_from_config(self):\\n\\n config_file_name = \\\"cicada/config/config.yaml\\\"\\n config_dict = None\\n self.labels = []\\n self.to_add_labels = []\\n if os.path.isfile(config_file_name):\\n with open(config_file_name, 'r') as stream:\\n config_dict = yaml.safe_load(stream)\\n print(f\\\"config_dict {config_dict}\\\")\\n if (config_dict is not None) and config_dict.get(\\\"dir_name\\\"):\\n self.load_data_from_dir(dir_name=config_dict[\\\"dir_name\\\"], method='clear')\",\n \"def extract_data(\\n self, config_data, pre_name=None, action=None, post_name=None, local=False):\\n val =[]\\n if os.path.isfile(config_data):\\n data = open(config_data, 'r')\\n config_data = yaml.load(data)\\n elif isinstance(config_data, str):\\n config_data = yaml.load(config_data)\\n else:\\n self.logger.info(\\n colorama.Fore.RED +\\n \\\"Incorrect config file or data, please chk !!!!\\\", extra=self.log_detail)\\n exit(1)\\n try:\\n host = config_data.get('hosts')[0]\\n except Exception as ex:\\n self.logger.error(\\n colorama.Fore.RED +\\n \\\"ERROR!! config file %s is not present\\\" %\\n ex,\\n extra=self.log_detail)\\n raise Exception(\\\"config file is not present \\\", ex)\\n else:\\n self.args.local = local\\n if config_data.__contains__(\\n 'sqlite') and config_data['sqlite'] and config_data['sqlite'][0]:\\n self.chk_database(\\n config_data,\\n pre_name,\\n post_name,\\n None,\\n None,\\n action)\\n if host.__contains__('include') or len(config_data.get('hosts'))>1:\\n res_obj = self.multiple_device_details(\\n config_data.get('hosts'),\\n config_data,\\n pre_name,\\n action,\\n post_name)\\n return res_obj\\n else:\\n hostname = host.get('device')\\n self.log_detail = {'hostname': hostname}\\n username = host.get('username')\\n password = host.get('passwd')\\n key_value = host\\n key_value= self.get_values(key_value)\\n #pre_name = hostname + '_' + pre_name if not os.path.isfile(pre_name) else pre_name\\n # if action is \\\"check\\\":\\n # post_name= hostname + '_' + post_name if not os.path.isfile(post_name) else post_name\\n val.append(self.connect(\\n hostname,\\n username,\\n password,\\n pre_name,\\n config_data,\\n action,\\n post_name,\\n **key_value))\\n return val\",\n \"def generate_data(self):\\n\\n # cfg.d_sour_num = 20 # number of source domains\\n self.d_sour_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_sour_num)]\\n self.d_sour_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_sour_num)]\\n # cfg.d_targ_num = 1 # number of target domain\\n self.d_targ_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_targ_num)]\\n self.d_targ_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_targ_num)]\\n\\n\\n # cfg.train_num = 100 # number of training point in each domain\\n self.train_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.train_num)], dtype=np.float32).reshape(-1,1)\\n self.train_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.train_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.train_num, 1)\\n\\n # cfg.val_num = 100\\n self.val_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.val_num)], dtype=np.float32).reshape(-1,1)\\n self.val_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.val_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.val_num, 1)\\n\\n # cfg.support_num = 10\\n self.support_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.support_num)], dtype=np.float32).reshape(-1,1)\\n self.support_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.support_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.support_num, 1)\\n\\n # cfg.test_num = 100\\n self.test_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\\n self.test_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.test_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.test_num, 1)\\n\\n self.test_x_old = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\\n self.test_y_old = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.test_x_old] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.test_num, 1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66749805","0.65164816","0.64016116","0.64016116","0.6307988","0.62377954","0.6136363","0.61220586","0.6081083","0.6076208","0.6051987","0.6048227","0.60396284","0.6021695","0.59975976","0.59783435","0.5976575","0.5976575","0.5946913","0.59431374","0.59334093","0.59176385","0.5914759","0.5899314","0.5875119","0.5875059","0.5869698","0.5822585","0.58207583","0.58188397","0.58023065","0.579884","0.57870674","0.57791716","0.57558113","0.5748749","0.574635","0.574113","0.57395077","0.57169044","0.57109755","0.5706606","0.56915176","0.56900537","0.5682866","0.5674794","0.5674276","0.5671537","0.5665083","0.565667","0.56530714","0.56501263","0.56474894","0.56386864","0.5630263","0.5630075","0.5622158","0.5620699","0.561522","0.5592562","0.5587134","0.55810314","0.557539","0.55752116","0.5568622","0.5568181","0.554969","0.55482477","0.55482125","0.5538191","0.55256987","0.552155","0.5517494","0.55165327","0.5511439","0.5503172","0.54998446","0.5495312","0.5495197","0.54883343","0.54781973","0.54762316","0.5461833","0.54605114","0.5454768","0.54500204","0.544807","0.5447067","0.544459","0.54418284","0.5433252","0.54298824","0.54260355","0.5420952","0.54089093","0.5403547","0.54034156","0.540124","0.53979343","0.5397801"],"string":"[\n \"0.66749805\",\n \"0.65164816\",\n \"0.64016116\",\n \"0.64016116\",\n \"0.6307988\",\n \"0.62377954\",\n \"0.6136363\",\n \"0.61220586\",\n \"0.6081083\",\n \"0.6076208\",\n \"0.6051987\",\n \"0.6048227\",\n \"0.60396284\",\n \"0.6021695\",\n \"0.59975976\",\n \"0.59783435\",\n \"0.5976575\",\n \"0.5976575\",\n \"0.5946913\",\n \"0.59431374\",\n \"0.59334093\",\n \"0.59176385\",\n \"0.5914759\",\n \"0.5899314\",\n \"0.5875119\",\n \"0.5875059\",\n \"0.5869698\",\n \"0.5822585\",\n \"0.58207583\",\n \"0.58188397\",\n \"0.58023065\",\n \"0.579884\",\n \"0.57870674\",\n \"0.57791716\",\n \"0.57558113\",\n \"0.5748749\",\n \"0.574635\",\n \"0.574113\",\n \"0.57395077\",\n \"0.57169044\",\n \"0.57109755\",\n \"0.5706606\",\n \"0.56915176\",\n \"0.56900537\",\n \"0.5682866\",\n \"0.5674794\",\n \"0.5674276\",\n \"0.5671537\",\n \"0.5665083\",\n \"0.565667\",\n \"0.56530714\",\n \"0.56501263\",\n \"0.56474894\",\n \"0.56386864\",\n \"0.5630263\",\n \"0.5630075\",\n \"0.5622158\",\n \"0.5620699\",\n \"0.561522\",\n \"0.5592562\",\n \"0.5587134\",\n \"0.55810314\",\n \"0.557539\",\n \"0.55752116\",\n \"0.5568622\",\n \"0.5568181\",\n \"0.554969\",\n \"0.55482477\",\n \"0.55482125\",\n \"0.5538191\",\n \"0.55256987\",\n \"0.552155\",\n \"0.5517494\",\n \"0.55165327\",\n \"0.5511439\",\n \"0.5503172\",\n \"0.54998446\",\n \"0.5495312\",\n \"0.5495197\",\n \"0.54883343\",\n \"0.54781973\",\n \"0.54762316\",\n \"0.5461833\",\n \"0.54605114\",\n \"0.5454768\",\n \"0.54500204\",\n \"0.544807\",\n \"0.5447067\",\n \"0.544459\",\n \"0.54418284\",\n \"0.5433252\",\n \"0.54298824\",\n \"0.54260355\",\n \"0.5420952\",\n \"0.54089093\",\n \"0.5403547\",\n \"0.54034156\",\n \"0.540124\",\n \"0.53979343\",\n \"0.5397801\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64124906"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":25594,"cells":{"query":{"kind":"string","value":"r\"\"\"align(imgDim, rgbImg, bb=None, landmarks=None, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP) Transform and align a face in an image."},"document":{"kind":"string","value":"def align(imgDim, rgbImg,\n landmarks, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP,\n skipMulti=True):\n assert imgDim is not None\n assert rgbImg is not None\n assert landmarks is not None\n\n #if bb is None:\n # bb = self.getLargestFaceBoundingBox(rgbImg, skipMulti)\n # if bb is None:\n # return\n\n #if landmarks is None:\n # landmarks = self.findLandmarks(rgbImg, bb)\n\n npLandmarks = np.float32(landmarks)\n npLandmarkIndices = np.array(landmarkIndices)\n\n H = cv2.getAffineTransform(npLandmarks[npLandmarkIndices],\n imgDim * MINMAX_TEMPLATE[npLandmarkIndices])\n thumbnail = cv2.warpAffine(rgbImg, H, (imgDim, imgDim))\n\n return thumbnail"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def align(self, image, landmark_indices, anchor_points, size=96):\n # Detect face in image and find landmarks\n box = self.detect(image)\n landmarks = self.find_landmarks(image, box)\n\n # Select three points in the landmarks(Eyes and nose)\n points_in_image = landmarks[landmark_indices]\n points_in_image = points_in_image.astype('float32')\n # Generate the normalized output size\n output_size = anchor_points * size\n\n # Calculates the 2 \\times 3 matrix of an affine transform\n affine_transf = cv2.getAffineTransform(points_in_image, output_size)\n\n # Transforms the source image using the specified matrix\n transformed_img = cv2.warpAffine(image, affine_transf, (size, size))\n\n return transformed_img","def align_face(np_img, mask=True):\n # Prepare extraction\n current_dir = os.getcwd()\n os.chdir(OPEN_FACE_BINARY_PATH)\n timestamp = datetime.now().timestamp()\n mask_param = '-nomask' if mask is False else ''\n\n # Align and mask face using OpenFace\n np_img *= 255\n np_img = np_img.astype(np.uint8)\n imsave('{}.jpg'.format(timestamp), np_img)\n exit_code = os.system(\n './FaceLandmarkImg -f {}.jpg -wild -simalign -simsize 192 {} -format_aligned jpg >/dev/null'.format(timestamp,\n mask_param))\n aligned_img = imread('processed/{}_aligned/face_det_000000.jpg'.format(timestamp))\n aligned_img = aligned_img / 255.\n\n # Delete temporary files created during face alignment\n exit_code = os.system('rm -r {}.jpg >/dev/null'.format(timestamp))\n exit_code = os.system('rm -r processed/{}* >/dev/null'.format(timestamp))\n\n os.chdir(current_dir)\n\n return aligned_img","def align(self, image, landmark_indices, anchor_points, size=96):\n\n detected = self.detect(image)\n coords = self.find_landmarks(image, detected)\n in_points = coords[landmark_indices]\n in_points = in_points.astype('float32')\n out_points = anchor_points * size\n warp_mat = cv2.getAffineTransform(in_points, out_points)\n warp_dst = cv2.warpAffine(image, warp_mat, (size, size))\n\n return warp_dst","def imalign(src_file, dst_file, face_landmarks, output_size=1024, transform_size=1024, enable_padding=True, x_scale=1, y_scale=1, em_scale=0.1, alpha=False):\n lm = np.array(face_landmarks)\n lm_chin = lm[0 : 17] # left-right\n lm_eyebrow_left = lm[17 : 22] # left-right\n lm_eyebrow_right = lm[22 : 27] # left-right\n lm_nose = lm[27 : 31] # top-down\n lm_nostrils = lm[31 : 36] # top-down\n lm_eye_left = lm[36 : 42] # left-clockwise\n lm_eye_right = lm[42 : 48] # left-clockwise\n lm_mouth_outer = lm[48 : 60] # left-clockwise\n lm_mouth_inner = lm[60 : 68] # left-clockwise\n\n # Calculate auxiliary vectors.\n eye_left = np.mean(lm_eye_left, axis=0)\n eye_right = np.mean(lm_eye_right, axis=0)\n eye_avg = (eye_left + eye_right) * 0.5\n eye_to_eye = eye_right - eye_left\n mouth_left = lm_mouth_outer[0]\n mouth_right = lm_mouth_outer[6]\n mouth_avg = (mouth_left + mouth_right) * 0.5\n eye_to_mouth = mouth_avg - eye_avg\n\n # Choose oriented crop rectangle.\n x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]\n x /= np.hypot(*x)\n x *= max(np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8)\n x *= x_scale\n y = np.flipud(x) * [-y_scale, y_scale]\n c = eye_avg + eye_to_mouth * em_scale\n quad = np.stack([c - x - y, c - x + y, c + x + y, c + x - y])\n qsize = np.hypot(*x) * 2\n\n # Load in-the-wild image.\n if not os.path.isfile(src_file):\n print('\\nCannot find source image. Please run \"--wilds\" before \"--align\".')\n return\n img = Image.open(src_file)\n\n # Shrink.\n shrink = int(np.floor(qsize / output_size * 0.5))\n if shrink > 1:\n rsize = (int(np.rint(float(img.size[0]) / shrink)), int(np.rint(float(img.size[1]) / shrink)))\n img = img.resize(rsize, Image.ANTIALIAS)\n quad /= shrink\n qsize /= shrink\n\n # Crop.\n border = max(int(np.rint(qsize * 0.1)), 3)\n crop = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))\n crop = (max(crop[0] - border, 0), max(crop[1] - border, 0), min(crop[2] + border, img.size[0]), min(crop[3] + border, img.size[1]))\n if crop[2] - crop[0] < img.size[0] or crop[3] - crop[1] < img.size[1]:\n img = img.crop(crop)\n quad -= crop[0:2]\n\n # Pad.\n pad = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))\n pad = (max(-pad[0] + border, 0), max(-pad[1] + border, 0), max(pad[2] - img.size[0] + border, 0), max(pad[3] - img.size[1] + border, 0))\n if enable_padding and max(pad) > border - 4:\n pad = np.maximum(pad, int(np.rint(qsize * 0.3)))\n img = np.pad(np.float32(img), ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), 'reflect')\n h, w, _ = img.shape\n y, x, _ = np.ogrid[:h, :w, :1]\n mask = np.maximum(1.0 - np.minimum(np.float32(x) / pad[0], np.float32(w-1-x) / pad[2]), 1.0 - np.minimum(np.float32(y) / pad[1], np.float32(h-1-y) / pad[3]))\n blur = qsize * 0.02\n img += (ndimage.gaussian_filter(img, [blur, blur, 0]) - img) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0)\n img += (np.median(img, axis=(0,1)) - img) * np.clip(mask, 0.0, 1.0)\n img = np.uint8(np.clip(np.rint(img), 0, 255))\n if alpha:\n mask = 1-np.clip(3.0 * mask, 0.0, 1.0)\n mask = np.uint8(np.clip(np.rint(mask*255), 0, 255))\n img = np.concatenate((img, mask), axis=2)\n img = Image.fromarray(img, 'RGBA')\n else:\n img = Image.fromarray(img, 'RGB')\n quad += pad[:2]\n\n # Transform.\n img = img.transform((transform_size, transform_size), Image.QUAD, (quad + 0.5).flatten(), Image.BILINEAR)\n print(transform_size)\n if output_size < transform_size:\n img = img.resize((output_size, output_size), Image.ANTIALIAS)\n\n # Save aligned image.\n img.save(dst_file, 'PNG')","def align_preprocessed(self, img):\n aligner = FaceAligner(self.args.wing_path, self.args.lm_path, self.args.img_size)\n return aligner.align(img)","def preprocess(img, bbox=None, landmark=None, **kwargs):\n M = None\n image_size = []\n str_image_size = kwargs.get('image_size', '')\n # Assert input image shape\n if len(str_image_size)>0:\n image_size = [int(x) for x in str_image_size.split(',')]\n if len(image_size)==1:\n image_size = [image_size[0], image_size[0]]\n assert len(image_size)==2\n assert image_size[0]==112\n assert image_size[0]==112 or image_size[1]==96\n # Do alignment using landmnark points\n if landmark is not None:\n assert len(image_size)==2\n src = np.array([\n [30.2946, 51.6963],\n [65.5318, 51.5014],\n [48.0252, 71.7366],\n [33.5493, 92.3655],\n [62.7299, 92.2041] ], dtype=np.float32 )\n if image_size[1]==112:\n src[:,0] += 8.0\n dst = landmark.astype(np.float32)\n\n tform = trans.SimilarityTransform()\n tform.estimate(dst, src)\n M = tform.params[0:2,:]\n\n # If no landmark points available, do alignment using bounding box. If no bounding box available use center crop\n if M is None:\n if bbox is None: #use center crop\n det = np.zeros(4, dtype=np.int32)\n det[0] = int(img.shape[1]*0.0625)\n det[1] = int(img.shape[0]*0.0625)\n det[2] = img.shape[1] - det[0]\n det[3] = img.shape[0] - det[1]\n else:\n det = bbox\n margin = kwargs.get('margin', 44)\n bb = np.zeros(4, dtype=np.int32)\n bb[0] = np.maximum(det[0]-margin/2, 0)\n bb[1] = np.maximum(det[1]-margin/2, 0)\n bb[2] = np.minimum(det[2]+margin/2, img.shape[1])\n bb[3] = np.minimum(det[3]+margin/2, img.shape[0])\n ret = img[bb[1]:bb[3],bb[0]:bb[2],:]\n if len(image_size)>0:\n ret = cv2.resize(ret, (image_size[1], image_size[0]))\n return ret\n else: #do align using landmark\n assert len(image_size)==2\n\n # warped = cv2.warpAffine(img,M,(image_size[1],image_size[0]), borderValue = 0.0)\n warped = cv2.warpAffine(img,M,(image_size[1],image_size[0]), borderValue = 0.0)\n\n return warped","def align_crop(img, landmarks, standard_landmarks, crop_size=572, face_factor=0.45, align_type='similarity', order=3,\r\n mode='edge'):\r\n interpolation = {0: cv2.INTER_NEAREST,\r\n 1: cv2.INTER_LINEAR,\r\n 2: cv2.INTER_AREA,\r\n 3: cv2.INTER_CUBIC,\r\n 4: cv2.INTER_LANCZOS4,\r\n 5: cv2.INTER_LANCZOS4}\r\n border = {'constant': cv2.BORDER_CONSTANT,\r\n 'edge': cv2.BORDER_REPLICATE,\r\n 'symmetric': cv2.BORDER_REFLECT,\r\n 'reflect': cv2.BORDER_REFLECT101,\r\n 'wrap': cv2.BORDER_WRAP}\r\n\r\n # check\r\n assert align_type in ['affine', 'similarity'], \\\r\n \" [!] Invalid 'align_type'! The {} is not included in ['affine' and 'similarity']!\".format(align_type)\r\n assert order in [0, 1, 2, 3, 4, 5], \\\r\n \" [!] Invalid 'order'! The {} is not included in [0, 1, 2, 3, 4, 5]!\".format(order)\r\n assert mode in ['constant', 'edge', 'symmetric', 'reflect', 'wrap'], \\\r\n \" [!] Invalid 'mode'! the {} is not included in ['constant', 'edge', 'symmetric', 'reflect', and 'wrap']\".format(mode)\r\n\r\n # crop size\r\n if isinstance(crop_size, (list, tuple)) and len(crop_size) == 2:\r\n crop_size_h = crop_size[0]\r\n crop_size_w = crop_size[1]\r\n elif isinstance(crop_size, int):\r\n crop_size_h = crop_size_w = crop_size\r\n else:\r\n raise Exception(\" [!] Invalid 'crop_size'! The 'crop_size' should be (1) one integer for (crop_size, crop_size) ar (2) (int, int) for (crop_size_h, crop_size_w)!\")\r\n\r\n # estimate transform matrix\r\n target_landmarks = standard_landmarks * max(crop_size_h, crop_size_w) * face_factor + np.array([crop_size_w // 2, crop_size_h // 2])\r\n if align_type == 'affine': # 6 degree of freedom\r\n transform_matrix, _ = cv2.estimateAffine2D(target_landmarks, landmarks, ransacReprojThreshold=np.Inf)\r\n else: # 4 degree of freedom: using the combinations of translation, rotation, and uniform scaling\r\n transform_matrix, _ = cv2.estimateAffinePartial2D(target_landmarks, landmarks, ransacReprojThreshold=np.Inf)\r\n\r\n # warp image by given transform\r\n img_crop = cv2.warpAffine(img, transform_matrix, dsize=(crop_size_w, crop_size_h),\r\n flags=cv2.WARP_INVERSE_MAP + interpolation[order], borderMode=border[mode])\r\n\r\n # get transformed landmarks\r\n transformed_landmarks = cv2.transform(np.expand_dims(landmarks, axis=0), m=cv2.invertAffineTransform(transform_matrix))\r\n\r\n return img_crop, transformed_landmarks","def align(img, landmarks, d_size=(400, 400), normalized=False, show=False):\n assert len(landmarks) == 10\n assert isinstance(img, np.ndarray)\n landmarks = np.array(landmarks).reshape(5, 2)\n dw, dh = d_size\n\n keypoints = landmarks.copy().astype(np.float64)\n if normalized:\n keypoints[:, 0] *= img.shape[1]\n keypoints[:, 1] *= img.shape[0]\n\n keypoints_ref = np.zeros((5, 2), dtype=np.float64)\n keypoints_ref[:, 0] = FivePointsAligner.ref_landmarks[:, 0] * dw\n keypoints_ref[:, 1] = FivePointsAligner.ref_landmarks[:, 1] * dh\n\n transform_matrix = transformation_from_points(keypoints_ref, keypoints)\n output_im = cv.warpAffine(img, transform_matrix, d_size, flags=cv.WARP_INVERSE_MAP)\n\n if show:\n tmp_output = output_im.copy()\n for point in keypoints_ref:\n cv.circle(tmp_output, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\n for point in keypoints:\n cv.circle(img, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\n img = cv.resize(img, d_size)\n cv.imshow('source/warped', np.hstack((img, tmp_output)))\n cv.waitKey()\n\n return output_im","def align_and_extract_face(self, image, landmarks, output_size=(150,150), desired_left_eye_relative_position=(0.55, 0.55)):\n\n # get the key landmark features\n lp, eye_center, facebox = landmarks['left-eye-center-pos'], landmarks['eye-center-pos'], landmarks['face-box']\n\n # calculating the center box for face box, this will also be the center for the output_box\n face_box_center = calc_box_center(facebox)\n\n # calculate the output box using the box center\n output_box = (face_box_center[0] - output_size[0] / 2, face_box_center[1] - output_size[1]/2, output_size[0], output_size[1])\n\n # left eye's absolute position relative to facebox\n current_left_eye_absolute_x_position = lp[0] - facebox[0]\n\n # desired left eye's absolute position relative to output box\n desired_left_eye_absolute_x_position = output_box[2] * desired_left_eye_relative_position[0]\n\n # scale needed would be the ratio between desired and current\n scale = desired_left_eye_absolute_x_position / current_left_eye_absolute_x_position\n\n # calculate alignment angle\n angle = self.determine_rotation_angle(landmarks)\n\n # rotation origin will be the eye_center\n rotation_origin = eye_center\n\n # calculate the rotation matrix\n rotation_matrix = self.determine_rotation_matrix(rotation_origin, angle, scale)\n\n # calculate the new bounding box needed to bound/contain the rotated image\n aligned_box = self.determine_bounding_box_of_rotated_box(calc_img_box(image), rotation_matrix)\n (aligned_x, aligned_y, aligned_w, aligned_h) = aligned_box\n # update the translation to fit the rotated image to the bounding box\n rotation_matrix[0, 2] -= aligned_x\n rotation_matrix[1, 2] -= aligned_y\n\n # perform the transformation\n warped_image = cv2.warpAffine(image, rotation_matrix, (aligned_w, aligned_h), flags=cv2.INTER_CUBIC)\n\n # calculate new box positions\n new_face_box_center = calc_rotate_point_with_rotation_matrix(face_box_center, rotation_matrix)\n new_output_box = [\n int(new_face_box_center[0] - output_size[0] / 2),\n int(new_face_box_center[1] - output_size[1]/2),\n output_size[0], output_size[1]\n ]\n\n # calculate new left eye position\n new_lp = calc_rotate_point_with_rotation_matrix(lp, rotation_matrix)\n\n # calculate how far we are from the ideal y position for the left eye\n desired_left_eye_absolute_y_position = new_output_box[1] + int(new_output_box[3] * desired_left_eye_relative_position[1])\n distance = new_lp[1] - desired_left_eye_absolute_y_position\n\n # shift the y position such that the output box is in the desired y position\n new_output_box[1] += distance\n\n # it's possible output boxes's position will extend beyond current image space, pad the current image space such that they'll be enough space for the output box\n\n # figure out the padding\n x_left_pad = abs(min(0, new_output_box[0]))\n x_right_pad = abs(min(0, warped_image.shape[1] - (new_output_box[0] + new_output_box[2])))\n y_top_pad = abs(min(0, new_output_box[1]))\n y_bottom_pad = abs(min(0, warped_image.shape[0] - (new_output_box[1] + new_output_box[3])))\n\n # some amount of padding exists, create an image with enough padding space\n if x_left_pad + x_right_pad + y_top_pad + y_bottom_pad != 0:\n # create a new image with the padded distance\n new_shape = (warped_image.shape[0] + y_top_pad + y_bottom_pad, warped_image.shape[1] + x_left_pad + x_right_pad, 3)\n padded_image = np.zeros(new_shape)\n\n # copy contents of warped image into padded image\n padded_image[y_top_pad:y_top_pad + warped_image.shape[0], x_left_pad:x_left_pad + warped_image.shape[1]] = warped_image\n\n # set the warped image to the padded image\n warped_image = padded_image\n\n # now \"tare\" the coordinates of the output box so that it fits in side the padded image\n new_output_box[0] += x_left_pad\n new_output_box[1] += y_top_pad\n\n # crop the output box out of the warped image\n cropped_image = warped_image[new_output_box[1]:new_output_box[1]+new_output_box[3], new_output_box[0]:new_output_box[0]+new_output_box[2]]\n\n # return the cropped image\n return cropped_image","def rotate(img, bbox, landmark, alpha):\r\n center = (bbox.x+bbox.w/2, bbox.y+bbox.h/2)\r\n rot_mat = cv2.getRotationMatrix2D(center, alpha, 1)\r\n img_rotated_by_alpha = cv2.warpAffine(img, rot_mat, img.shape)\r\n landmark_ = np.asarray([(rot_mat[0][0]*x+rot_mat[0][1]*y+rot_mat[0][2],\r\n rot_mat[1][0]*x+rot_mat[1][1]*y+rot_mat[1][2]) for (x, y) in landmark])\r\n face = img_rotated_by_alpha[bbox.y:bbox.y+bbox.h,bbox.x:bbox.x+bbox.w]\r\n return (face, landmark_)","def align_crop_opencv(img,\n src_landmarks,\n standard_landmarks,\n celeba_standard_landmark,\n src_celeba_landmark,\n crop_size=512,\n face_factor=0.8,\n align_type='similarity',\n order=3,\n mode='edge'):\n # set OpenCV\n\n #img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n\n inter = {0: cv2.INTER_NEAREST, 1: cv2.INTER_LINEAR, 2: cv2.INTER_AREA,\n 3: cv2.INTER_CUBIC, 4: cv2.INTER_LANCZOS4, 5: cv2.INTER_LANCZOS4}\n border = {'constant': cv2.BORDER_CONSTANT, 'edge': cv2.BORDER_REPLICATE,\n 'symmetric': cv2.BORDER_REFLECT, 'reflect': cv2.BORDER_REFLECT101,\n 'wrap': cv2.BORDER_WRAP}\n\n # check\n assert align_type in ['affine', 'similarity'], 'Invalid `align_type`! Allowed: %s!' % ['affine', 'similarity']\n assert order in [0, 1, 2, 3, 4, 5], 'Invalid `order`! Allowed: %s!' % [0, 1, 2, 3, 4, 5]\n assert mode in ['constant', 'edge', 'symmetric', 'reflect', 'wrap'], 'Invalid `mode`! Allowed: %s!' % ['constant',\n 'edge',\n 'symmetric',\n 'reflect',\n 'wrap']\n # crop size\n if isinstance(crop_size, (list, tuple)) and len(crop_size) == 2:\n crop_size_h = crop_size[0]\n crop_size_w = crop_size[1]\n elif isinstance(crop_size, int):\n crop_size_h = crop_size_w = crop_size\n else:\n raise Exception(\n 'Invalid `crop_size`! `crop_size` should be 1. int for (crop_size, crop_size) or 2. (int, int) for (crop_size_h, crop_size_w)!')\n\n # estimate transform matrix\n trg_landmarks = standard_landmarks * max(crop_size_h, crop_size_w) * face_factor + np.array(\n [crop_size_w // 2, crop_size_h // 2])\n\n if align_type == 'affine':\n tform = cv2.estimateAffine2D(trg_landmarks, src_landmarks, ransacReprojThreshold=np.Inf)[0]\n else:\n tform = cv2.estimateAffinePartial2D(trg_landmarks, src_landmarks, ransacReprojThreshold=np.Inf)[0] #tform{2,3}\n\n # calcaute the scale of tform\n m1 = np.mat('0;0;1')\n m2 = np.mat('1;0;1')\n p1 = tform.dot(m1)\n p2 = tform.dot(m2)\n scale = LA.norm(p2 - p1) # defualt is Frobenius norm\n # change the translations part of the transformation matrix for downwarding vertically\n tform[1][2] = tform[1][2] + 20 * scale\n output_shape = (crop_size_h, crop_size_w)\n img_crop = cv2.warpAffine(img, tform, output_shape[::-1], flags=cv2.WARP_INVERSE_MAP + inter[order],\n borderMode=border[mode])\n\n tformed_landmarks = cv2.transform(np.expand_dims(src_landmarks, axis=0), cv2.invertAffineTransform(tform))[0]\n tformed_celeba_landmarks = cv2.transform(np.expand_dims(src_celeba_landmark, axis=0), cv2.invertAffineTransform(tform))[0]\n return img_crop, tformed_landmarks, tformed_celeba_landmarks","def augment_image(im):\n # First crop out the face to save reduce computation load\n bb = im.landmarks['bb'].lms\n bb_vec = bb.as_vector()\n bb_ul = (np.array([bb_vec[0], bb_vec[1]]) - bb.centre()) * 2\n bb_lr = (np.array([bb_vec[4], bb_vec[5]]) - bb.centre()) * 2\n ul = bb_ul + bb.centre()\n lr = bb_lr + bb.centre()\n im = im.crop(ul, lr, constrain_to_boundary=True)\n if im.pixels.shape[0] == 1:\n pix = np.zeros((3, im.pixels.shape[1], im.pixels.shape[2]))\n pix[:,] = im.pixels\n im.pixels = pix\n\n beta = 0.3\n cx = np.random.uniform(-beta, beta)\n cy = np.random.uniform(-beta, beta)\n fx = 1.0\n fy = np.random.uniform(0.6, 1.4)\n max_rotation = 30\n theta = np.random.uniform(-max_rotation, max_rotation)\n\n rotation = menpo.transform.Rotation.init_from_2d_ccw_angle(theta)\n shear = menpo.transform.Affine(np.array([[1, cx, 0],[cy, 1, 0], [0,0,1]]))\n scale = menpo.transform.Affine(np.array([[fx, 0, 0],[0, fy, 0], [0,0,1]]))\n T = scale.compose_after(shear).compose_after(rotation)\n\n t_im = im.transform_about_centre(T)\n\n t_im = add_color_jetting(t_im)\n t_im = add_occlusion(t_im)\n\n\n new_bb = t_im.landmarks['PTS'].lms.bounding_box()\n\n #new_bb contains the gt bounding box\n augmented_bb = add_bb_noise(new_bb)\n augmented_bb = augmented_bb.reshape((4,2))\n augmented_bb = menpo.shape.PointCloud(augmented_bb)\n t_im.landmarks['bb'] = menpo.landmark.LandmarkGroup.init_with_all_label(augmented_bb)\n\n return t_im","def prepocessImg(self, method, size, img, bb,offset=0.3,gray=True,\n boundry=False, outputDebug=False,outputprefix=None):\n if method == 'crop':\n crop_img = crop_only(img,bb.left(),bb.top(),bb.width(),bb.height(),offset,size)\n elif method == 'affine':\n img = Image.fromarray(img)\n if self.predictor == None:\n raise Exception(\"Error: method affine should initial with an facepredictor.\")\n alignPoints = self.align(img, bb)\n (xs, ys) = zip(*alignPoints)\n (l, r, t, b) = (min(xs), max(xs), min(ys), max(ys))\n w,h = img.size\n if boundry and (l < 0 or r > w or t < 0 or b > h):\n raise AliError('face out of boundry')\n \n left_eye_l = alignPoints[36]\n left_eye_r = alignPoints[39]\n left_eye = (np.array(left_eye_l)+np.array(left_eye_r))/2\n right_eye_l = alignPoints[42]\n right_eye_r = alignPoints[45]\n right_eye = (np.array(right_eye_l)+np.array(right_eye_r))/2\n crop_img = crop_simi(img,left_eye,right_eye,(offset,offset),(size,size))\n im_buffer = cStringIO.StringIO()\n crop_img.save(im_buffer, format=\"JPEG\")\n im_str = base64.b64encode(im_buffer.getvalue())\n else:\n raise Exception(\"undefined crop method\")\n if gray:\n crop_img = crop_img.convert('L')\n if outputDebug:\n dirname = './aligndebug'\n if not os.path.exists(os.path.abspath(dirname)):\n os.mkdir(dirname)\n drawbox(img,(bb.left(),bb.right(),bb.top(),bb.bottom()))\n if method == 'affine':\n drawpoint(img,left_eye)\n drawpoint(img,right_eye)\n img.save('{}/{}_annotated.jpg'.format(dirname,outputprefix))\n crop_img.save('{}/{}_crop.jpg'.format(dirname,outputprefix))\n crop_img = np.array(crop_img,dtype=np.float32) #look carefully on data format\n if crop_img.ndim == 3: #data shape for caffe\n return crop_img,score\n elif crop_img.ndim == 2:\n bbox = [bb.left(),bb.top(),bb.right(),bb.bottom()]\n return crop_img[:,:,np.newaxis], bbox\n else:\n raise Exception(\"wrong dimension\")","def alignment(src_img, src_pts, output_size=(96, 112)):\n ref_pts = [\n [30.2946, 51.6963],\n [65.5318, 51.5014],\n [48.0252, 71.7366],\n [33.5493, 92.3655],\n [62.7299, 92.2041],\n ]\n src_pts = np.array(src_pts).reshape(5, 2)\n s = np.array(src_pts).astype(np.float32)\n r = np.array(ref_pts).astype(np.float32)\n tfm = get_similarity_transform_for_cv2(s, r)\n face_img = cv2.warpAffine(src_img, tfm, output_size)\n return face_img","def align(img, left_eye, right_eye):\n left_eye_x, left_eye_y = left_eye\n right_eye_x, right_eye_y = right_eye\n point_3rd, direction = (left_eye, -1) if left_eye_y > right_eye_y else (right_eye, 1)\n\n # np.linalg.norm is being used for euclidean distance\n a = np.linalg.norm(np.array(left_eye) - np.array(point_3rd))\n b = np.linalg.norm(np.array(right_eye) - np.array(point_3rd))\n c = np.linalg.norm(np.array(right_eye) - np.array(left_eye))\n\n if b != 0 and c != 0:\n angle = np.arccos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))\n angle = (angle * 180) / math.pi\n if direction == -1:\n angle = 90 - angle\n img = Image.fromarray(img)\n img = np.array(img.rotate(direction * angle))\n\n return img","def draw_annotations(self, image, results):\n image.flags.writeable = True\n image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n for face_landmarks in results.multi_face_landmarks:\n # draw face landmark net\n mp_drawing.draw_landmarks(\n image=image,\n landmark_list=face_landmarks,\n connections=mp_face_mesh.FACE_CONNECTIONS,\n landmark_drawing_spec=self.drawing_spec,\n connection_drawing_spec=self.drawing_spec)\n cv2.imshow('MediaPipe FaceMesh', image)","def _calibrate_landmarks(self, bboxes, landmarks, align=False):\n\n x1, y1, x2, y2 = [bboxes[:, i] for i in range(4)]\n w = x2 - x1 + 1.0\n h = y2 - y1 + 1.0\n w = torch.unsqueeze(w, 1)\n h = torch.unsqueeze(h, 1)\n\n translation = torch.cat([w]*5 + [h]* 5, 1).float() * landmarks\n if align:\n landmarks = torch.ceil(translation).int()\n else:\n landmarks = torch.stack([bboxes[:, 0]] * 5 + [bboxes[:, 1]] * 5, 1) + torch.round(translation).int()\n return landmarks","def imagesAlign(I,Iref,fillval=np.nan,trfm_type='similarity',\n vCells=1,hCells=1,rszFac=1,verbose=False,\n minArea = np.power(2, 11), applyWarp=True):\n if len(I.shape)==3:\n I1=sh.rgb2gray(I)\n else:\n I1=I\n \n if len(Iref.shape)==3:\n Iref1=sh.rgb2gray(Iref)\n else:\n Iref1=Iref\n\n WARN_USER, ORIG_DTYPE = False, None\n if I1.dtype != 'float32':\n WARN_USER, ORIG_DTYPE = True, I1.dtype\n I1 = I1.astype('float32')\n if Iref1.dtype != 'float32':\n WARN_USER, ORIG_DTYPE = True, Iref1.dtype\n Iref1 = Iref1.astype('float32')\n if WARN_USER:\n print \"(Info) imagesAlign was called with input image dtype={0}. \\\nimagesAlign expects image dtype='float32' (Also, intensity vals in range \\\n[0.0,1.0]. The image dtype conversion was \\\nautomatically done, but this slows down the computation a little. Consider \\\ntrying to work in 'float32' in the first place if convenient for a little \\\nspeed boost.\".format(ORIG_DTYPE)\n\n t1 = time.clock()\n # check if more than one vertical and horizontal cell\n if (vCells>1) and (hCells>1):\n I2=imagesAlign(I1,Iref1,trfm_type=trfm_type, minArea=minArea)[1];\n Iout=np.copy(Iref1);\n pFac=.25;\n vStep=math.ceil(I1.shape[0]/vCells); vPad=pFac*vStep;\n hStep=math.ceil(I1.shape[1]/hCells); hPad=pFac*vStep;\n for i in range(vCells):\n for j in range(hCells):\n # 2. chop + pad each cell then align\n # 3. stitch back together\n i1=i*vStep; i1=max(i1,0);\n i2=(i+1)*vStep; i2=min(i2,I1.shape[0]-1);\n j1=j*hStep; j1=max(j1,0);\n j2=(j+1)*hStep; j2=min(j2,I1.shape[1]-1);\n\n i1p=i1-vPad; i1p=max(i1p,0);\n i2p=i2+vPad; i2p=min(i2p,I1.shape[0]-1);\n j1p=j1-hPad; j1p=max(j1p,0);\n j2p=j2+hPad; j2p=min(j2p,I1.shape[1]-1);\n \n Ic=I2[i1p:i2p,j1p:j2p]\n Irefc=Iref1[i1p:i2p,j1p:j2p]\n (H,err)=imagesAlign1(Ic,Irefc,trfm_type=trfm_type,verbose=verbose, minArea=minArea)\n IcT=sh.imtransform(Ic, H)\n Iout[i1:i2,j1:j2]=IcT[i1-i1p:(i1-i1p)+(i2-i1),j1-j1p:(j1-j1p)+(j2-j1)]\n\n return (np.eye(3),Iout,-1)\n\n if rszFac==1:\n t0 = time.clock()\n (H,err)=imagesAlign1(I1,Iref1,trfm_type=trfm_type,verbose=verbose, minArea=minArea)\n if verbose:\n print 'alignment time:',time.clock()-t0,'(s)'\n\n #print 'alignment time:',time.clock()-t0,'(s)' \n else:\n I1=sh.fastResize(I1,rszFac)\n Iref1=sh.fastResize(Iref1,rszFac)\n S=np.eye(3, dtype=np.float32);\n S[0,0]=1/rszFac; S[1,1]=1/rszFac;\n H0=np.eye(3, dtype=np.float32)\n H0=np.dot(np.dot(np.linalg.inv(S),H0),S)\n t0 = time.clock()\n (H,err)=imagesAlign1(I1,Iref1,H0=H0,trfm_type=trfm_type,verbose=verbose, minArea=minArea)\n if verbose:\n print 'alignment time:',time.clock()-t0,'(s)'\n\n #print 'alignment time:',time.clock()-t0,'(s)'\n H=np.dot(S,np.dot(H,np.linalg.inv(S)))\n\n #print \"overall time: \", time.clock() - t1\n if applyWarp:\n return (H,sh.imtransform(I,H,fillval=fillval),err)\n else:\n return (H,err)","def align_and_crop_face(self, img, rect_list, desired_width, desired_height):\n \n for j, det in enumerate(rect_list):\n shape = self.align_predictor(img, det)\n left_eye = extract_left_eye_center(shape)\n right_eye = extract_right_eye_center(shape)\n M = get_rotation_matrix(left_eye, right_eye)\n\n rotated_img = cv2.warpAffine(img, M, (img.shape[1], img.shape[0]), flags=cv2.INTER_CUBIC)\n cropped = crop_image(rotated_img, det)\n try:\n \n cropped_res = cv2.resize(cropped, (desired_width, desired_height))\n except:\n print(det)\n print(img.shape)\n cropped_res = cv2.resize(rotated_img,(desired_width, desired_height))\n cropped_img = cropped_res[:, :, ::-1]\n\n return cropped_img, left_eye, right_eye","def load_aligned(self, image, size=256, padding=48, align_eyes=False):\n self.aligned[\"size\"] = size\n self.aligned[\"padding\"] = padding\n self.aligned[\"align_eyes\"] = align_eyes\n self.aligned[\"matrix\"] = get_align_mat(self, size, align_eyes)\n self.aligned[\"face\"] = AlignerExtract().transform(\n image,\n self.aligned[\"matrix\"],\n size,\n padding)","def image_bbox(img, bbox, label=None, score=None, ax=None):\n\n label_names = list(labels) + ['bg']\n ax = image_vis(img, ax=ax)\n\n\n # If there is no bounding box to display, visualize the image and exit.\n if len(bbox) == 0:\n return ax\n\n for i, bb in enumerate(bbox):\n xy = (bb[1], bb[0])\n height = bb[2] - bb[0]\n width = bb[3] - bb[1]\n ax.add_patch(plt.Rectangle(\n xy, width, height, fill=False, edgecolor='red', linewidth=2))\n\n caption = list()\n\n if label is not None and label_names is not None:\n lb = label[i]\n caption.append(label_names[lb])\n if score is not None:\n sc = score[i]\n caption.append('{:.2f}'.format(sc))\n\n if len(caption) > 0:\n ax.text(bb[1], bb[0],\n ': '.join(caption),\n style='italic',\n bbox={'facecolor': 'white', 'alpha': 0.5, 'pad': 0})\n return ax","def normalize_face(image: Image, face):\n y, x, h, w = face['box']\n cropped_face = image[x:x + w, y:y + h]\n\n left_eye = face['keypoints']['left_eye']\n right_eye = face['keypoints']['right_eye']\n aligned_face = align(cropped_face, left_eye, right_eye)\n aligned_face = cv2.resize(aligned_face, (160, 160))\n\n return np.expand_dims(aligned_face / 255, axis=0)","def transform(self,image,landmarks,s0=None):\n if s0 is None:\n s0 = np.array([[127.6475, 227.8161], [79.1608, 87.0376], [176.8392, 87.0376]], np.float32)\n idx = [8,36,45] #\"\"\"Anchor points\"\"\"\n pts = np.float32(landmarks[idx,:])\n M = cv2.getAffineTransform(pts,s0)\n dst = cv2.warpAffine(image, M, (256,256))\n return dst","def align_single_image(filename, crop_list, bead_channel='488',\n all_channels=_allowed_colors, \n single_im_size=_image_size,\n num_buffer_frames=_num_buffer_frames,\n num_empty_frames=_num_empty_frames,\n illumination_corr=True, \n correction_folder=_correction_folder,\n ref_filename=None, ref_all_channels=None,\n ref_centers=None, ref_ims=None,\n th_seed=100, th_seed_per=98, use_percentile=False,\n max_num_seeds=None, min_num_seeds=50, \n fitting_kwargs={}, \n use_fft=True, fft_filt_size=0, \n match_distance_th=2., \n check_paired_cts=True,\n outlier_sigma=1.5,\n good_drift_th=1.,\n return_target_ims=False,\n return_paired_cts=False,\n verbose=False, \n ):\n from scipy.spatial.distance import cdist, pdist, squareform\n from ..io_tools.load import correct_fov_image\n from ..alignment_tools import fft3d_from2d\n from ..spot_tools.fitting import get_centers\n ## check inputs\n # check crop_list:\n if len(crop_list) < 2:\n raise IndexError(f\"crop_list should at least have 2 elements\")\n elif len(crop_list[0]) != len(single_im_size):\n raise IndexError(\"dimension of crop_list should match single_im_size\")\n # check channels:\n _all_channels = [str(_ch) for _ch in all_channels]\n # check bead_channel\n _bead_channel = str(bead_channel)\n if _bead_channel not in all_channels:\n raise ValueError(f\"bead channel {_bead_channel} not exist in all channels given:{_all_channels}\")\n # check ref_all_channels\n if ref_all_channels is None:\n _ref_all_channels = _all_channels\n else:\n _ref_all_channels = [str(_ch) for _ch in ref_all_channels]\n\n # check filename file type \n if isinstance(filename, np.ndarray):\n if verbose:\n print(f\"-- start aligning given image to\", end=' ')\n _bead_im = filename\n if np.shape(_bead_im) != tuple(single_im_size):\n raise IndexError(f\"shape of target image:{np.shape(_bead_im)} and single_im_size:{single_im_size} doesn't match!\")\n elif isinstance(filename, str):\n if verbose:\n print(f\"-- start aligning file {filename} to\", end=' ')\n if not os.path.isfile(filename) or filename.split('.')[-1] != 'dax':\n raise IOError(f\"input filename: {filename} should be a .dax file!\")\n _bead_im = correct_fov_image(filename, [_bead_channel], \n single_im_size=single_im_size, \n all_channels=all_channels,\n num_buffer_frames=num_buffer_frames, \n num_empty_frames=num_empty_frames, \n calculate_drift=False, \n correction_folder=correction_folder,\n illumination_corr=illumination_corr,\n bleed_corr=False, chromatic_corr=False,\n z_shift_corr=False, hot_pixel_corr=True,\n normalization=False, return_drift=False,\n verbose=False,\n )[0]\n else:\n raise IOError(f\"Wrong input file type, {filename} should be .dax file or np.ndarray\")\n # crop target image:\n _tar_ims = [_bead_im[tuple([slice(_s[0], _s[-1]) for _s in _c])] for _c in crop_list]\n # get centers\n _tar_ct_list = [get_centers(_im, th_seed=th_seed,\n th_seed_per=th_seed_per, \n use_percentile=use_percentile,\n max_num_seeds=max_num_seeds, \n min_num_seeds=min_num_seeds,\n **fitting_kwargs,\n ) for _im in _tar_ims]\n\n ## acquire references\n # case 1: ref_centers and ref_ims are given:\n if ref_centers is not None and ref_ims is not None:\n if verbose:\n print(f\"given ref_centers and images, n={len(ref_centers)}\")\n if len(ref_centers) != len(ref_ims):\n raise IndexError(f\"length of ref_centers:{len(ref_centers)} should match length of ref_ims:{len(ref_ims)}\")\n elif len(crop_list) != len(ref_centers):\n raise IndexError(f\"length of crop_list:{len(crop_list)} should match length of ref_centers:{len(ref_centers)}\")\n _ref_ims = ref_ims\n _ref_ct_list = ref_centers\n # case 2: ref_filename is given:\n elif ref_filename is not None:\n if isinstance(ref_filename, np.ndarray):\n if verbose:\n print(f\"ref image directly given\")\n _ref_bead_im = ref_filename\n elif isinstance(ref_filename, str):\n if verbose:\n print(f\"ref_file: {ref_filename}\")\n _ref_bead_im = old_correct_fov_image(ref_filename, [_bead_channel], \n single_im_size=single_im_size, \n all_channels=all_channels,\n num_buffer_frames=num_buffer_frames,\n num_empty_frames=num_empty_frames, \n calculate_drift=False, \n correction_folder=correction_folder,\n illumination_corr=illumination_corr,\n warp_image=False,\n bleed_corr=False, \n chromatic_corr=False,\n z_shift_corr=False, \n hot_pixel_corr=True,\n normalization=False, \n return_drift=False,\n verbose=False,\n )[0][0]\n _ref_ims = []\n for _c in crop_list:\n _crop = tuple([slice(int(_s[0]), int(_s[-1])) for _s in _c])\n _ref_ims.append(_ref_bead_im[_crop])\n # collect ref_ct_list\n from ..spot_tools.fitting import select_sparse_centers\n _ref_ct_list = []\n for _im in _ref_ims:\n _cand_cts = get_centers(_im, th_seed=th_seed,\n th_seed_per=th_seed_per, \n use_percentile=use_percentile,\n max_num_seeds=max_num_seeds, \n min_num_seeds=min_num_seeds,\n **fitting_kwargs,\n )\n _ref_ct_list.append(select_sparse_centers(_cand_cts, \n distance_th=match_distance_th))\n else:\n raise ValueError(f\"ref_filename or ref_centers+ref_ims should be given!\")\n \n # Do alignment\n _drift_list = []\n _paired_tar_ct_list = []\n _paired_ref_ct_list = []\n # iterate until find good drifts or calculated all cropped images\n while len(_drift_list) < len(crop_list):\n # get image\n _cid = len(_drift_list)\n # calculate drift\n _drift, _paired_tar_cts, _paired_ref_cts = align_beads(\n _tar_ct_list[_cid], _ref_ct_list[_cid], \n _tar_ims[_cid], _ref_ims[_cid],\n use_fft=use_fft, \n fft_filt_size=fft_filt_size, \n match_distance_th=match_distance_th, \n check_paired_cts=check_paired_cts,\n outlier_sigma=outlier_sigma,\n return_paired_cts=True,\n verbose=verbose,\n )\n # judge whether this matching is successful\n if len(_paired_tar_cts) == 0:\n _drift = np.inf * np.ones(len(single_im_size))\n # append\n _drift_list.append(_drift)\n _paired_tar_ct_list.append(_paired_tar_cts)\n _paired_ref_ct_list.append(_paired_ref_cts)\n\n # check if matched well: \n if len(_drift_list) >=2:\n if (cdist(_drift[np.newaxis,:], _drift_list[:-1])[0] < good_drift_th).any():\n break\n ## select drifts\n _dists = squareform(pdist(_drift_list))\n _dists[np.arange(len(_dists)), np.arange(len(_dists))] = np.inf\n _inds = np.unravel_index(np.argmin(_dists, axis=None), _dists.shape)\n # get the two that are closest\n if _dists[_inds] > good_drift_th:\n _success_flag = False\n print(f\"-- Suspicious Failure: selcted drifts: {_drift_list[_inds[0]]}, {_drift_list[_inds[1]]} are not close enough.\")\n else:\n _success_flag = True\n # extract _final_drift and return\n _final_drift = np.nanmean([_drift_list[_inds[0]], _drift_list[_inds[1]]], axis=0)\n\n # return\n _return_args = [_final_drift, _success_flag]\n if return_target_ims:\n _return_args.append(_tar_ims)\n if return_paired_cts:\n _return_args.append(_paired_tar_ct_list)\n _return_args.append(_paired_ref_ct_list)\n \n return tuple(_return_args)","def _perform_alignment(self, formulatrix_image, beamline_image, formulatrix_points):\n aligner = ImageAligner(formulatrix_image, beamline_image, self._config_align, self._config_detector)\n aligned_images = aligner.align()\n scaled_formulatrix_points = aligner.scale_points(formulatrix_points)\n self._log_alignment_status(aligned_images)\n\n return aligned_images, scaled_formulatrix_points","def show_bboxes(img, bounding_boxes=None, facial_landmarks=[]):\n\n img_copy = img.copy()\n draw = ImageDraw.Draw(img_copy)\n# for b in bounding_boxes:\n# draw.rectangle([\n# (b[0], b[1]), (b[2], b[3])\n# ], outline='white')\n\n for p in facial_landmarks:\n for i in range(106):\n draw.ellipse([\n (p[i*2] - 1.0, p[2*i + 1] - 1.0),\n (p[i*2] + 1.0, p[2*i+1] + 1.0)\n ], outline='blue')\n font = ImageFont.truetype(\"arial.ttf\", 10)\n draw.text([p[2*i], p[2*i+1]], str(i), font=font)\n\n return img_copy","def highlight_faces(image, faces, output_filename, terminal_print=True):\n im = Image.open(image)\n draw = ImageDraw.Draw(im)\n\n for (face_ind, face) in enumerate(faces):\n\n # compute emotions\n list_emotion_scores = [face.sorrow_likelihood,\n face.joy_likelihood,\n face.anger_likelihood,\n face.surprise_likelihood]\n\n list_emotions = [\"SORROW\",\n \"JOY\",\n \"ANGER\",\n \"SURPRISE\"]\n\n string_label = generate_string_label(list_emotions, list_emotion_scores)\n\n if terminal_print:\n # print emotions on terminal\n print(\"\\n\")\n print(\"-----------------------\")\n print(\"Face {}\".format(face_ind))\n\n for (crrt_emotion, crrt_score) in zip(list_emotions, list_emotion_scores):\n print(\"{}: {}\".format(crrt_emotion, crrt_score))\n\n print(string_label)\n\n print(\"-----------------------\")\n\n # draw box around face\n box = [(vertex.x, vertex.y)\n for vertex in face.bounding_poly.vertices]\n draw.line(box + [box[0]], width=5, fill='#00ff00')\n\n # add legend in the face box\n fontsize = 35\n font = ImageFont.truetype(\"/usr/share/fonts/truetype/freefont/FreeMono.ttf\", fontsize)\n\n offset = 5\n heigth_text = 40\n length_text = box[1][0] - box[0][0] - 2 * offset\n draw.rectangle(((box[0][0] + offset, box[0][1] + offset), (box[0][0] + length_text + offset, box[0][1] + heigth_text + offset)), fill=\"black\")\n draw.text((box[0][0] + offset, box[0][1] + offset), string_label, font=font, fill=(255, 255, 255, 255))\n\n # highlight significant points\n point_nbr = 0\n half_width_sqare = 2\n\n list_point_coords = []\n\n for point in face.landmarks:\n x = point.position.x\n y = point.position.y\n\n list_point_coords.append((x, y))\n\n draw.rectangle(((x - half_width_sqare, y - half_width_sqare), (x + half_width_sqare, y + half_width_sqare)), fill=\"red\")\n\n # fontsize = 15\n # font = ImageFont.truetype(\"/usr/share/fonts/truetype/freefont/FreeMono.ttf\", fontsize)\n # draw.text((x, y), str(point_nbr), font=font, fill=(255, 255, 0, 0))\n\n point_nbr += 1\n\n all_lists_points = [\n [10, 11, 9],\n [10, 12, 11],\n [14, 7, 13, 15],\n [7, 6],\n [14, 6, 13, 7, 14],\n [16, 17, 18, 19],\n [21, 22, 23, 24],\n [30, 6],\n ]\n\n for crrt_list_points in all_lists_points:\n draw_line_list_points(draw, crrt_list_points, list_point_coords)\n\n draw_line_list_points(draw, [2, 26, 3], list_point_coords, close=False)\n draw_line_list_points(draw, [4, 27, 5], list_point_coords, close=False)\n draw_line_list_points(draw, [10, 8, 11], list_point_coords, close=False)\n\n im.save(output_filename)","def correctMisalign(img, marker, center, compus, scope=100):\n\n markerCenter = np.asarray(marker.shape)//2\n guide = np.asarray([center, compus])\n landmark = np.zeros(guide.shape)\n \n #To run template matching to finder markers\n result = cv2.matchTemplate(img, marker, 0)\n result = (1-result/np.max(result))*255\n M = np.float32([\n [1, 0, markerCenter[1]] ,\n [0, 1, markerCenter[0]] ])\n resultPadded = cv2.warpAffine(result, M, (width, height))\n \n mask = np.zeros(resultPadded.shape)\n\n for i in range(0, len(guide)):\n mask[:] = 0\n mask_xfr = max(0, guide[i,1]-(scope+markerCenter[0]))\n mask_xto = min(width, guide[i,1]+(scope+markerCenter[0]))\n mask_yfr = max(0, guide[i,0]-(scope+markerCenter[1]))\n mask_yto = min(width, guide[i,0]+(scope+markerCenter[1]))\n mask[mask_xfr:mask_xto, mask_yfr:mask_yto] = 255\n min_val, max_val, min_loc, landmark[i,:] = \\\n cv2.minMaxLoc(np.multiply(resultPadded, mask))\n \n #To shift image\n shift = guide[0] - landmark[0] \n M = np.float32([\n [1, 0, shift[0]] ,\n [0, 1, shift[1]] ])\n imgShifted = cv2.warpAffine(img, M, (width, height))\n \n #To rescale & rotate image\n radius = np.linalg.norm(landmark[1,:] - landmark[0,:])\n scale = np.linalg.norm(guide[1,:] - guide[0,:])/radius\n cos = (landmark[1,0]-landmark[0,0])/radius\n theta = np.arccos(cos) / (2 * np.pi) * 360\n M = cv2.getRotationMatrix2D((guide[0,0],guide[0,1]),-theta,scale)\n imgModified = cv2.warpAffine(imgShifted,M,(width,height))\n return imgModified\n\n #}}}","def align(image):\n angle = find_angle(image)\n image = rotate(image, angle)\n return image","def align_faces(frames):\n align = get_entry('recognition')['face alignment']\n provider = align['provider']\n\n logger = logging.getLogger('alignment')\n logger.setLevel(logging.INFO)\n\n logger.info('alignment provider: ' + provider)\n if provider == 'opencv':\n from faceR.alignment import opencv as aligner\n elif provider == 'dlib':\n import dlib_al as aligner\n elif provider == 'mtcnn':\n from faceR.alignment import mtcnn as aligner\n elif provider == 'face-boxes':\n from faceR.alignment import face_boxes as aligner\n elif provider == 'adas':\n from faceR.alignment import adas as aligner\n\n return aligner.align_faces(frames, align[provider])","def _box_face(image, face):\n draw = PIL.ImageDraw.Draw(image.image)\n draw.rectangle(face.as_box(), outline=\"yellow\")","def _align(self):\n\n shape = np.shape(self.x)\n\n # Get angle of direction (cbi: center beam index)\n # NOTE: This implementation seems to be unstable, because the shot with the center beam index can be NaN\n # cbi = np.median(np.arange(len(self.x[0, :]))).astype(int)\n # vec1 = [self.x[0, cbi], self.y[0, cbi], 0.0]\n # vec2 = [self.x[-1, cbi], self.y[-1, cbi], 0.0]\n\n # Alternative implementation with mean over all entries within the line.\n # -> should be a good approximation of the line center\n # NOTE: 2019-05-30: Relaxed the criterion even further (mean of first and last 10 scan lines)\n vec1 = [np.nanmedian(self.x[0:10, :]), np.nanmedian(self.y[0:10, :]), 0.0]\n vec2 = [np.nanmedian(self.x[-11:-1, :]), np.nanmedian(self.y[-11:-1, :]), 0.0]\n angle = -1.0*np.arctan((vec2[1]-vec1[1])/(vec2[0]-vec1[0]))\n\n # validity check -> Do not rotate if angle is nan\n if np.isnan(angle):\n return\n\n # Get center point\n xc = np.nanmedian(self.x)\n yc = np.nanmedian(self.y)\n\n # Reform points\n points = [self.x.flatten()-xc, self.y.flatten()-yc]\n\n # Execute the rotation\n rot_matrix = np.array([[np.cos(angle), -np.sin(angle)],\n [np.sin(angle), np.cos(angle)]])\n points_rotated = rot_matrix.dot(points)\n self.x = np.reshape(points_rotated[0, :], shape)\n self.y = np.reshape(points_rotated[1, :], shape)\n\n # Save conversion parameters for reuse\n self._align_parameters = {'center_point': (xc, yc),\n 'angle': angle,\n 'rotation_matrix': rot_matrix}","def align(self, *, skip_corners=False, return_on_invalid_result=False, warpwarnings=False, **kwargs):\n #load the images for all HPFs and keep them in memory as long as\n #the AlignSample is active\n self.getDAPI()\n self.logger.info(\"starting alignment\")\n\n weighted_sum_mse = 0.\n sum_weights = 0.\n done = set()\n\n for i, overlap in enumerate(self.overlaps, start=1):\n if skip_corners and overlap.tag in [1,3,7,9] :\n continue\n self.logger.debug(f\"aligning overlap {overlap.n} ({i}/{len(self.overlaps)})\")\n result = None\n #check if the inverse overlap has already been aligned\n #(e.g. if the current overlap is between (1, 2), check the overlap between (2, 1))\n #if so, we don't have to align again\n if self.inverseoverlapsdictkey(overlap) in done:\n inverseoverlap = self.overlapsdict[self.inverseoverlapsdictkey(overlap)]\n if hasattr(inverseoverlap, \"result\"):\n result = overlap.getinversealignment(inverseoverlap)\n #do the alignment\n if result is None:\n result = overlap.align(gputhread=self.gputhread, gpufftdict=self.gpufftdict, **kwargs)\n done.add(self.overlapsdictkey(overlap))\n\n #contribution of the mean squared difference after alignment\n #to the weighted sum\n if result is not None and result.exit == 0: \n w = (overlap.cutimages[0].shape[0]*overlap.cutimages[0].shape[1])\n weighted_sum_mse+=w*result.mse[2]\n sum_weights+=w\n else :\n if result is None:\n reason = \"is None\"\n else:\n reason = f\"has exit status {result.exit}\"\n if return_on_invalid_result :\n if warpwarnings: self.logger.warningglobal(f'Overlap number {i} alignment result {reason}: returning 1e10!!')\n return 1e10\n else :\n if warpwarnings: self.logger.warningglobal(f'Overlap number {i} alignment result {reason}: adding 1e10 to sum_mse!!')\n w = (overlap.cutimages[0].shape[0]*overlap.cutimages[0].shape[1])\n weighted_sum_mse+=w*1e10\n sum_weights+=w\n\n self.logger.info(\"finished align loop for \"+self.SlideID)\n return weighted_sum_mse/sum_weights","def from_alignment(self, alignment, image=None):\n self.x = alignment[\"x\"]\n self.w = alignment[\"w\"]\n self.y = alignment[\"y\"]\n self.h = alignment[\"h\"]\n self.frame_dims = alignment[\"frame_dims\"]\n self.landmarksXY = alignment[\"landmarksXY\"]\n if image.any():\n self.image_to_face(image)","def __call__(self, loc, scores, anchors, img_size):\n anchors = bbox.loc2bbox(anchor)","def forward(self, image, dtype=torch.float32):\n image_shape = image.shape[2:]\n\n if image_shape == self.last_shape and image.device in self.last_anchors:\n return self.last_anchors[image.device]\n\n if self.last_shape is None or self.last_shape != image_shape:\n self.last_shape = image_shape\n\n if dtype == torch.float16:\n dtype = np.float16\n else:\n dtype = np.float32\n\n boxes_all = []\n for stride in self.strides:\n boxes_level = []\n for scale, ratio in itertools.product(self.scales, self.ratios):\n if image_shape[1] % stride != 0:\n raise ValueError('input size must be divided by the stride.')\n base_anchor_size = self.anchor_scale * stride * scale\n anchor_size_x_2 = base_anchor_size * ratio[0] / 2.0\n anchor_size_y_2 = base_anchor_size * ratio[1] / 2.0\n\n x = np.arange(stride / 2, image_shape[1], stride)\n y = np.arange(stride / 2, image_shape[0], stride)\n xv, yv = np.meshgrid(x, y)\n xv = xv.reshape(-1)\n yv = yv.reshape(-1)\n\n # y1,x1,y2,x2\n boxes = np.vstack((yv - anchor_size_y_2, xv - anchor_size_x_2,\n yv + anchor_size_y_2, xv + anchor_size_x_2))\n boxes = np.swapaxes(boxes, 0, 1)\n boxes_level.append(np.expand_dims(boxes, axis=1))\n # concat anchors on the same level to the reshape NxAx4\n boxes_level = np.concatenate(boxes_level, axis=1)\n boxes_all.append(boxes_level.reshape([-1, 4]))\n\n anchor_boxes = np.vstack(boxes_all)\n\n anchor_boxes = torch.from_numpy(anchor_boxes.astype(dtype)).to(image.device)\n anchor_boxes = anchor_boxes.unsqueeze(0)\n\n # save it for later use to reduce overhead\n self.last_anchors[image.device] = anchor_boxes\n return anchor_boxes","def center_image_anchor(image):\n image.anchor_x = image.height/2\n image.anchor_y = image.height/2","def alignCtx(*args, align: bool=True, anchorFirstObject: bool=False, distribute: bool=True,\n exists: bool=True, history: bool=True, image1: Union[AnyStr, bool]=\"\", image2:\n Union[AnyStr, bool]=\"\", image3: Union[AnyStr, bool]=\"\", name: AnyStr=\"\",\n showAlignTouch: bool=True, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[AnyStr, Any]:\n pass","def __call__(self, src, label):\r\n \"\"\"color distort\"\"\"\r\n # img = random_color_distort(src)\r\n\r\n # print(\"previous label shape = \", label.shape)\r\n target = np.zeros(shape=(label.shape[0],))\r\n\r\n \"\"\"Pyramid Anchor sampling\"\"\"\r\n img, boxes, label = self.random_baiducrop(src, label[:, :4], target)\r\n # print(\"label shape = \", label.shape)\r\n # print('boxes shape =', boxes.shape)\r\n bbox = boxes\r\n # img = mx.nd.array(img)\r\n\r\n \"\"\"color distort\"\"\"\r\n img = mx.nd.array(img)\r\n img = random_color_distort(img)\r\n\r\n # \"\"\"random crop, keep aspect ration=1\"\"\"\r\n # h, w, _ = img.shape\r\n # bbox, crop_size = random_crop_with_constraints(label, (w, h))\r\n # x_offset, y_offset, new_width, new_height = crop_size\r\n # img = mx.image.fixed_crop(img, x_offset, y_offset, new_width, new_height)\r\n\r\n \"\"\"resize with random interpolation\"\"\"\r\n h, w, _ = img.shape\r\n interp = np.random.randint(0, 5)\r\n img = gimage.imresize(img, self._width, self._height, interp=interp)\r\n bbox = gbbox.resize(bbox, (w, h), (self._width, self._height))\r\n\r\n \"\"\"random horizontal flip\"\"\"\r\n h, w, _ = img.shape\r\n img, flips = gimage.random_flip(img, px=0.5)\r\n bbox = gbbox.flip(bbox, (w, h), flip_x=flips[0])\r\n\r\n \"\"\"To Tensor & Normalization\"\"\"\r\n img = mx.nd.image.to_tensor(img)\r\n img = mx.nd.image.normalize(img, mean=self._mean, std=self._std)\r\n\r\n if self._anchors is None:\r\n return img, bbox\r\n\r\n # @TODO: generating training target so cpu workers can help reduce the workload on gpu\r\n face_anchors, head_anchors, body_anchors = self._anchors\r\n gt_bboxes = mx.nd.array(bbox[:, :4]).expand_dims(0)\r\n gt_ids = mx.nd.zeros((1, gt_bboxes.shape[1], 1), dtype=gt_bboxes.dtype)\r\n\r\n face_cls_targets, face_box_targets, _ = self._target_generator(\r\n face_anchors, None, gt_bboxes, gt_ids)\r\n\r\n head_cls_targets, head_box_targets, _ = self._target_generator(\r\n head_anchors, None, gt_bboxes, gt_ids)\r\n\r\n body_cls_targets, body_box_targets, _ = self._target_generator(\r\n body_anchors, None, gt_bboxes, gt_ids)\r\n\r\n return img, \\\r\n face_cls_targets[0], head_cls_targets[0], body_cls_targets[0], \\\r\n face_box_targets[0], head_box_targets[0], body_box_targets[0]","def render(self, image=False, **kwargs):\n import matplotlib.pyplot as plt\n\n source = self.alignment_transform.source.points\n target = self.alignment_transform.target.points\n # a factor by which the minimum and maximum x and y values of the warp\n # will be increased by.\n x_margin_factor, y_margin_factor = 0.5, 0.5\n # the number of x and y samples to take\n n_x, n_y = 50, 50\n # {x y}_{min max} is the actual bounds on either source or target\n # landmarks\n x_min, y_min = np.vstack([target.min(0), source.min(0)]).min(0)\n x_max, y_max = np.vstack([target.max(0), source.max(0)]).max(0)\n x_margin = x_margin_factor * (x_max - x_min)\n y_margin = y_margin_factor * (y_max - y_min)\n # {x y}_{min max}_m is the bound once it has been grown by the factor\n # of the spread in that dimension\n x_min_m = x_min - x_margin\n x_max_m = x_max + x_margin\n y_min_m = y_min - y_margin\n y_max_m = y_max + y_margin\n # build sample points for the selected region\n x = np.linspace(x_min_m, x_max_m, n_x)\n y = np.linspace(y_min_m, y_max_m, n_y)\n xx, yy = np.meshgrid(x, y)\n sample_points = np.concatenate(\n [xx.reshape([-1, 1]), yy.reshape([-1, 1])], axis=1\n )\n warped_points = self.alignment_transform.apply(sample_points)\n delta = warped_points - sample_points\n # plot the sample points result\n x, y, = (\n 0,\n 1,\n )\n if image:\n # if we are overlaying points onto an image,\n # we have to account for the fact that axis 0 is typically\n # called 'y' and axis 1 is typically called 'x'. Flip them here\n x, y = y, x\n plt.quiver(sample_points[:, x], sample_points[:, y], delta[:, x], delta[:, y])\n delta = target - source\n # plot how the landmarks move from source to target\n plt.quiver(\n source[:, x],\n source[:, y],\n delta[:, x],\n delta[:, y],\n angles=\"xy\",\n scale_units=\"xy\",\n scale=1,\n )\n # rescale to the bounds\n plt.xlim((x_min_m, x_max_m))\n plt.ylim((y_min_m, y_max_m))\n if image:\n # if we are overlaying points on an image, axis0 (the 'y' axis)\n # is flipped.\n plt.gca().invert_yaxis()\n return self","def img_augmentation(augmentation, img, bbox):\n\n # img_copy = img.copy()\n image_shape = img.shape\n h, w = image_shape[0:2]\n\n # Convert the stochastic sequence of augmenters to a deterministic one.\n # The deterministic sequence will always apply the exactly same effects to the images.\n det = augmentation.to_deterministic()\n img_aug = det.augment_image(img)\n\n ia_bbox = list()\n for bounding_box in bbox:\n x1, y1, x2, y2 = bounding_box\n ia_bbox.append(ia.BoundingBox(x1=x1, y1=y1, x2=x2, y2=y2))\n\n bbs = ia.BoundingBoxesOnImage(ia_bbox, shape=image_shape)\n bbs_aug = det.augment_bounding_boxes([bbs])[0]\n # img = bbs_aug.draw_on_image(img)\n\n after_bbox = list()\n for bounding_box in bbs_aug.bounding_boxes:\n bbox_list = [bounding_box.x1_int, bounding_box.y1_int, bounding_box.x2_int, bounding_box.y2_int]\n\n if bbox_list[0] >= w: bbox_list[0] = w - 1\n if bbox_list[1] >= h: bbox_list[1] = h - 1\n if bbox_list[2] >= w: bbox_list[2] = w - 1\n if bbox_list[3] >= h: bbox_list[3] = h - 1\n\n if bbox_list[0] == bbox_list[2] or bbox_list[1] == bbox_list[3]:\n return img_augmentation(augmentation, img, bbox)\n\n bbox_list = list(map(lambda x: max(x, 0), bbox_list))\n after_bbox.append(bbox_list)\n\n assert img_aug.shape == image_shape, \"Augmentation shouldn't change image size\"\n\n return img_aug, after_bbox","def _set_anchor_center(img):\n img.anchor_x = int(img.width / 2)\n img.anchor_y = int(img.height / 2)","def gonio_axis_align():\n \n # Invert camera image, so dark pin on light image becomes a peak\n cam_7.proc1.scale.put(-1)\n cam_8.proc1.scale.put(-1)\n \n # High threshold, so AD centroid doesn't interpret background\n cam_8ThresholdOld = cam_8.stats4.centroid_threshold.get()\n cam_8.stats4.centroid_threshold.put(150)\n cam_7ThresholdOld = cam_7.stats4.centroid_threshold.get()\n cam_7.stats4.centroid_threshold.put(150)\n \n # HiMag\n # Copy ROI2 geometry (HiMag Mag3) to ROI4 and use ROI4 centroid plugin\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get())\n cam_8.roi4.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get())\n cam_8.roi4.size.x.put(cam_8.roi2.size.x.get() * 0.20)\n cam_8.roi4.size.y.put(cam_8.roi2.size.y.get())\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get() + cam_8.roi2.size.x.get()/2 - cam_8.roi4.size.x.get()/2)\n \n # LoMag\n # Copy ROI2 geometry (LoMag Mag1) to ROI4 and use ROI4 centroid plugin\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get())\n cam_7.roi4.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get())\n cam_7.roi4.size.x.put(cam_7.roi2.size.x.get() * 0.05)\n cam_7.roi4.size.y.put(cam_7.roi2.size.y.get())\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get() + cam_7.roi2.size.x.get()/2 - cam_7.roi4.size.x.get()/2)\n \n centerPinYHiMag0 = centroid_avg(cam_8.stats4)[1]\n centerPinYLoMag0 = centroid_avg(cam_7.stats4)[1]\n yield from bps.mvr(gonio.o,180)\n time.sleep(2)\n centerPinYHiMag180 = centroid_avg(cam_8.stats4)[1]\n centerPinYLoMag180 = centroid_avg(cam_7.stats4)[1]\n centerPinYHiMag = (centerPinYHiMag0 + centerPinYHiMag180)/2\n centerPinYLoMag = (centerPinYLoMag0 + centerPinYLoMag180)/2\n\n centerPinOffsYHiMag = centerPinYHiMag - cam_8.roi4.size.y.get() / 2\n centerPinOffsYLoMag = centerPinYLoMag - cam_7.roi4.size.y.get() / 2\n \n # Correct Mag 3 (cam_8 ROI2)\n cam_8.roi2.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + centerPinOffsYHiMag)\n # Correct Mag 4 (cam_8 ROI1)\n cam_8.roi1.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + (cam_8.roi2.size.y.get()-cam_8.roi1.size.y.get())/2)\n \n # Correct Mag 1 (cam_7 ROI2)\n cam_7.roi2.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + centerPinOffsYLoMag)\n # Correct Mag 2 (cam_7 ROI3)\n cam_7.roi3.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + (cam_7.roi2.size.y.get()-cam_7.roi3.size.y.get())/2)\n\n # De-invert image\n cam_7.proc1.scale.put(-1)\n cam_8.proc1.scale.put(-1)\n \n # Set thresold to previous value\n cam_8.stats4.centroid_threshold.put(cam_8ThresholdOld)\n cam_7.stats4.centroid_threshold.put(cam_7ThresholdOld)\n \n return","def image_align(first_image, second_image):\r\n\r\n high_diff = (second_image.shape[0] - first_image.shape[0]) // 2\r\n width_diff = (second_image.shape[1] - first_image.shape[1]) // 2\r\n\r\n align_image = second_image[high_diff: high_diff + first_image.shape[0],\r\n width_diff: width_diff + first_image.shape[1],\r\n :]\r\n\r\n\r\n assert align_image.shape == first_image.shape\r\n\r\n return align_image","def face_lm_preprocess(img, detections, scale, padding):\n # Only handles detections from the 1st image\n detections = denormalize_detections(detections[0], 128, scale[0], padding[[0, 2]])\n xc, yc, roi_scale, theta = detection2roi(detections)\n input_face_lm, affine, _ = extract_roi(img[..., ::-1], xc, yc, theta, roi_scale)\n centers = np.stack((xc, yc), axis=1)\n\n return input_face_lm, affine, centers, theta","def add_faces_to_map(bm, faces, group, skip=None):\n face_map = bm.faces.layers.face_map.active\n group_index = face_map_index_from_name(group.name.lower())\n\n def remove_skipped(f):\n if skip:\n skip_index = face_map_index_from_name(skip.name.lower())\n return not (f[face_map] == skip_index)\n return True\n\n for face in list(filter(remove_skipped, faces)):\n face[face_map] = group_index\n\n obj = bpy.context.object\n\n # -- if auto uv map is set, perform UV Mapping for given faces\n if obj.facemap_materials[group_index].auto_map:\n map_method = obj.facemap_materials[group_index].uv_mapping_method\n uv_map_active_editmesh_selection(faces, map_method)\n\n # -- if the facemap already has a material assigned, assign the new faces to the material\n mat = obj.facemap_materials[group_index].material\n mat_id = [idx for idx, m in enumerate(obj.data.materials) if m == mat]\n if mat_id:\n for f in faces:\n f.material_index = mat_id[-1]","def align_image(\n src_im:np.ndarray, \n ref_im:np.ndarray, \n crop_list=None,\n use_autocorr=True, precision_fold=100, \n min_good_drifts=3, drift_diff_th=1.,\n all_channels=_allowed_colors, \n ref_all_channels=None, \n drift_channel='488',\n correction_args={},\n fitting_args={},\n match_distance_th=2.,\n verbose=True, \n detailed_verbose=False, \n ):\n \n from ..io_tools.load import correct_fov_image\n from ..spot_tools.fitting import fit_fov_image\n from ..spot_tools.fitting import select_sparse_centers\n from skimage.registration import phase_cross_correlation\n #print(\"**\", type(src_im), type(ref_im))\n ## check inputs\n # correciton keywords\n _correction_args = {_k:_v for _k,_v in _default_align_corr_args.items()}\n _correction_args.update(correction_args)\n # fitting keywords\n _fitting_args = {_k:_v for _k,_v in _default_align_fitting_args.items()}\n _fitting_args.update(fitting_args)\n \n # check crop_list:\n if crop_list is None:\n crop_list = generate_drift_crops(_correction_args['single_im_size'])\n for _crop in crop_list:\n if np.shape(np.array(_crop)) != (3,2):\n raise IndexError(f\"crop should be 3x2 np.ndarray.\")\n # check channels\n _all_channels = [str(_ch) for _ch in all_channels]\n # check bead_channel\n _drift_channel = str(drift_channel)\n if _drift_channel not in all_channels:\n raise ValueError(f\"bead channel {_drift_channel} not exist in all channels given:{_all_channels}\")\n # check ref_all_channels\n if ref_all_channels is None:\n _ref_all_channels = _all_channels\n else:\n _ref_all_channels = [str(_ch) for _ch in ref_all_channels]\n \n ## process source image\n # define result flag\n _result_flag = 0\n # process image\n if isinstance(src_im, np.ndarray):\n if verbose:\n print(f\"-- start aligning given source image to\", end=' ')\n _src_im = src_im\n elif isinstance(src_im, str):\n if verbose:\n print(f\"-- start aligning file {src_im}.\", end=' ')\n if not os.path.isfile(src_im) or src_im.split('.')[-1] != 'dax':\n raise IOError(f\"input src_im: {src_im} should be a .dax file!\")\n _src_im = correct_fov_image(src_im, [_drift_channel], \n all_channels=_all_channels,\n calculate_drift=False, \n return_drift=False, verbose=detailed_verbose,\n **_correction_args)[0]\n else:\n raise IOError(f\"Wrong input file type, {type(src_im)} should be .dax file or np.ndarray\")\n \n ## process reference image\n if isinstance(ref_im, np.ndarray):\n if verbose:\n print(f\"given reference image.\")\n _ref_im = ref_im\n elif isinstance(ref_im, str):\n if verbose:\n print(f\"reference file:{ref_im}.\")\n if not os.path.isfile(ref_im) or ref_im.split('.')[-1] != 'dax':\n raise IOError(f\"input ref_im: {ref_im} should be a .dax file!\")\n _ref_im = correct_fov_image(ref_im, [_drift_channel], \n all_channels=_ref_all_channels,\n calculate_drift=False, \n return_drift=False, verbose=detailed_verbose,\n **_correction_args)[0][0]\n else:\n raise IOError(f\"Wrong input ref file type, {type(ref_im)} should be .dax file or np.ndarray\")\n\n if np.shape(_src_im) != np.shape(_ref_im):\n raise IndexError(f\"shape of target image:{np.shape(_src_im)} and reference image:{np.shape(_ref_im)} doesnt match!\")\n\n ## crop images\n _crop_src_ims, _crop_ref_ims = [], []\n for _crop in crop_list:\n _s = tuple([slice(*np.array(_c,dtype=np.int)) for _c in _crop])\n _crop_src_ims.append(_src_im[_s])\n _crop_ref_ims.append(_ref_im[_s])\n ## align two images\n _drifts = []\n for _i, (_sim, _rim) in enumerate(zip(_crop_src_ims, _crop_ref_ims)):\n _start_time = time.time()\n if use_autocorr:\n if detailed_verbose:\n print(\"--- use auto correlation to calculate drift.\")\n # calculate drift with autocorr\n _dft, _error, _phasediff = phase_cross_correlation(_rim, _sim, \n upsample_factor=precision_fold)\n else:\n if detailed_verbose:\n print(\"--- use beads fitting to calculate drift.\")\n # source\n _src_spots = fit_fov_image(_sim, _drift_channel, \n verbose=detailed_verbose,\n **_fitting_args) # fit source spots\n _sp_src_cts = select_sparse_centers(_src_spots[:,1:4], match_distance_th) # select sparse source spots\n # reference\n _ref_spots = fit_fov_image(_rim, _drift_channel, \n verbose=detailed_verbose,\n **_fitting_args)\n _sp_ref_cts = select_sparse_centers(_ref_spots[:,1:4], match_distance_th, \n verbose=detailed_verbose) # select sparse ref spots\n #print(_sp_src_cts, _sp_ref_cts)\n \n # align\n _dft, _paired_src_cts, _paired_ref_cts = align_beads(\n _sp_src_cts, _sp_ref_cts,\n _sim, _rim,\n use_fft=True,\n match_distance_th=match_distance_th, \n return_paired_cts=True,\n verbose=detailed_verbose,\n )\n _dft = _dft * -1 # beads center is the opposite as cross correlation\n # append \n _drifts.append(_dft) \n if verbose:\n print(f\"-- drift {_i}: {np.around(_dft, 2)} in {time.time()-_start_time:.3f}s.\")\n\n # detect variance within existing drifts\n _mean_dft = np.nanmean(_drifts, axis=0)\n if len(_drifts) >= min_good_drifts:\n _dists = np.linalg.norm(_drifts-_mean_dft, axis=1)\n _kept_drift_inds = np.where(_dists <= drift_diff_th)[0]\n if len(_kept_drift_inds) >= min_good_drifts:\n _updated_mean_dft = np.nanmean(np.array(_drifts)[_kept_drift_inds], axis=0)\n _result_flag += 0\n if verbose:\n print(f\"--- drifts for crops:{_kept_drift_inds} pass the thresold, exit cycle.\")\n break\n \n if '_updated_mean_dft' not in locals():\n if verbose:\n print(f\"-- return a sub-optimal drift\")\n _drifts = np.array(_drifts)\n # select top 3 drifts\n from scipy.spatial.distance import pdist, squareform\n _dist_mat = squareform(pdist(_drifts))\n np.fill_diagonal(_dist_mat, np.inf)\n # select closest pair\n _sel_inds = np.array(np.unravel_index(np.argmin(_dist_mat), np.shape(_dist_mat)))\n _sel_drifts = list(_drifts[_sel_inds])\n # select closest 3rd drift\n _sel_drifts.append(_drifts[np.argmin(_dist_mat[:, _sel_inds].sum(1))])\n if detailed_verbose:\n print(f\"--- select drifts: {np.round(_sel_drifts, 2)}\")\n # return mean\n _updated_mean_dft = np.nanmean(_sel_drifts, axis=0)\n _result_flag += 1\n\n return _updated_mean_dft, _result_flag","def find_face(im, bias=None, padding=0, min_padding=0):\n\n # Import optional libraries required for face detection\n import dlib\n from skimage import io as skimage_io\n skimage_io.use_plugin('pil')\n\n # Check we have already aquired a face detector and if not do so now\n if not hasattr(Variation, '_face_detector'):\n Variation._face_detector = dlib.get_frontal_face_detector()\n\n # Convert the image to an array that can be read by skimage\n w, h = im.size\n skimage_im = numpy.array(im.getdata(), numpy.uint8).reshape(h, w, 3)\n\n d = dlib.get_frontal_face_detector()\n faces = d(skimage_im, 1)\n\n # Detect faces\n faces = Variation._face_detector(skimage_im, 1)\n\n # If no faces were detected there's nothing more to do, we return `None`\n if len(faces) == 0:\n return\n\n # If a face was found apply any bias and padding to it\n face = faces[0]\n rect = [face.left(), face.top(), face.right(), face.bottom()]\n\n # Apply bias\n if bias:\n # Shift the center of the face\n bias_x = int(face.width() * bias[0])\n bias_y = int(face.width() * bias[1])\n rect[0] += bias_x\n rect[1] += bias_y\n rect[2] += bias_x\n rect[3] += bias_y\n\n # Apply padding\n if padding > 0:\n\n # Determine the maximum amount of padding that can be applied in any\n # direction.\n max_padding = rect[0]\n max_padding = min(rect[1], max_padding)\n max_padding = min(rect[2], max_padding)\n max_padding = min(rect[3], max_padding)\n\n # Calculate the padding to apply\n pad = [\n int(face.width() * padding),\n int(face.height() * padding)\n ]\n\n # Ensure that the minimum padding is observed\n if min_padding > 0:\n pad = [\n min(pad[0], max(max_padding, int(pad[0] * min_padding))),\n min(pad[1], max(max_padding, int(pad[1] * min_padding)))\n ]\n\n # Apply the padding to the face rectangle\n rect[0] = max(rect[0] - pad[0], 0)\n rect[1] = max(rect[1] - pad[1], 0)\n rect[2] = min(rect[2] + pad[0], im.size[0])\n rect[3] = min(rect[3] + pad[1], im.size[1])\n\n return rect","def detect_face(self, img):\n # Fetch face location from the frame with 128 encoding of face landmarks\n curr_face_loc, name_list, info_list = load_encode_loc(img, self.kwn_names,\n self.kwn_encoding,\n self.status_list, self.since_list)\n print('Current value is ', curr_face_loc, name_list)\n face_list = []\n face_area = []\n print('face loc', curr_face_loc)\n if len(curr_face_loc):\n\n for (top, right, bottom, left), name in zip(curr_face_loc, name_list):\n print(top, right, bottom, left)\n cv2.rectangle(img, (top, right), (bottom, left), (0, 255, 2), 2)\n\n w = right - left\n h = bottom - top\n cx = left + w // 2\n cy = top + h // 2\n area = w * h\n\n for idx, info in enumerate(info_list):\n cv2.putText(img, info, (bottom, int(left * idx * 0.2)),\n cv2.FONT_HERSHEY_COMPLEX, 1,\n (0, 0, 255), 1)\n\n face_list.append([cx, cy])\n face_area.append(area)\n\n i = face_area.index(max(face_area))\n\n return img, [face_list[i], face_area[i]]\n\n else:\n return img, [[0, 0], 0]","def AlignFieldmaps(self):\n for entry in self.entry_map['fmap']:\n info = self.info[entry]\n\n# Register the magnitude image at the shortest TR to the T1-IR\n# structural image.\n target = self.info[self.norm_src]['imgfile'] + \\\n self.info[self.norm_src]['suffix']\n source = info['magfile'] + info['suffix']\n matfile = info['matfile']\n fmt = '3dAllineate -prefix NULL -1Dmatrix_save %s -base %s ' + \\\n '-source %s -cost mi -warp shift_rotate'\n cmd = fmt % (info['matfile'], target, source)\n self.CheckExec(cmd, [info['matfile']])\n\n# Convert to unitary matrix (remove scaling component.)\n cmd = 'cat_matvec -ONELINE %s -P > %s' % \\\n (info['matfile'], info['matfile_unitary'])\n self.CheckExec(cmd, [info['matfile_unitary']])\n\n# Rotate the magnitude image to the new grid.\n fmt = '3dAllineate -prefix %s -interp cubic -1Dmatrix_apply %s %s'\n cmd = fmt % (info['magfile_r']+info['suffix'], \\\n info['matfile_unitary'], info['magfile'] + info['suffix'])\n self.CheckExec(cmd, [info['magfile_r']+info['suffix']])\n\n# Rotate the fieldmap to the new grid.\n fmt = '3dAllineate -prefix %s -interp cubic -1Dmatrix_apply %s %s'\n cmd = fmt % (info['imgfile_r']+info['suffix'], \\\n info['matfile_unitary'], info['imgfile'] + info['suffix'])\n self.CheckExec(cmd, [info['imgfile_r']+info['suffix']])","def generate_anchor_boxes(image_size, feature_map_size, sizes, scales):\n image_height, image_width = image_size\n fm_height, fm_width = feature_map_size\n height_stride = int(image_height / fm_height)\n width_stride = int(image_width / fm_width)\n\n # Compose horizontal and vertical positions into grid and reshape result into (-1, 2)\n y_centers = np.arange(0, image_height, height_stride)\n x_centers = np.arange(0, image_width, width_stride)\n centers = np.dstack(np.meshgrid(y_centers, x_centers)).reshape((-1, 2))\n\n # Creates anchor boxes pyramid. Somewhat vectorized version of itertools.product\n r_scales = np.repeat([scales], len(sizes), axis=0).ravel()\n r_sides = np.repeat([sizes], len(scales), axis=1).ravel()\n ab_pyramid = np.transpose([r_sides / (r_scales ** .5),\n r_sides * (r_scales ** .5)]).astype(int)\n\n # Creates combinations of all anchor boxes centers and sides\n r_centers = np.repeat(centers, len(ab_pyramid), axis=0)\n r_ab_pyramid = np.repeat([ab_pyramid], len(centers), axis=0).reshape((-1, 2))\n return np.hstack((r_centers, r_ab_pyramid))","def __scale_and_shift(self, image, landmarks, scale_range, output_size):\n (x1, y1, x2, y2), new_size, need_pad, (p_x, p_y, p_w, p_h) = self.get_bbox_of_landmarks(\n image, landmarks, scale_range, shift_rate=0.3)\n box_image = image[y1:y2, x1:x2]\n if need_pad:\n box_image = np.lib.pad(box_image, ((p_y, p_h), (p_x, p_w), (0, 0)), 'constant')\n box_image = cv2.resize(box_image, (output_size, output_size))\n landmarks = (landmarks - (x1 - p_x, y1 - p_y)) / (new_size, new_size)\n return box_image, landmarks","def add_boundary_regions(regions=None, faces=['front', 'back', 'left',\n 'right', 'top', 'bottom']):\n if faces is None:\n return regions\n\n if regions.ndim not in [2, 3]:\n raise Exception(\"add_boundary_regions works only on 2D and 3D images\")\n\n if regions.ndim == 2:\n if set([\"bottom\", \"top\"]).intersection(faces):\n raise Exception(\"For 2D images, use 'left', 'right', 'front', 'back' labels\")\n\n # Map which image slice corresponds to which face\n face_to_slice = {\n \"left\": 0, \"right\": -1, \"front\": 0, \"back\": -1, \"bottom\": 0, \"top\": -1\n }\n # Map face label to corresponding axis\n face_to_axis = {\n \"left\": 0, \"right\": 0, \"front\": 1, \"back\": 1, \"bottom\": 2, \"top\": 2\n }\n\n ndim = regions.ndim\n indices = []\n # Note: pad_width format: each elem is [pad_before, pad_after]\n pad_width = [[0, 0] for i in range(ndim)]\n # 1. Create indices for boundary faces, ex. bottom\" => [:, :, -1]\n # Note: slice(None) is equivalent to \":\" in fancy indexing, ex. [0, 0, :]\n # 2. populate pad_width based on labels\n for face in faces:\n temp = [slice(None) for i in range(ndim)]\n axis = face_to_axis[face]\n plane = face_to_slice[face]\n temp[axis] = plane\n indices.append(tuple(temp))\n pad_width[axis][plane] = 1 # Pad each face by 1 pixel\n\n regions = np.pad(regions, pad_width=pad_width, mode=\"edge\")\n\n # Increment boundary regions to distinguish from internal regions\n for idx in indices:\n # Only increment non-background regions (i.e. != 0)\n non_background = regions[idx] != 0\n regions[idx][non_background] += regions.max()\n\n # Remove connections between boundary regions\n for idx in indices:\n regions[idx] *= ~find_boundaries(regions[idx], mode=\"outer\")\n\n # Pad twice to make boundary regions 3-pixel thick -> required for marching_cube\n regions = np.pad(regions, pad_width=pad_width, mode=\"edge\")\n regions = np.pad(regions, pad_width=pad_width, mode=\"edge\")\n\n # Convert pad-induced corners to 0\n zero_corners(regions, pad_width)\n\n # Make labels contiguous\n regions = make_contiguous(regions)\n\n return regions","def main():\n filename = sys.argv[1]\n aligner = Aligner(cv2.imread(filename))\n aligned_image = aligner.get_aligned_image()\n\n return aligned_image","def transform_grouped_faces(bm, faces, prop):\r\n face_height = max(map(lambda f: calc_face_dimensions(f)[1], faces))\r\n target_height = clamp(prop.height, 0.01, face_height)\r\n prop.height = target_height\r\n\r\n trans_offset = target_height - face_height\r\n verts = list({v for f in faces for v in f.verts})\r\n top_verts = sort_verts(verts, VEC_UP)[len(verts) // 2 :]\r\n bmesh.ops.translate(bm, verts=top_verts, vec=VEC_UP * trans_offset)\r\n bmesh.ops.translate(bm, verts=verts, vec=VEC_UP * prop.height)","def _merge_face(merge, image, face):\n scaled = merge.image.resize(face.as_dimension()).convert(\"RGBA\")\n image.image = image.image.convert(\"RGBA\")\n image.image.paste(scaled, face.as_box(), mask=scaled)\n return image","def soft_align_faces(self):\n drivers_idx = [self.joints_qpos_map[x] for x in self.drivers]\n\n current_angles = self.sim.data.qpos[drivers_idx]\n straight_angles = rotation.round_to_straight_angles(current_angles)\n normalized_diff = rotation.normalize_angles(straight_angles - current_angles)\n\n # From the largest angle to the smallest\n for _, idx in reversed(\n sorted(zip(np.abs(normalized_diff), range(len(normalized_diff))))\n ):\n self.rotate_face(idx // 2, idx % 2, normalized_diff[idx])\n\n # Align all little cubelets at the end\n for i in range(27):\n info = self.cubelet_meta_info[i]\n\n if \"euler_qpos\" in info:\n mtx = self._cubelet_rotation_matrix(info, self.sim.data.qpos)\n # Much better alignment than in the euler angle representation\n # If the cube is close enough to the aligned state it should work\n mtx = mtx.round()\n self.sim.data.qpos[info[\"euler_qpos\"]] = rotation.mat2euler(mtx)","def align_image(ref_image, img2transf,\n n_ref_src=50, n_img_src=70, px_tol=2.):\n\n from scipy.ndimage.interpolation import affine_transform\n\n try:\n import sep # noqa\n except ImportError:\n source_finder = find_sources\n else:\n source_finder = find_sources_with_sep\n\n ref_srcs = source_finder(ref_image)[:n_ref_src]\n img_sources = source_finder(img2transf)[:n_img_src]\n\n m = find_affine_transform(ref_srcs, ref_srcs=img_sources,\n max_pix_tol=px_tol)\n\n # SciPy Affine transformation transform a (row,col) pixel according to pT+s\n # where p is in the _output_ image, T is the rotation and s the translation\n # offset, so some mathematics is required to put it into a suitable form\n # In particular, affine_transform() requires the inverse transformation\n # that registration returns but for (row, col) instead of (x,y)\n def inverse_transform(m):\n m_rot_inv = np.linalg.inv(m[:2, :2])\n m_offset_inv = -m_rot_inv.dot(m[:2, 2])\n m_inv = np.zeros(m.shape)\n m_inv[:2, :2] = m_rot_inv\n m_inv[:2, 2] = m_offset_inv\n if m.shape == (3, 3):\n m_inv[2, 2] = 1\n return m_inv\n\n m_inv = inverse_transform(m)\n # p will transform from (x,y) to (row, col)=(y,x)\n p = np.array([[0, 1], [1, 0]])\n mrcinv_rot = p.dot(m_inv[:2, :2]).dot(p)\n mrcinv_offset = p.dot(m_inv[:2, 2])\n\n aligned_image = affine_transform(img2transf, mrcinv_rot,\n offset=mrcinv_offset,\n output_shape=ref_image.shape,\n cval=np.median(img2transf)\n )\n if isinstance(img2transf, np.ma.MaskedArray):\n # it could be that img2transf's mask is just set to False\n if type(img2transf.mask) is np.ndarray:\n aligned_image_mask = \\\n affine_transform(img2transf.mask.astype('float32'),\n mrcinv_rot,\n offset=mrcinv_offset,\n output_shape=ref_image.shape,\n cval=1.0\n )\n aligned_image_mask = aligned_image_mask > 0.4\n aligned_image = np.ma.array(aligned_image, mask=aligned_image_mask)\n else:\n # If img2transf is masked array with mask set to false, we\n # return the same\n aligned_image = np.ma.array(aligned_image)\n return aligned_image","def draw_and_show_landmarks_and_head_pose(landmarks, image, yaw='unknown', pitch='unknown', roll='unknown', info_text=''):\n for pos in landmarks:\n cv2.circle(image, (int(pos[0]), int(pos[1])), 5, (0, 0, 255), -1)\n cv2.putText(image, 'Yaw: {}'.format(yaw), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)\n cv2.putText(image, 'Pitch: {}'.format(pitch), (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)\n cv2.putText(image, 'Roll: {}'.format(roll), (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)\n cv2.putText(image, info_text, (10, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)\n\n if not isinstance(yaw, str) and not isinstance(pitch, str) and not isinstance(roll, str):\n # Create rotation matrix\n rotation = Rotation.from_euler('yxz', [-yaw, pitch, roll], degrees=True)\n rotation_matrix = rotation.as_dcm()\n # offsets to axis end-points\n axis_points = np.float32([[50, 0, 0],\n [0, -50, 0],\n [0, 0, 50],\n ])\n\n # position in image\n position = np.array([60, image.shape[0] - 60, 0])\n\n axis = np.zeros((3, 3), dtype=float)\n axis[0] = np.dot(rotation_matrix, axis_points[0]) + position\n axis[1] = np.dot(rotation_matrix, axis_points[1]) + position\n axis[2] = np.dot(rotation_matrix, axis_points[2]) + position\n\n cv2.rectangle(image,\n (0, image.shape[0] - 120),\n (120, image.shape[0]),\n (255, 255, 255),\n -1)\n cv2.line(image, (int(position[0]), int(position[1])), (int(axis[1][0]), int(axis[1][1])), (0, 255, 0), 3)\n cv2.line(image, (int(position[0]), int(position[1])), (int(axis[0][0]), int(axis[0][1])), (255, 0, 0), 3)\n cv2.line(image, (int(position[0]), int(position[1])), (int(axis[2][0]), int(axis[2][1])), (0, 0, 255), 3)\n\n cv2.imshow('Out', image)","def align_image(rgb, thresh=0.02, step=1, channel=1):\n r = assess_rotations(rgb, thresh=thresh, step=step, channel=channel)\n rot_id = np.argmax(r['prominences'])\n best_rotation = step * rot_id\n n_rows = r['numbers'][rot_id]\n print(\"Optimal rotation angle: {} degrees.\".format(best_rotation))\n print(\"Number of rows identified: {}.\".format(n_rows))\n rotated_image = imutils.rotate(rgb, best_rotation)\n return rotated_image","def aligned_landmarks(self):\n landmarks = AlignerExtract().transform_points(self.landmarksXY,\n self.aligned[\"matrix\"],\n self.aligned[\"size\"],\n self.aligned[\"padding\"])\n return landmarks","def group2mmdetection(group: dict) -> dict:\n\n image_id, group = group\n filename = group['filename'].values[0]\n fullpath = osp.join(IMG_DIR, filename)\n assert image_id == osp.basename(filename).split('.')[0]\n\n width, height = get_image_size(fullpath)\n\n group['XMin'] = group['XMin'] * width\n group['XMax'] = group['XMax'] * width\n group['YMin'] = group['YMin'] * height\n group['YMax'] = group['YMax'] * height\n\n bboxes = [np.expand_dims(group[col].values, -1) for col in['XMin', 'YMin', 'XMax', 'YMax']]\n bboxes = np.concatenate(bboxes, axis=1)\n #print(bboxes)\n #print(bboxes.shape)\n return {\n 'filename': group['filename'].values[0], #image_id+'.jpg',\n 'width': width,\n 'height': height,\n 'ann': {\n 'bboxes': np.array(bboxes, dtype=np.float32),\n 'labels': np.array([stoi[x] for x in group['LabelName'].values]) + 1\n }\n }","def process_image_bbox(image, bbox, labels, file_name):\n bounds, classes, scores = postprocessing(bbox, image)\n image_processed = annotate(image, bounds, classes, scores, labels)\n image_processed.save(file_name, 'png')\n return image_processed","def center_image_grid_anchors(image_grid):\n for image in image_grid:\n center_image_anchor(image)","def anchor_target_layer(rpn_cls_score, gt_boxes, im_info, _feat_stride, all_anchors, num_anchors):\n A = num_anchors\n total_anchors = all_anchors.shape[0]\n K = total_anchors / num_anchors\n\n # allow boxes to sit over the edge by a small amount\n _allowed_border = 0\n\n # map of shape (..., H, W)\n height, width = rpn_cls_score.shape[1:3]\n\n # only keep anchors inside the image\n inds_inside = np.where(\n (all_anchors[:, 0] >= -_allowed_border) &\n (all_anchors[:, 1] >= -_allowed_border) &\n (all_anchors[:, 2] < im_info[1] + _allowed_border) & # width\n (all_anchors[:, 3] < im_info[0] + _allowed_border) # height\n )[0]\n\n # keep only inside anchors\n anchors = all_anchors[inds_inside, :]\n\n # label: 1 is positive, 0 is negative, -1 is dont care\n labels = np.empty((len(inds_inside),), dtype=np.float32)\n labels.fill(-1)\n\n # overlaps between the anchors and the gt boxes\n # overlaps (ex, gt)\n overlaps = bbox_overlaps(\n np.ascontiguousarray(anchors, dtype=np.float),\n np.ascontiguousarray(gt_boxes, dtype=np.float))\n argmax_overlaps = overlaps.argmax(axis=1)\n max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]\n gt_argmax_overlaps = overlaps.argmax(axis=0)\n gt_max_overlaps = overlaps[gt_argmax_overlaps,\n np.arange(overlaps.shape[1])]\n gt_argmax_overlaps = np.where(overlaps == gt_max_overlaps)[0]\n\n if not cfg.TRAIN.RPN_CLOBBER_POSITIVES:\n # assign bg labels first so that positive labels can clobber them\n # first set the negatives\n labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0\n\n # fg label: for each gt, anchor with highest overlap\n labels[gt_argmax_overlaps] = 1\n\n # fg label: above threshold IOU\n labels[max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = 1\n\n if cfg.TRAIN.RPN_CLOBBER_POSITIVES:\n # assign bg labels last so that negative labels can clobber positives\n labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0\n\n # subsample positive labels if we have too many\n num_fg = int(cfg.TRAIN.RPN_FG_FRACTION * cfg.TRAIN.RPN_BATCHSIZE)\n fg_inds = np.where(labels == 1)[0]\n if len(fg_inds) > num_fg:\n disable_inds = npr.choice(\n fg_inds, size=(len(fg_inds) - num_fg), replace=False)\n labels[disable_inds] = -1\n\n # subsample negative labels if we have too many\n num_bg = cfg.TRAIN.RPN_BATCHSIZE - np.sum(labels == 1)\n bg_inds = np.where(labels == 0)[0]\n if len(bg_inds) > num_bg:\n disable_inds = npr.choice(\n bg_inds, size=(len(bg_inds) - num_bg), replace=False)\n labels[disable_inds] = -1\n\n bbox_targets = np.zeros((len(inds_inside), 4), dtype=np.float32)\n bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])\n\n bbox_inside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)\n # only the positive ones have regression targets\n bbox_inside_weights[labels == 1, :] = np.array(cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS)\n\n bbox_outside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)\n if cfg.TRAIN.RPN_POSITIVE_WEIGHT < 0:\n # uniform weighting of examples (given non-uniform sampling)\n num_examples = np.sum(labels >= 0)\n positive_weights = np.ones((1, 4)) * 1.0 / num_examples\n negative_weights = np.ones((1, 4)) * 1.0 / num_examples\n else:\n assert ((cfg.TRAIN.RPN_POSITIVE_WEIGHT > 0) &\n (cfg.TRAIN.RPN_POSITIVE_WEIGHT < 1))\n positive_weights = (cfg.TRAIN.RPN_POSITIVE_WEIGHT /\n np.sum(labels == 1))\n negative_weights = ((1.0 - cfg.TRAIN.RPN_POSITIVE_WEIGHT) /\n np.sum(labels == 0))\n bbox_outside_weights[labels == 1, :] = positive_weights\n bbox_outside_weights[labels == 0, :] = negative_weights\n\n # map up to original set of anchors\n labels = _unmap(labels, total_anchors, inds_inside, fill=-1)\n bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, fill=0)\n bbox_inside_weights = _unmap(bbox_inside_weights, total_anchors, inds_inside, fill=0)\n bbox_outside_weights = _unmap(bbox_outside_weights, total_anchors, inds_inside, fill=0)\n\n # labels\n labels = labels.reshape((1, height, width, A)).transpose(0, 3, 1, 2)\n labels = labels.reshape((1, 1, A * height, width))\n rpn_labels = labels\n\n # bbox_targets\n bbox_targets = bbox_targets \\\n .reshape((1, height, width, A * 4))\n\n rpn_bbox_targets = bbox_targets\n # bbox_inside_weights\n bbox_inside_weights = bbox_inside_weights \\\n .reshape((1, height, width, A * 4))\n\n rpn_bbox_inside_weights = bbox_inside_weights\n\n # bbox_outside_weights\n bbox_outside_weights = bbox_outside_weights \\\n .reshape((1, height, width, A * 4))\n\n rpn_bbox_outside_weights = bbox_outside_weights\n return rpn_labels, rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights","def apply_alignment_matrix(job, matrix):\n # Get the SVG-style 6-element vector from the 3x3 matrix\n mat = [matrix[0][0], matrix[1][0], matrix[0][1], matrix[1][1], matrix[0][2], matrix[1][2]]\n\n # Only the 'defs' list contains coordinates that need to be transformed\n defs = job['defs']\n\n for one_def in defs:\n if one_def['kind'] == \"image\":\n # TODO: raster images are not supported!\n # The rest of the code assumes the rows of pixel data are aligned\n # with the X axis, so handling rotation will require transforming\n # the entire image and generating new data.\n pass\n elif one_def['kind'] == \"path\":\n for one_path in one_def['data']:\n for one_point in one_path:\n matrixApply(mat, one_point)","def process(self, img, enableMouthDetection = Global.DETECT_MOUTH_AREA_FLAG):\n mouthPos=[]\n [maxH,maxW,channels] = img.shape\n facePos = self.faceDetector.detect_biggest(img, self.faceScales, self.faceNeightbors)\n # print facePos\n if enableMouthDetection and len(facePos)>0:\n mouthDetectingArea = adjustRoiWithinRange(facePos[0], facePos[1], facePos[2], facePos[3], 0.1, 0.1, 0.5, -0.3, maxW, maxH)\n mouthRegionForDetection = getROI(img, mouthDetectingArea)\n mouthPos = self.mouthDetector.detect_biggest(mouthRegionForDetection, self.mouthScales, self.mouthNeighbors)\n if len(mouthPos) > 0:\n mouthPos[0] += mouthDetectingArea[0]\n mouthPos[1] += mouthDetectingArea[1]\n return [ facePos, mouthPos]","def center_image(image):\r\n image.anchor_x = image.width / 2\r\n image.anchor_y = image.height / 2","def center_image(image):\r\n image.anchor_x = image.width / 2\r\n image.anchor_y = image.height / 2","def assign_landmark_to_box(self, landmarks_pos, boxes):\n for box in boxes:\n # extract box corners\n bottom, right, top, left = box\n # initialise the counter for each box\n confirmed_box = 0\n for feature_pos in landmarks_pos:\n # extract the feature averaged position\n mean_w, mean_h = feature_pos\n # states if the feature position is inside the face box corners\n if (bottom < mean_h < top\n and left < mean_w < right):\n # if the feature is inside we increae the counter\n confirmed_box = confirmed_box + 1\n\n # if every feature is inside the box there is a match\n if confirmed_box == len(landmarks_pos):\n print(\"0k\")\n return box\n\n return None","def map_face(self):\n #Array Order: U0,D1,R2,L3,F4,B5,\n \n cube_list = []\n cube_list = self.cube.definition()\n \n for index, cubit in enumerate(self.faces['Up']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index]])\n for index, cubit in enumerate(self.faces['Ri']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+9]])\n for index, cubit in enumerate(self.faces['Ft']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+18]])\n for index, cubit in enumerate(self.faces['Dn']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+27]])\n for index, cubit in enumerate(self.faces['Le']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+36]])\n for index, cubit in enumerate(self.faces['Bk']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+45]])","def batch_align(image_list, dest_dir=\"output\"):\n if not path.exists(dest_dir):\n mkdir(dest_dir)\n if path.isdir(dest_dir):\n print \"Aligning %d images, output in %s, this may take a while\" % (len(im_list), dest_dir)\n\n ref_img = io.imread(image_list[0])\n r = Parallel(n_jobs=4, backend=\"threading\", verbose=25)(\n delayed(find_shift)(io.imread(img), ref_img) for img in image_list[1:])\n y_shift = map(lambda x: x[0], r)\n x_shift = map(lambda x: x[1], r)\n\n print min(y_shift), max(y_shift), min(x_shift), max(x_shift)\n crop = [int(min(y_shift)) - 1, int(max(y_shift)) + 1, int(min(x_shift)) - 1, int(max(x_shift)) + 1]\n\n correct(ref_img, (0, 0), \"%s/%s\" % (dest_dir, path.basename(image_list[0])), crop)\n Parallel(n_jobs=4, backend=\"threading\", verbose=25)(\n delayed(correct)(io.imread(img), r[k], \"%s/%s\" % (dest_dir, path.basename(image_list[k])), crop)\n for k, img in enumerate(image_list[1:]))\n else:\n print \"Output dir does not exists or is not a directory : %s\" % dest_dir","def aligned_face(self):\n return self.aligned[\"face\"]","def get_landmarks(self, image): # from https://www.paulvangent.com/2016/08/05/emotion-recognition-using-facial-landmarks/\n # Ask the detector to find the bounding boxes of each face. The 1 in the\n # second argument indicates that we should upsample the image 1 time. This\n # will make everything bigger and allow us to detect more faces.\n detections = self.detector(image, 1)\n if len(detections) < 1: # Number of faces detected = 0\n # print(\"Number of faces detected: {}\".format(len(detections)))\n return None\n # Draw Facial Landmarks with the predictor class\n shape = self.predictor(image, detections[0])\n xlist = []\n ylist = []\n for i in range(68): # Store X and Y coordinates in two lists\n xlist.append(float(shape.part(i).x))\n ylist.append(float(shape.part(i).y))\n\n landmarks_vectorised = []\n landmarks_vectorised = self.our_ft_landmark(xlist, ylist)# Extaraction des features\n\n xmean = np.mean(xlist)\n ymean = np.mean(ylist)\n xcentral = [(x-xmean) for x in xlist]\n ycentral = [(y-ymean) for y in ylist]\n \n for x, y, w, z in zip(xcentral, ycentral, xlist, ylist):\n landmarks_vectorised.append(w)\n landmarks_vectorised.append(z)\n # landmarks_vectorised.append(x)\n # landmarks_vectorised.append(y)\n meannp = np.asarray((ymean, xmean))\n coornp = np.asarray((z, w))\n dist = np.linalg.norm(coornp-meannp)# Distance euclidienne\n landmarks_vectorised.append(dist)\n landmarks_vectorised.append((math.atan2(y, x)*360)/(2*math.pi))# Calcule de l'ongle entre le moyenne et un point\n\n return landmarks_vectorised","def add_bbox(self, image_path, image_size, obj):\n\n if image_path not in self.img_path_2_img_id:\n self.img_path_2_img_id[image_path] = len(self.img_path_2_img_id)\n\n self.annotation['images'].append({\n \"file_name\": image_path,\n \"height\": image_size[1],\n \"width\": image_size[0],\n \"id\": self.img_path_2_img_id[image_path]\n })\n\n new_ann_id = len(self.annotation['annotations'])\n self.img_id_2_ann_id[self.img_path_2_img_id[image_path]].append(new_ann_id)\n bbox = self.fit_box_in_image(obj['bbox'], image_size)\n\n if bbox:\n self.annotation['annotations'].append({\n \"bbox\": bbox, # x, y, w, h\n \"segmentation\": obj['segmentation'],\n \"attributes\": obj['attributes'],\n \"ignore\": 0,\n \"id\": new_ann_id,\n \"image_id\": self.img_path_2_img_id[image_path],\n \"area\": obj['bbox'][2] * obj['bbox'][3],\n \"iscrowd\": 1 - int(obj['attributes']['legible']),\n \"category_id\": self.label_map['text']\n })","def align(filename, prog, outfile):\n ra = RunAlign()\n ra.run_align(filename, prog, outfile)","def _vertices2landmarks(self, vertices, faces, lmk_faces_idx, lmk_bary_coords):\n batch_size, num_verts = vertices.shape[:dd2]\n lmk_faces = torch.index_select(faces, 0, lmk_faces_idx.view(-1)).view(1, -1, 3).view(batch_size, lmk_faces_idx.shape[1], -1)\n lmk_faces += torch.arange(batch_size, dtype=torch.long).view(-1, 1, 1) * num_verts\n lmk_vertices = vertices.view(-1, 3)[lmk_faces]\n landmarks = torch.einsum('blfi,blf->bli', [lmk_vertices, lmk_bary_coords])\n return landmarks","def detect_face_landmarks(gray_img, detector, predictor):\r\n # detect face in the grayscale image\r\n rects = detector(gray_img, 1)\r\n \r\n if len(rects)==0:\r\n # if no face was detected, we set the rectangle arbitrarily\r\n p = 24\r\n rect = dlib.rectangle(p,p,gray_img.shape[0]-p,gray_img.shape[1]-p)\r\n else:\r\n rect = rects[0]\r\n\r\n # determine the facial landmarks for the face region\r\n face_landmarks = face_utils.shape_to_np(predictor(gray_img, rect))\r\n face_landmarks = face_landmarks[17:] # remove landmarks around the face (useless)\r\n \r\n return face_landmarks","def __convert_3d_bbox_to_corners(self, bbox: BBox3D, calib=None):\n x = bbox.x\n y = bbox.y\n z = bbox.z\n w = bbox.width # y\n h = bbox.height # z\n l = bbox.length # x\n angle = bbox.rotation\n\n # convert from Camera 3D coordinates to LIDAR coordinates.\n if bbox.coordinates == Coordinates.CAM_3D_RECT:\n if calib is None:\n print(\"WARNING: Visualization is in LIDAR coord & you pass a bbox of camera coord\")\n\n point = np.array([x, y, z]).reshape(1,3)\n\n # convert x, y, z from rectified cam coordinates to velodyne coordinates\n point = calib.rectified_camera_to_velodyne(point)\n\n x = point[0,0]\n y = point[0,1] \n # model output is z center but dataset annotations consider z at the bottom \n z = point[0,2] + h/2\n\n # angle in annotations is inverted .. while angle in predictions is correct\n angle = -angle\n \n # convert (x,y,z) from center to top left corner (corner 0)\n x = x - w/2\n y = y - l/2\n z = z + h/2\n\n top_corners = np.array([\n [x, y, z],\n [x+w, y, z],\n [x, y+l, z],\n [x+w, y+l, z]\n ])\n\n # same coordinates but z = z_top - box_height\n bottom_corners = top_corners - np.array([0,0, h])\n\n # concatinate \n corners = np.concatenate((top_corners,bottom_corners), axis=0)\n\n # 3x3 Rotation Matrix along z \n cosa = cos(angle)\n sina = sin(angle)\n R = np.array([\n [cosa, -sina, 0],\n [sina, cosa, 0],\n [0, 0, 1]\n ])\n\n # Translate the box to origin to perform rotation\n center = np.array([x+w/2, y+l/2, z-h/2])\n centered_corners = corners - center\n\n # Rotate\n rotated_corners = np.dot( R, centered_corners.T ).T\n\n # Translate it back to its position\n corners = rotated_corners + center\n\n # output of sin & cos sometimes is e-17 instead of 0\n corners = np.round(corners, decimals=10)\n\n return corners","def center_image(image):\n image.anchor_x = image.width/2\n image.anchor_y = image.height/2","def inset_face_with_scale_offset(bm, face, scale_y, scale_x, offx=0, offy=0, offz=0):\n cuts = 2\n scale = cuts + 1\n scale_y *= scale\n scale_x *= scale\n\n do_vertical = scale_y < scale\n do_horizontal = scale_x < scale\n\n if not do_horizontal and not do_vertical:\n return face\n\n face.select = False\n verts = subdivide_flagged_edges(\n bm, face, do_horizontal, do_vertical, scale_x, scale_y\n )\n offset_flagged_verts(bm, verts, do_horizontal, do_vertical, offx, offy, offz)\n return face_with_verts(bm, verts)","def plot_faces(img, w, h, B, hist_h, hist_hT, R, name_img, mode_color=\"RGB\", Q=256, g_mask=False, nb_angles=1, nb_scales=1):\n img_skin = convert_colors_probalities(img, hist_h, hist_hT, Q, mode_color)\n #print(img_skin.shape)\n set_face = recognition_function(img_skin, w, h, B, g_mask=g_mask, nb_angles=nb_angles, nb_scales=nb_scales)\n draw_faces(img, set_face, \"raw_\"+name_img, (212, 85, 186))\n if cluster_ellipse(set_face, R) != {}:\n set_face = cluster_ellipse(set_face, R)\n else:\n set_face = non_maximum_suppression(set_face, R)\n draw_faces(img, set_face, name_img, (212, 85, 186))","def align(args) :\n from aligner import align_reads\n align_reads(args)","def forward(self, bbox, anchor, width, height):\n F = mx.nd\n with autograd.pause():\n # anchor with shape (N, 4)\n a_xmin, a_ymin, a_xmax, a_ymax = self._bbox_split(anchor)\n # invalid anchor mask with shape (N, 1)\n imask = (\n (a_xmin >= -self._allowed_border) *\n (a_ymin >= -self._allowed_border) *\n (a_xmax <= (width + self._allowed_border)) *\n (a_ymax <= (height + self._allowed_border))) <= 0\n imask = mx.nd.array(np.where(imask.asnumpy() > 0)[0], ctx=anchor.context)\n\n # calculate ious between (N, 4) anchors and (M, 4) bbox ground-truths\n # ious is (N, M)\n ious = F.contrib.box_iou(anchor, bbox, format='corner').transpose((1, 0, 2))\n ious[:, imask, :] = -1\n matches = self._matcher(ious)\n samples = self._sampler(matches, ious)\n samples = samples.as_in_context(anchor.context)\n # training targets for RPN\n cls_target, _ = self._cls_encoder(samples)\n box_target, box_mask = self._box_encoder(\n samples, matches, anchor.expand_dims(axis=0), bbox)\n return cls_target, box_target, box_mask","def put_text(img: np.ndarray,\n bbox: Tuple[float, float, float, float],\n person: Person,\n all_frames_cnt: int) -> np.ndarray:\n x, y, w, h = bbox\n\n pivot_img_size = 112\n resolution_x = img.shape[1];\n\n overlay = img.copy()\n opacity = 0.4\n\n img = cv2.rectangle(img, (x, y), (x + w, y + h), (67, 67, 67), 1)\n if x + w + pivot_img_size < resolution_x:\n # right\n cv2.rectangle(img, (x + w, y), (x + w + pivot_img_size + 20, y + h), (64, 64, 64), cv2.FILLED)\n cv2.addWeighted(overlay, opacity, img, 1 - opacity, 0, img)\n\n elif x - pivot_img_size > 0:\n # left\n cv2.rectangle(img, (x - pivot_img_size - 20, y), (x, y + h), (64, 64, 64), cv2.FILLED)\n cv2.addWeighted(overlay, opacity, img, 1 - opacity, 0, img)\n\n gender_label = person.gender\n race_label = person.race\n age_label = person.age\n num_frames = person.percent_in_video(all_frames_cnt)\n\n attributes = [gender_label, race_label, age_label, num_frames]\n\n for index, attribute in enumerate(attributes):\n if x + w + pivot_img_size < resolution_x:\n\n text_location_y = y + 20 + (index + 1) * 20\n text_location_x = x + w\n\n if text_location_y < y + h:\n cv2.putText(img, attribute, (text_location_x + 10, text_location_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\n (255, 255, 255), 1)\n\n elif x - pivot_img_size > 0:\n\n text_location_y = y + 20 + (index + 1) * 20\n text_location_x = x - pivot_img_size\n\n if text_location_y <= y + h:\n cv2.putText(img, attribute, (text_location_x + 10, text_location_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\n (255, 255, 255), 1)\n\n return img","def marksimilar(image, clust, size):\n global opt\n blocks = []\n if clust:\n draw = ImageDraw.Draw(image)\n mask = Image.new('RGB', (size,size), 'cyan')\n for cl in clust:\n for x,y in cl:\n \tim = image.crop((x,y,x+size,y+size))\n \tim = Image.blend(im,mask,0.5)\n \tblocks.append((x,y,im))\n for bl in blocks:\n \tx,y,im = bl\n \timage.paste(im,(x,y,x+size,y+size))\n if int(opt.imauto):\n for cl in clust:\n cx1 = min([cx for cx,cy in cl])\n cy1 = min([cy for cx,cy in cl])\n cx2 = max([cx for cx,cy in cl]) + block_len\n cy2 = max([cy for cx,cy in cl]) + block_len\n draw.rectangle([cx1,cy1,cx2,cy2],outline=\"magenta\")\n return image","def beam_align():\n\n # do nothing if there is a sample mounted to avoid collisions\n if smart_magnet.sample_detect.get() == 0:\n raise Exception(\"Sample mounted on gonio! Avoided collision\")\n\n # wait for attenuators to finish moving\n yield from bps.abs_set(mxatten, 0.002)\n yield from bps.sleep(5)\n\n # transition to BL and open shutter\n yield from bps.abs_set(gov_rbt, \"BL\", wait=True)\n yield from bps.mv(sht.r, 0)\n\n yield from bps.abs_set(rot_aligner.cam_hi.cam_mode, \"beam_align\")\n\n # which direction, x pos. pitch beam outboard (-), y pos. pitch beam up (+)\n scan_uid = yield from bp.count([rot_aligner.cam_hi], 1)\n centroid_x, centroid_y = (\n db[scan_uid].table()[rot_aligner.cam_hi.cv1.outputs.output1.name][1],\n db[scan_uid].table()[rot_aligner.cam_hi.cv1.outputs.output2.name][1],\n )\n\n if np.isclose(0, centroid_x) or np.isclose(0, centroid_y):\n raise Exception(\"No centroid detected!\")\n\n yield from bps.abs_set(kbt.hor.delta_px, (centroid_x - 320))\n yield from bps.abs_set(kbt.ver.delta_px, -(centroid_y - 256))\n\n def lin_reg(independent, dependent, goal, **kwargs) -> float:\n b = dependent\n A = np.matrix([[pos, 1] for pos in independent])\n p = (\n np.linalg.inv(A.transpose() * A)\n * A.transpose()\n * np.matrix(b.to_numpy()).transpose()\n )\n best = (goal - p[1]) / p[0]\n return best\n\n for axis, signal, center in (\n kbt.hor,\n rot_aligner.cam_hi.cv1.outputs.output1,\n 320,\n ), (kbt.ver, rot_aligner.cam_hi.cv1.outputs.output2, 256):\n # skip if we are within 1 um\n if abs(axis.delta_px.get()) > 2:\n scan_uid = yield from rel_scan_no_reset(\n [rot_aligner.cam_hi],\n axis,\n 0,\n 0.4 * -(axis.delta_px.get() / abs(axis.delta_px.get())),\n 10,\n )\n scan_df = db[scan_uid].table()\n best_voltage = lin_reg(\n scan_df[axis.readback.name],\n scan_df[signal.name],\n center,\n )\n yield from bps.mv(axis, best_voltage)\n yield from bps.sleep(1)\n\n # close shutters and reset attenuators for manual viewing\n yield from bps.mv(sht.r, 20)","def draw_bbox(img, bbox: list,\n gca_axes: SubplotBase = None,\n label: str = None,\n color: str = \"#00ffff\") -> SubplotBase:\n\n cx, cy, w, h = bbox\n\n if not gca_axes:\n gca_axes = plt.gca()\n\n top_bottom_pt = ((cx - w/2) * img.size[0],\n (cy - h/2) * img.size[1])\n\n gca_axes.add_patch(plt.Rectangle(top_bottom_pt,\n w * img.size[0], h * img.size[1],\n color=color, fill=False, linewidth=2))\n\n font = {'color': 'white',\n 'weight': 'bold',\n 'size': 16}\n\n if label:\n gca_axes.text(top_bottom_pt[0], top_bottom_pt[1], label,\n fontdict=font,\n bbox={'facecolor': '#00abab', 'alpha': 1})\n\n return gca_axes","def compute_transform(self, image_pair, figure):\t\n\t\timage_pair = [int(image_pair[1]), int(image_pair[3])]\n\t\tindices = np.where(np.all(np.abs(self.Matches[\"image_pairs\"][0] - image_pair) == 0, axis=1)) \n\t\tfeature_pairs = self.Matches[\"image_match_pairs\"][0][indices[0][0]]\n\t\tfeature_pair_scores = self.Matches[\"image_feature_scores\"][0][indices[0][0]] \n\n\t\ti1_loc = self.Database[\"image_locs\"][np.where(np.array(self.Database[\"image_idx\"]) == image_pair[0])[0][0]]\n\t\ti2_loc = self.Database[\"image_locs\"][np.where(np.array(self.Database[\"image_idx\"]) == image_pair[1])[0][0]]\n\n\t\tself.image1 = cv2.cvtColor(extract_image(figure, i1_loc), cv2.COLOR_BGR2GRAY)\n\t\tself.image2 = cv2.cvtColor(extract_image(figure, i2_loc), cv2.COLOR_BGR2GRAY)\n\t\t# self.image1 = extract_image(figure, i1_loc)\n\t\t# self.image2 = extract_image(figure, i2_loc)\n\n\t\tself.match_alignment = {}; self.match_alignment_scores = {}\n\t\tfor pair, score in zip(feature_pairs, feature_pair_scores):\n\t\t\ti1 = self.Database[\"image_idx\"][pair[0]]\n\t\t\ti2 = self.Database[\"image_idx\"][pair[1]]\n\n\t\t\tif i1 == image_pair[0]:\n\t\t\t\ttarget = pair[0] \n\t\t\t\tstart = pair[1]\n\t\t\t\tif target not in self.match_alignment.keys():\n\t\t\t\t\tself.init_match_alignment(target)\n\t\t\telse:\n\t\t\t\ttarget = pair[1]\n\t\t\t\tstart = pair[0]\t\t\t\t\n\t\t\t\tif target not in self.match_alignment.keys():\n\t\t\t\t\tself.init_match_alignment(target)\n\n\t\t\t# get ellipse and convert to three cardinal points\n\t\t\ttarget_ellipse = self.Database[\"orientation\"][target]\n\t\t\tstart_ellipse = self.Database[\"orientation\"][start]\n\t\t\ttarget_points, target_params = utils.ellipse2points(target_ellipse)\n\t\t\tstart_points, start_params = utils.ellipse2points(start_ellipse)\n\n\t\t\t# compute angle between Major axes\n\t\t\trotation_angle = int(np.abs(target_params[0] - start_params[0]))\n\t\t\treflection_truth = target_params[1] * start_params[1]\n\t\t\tif reflection_truth > 0:\n\t\t\t\treflection_truth = \"No\"\n\t\t\telse:\n\t\t\t\treflection_truth = \"Yes\"\n\t\t\tresolution_perc = round(((target_params[2] / start_params[2]) - 1), 1)\n\n\t\t\t# extract features for histogram matching\n\t\t\ttarget_bloc = self.Database[\"blot_locs\"][target]\n\t\t\tstart_bloc = self.Database[\"blot_locs\"][start]\n\t\t\ttarget_feature = extract_image(self.image1, target_bloc, ex=5)\n\t\t\tfinal_feature = extract_image(self.image2, start_bloc, ex=5) \n\n\t\t\t#find affine transform to match\n\t\t\tif self.AFFINE:\n\t\t\t\tT = utils.compute_affine(start_points, target_points)\n\t\t\t\timage2_warped = cv2.warpAffine(self.image2.copy(), T, (self.image1.shape[1], self.image1.shape[0]))\n\t\t\t\tfinal_feature = extract_image(image2_warped, target_bloc, ex=5)\n\t\t\t\n\t\t\t# match hist\n\t\t\tif self.CONTRAST:\n\t\t\t\tfinal_feature = utils.histogram_match(final_feature, target_feature)\n\n\t\t\tself.match_alignment[target].append((final_feature, start, rotation_angle, reflection_truth, \\\n\t\t\t\t\t\t\t\t\t\t\t\t resolution_perc, score))\n\t\t\tself.match_alignment_scores[target].append(score)","def faceRecognition(image):\r\n faceLandmarks = [[],[],[]]\r\n face_landmarks_list = face_recognition.face_landmarks(image)\r\n if len(face_landmarks_list)>0:\r\n if len(face_landmarks_list[0]['left_eye'])>0:\r\n leftEyePos = [tuple(map(lambda i: int(i/32),i)) for i in face_landmarks_list[0]['left_eye']]\r\n for i in set(leftEyePos):\r\n if leftEyePos.count(i)>=len(leftEyePos)//len(set(leftEyePos)):\r\n faceLandmarks[0] += [i,]\r\n if len(face_landmarks_list[0]['right_eye'])>0:\r\n rightEyePos = [tuple(map(lambda i: int(i/32),i)) for i in face_landmarks_list[0]['right_eye']]\r\n for i in set(rightEyePos):\r\n if rightEyePos.count(i)>=len(rightEyePos)//len(set(rightEyePos)):\r\n faceLandmarks[1] += [i,]\r\n if len(face_landmarks_list[0]['top_lip'])>0:\r\n mouthPos = [tuple(map(lambda i: int(i/32),i)) for i in (face_landmarks_list[0]['top_lip']+face_landmarks_list[0]['bottom_lip'])]\r\n for i in set(mouthPos):\r\n if mouthPos.count(i)>=len(mouthPos)//len(set(mouthPos)):\r\n faceLandmarks[2] += [i,]\r\n return faceLandmarks","def image_to_face(self, image):\n self.image = image[self.y: self.y + self.h,\n self.x: self.x + self.w]","def apply_mapping(mask, mapping):\n _, F = mapping.shape\n aligned_mask = np.zeros_like(mask)\n for f in range(F):\n aligned_mask[:, f, :] = mask[mapping[:, f], f, :]\n return aligned_mask","def test_align(self):\n al = align(self.amp1, self.amp2).m\n\n # Both objects are already centered, so should be close to origin (allowing for some inaccuracy)\n self.assertAlmostEqual(al.vert.mean(axis=0)[0], 0, delta=TestAlign.DELTA)\n self.assertAlmostEqual(al.vert.mean(axis=0)[1], 0, delta=TestAlign.DELTA)\n self.assertAlmostEqual(al.vert.mean(axis=0)[2], 0, delta=TestAlign.DELTA)","def detectFaceAndClassify(faceNet, faceMaskClassifier, testImagePath, threshold):\n # load the input test image from disk\n image = cv2.imread(testImagePath)\n # making a copy of image and finding the image spatial dimensions\n orig = image.copy()\n (h, w) = image.shape[:2]\n\n # construct a blob from the image to pass to the network\n # using standard weights for the face detection model for image preprocessing\n blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), (104.0, 177.0, 123.0))\n\n # obtain the face detections by passing the blob through the network\n print(\"computing face detections...\")\n faceNet.setInput(blob)\n faceDetections = faceNet.forward()\n\n # loop over the detections to classify them and form bounding boxes and labels\n for i in range(0, faceDetections.shape[2]):\n # extract only confident detections using the confidence/probability\n # associated with the detection\n confidence = faceDetections[0, 0, i, 2]\n\n # filter out weak detections by ensuring the confidence is\n # greater than the minimum confidence 0.5 or input variable\n if confidence > threshold:\n # extract bounding box dimensions and face Region of intrest for classification\n faceROI, startX, startY, endX, endY = extractBoxAndFaceROI(image, faceDetections, itemNum=i,\n height=h, width=w)\n\n faceROI = np.expand_dims(faceROI, axis=0)\n\n # Passing the pre-processed image with classification model to check if there is a mask or not\n (mask, withoutMask) = faceMaskClassifier.predict(faceROI)[0]\n # (mask, withoutMask) = faceMaskClassifier.predict(faceROI)\n\n # find the class and associated colour to use for the bounding box and text\n label = \"Mask\" if mask > withoutMask else \"No Mask\"\n color = (0, 255, 0) if label == \"Mask\" else (0, 0, 255)\n\n # include the probability of prediction in the label of the bounding box\n label = \"{}: {:.2f}%\".format(label, max(mask, withoutMask) * 100)\n\n # forming bounding box rectangle and display the label the output image frame\n cv2.putText(image, label, (startX, startY - 10),\n cv2.FONT_HERSHEY_COMPLEX, 0.45, color, 2)\n cv2.rectangle(image, (startX, startY), (endX, endY), color, 2)\n\n # show the output image\n cv2.imshow(\"Output\", image)\n # display the image still a key is pressed, when key is pressed program is terminated\n cv2.waitKey(0)","def facial_landmarks(img):\n detector = dlib.get_frontal_face_detector()\n predictor = dlib.shape_predictor('/home/aditya/Desktop/stuff/ComputerVision-CMSC733/FaceSwap/scripts/traditional/shape_predictor_68_face_landmarks.dat')\n grayscale_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n rectangles = detector(grayscale_image, 1)\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n\n facial_points = []\n no_of_faces = len(rectangles)\n for (i, rect) in enumerate(rectangles):\n\n shape = predictor(grayscale_image, rect)\n shape = face_utils.shape_to_np(shape)\n (x, y, w, h) = face_utils.rect_to_bb(rect)\n\n cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)\n\n for (x, y) in shape:\n cv2.circle(img, (x, y), 2, (0, 0, 255), -1)\n facial_points.append((x, y))\n\n return no_of_faces, facial_points","def apply_mask(face: np.array, mask: np.array) -> np.array:\n mask_h, mask_w, _ = mask.shape\n face_h, face_w, _ = face.shape\n\n # Resize the mask to fit on face\n factor = min(face_h / mask_h, face_w / mask_w)\n new_mask_w = int(factor * mask_w)\n new_mask_h = int(factor * mask_h)\n new_mask_shape = (new_mask_w, new_mask_h)\n resized_mask = cv2.resize(mask, new_mask_shape)\n\n # Add mask to face - ensure mask is centered\n face_with_mask = face.copy()\n non_white_pixels = (resized_mask < 250).all(axis=2)\n off_h = int((face_h - new_mask_h) / 2)\n off_w = int((face_w - new_mask_w) / 2)\n face_with_mask[off_h: off_h+new_mask_h, off_w: off_w+new_mask_w][non_white_pixels] = \\\n resized_mask[non_white_pixels]\n\n return face_with_mask","def convert_roi_align(g, op, block):\n\n rois = g.get_node(op.input(\"ROIs\")[0])\n spatial_scale = op.attr(\"spatial_scale\")\n if op.attr(\"aligned\"):\n offset = _expr.const(0.5, dtype=\"float32\")\n roi_offset = _op.divide(offset, _expr.const(spatial_scale, dtype=\"float32\"))\n rois = _op.subtract(rois, roi_offset)\n num_rois = infer_shape(rois)[0]\n zero_node = _expr.const(0, dtype=\"int32\")\n batch_index = _op.full(zero_node, [num_rois, 1], dtype=\"float32\")\n rois = _op.concatenate([batch_index, rois], axis=1)\n out = _op.vision.roi_align(\n g.get_node(op.input(\"X\")[0]),\n rois,\n pooled_size=[op.attr(\"pooled_height\"), op.attr(\"pooled_width\")],\n spatial_scale=spatial_scale,\n sample_ratio=op.attr(\"sampling_ratio\"),\n mode=\"avg\",\n )\n g.add_node(op.output(\"Out\")[0], out)","def rpn_anchor_boxes(image_size, *args, **kwargs):\n anchor_boxes = generate_anchor_boxes(image_size, *args, **kwargs)\n valid_ab_indices = valid_anchor_boxes(anchor_boxes, image_size)\n return anchor_boxes, valid_ab_indices","def detect_landmarks(img, return_face_pos=False):\n model_path = f\"{MODELS_PATH}/Keypoint Detection/shape_predictor_68_face_landmarks.dat\"\n\n detector = dlib.get_frontal_face_detector()\n predictor = dlib.shape_predictor(model_path)\n\n rect = detector(img)\n shape = predictor(img, rect[0])\n\n coords = np.zeros((68, 2), dtype='int')\n for i in range(0, 68):\n coords[i] = (shape.part(i).x, shape.part(i).y)\n\n if return_face_pos:\n return coords, rect\n else:\n return coords","def load_and_align_data(image_paths, image_size, margin, gpu_memory_fraction):\n\n minsize = 20 # minimum size of face\n threshold = [ 0.6, 0.7, 0.7 ] # three steps's threshold\n factor = 0.709 # scale factor\n \n print('Creating networks and loading parameters')\n with tf.Graph().as_default() as g:\n sess = tf.Session(graph=g, config=tf.ConfigProto(log_device_placement=False))\n with sess.as_default():\n pnet, rnet, onet = detect_face.create_mtcnn(sess, _files.model_dir)\n\n nrof_samples = len(image_paths)\n img_list = [None] * nrof_samples\n for i in xrange(nrof_samples):\n img = misc.imread(os.path.expanduser(image_paths[i]))\n img_size = np.asarray(img.shape)[0:2]\n bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)\n det = np.squeeze(bounding_boxes[0, 0:4])\n bb = np.zeros(4, dtype=np.int32)\n bb[0] = np.maximum(det[0] - margin / 2, 0)\n bb[1] = np.maximum(det[1] - margin / 2, 0)\n bb[2] = np.minimum(det[2] + margin / 2, img_size[1])\n bb[3] = np.minimum(det[3] + margin / 2, img_size[0])\n cropped = img[bb[1]:bb[3], bb[0]:bb[2], :]\n aligned = misc.imresize(cropped, (image_size, image_size), interp='bilinear')\n prewhitened = facenet.prewhiten(aligned)\n img_list[i] = prewhitened\n images = np.stack(img_list)\n \n return images"],"string":"[\n \"def align(self, image, landmark_indices, anchor_points, size=96):\\n # Detect face in image and find landmarks\\n box = self.detect(image)\\n landmarks = self.find_landmarks(image, box)\\n\\n # Select three points in the landmarks(Eyes and nose)\\n points_in_image = landmarks[landmark_indices]\\n points_in_image = points_in_image.astype('float32')\\n # Generate the normalized output size\\n output_size = anchor_points * size\\n\\n # Calculates the 2 \\\\times 3 matrix of an affine transform\\n affine_transf = cv2.getAffineTransform(points_in_image, output_size)\\n\\n # Transforms the source image using the specified matrix\\n transformed_img = cv2.warpAffine(image, affine_transf, (size, size))\\n\\n return transformed_img\",\n \"def align_face(np_img, mask=True):\\n # Prepare extraction\\n current_dir = os.getcwd()\\n os.chdir(OPEN_FACE_BINARY_PATH)\\n timestamp = datetime.now().timestamp()\\n mask_param = '-nomask' if mask is False else ''\\n\\n # Align and mask face using OpenFace\\n np_img *= 255\\n np_img = np_img.astype(np.uint8)\\n imsave('{}.jpg'.format(timestamp), np_img)\\n exit_code = os.system(\\n './FaceLandmarkImg -f {}.jpg -wild -simalign -simsize 192 {} -format_aligned jpg >/dev/null'.format(timestamp,\\n mask_param))\\n aligned_img = imread('processed/{}_aligned/face_det_000000.jpg'.format(timestamp))\\n aligned_img = aligned_img / 255.\\n\\n # Delete temporary files created during face alignment\\n exit_code = os.system('rm -r {}.jpg >/dev/null'.format(timestamp))\\n exit_code = os.system('rm -r processed/{}* >/dev/null'.format(timestamp))\\n\\n os.chdir(current_dir)\\n\\n return aligned_img\",\n \"def align(self, image, landmark_indices, anchor_points, size=96):\\n\\n detected = self.detect(image)\\n coords = self.find_landmarks(image, detected)\\n in_points = coords[landmark_indices]\\n in_points = in_points.astype('float32')\\n out_points = anchor_points * size\\n warp_mat = cv2.getAffineTransform(in_points, out_points)\\n warp_dst = cv2.warpAffine(image, warp_mat, (size, size))\\n\\n return warp_dst\",\n \"def imalign(src_file, dst_file, face_landmarks, output_size=1024, transform_size=1024, enable_padding=True, x_scale=1, y_scale=1, em_scale=0.1, alpha=False):\\n lm = np.array(face_landmarks)\\n lm_chin = lm[0 : 17] # left-right\\n lm_eyebrow_left = lm[17 : 22] # left-right\\n lm_eyebrow_right = lm[22 : 27] # left-right\\n lm_nose = lm[27 : 31] # top-down\\n lm_nostrils = lm[31 : 36] # top-down\\n lm_eye_left = lm[36 : 42] # left-clockwise\\n lm_eye_right = lm[42 : 48] # left-clockwise\\n lm_mouth_outer = lm[48 : 60] # left-clockwise\\n lm_mouth_inner = lm[60 : 68] # left-clockwise\\n\\n # Calculate auxiliary vectors.\\n eye_left = np.mean(lm_eye_left, axis=0)\\n eye_right = np.mean(lm_eye_right, axis=0)\\n eye_avg = (eye_left + eye_right) * 0.5\\n eye_to_eye = eye_right - eye_left\\n mouth_left = lm_mouth_outer[0]\\n mouth_right = lm_mouth_outer[6]\\n mouth_avg = (mouth_left + mouth_right) * 0.5\\n eye_to_mouth = mouth_avg - eye_avg\\n\\n # Choose oriented crop rectangle.\\n x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]\\n x /= np.hypot(*x)\\n x *= max(np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8)\\n x *= x_scale\\n y = np.flipud(x) * [-y_scale, y_scale]\\n c = eye_avg + eye_to_mouth * em_scale\\n quad = np.stack([c - x - y, c - x + y, c + x + y, c + x - y])\\n qsize = np.hypot(*x) * 2\\n\\n # Load in-the-wild image.\\n if not os.path.isfile(src_file):\\n print('\\\\nCannot find source image. Please run \\\"--wilds\\\" before \\\"--align\\\".')\\n return\\n img = Image.open(src_file)\\n\\n # Shrink.\\n shrink = int(np.floor(qsize / output_size * 0.5))\\n if shrink > 1:\\n rsize = (int(np.rint(float(img.size[0]) / shrink)), int(np.rint(float(img.size[1]) / shrink)))\\n img = img.resize(rsize, Image.ANTIALIAS)\\n quad /= shrink\\n qsize /= shrink\\n\\n # Crop.\\n border = max(int(np.rint(qsize * 0.1)), 3)\\n crop = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))\\n crop = (max(crop[0] - border, 0), max(crop[1] - border, 0), min(crop[2] + border, img.size[0]), min(crop[3] + border, img.size[1]))\\n if crop[2] - crop[0] < img.size[0] or crop[3] - crop[1] < img.size[1]:\\n img = img.crop(crop)\\n quad -= crop[0:2]\\n\\n # Pad.\\n pad = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))\\n pad = (max(-pad[0] + border, 0), max(-pad[1] + border, 0), max(pad[2] - img.size[0] + border, 0), max(pad[3] - img.size[1] + border, 0))\\n if enable_padding and max(pad) > border - 4:\\n pad = np.maximum(pad, int(np.rint(qsize * 0.3)))\\n img = np.pad(np.float32(img), ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), 'reflect')\\n h, w, _ = img.shape\\n y, x, _ = np.ogrid[:h, :w, :1]\\n mask = np.maximum(1.0 - np.minimum(np.float32(x) / pad[0], np.float32(w-1-x) / pad[2]), 1.0 - np.minimum(np.float32(y) / pad[1], np.float32(h-1-y) / pad[3]))\\n blur = qsize * 0.02\\n img += (ndimage.gaussian_filter(img, [blur, blur, 0]) - img) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0)\\n img += (np.median(img, axis=(0,1)) - img) * np.clip(mask, 0.0, 1.0)\\n img = np.uint8(np.clip(np.rint(img), 0, 255))\\n if alpha:\\n mask = 1-np.clip(3.0 * mask, 0.0, 1.0)\\n mask = np.uint8(np.clip(np.rint(mask*255), 0, 255))\\n img = np.concatenate((img, mask), axis=2)\\n img = Image.fromarray(img, 'RGBA')\\n else:\\n img = Image.fromarray(img, 'RGB')\\n quad += pad[:2]\\n\\n # Transform.\\n img = img.transform((transform_size, transform_size), Image.QUAD, (quad + 0.5).flatten(), Image.BILINEAR)\\n print(transform_size)\\n if output_size < transform_size:\\n img = img.resize((output_size, output_size), Image.ANTIALIAS)\\n\\n # Save aligned image.\\n img.save(dst_file, 'PNG')\",\n \"def align_preprocessed(self, img):\\n aligner = FaceAligner(self.args.wing_path, self.args.lm_path, self.args.img_size)\\n return aligner.align(img)\",\n \"def preprocess(img, bbox=None, landmark=None, **kwargs):\\n M = None\\n image_size = []\\n str_image_size = kwargs.get('image_size', '')\\n # Assert input image shape\\n if len(str_image_size)>0:\\n image_size = [int(x) for x in str_image_size.split(',')]\\n if len(image_size)==1:\\n image_size = [image_size[0], image_size[0]]\\n assert len(image_size)==2\\n assert image_size[0]==112\\n assert image_size[0]==112 or image_size[1]==96\\n # Do alignment using landmnark points\\n if landmark is not None:\\n assert len(image_size)==2\\n src = np.array([\\n [30.2946, 51.6963],\\n [65.5318, 51.5014],\\n [48.0252, 71.7366],\\n [33.5493, 92.3655],\\n [62.7299, 92.2041] ], dtype=np.float32 )\\n if image_size[1]==112:\\n src[:,0] += 8.0\\n dst = landmark.astype(np.float32)\\n\\n tform = trans.SimilarityTransform()\\n tform.estimate(dst, src)\\n M = tform.params[0:2,:]\\n\\n # If no landmark points available, do alignment using bounding box. If no bounding box available use center crop\\n if M is None:\\n if bbox is None: #use center crop\\n det = np.zeros(4, dtype=np.int32)\\n det[0] = int(img.shape[1]*0.0625)\\n det[1] = int(img.shape[0]*0.0625)\\n det[2] = img.shape[1] - det[0]\\n det[3] = img.shape[0] - det[1]\\n else:\\n det = bbox\\n margin = kwargs.get('margin', 44)\\n bb = np.zeros(4, dtype=np.int32)\\n bb[0] = np.maximum(det[0]-margin/2, 0)\\n bb[1] = np.maximum(det[1]-margin/2, 0)\\n bb[2] = np.minimum(det[2]+margin/2, img.shape[1])\\n bb[3] = np.minimum(det[3]+margin/2, img.shape[0])\\n ret = img[bb[1]:bb[3],bb[0]:bb[2],:]\\n if len(image_size)>0:\\n ret = cv2.resize(ret, (image_size[1], image_size[0]))\\n return ret\\n else: #do align using landmark\\n assert len(image_size)==2\\n\\n # warped = cv2.warpAffine(img,M,(image_size[1],image_size[0]), borderValue = 0.0)\\n warped = cv2.warpAffine(img,M,(image_size[1],image_size[0]), borderValue = 0.0)\\n\\n return warped\",\n \"def align_crop(img, landmarks, standard_landmarks, crop_size=572, face_factor=0.45, align_type='similarity', order=3,\\r\\n mode='edge'):\\r\\n interpolation = {0: cv2.INTER_NEAREST,\\r\\n 1: cv2.INTER_LINEAR,\\r\\n 2: cv2.INTER_AREA,\\r\\n 3: cv2.INTER_CUBIC,\\r\\n 4: cv2.INTER_LANCZOS4,\\r\\n 5: cv2.INTER_LANCZOS4}\\r\\n border = {'constant': cv2.BORDER_CONSTANT,\\r\\n 'edge': cv2.BORDER_REPLICATE,\\r\\n 'symmetric': cv2.BORDER_REFLECT,\\r\\n 'reflect': cv2.BORDER_REFLECT101,\\r\\n 'wrap': cv2.BORDER_WRAP}\\r\\n\\r\\n # check\\r\\n assert align_type in ['affine', 'similarity'], \\\\\\r\\n \\\" [!] Invalid 'align_type'! The {} is not included in ['affine' and 'similarity']!\\\".format(align_type)\\r\\n assert order in [0, 1, 2, 3, 4, 5], \\\\\\r\\n \\\" [!] Invalid 'order'! The {} is not included in [0, 1, 2, 3, 4, 5]!\\\".format(order)\\r\\n assert mode in ['constant', 'edge', 'symmetric', 'reflect', 'wrap'], \\\\\\r\\n \\\" [!] Invalid 'mode'! the {} is not included in ['constant', 'edge', 'symmetric', 'reflect', and 'wrap']\\\".format(mode)\\r\\n\\r\\n # crop size\\r\\n if isinstance(crop_size, (list, tuple)) and len(crop_size) == 2:\\r\\n crop_size_h = crop_size[0]\\r\\n crop_size_w = crop_size[1]\\r\\n elif isinstance(crop_size, int):\\r\\n crop_size_h = crop_size_w = crop_size\\r\\n else:\\r\\n raise Exception(\\\" [!] Invalid 'crop_size'! The 'crop_size' should be (1) one integer for (crop_size, crop_size) ar (2) (int, int) for (crop_size_h, crop_size_w)!\\\")\\r\\n\\r\\n # estimate transform matrix\\r\\n target_landmarks = standard_landmarks * max(crop_size_h, crop_size_w) * face_factor + np.array([crop_size_w // 2, crop_size_h // 2])\\r\\n if align_type == 'affine': # 6 degree of freedom\\r\\n transform_matrix, _ = cv2.estimateAffine2D(target_landmarks, landmarks, ransacReprojThreshold=np.Inf)\\r\\n else: # 4 degree of freedom: using the combinations of translation, rotation, and uniform scaling\\r\\n transform_matrix, _ = cv2.estimateAffinePartial2D(target_landmarks, landmarks, ransacReprojThreshold=np.Inf)\\r\\n\\r\\n # warp image by given transform\\r\\n img_crop = cv2.warpAffine(img, transform_matrix, dsize=(crop_size_w, crop_size_h),\\r\\n flags=cv2.WARP_INVERSE_MAP + interpolation[order], borderMode=border[mode])\\r\\n\\r\\n # get transformed landmarks\\r\\n transformed_landmarks = cv2.transform(np.expand_dims(landmarks, axis=0), m=cv2.invertAffineTransform(transform_matrix))\\r\\n\\r\\n return img_crop, transformed_landmarks\",\n \"def align(img, landmarks, d_size=(400, 400), normalized=False, show=False):\\n assert len(landmarks) == 10\\n assert isinstance(img, np.ndarray)\\n landmarks = np.array(landmarks).reshape(5, 2)\\n dw, dh = d_size\\n\\n keypoints = landmarks.copy().astype(np.float64)\\n if normalized:\\n keypoints[:, 0] *= img.shape[1]\\n keypoints[:, 1] *= img.shape[0]\\n\\n keypoints_ref = np.zeros((5, 2), dtype=np.float64)\\n keypoints_ref[:, 0] = FivePointsAligner.ref_landmarks[:, 0] * dw\\n keypoints_ref[:, 1] = FivePointsAligner.ref_landmarks[:, 1] * dh\\n\\n transform_matrix = transformation_from_points(keypoints_ref, keypoints)\\n output_im = cv.warpAffine(img, transform_matrix, d_size, flags=cv.WARP_INVERSE_MAP)\\n\\n if show:\\n tmp_output = output_im.copy()\\n for point in keypoints_ref:\\n cv.circle(tmp_output, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\\n for point in keypoints:\\n cv.circle(img, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\\n img = cv.resize(img, d_size)\\n cv.imshow('source/warped', np.hstack((img, tmp_output)))\\n cv.waitKey()\\n\\n return output_im\",\n \"def align_and_extract_face(self, image, landmarks, output_size=(150,150), desired_left_eye_relative_position=(0.55, 0.55)):\\n\\n # get the key landmark features\\n lp, eye_center, facebox = landmarks['left-eye-center-pos'], landmarks['eye-center-pos'], landmarks['face-box']\\n\\n # calculating the center box for face box, this will also be the center for the output_box\\n face_box_center = calc_box_center(facebox)\\n\\n # calculate the output box using the box center\\n output_box = (face_box_center[0] - output_size[0] / 2, face_box_center[1] - output_size[1]/2, output_size[0], output_size[1])\\n\\n # left eye's absolute position relative to facebox\\n current_left_eye_absolute_x_position = lp[0] - facebox[0]\\n\\n # desired left eye's absolute position relative to output box\\n desired_left_eye_absolute_x_position = output_box[2] * desired_left_eye_relative_position[0]\\n\\n # scale needed would be the ratio between desired and current\\n scale = desired_left_eye_absolute_x_position / current_left_eye_absolute_x_position\\n\\n # calculate alignment angle\\n angle = self.determine_rotation_angle(landmarks)\\n\\n # rotation origin will be the eye_center\\n rotation_origin = eye_center\\n\\n # calculate the rotation matrix\\n rotation_matrix = self.determine_rotation_matrix(rotation_origin, angle, scale)\\n\\n # calculate the new bounding box needed to bound/contain the rotated image\\n aligned_box = self.determine_bounding_box_of_rotated_box(calc_img_box(image), rotation_matrix)\\n (aligned_x, aligned_y, aligned_w, aligned_h) = aligned_box\\n # update the translation to fit the rotated image to the bounding box\\n rotation_matrix[0, 2] -= aligned_x\\n rotation_matrix[1, 2] -= aligned_y\\n\\n # perform the transformation\\n warped_image = cv2.warpAffine(image, rotation_matrix, (aligned_w, aligned_h), flags=cv2.INTER_CUBIC)\\n\\n # calculate new box positions\\n new_face_box_center = calc_rotate_point_with_rotation_matrix(face_box_center, rotation_matrix)\\n new_output_box = [\\n int(new_face_box_center[0] - output_size[0] / 2),\\n int(new_face_box_center[1] - output_size[1]/2),\\n output_size[0], output_size[1]\\n ]\\n\\n # calculate new left eye position\\n new_lp = calc_rotate_point_with_rotation_matrix(lp, rotation_matrix)\\n\\n # calculate how far we are from the ideal y position for the left eye\\n desired_left_eye_absolute_y_position = new_output_box[1] + int(new_output_box[3] * desired_left_eye_relative_position[1])\\n distance = new_lp[1] - desired_left_eye_absolute_y_position\\n\\n # shift the y position such that the output box is in the desired y position\\n new_output_box[1] += distance\\n\\n # it's possible output boxes's position will extend beyond current image space, pad the current image space such that they'll be enough space for the output box\\n\\n # figure out the padding\\n x_left_pad = abs(min(0, new_output_box[0]))\\n x_right_pad = abs(min(0, warped_image.shape[1] - (new_output_box[0] + new_output_box[2])))\\n y_top_pad = abs(min(0, new_output_box[1]))\\n y_bottom_pad = abs(min(0, warped_image.shape[0] - (new_output_box[1] + new_output_box[3])))\\n\\n # some amount of padding exists, create an image with enough padding space\\n if x_left_pad + x_right_pad + y_top_pad + y_bottom_pad != 0:\\n # create a new image with the padded distance\\n new_shape = (warped_image.shape[0] + y_top_pad + y_bottom_pad, warped_image.shape[1] + x_left_pad + x_right_pad, 3)\\n padded_image = np.zeros(new_shape)\\n\\n # copy contents of warped image into padded image\\n padded_image[y_top_pad:y_top_pad + warped_image.shape[0], x_left_pad:x_left_pad + warped_image.shape[1]] = warped_image\\n\\n # set the warped image to the padded image\\n warped_image = padded_image\\n\\n # now \\\"tare\\\" the coordinates of the output box so that it fits in side the padded image\\n new_output_box[0] += x_left_pad\\n new_output_box[1] += y_top_pad\\n\\n # crop the output box out of the warped image\\n cropped_image = warped_image[new_output_box[1]:new_output_box[1]+new_output_box[3], new_output_box[0]:new_output_box[0]+new_output_box[2]]\\n\\n # return the cropped image\\n return cropped_image\",\n \"def rotate(img, bbox, landmark, alpha):\\r\\n center = (bbox.x+bbox.w/2, bbox.y+bbox.h/2)\\r\\n rot_mat = cv2.getRotationMatrix2D(center, alpha, 1)\\r\\n img_rotated_by_alpha = cv2.warpAffine(img, rot_mat, img.shape)\\r\\n landmark_ = np.asarray([(rot_mat[0][0]*x+rot_mat[0][1]*y+rot_mat[0][2],\\r\\n rot_mat[1][0]*x+rot_mat[1][1]*y+rot_mat[1][2]) for (x, y) in landmark])\\r\\n face = img_rotated_by_alpha[bbox.y:bbox.y+bbox.h,bbox.x:bbox.x+bbox.w]\\r\\n return (face, landmark_)\",\n \"def align_crop_opencv(img,\\n src_landmarks,\\n standard_landmarks,\\n celeba_standard_landmark,\\n src_celeba_landmark,\\n crop_size=512,\\n face_factor=0.8,\\n align_type='similarity',\\n order=3,\\n mode='edge'):\\n # set OpenCV\\n\\n #img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n\\n inter = {0: cv2.INTER_NEAREST, 1: cv2.INTER_LINEAR, 2: cv2.INTER_AREA,\\n 3: cv2.INTER_CUBIC, 4: cv2.INTER_LANCZOS4, 5: cv2.INTER_LANCZOS4}\\n border = {'constant': cv2.BORDER_CONSTANT, 'edge': cv2.BORDER_REPLICATE,\\n 'symmetric': cv2.BORDER_REFLECT, 'reflect': cv2.BORDER_REFLECT101,\\n 'wrap': cv2.BORDER_WRAP}\\n\\n # check\\n assert align_type in ['affine', 'similarity'], 'Invalid `align_type`! Allowed: %s!' % ['affine', 'similarity']\\n assert order in [0, 1, 2, 3, 4, 5], 'Invalid `order`! Allowed: %s!' % [0, 1, 2, 3, 4, 5]\\n assert mode in ['constant', 'edge', 'symmetric', 'reflect', 'wrap'], 'Invalid `mode`! Allowed: %s!' % ['constant',\\n 'edge',\\n 'symmetric',\\n 'reflect',\\n 'wrap']\\n # crop size\\n if isinstance(crop_size, (list, tuple)) and len(crop_size) == 2:\\n crop_size_h = crop_size[0]\\n crop_size_w = crop_size[1]\\n elif isinstance(crop_size, int):\\n crop_size_h = crop_size_w = crop_size\\n else:\\n raise Exception(\\n 'Invalid `crop_size`! `crop_size` should be 1. int for (crop_size, crop_size) or 2. (int, int) for (crop_size_h, crop_size_w)!')\\n\\n # estimate transform matrix\\n trg_landmarks = standard_landmarks * max(crop_size_h, crop_size_w) * face_factor + np.array(\\n [crop_size_w // 2, crop_size_h // 2])\\n\\n if align_type == 'affine':\\n tform = cv2.estimateAffine2D(trg_landmarks, src_landmarks, ransacReprojThreshold=np.Inf)[0]\\n else:\\n tform = cv2.estimateAffinePartial2D(trg_landmarks, src_landmarks, ransacReprojThreshold=np.Inf)[0] #tform{2,3}\\n\\n # calcaute the scale of tform\\n m1 = np.mat('0;0;1')\\n m2 = np.mat('1;0;1')\\n p1 = tform.dot(m1)\\n p2 = tform.dot(m2)\\n scale = LA.norm(p2 - p1) # defualt is Frobenius norm\\n # change the translations part of the transformation matrix for downwarding vertically\\n tform[1][2] = tform[1][2] + 20 * scale\\n output_shape = (crop_size_h, crop_size_w)\\n img_crop = cv2.warpAffine(img, tform, output_shape[::-1], flags=cv2.WARP_INVERSE_MAP + inter[order],\\n borderMode=border[mode])\\n\\n tformed_landmarks = cv2.transform(np.expand_dims(src_landmarks, axis=0), cv2.invertAffineTransform(tform))[0]\\n tformed_celeba_landmarks = cv2.transform(np.expand_dims(src_celeba_landmark, axis=0), cv2.invertAffineTransform(tform))[0]\\n return img_crop, tformed_landmarks, tformed_celeba_landmarks\",\n \"def augment_image(im):\\n # First crop out the face to save reduce computation load\\n bb = im.landmarks['bb'].lms\\n bb_vec = bb.as_vector()\\n bb_ul = (np.array([bb_vec[0], bb_vec[1]]) - bb.centre()) * 2\\n bb_lr = (np.array([bb_vec[4], bb_vec[5]]) - bb.centre()) * 2\\n ul = bb_ul + bb.centre()\\n lr = bb_lr + bb.centre()\\n im = im.crop(ul, lr, constrain_to_boundary=True)\\n if im.pixels.shape[0] == 1:\\n pix = np.zeros((3, im.pixels.shape[1], im.pixels.shape[2]))\\n pix[:,] = im.pixels\\n im.pixels = pix\\n\\n beta = 0.3\\n cx = np.random.uniform(-beta, beta)\\n cy = np.random.uniform(-beta, beta)\\n fx = 1.0\\n fy = np.random.uniform(0.6, 1.4)\\n max_rotation = 30\\n theta = np.random.uniform(-max_rotation, max_rotation)\\n\\n rotation = menpo.transform.Rotation.init_from_2d_ccw_angle(theta)\\n shear = menpo.transform.Affine(np.array([[1, cx, 0],[cy, 1, 0], [0,0,1]]))\\n scale = menpo.transform.Affine(np.array([[fx, 0, 0],[0, fy, 0], [0,0,1]]))\\n T = scale.compose_after(shear).compose_after(rotation)\\n\\n t_im = im.transform_about_centre(T)\\n\\n t_im = add_color_jetting(t_im)\\n t_im = add_occlusion(t_im)\\n\\n\\n new_bb = t_im.landmarks['PTS'].lms.bounding_box()\\n\\n #new_bb contains the gt bounding box\\n augmented_bb = add_bb_noise(new_bb)\\n augmented_bb = augmented_bb.reshape((4,2))\\n augmented_bb = menpo.shape.PointCloud(augmented_bb)\\n t_im.landmarks['bb'] = menpo.landmark.LandmarkGroup.init_with_all_label(augmented_bb)\\n\\n return t_im\",\n \"def prepocessImg(self, method, size, img, bb,offset=0.3,gray=True,\\n boundry=False, outputDebug=False,outputprefix=None):\\n if method == 'crop':\\n crop_img = crop_only(img,bb.left(),bb.top(),bb.width(),bb.height(),offset,size)\\n elif method == 'affine':\\n img = Image.fromarray(img)\\n if self.predictor == None:\\n raise Exception(\\\"Error: method affine should initial with an facepredictor.\\\")\\n alignPoints = self.align(img, bb)\\n (xs, ys) = zip(*alignPoints)\\n (l, r, t, b) = (min(xs), max(xs), min(ys), max(ys))\\n w,h = img.size\\n if boundry and (l < 0 or r > w or t < 0 or b > h):\\n raise AliError('face out of boundry')\\n \\n left_eye_l = alignPoints[36]\\n left_eye_r = alignPoints[39]\\n left_eye = (np.array(left_eye_l)+np.array(left_eye_r))/2\\n right_eye_l = alignPoints[42]\\n right_eye_r = alignPoints[45]\\n right_eye = (np.array(right_eye_l)+np.array(right_eye_r))/2\\n crop_img = crop_simi(img,left_eye,right_eye,(offset,offset),(size,size))\\n im_buffer = cStringIO.StringIO()\\n crop_img.save(im_buffer, format=\\\"JPEG\\\")\\n im_str = base64.b64encode(im_buffer.getvalue())\\n else:\\n raise Exception(\\\"undefined crop method\\\")\\n if gray:\\n crop_img = crop_img.convert('L')\\n if outputDebug:\\n dirname = './aligndebug'\\n if not os.path.exists(os.path.abspath(dirname)):\\n os.mkdir(dirname)\\n drawbox(img,(bb.left(),bb.right(),bb.top(),bb.bottom()))\\n if method == 'affine':\\n drawpoint(img,left_eye)\\n drawpoint(img,right_eye)\\n img.save('{}/{}_annotated.jpg'.format(dirname,outputprefix))\\n crop_img.save('{}/{}_crop.jpg'.format(dirname,outputprefix))\\n crop_img = np.array(crop_img,dtype=np.float32) #look carefully on data format\\n if crop_img.ndim == 3: #data shape for caffe\\n return crop_img,score\\n elif crop_img.ndim == 2:\\n bbox = [bb.left(),bb.top(),bb.right(),bb.bottom()]\\n return crop_img[:,:,np.newaxis], bbox\\n else:\\n raise Exception(\\\"wrong dimension\\\")\",\n \"def alignment(src_img, src_pts, output_size=(96, 112)):\\n ref_pts = [\\n [30.2946, 51.6963],\\n [65.5318, 51.5014],\\n [48.0252, 71.7366],\\n [33.5493, 92.3655],\\n [62.7299, 92.2041],\\n ]\\n src_pts = np.array(src_pts).reshape(5, 2)\\n s = np.array(src_pts).astype(np.float32)\\n r = np.array(ref_pts).astype(np.float32)\\n tfm = get_similarity_transform_for_cv2(s, r)\\n face_img = cv2.warpAffine(src_img, tfm, output_size)\\n return face_img\",\n \"def align(img, left_eye, right_eye):\\n left_eye_x, left_eye_y = left_eye\\n right_eye_x, right_eye_y = right_eye\\n point_3rd, direction = (left_eye, -1) if left_eye_y > right_eye_y else (right_eye, 1)\\n\\n # np.linalg.norm is being used for euclidean distance\\n a = np.linalg.norm(np.array(left_eye) - np.array(point_3rd))\\n b = np.linalg.norm(np.array(right_eye) - np.array(point_3rd))\\n c = np.linalg.norm(np.array(right_eye) - np.array(left_eye))\\n\\n if b != 0 and c != 0:\\n angle = np.arccos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))\\n angle = (angle * 180) / math.pi\\n if direction == -1:\\n angle = 90 - angle\\n img = Image.fromarray(img)\\n img = np.array(img.rotate(direction * angle))\\n\\n return img\",\n \"def draw_annotations(self, image, results):\\n image.flags.writeable = True\\n image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\\n for face_landmarks in results.multi_face_landmarks:\\n # draw face landmark net\\n mp_drawing.draw_landmarks(\\n image=image,\\n landmark_list=face_landmarks,\\n connections=mp_face_mesh.FACE_CONNECTIONS,\\n landmark_drawing_spec=self.drawing_spec,\\n connection_drawing_spec=self.drawing_spec)\\n cv2.imshow('MediaPipe FaceMesh', image)\",\n \"def _calibrate_landmarks(self, bboxes, landmarks, align=False):\\n\\n x1, y1, x2, y2 = [bboxes[:, i] for i in range(4)]\\n w = x2 - x1 + 1.0\\n h = y2 - y1 + 1.0\\n w = torch.unsqueeze(w, 1)\\n h = torch.unsqueeze(h, 1)\\n\\n translation = torch.cat([w]*5 + [h]* 5, 1).float() * landmarks\\n if align:\\n landmarks = torch.ceil(translation).int()\\n else:\\n landmarks = torch.stack([bboxes[:, 0]] * 5 + [bboxes[:, 1]] * 5, 1) + torch.round(translation).int()\\n return landmarks\",\n \"def imagesAlign(I,Iref,fillval=np.nan,trfm_type='similarity',\\n vCells=1,hCells=1,rszFac=1,verbose=False,\\n minArea = np.power(2, 11), applyWarp=True):\\n if len(I.shape)==3:\\n I1=sh.rgb2gray(I)\\n else:\\n I1=I\\n \\n if len(Iref.shape)==3:\\n Iref1=sh.rgb2gray(Iref)\\n else:\\n Iref1=Iref\\n\\n WARN_USER, ORIG_DTYPE = False, None\\n if I1.dtype != 'float32':\\n WARN_USER, ORIG_DTYPE = True, I1.dtype\\n I1 = I1.astype('float32')\\n if Iref1.dtype != 'float32':\\n WARN_USER, ORIG_DTYPE = True, Iref1.dtype\\n Iref1 = Iref1.astype('float32')\\n if WARN_USER:\\n print \\\"(Info) imagesAlign was called with input image dtype={0}. \\\\\\nimagesAlign expects image dtype='float32' (Also, intensity vals in range \\\\\\n[0.0,1.0]. The image dtype conversion was \\\\\\nautomatically done, but this slows down the computation a little. Consider \\\\\\ntrying to work in 'float32' in the first place if convenient for a little \\\\\\nspeed boost.\\\".format(ORIG_DTYPE)\\n\\n t1 = time.clock()\\n # check if more than one vertical and horizontal cell\\n if (vCells>1) and (hCells>1):\\n I2=imagesAlign(I1,Iref1,trfm_type=trfm_type, minArea=minArea)[1];\\n Iout=np.copy(Iref1);\\n pFac=.25;\\n vStep=math.ceil(I1.shape[0]/vCells); vPad=pFac*vStep;\\n hStep=math.ceil(I1.shape[1]/hCells); hPad=pFac*vStep;\\n for i in range(vCells):\\n for j in range(hCells):\\n # 2. chop + pad each cell then align\\n # 3. stitch back together\\n i1=i*vStep; i1=max(i1,0);\\n i2=(i+1)*vStep; i2=min(i2,I1.shape[0]-1);\\n j1=j*hStep; j1=max(j1,0);\\n j2=(j+1)*hStep; j2=min(j2,I1.shape[1]-1);\\n\\n i1p=i1-vPad; i1p=max(i1p,0);\\n i2p=i2+vPad; i2p=min(i2p,I1.shape[0]-1);\\n j1p=j1-hPad; j1p=max(j1p,0);\\n j2p=j2+hPad; j2p=min(j2p,I1.shape[1]-1);\\n \\n Ic=I2[i1p:i2p,j1p:j2p]\\n Irefc=Iref1[i1p:i2p,j1p:j2p]\\n (H,err)=imagesAlign1(Ic,Irefc,trfm_type=trfm_type,verbose=verbose, minArea=minArea)\\n IcT=sh.imtransform(Ic, H)\\n Iout[i1:i2,j1:j2]=IcT[i1-i1p:(i1-i1p)+(i2-i1),j1-j1p:(j1-j1p)+(j2-j1)]\\n\\n return (np.eye(3),Iout,-1)\\n\\n if rszFac==1:\\n t0 = time.clock()\\n (H,err)=imagesAlign1(I1,Iref1,trfm_type=trfm_type,verbose=verbose, minArea=minArea)\\n if verbose:\\n print 'alignment time:',time.clock()-t0,'(s)'\\n\\n #print 'alignment time:',time.clock()-t0,'(s)' \\n else:\\n I1=sh.fastResize(I1,rszFac)\\n Iref1=sh.fastResize(Iref1,rszFac)\\n S=np.eye(3, dtype=np.float32);\\n S[0,0]=1/rszFac; S[1,1]=1/rszFac;\\n H0=np.eye(3, dtype=np.float32)\\n H0=np.dot(np.dot(np.linalg.inv(S),H0),S)\\n t0 = time.clock()\\n (H,err)=imagesAlign1(I1,Iref1,H0=H0,trfm_type=trfm_type,verbose=verbose, minArea=minArea)\\n if verbose:\\n print 'alignment time:',time.clock()-t0,'(s)'\\n\\n #print 'alignment time:',time.clock()-t0,'(s)'\\n H=np.dot(S,np.dot(H,np.linalg.inv(S)))\\n\\n #print \\\"overall time: \\\", time.clock() - t1\\n if applyWarp:\\n return (H,sh.imtransform(I,H,fillval=fillval),err)\\n else:\\n return (H,err)\",\n \"def align_and_crop_face(self, img, rect_list, desired_width, desired_height):\\n \\n for j, det in enumerate(rect_list):\\n shape = self.align_predictor(img, det)\\n left_eye = extract_left_eye_center(shape)\\n right_eye = extract_right_eye_center(shape)\\n M = get_rotation_matrix(left_eye, right_eye)\\n\\n rotated_img = cv2.warpAffine(img, M, (img.shape[1], img.shape[0]), flags=cv2.INTER_CUBIC)\\n cropped = crop_image(rotated_img, det)\\n try:\\n \\n cropped_res = cv2.resize(cropped, (desired_width, desired_height))\\n except:\\n print(det)\\n print(img.shape)\\n cropped_res = cv2.resize(rotated_img,(desired_width, desired_height))\\n cropped_img = cropped_res[:, :, ::-1]\\n\\n return cropped_img, left_eye, right_eye\",\n \"def load_aligned(self, image, size=256, padding=48, align_eyes=False):\\n self.aligned[\\\"size\\\"] = size\\n self.aligned[\\\"padding\\\"] = padding\\n self.aligned[\\\"align_eyes\\\"] = align_eyes\\n self.aligned[\\\"matrix\\\"] = get_align_mat(self, size, align_eyes)\\n self.aligned[\\\"face\\\"] = AlignerExtract().transform(\\n image,\\n self.aligned[\\\"matrix\\\"],\\n size,\\n padding)\",\n \"def image_bbox(img, bbox, label=None, score=None, ax=None):\\n\\n label_names = list(labels) + ['bg']\\n ax = image_vis(img, ax=ax)\\n\\n\\n # If there is no bounding box to display, visualize the image and exit.\\n if len(bbox) == 0:\\n return ax\\n\\n for i, bb in enumerate(bbox):\\n xy = (bb[1], bb[0])\\n height = bb[2] - bb[0]\\n width = bb[3] - bb[1]\\n ax.add_patch(plt.Rectangle(\\n xy, width, height, fill=False, edgecolor='red', linewidth=2))\\n\\n caption = list()\\n\\n if label is not None and label_names is not None:\\n lb = label[i]\\n caption.append(label_names[lb])\\n if score is not None:\\n sc = score[i]\\n caption.append('{:.2f}'.format(sc))\\n\\n if len(caption) > 0:\\n ax.text(bb[1], bb[0],\\n ': '.join(caption),\\n style='italic',\\n bbox={'facecolor': 'white', 'alpha': 0.5, 'pad': 0})\\n return ax\",\n \"def normalize_face(image: Image, face):\\n y, x, h, w = face['box']\\n cropped_face = image[x:x + w, y:y + h]\\n\\n left_eye = face['keypoints']['left_eye']\\n right_eye = face['keypoints']['right_eye']\\n aligned_face = align(cropped_face, left_eye, right_eye)\\n aligned_face = cv2.resize(aligned_face, (160, 160))\\n\\n return np.expand_dims(aligned_face / 255, axis=0)\",\n \"def transform(self,image,landmarks,s0=None):\\n if s0 is None:\\n s0 = np.array([[127.6475, 227.8161], [79.1608, 87.0376], [176.8392, 87.0376]], np.float32)\\n idx = [8,36,45] #\\\"\\\"\\\"Anchor points\\\"\\\"\\\"\\n pts = np.float32(landmarks[idx,:])\\n M = cv2.getAffineTransform(pts,s0)\\n dst = cv2.warpAffine(image, M, (256,256))\\n return dst\",\n \"def align_single_image(filename, crop_list, bead_channel='488',\\n all_channels=_allowed_colors, \\n single_im_size=_image_size,\\n num_buffer_frames=_num_buffer_frames,\\n num_empty_frames=_num_empty_frames,\\n illumination_corr=True, \\n correction_folder=_correction_folder,\\n ref_filename=None, ref_all_channels=None,\\n ref_centers=None, ref_ims=None,\\n th_seed=100, th_seed_per=98, use_percentile=False,\\n max_num_seeds=None, min_num_seeds=50, \\n fitting_kwargs={}, \\n use_fft=True, fft_filt_size=0, \\n match_distance_th=2., \\n check_paired_cts=True,\\n outlier_sigma=1.5,\\n good_drift_th=1.,\\n return_target_ims=False,\\n return_paired_cts=False,\\n verbose=False, \\n ):\\n from scipy.spatial.distance import cdist, pdist, squareform\\n from ..io_tools.load import correct_fov_image\\n from ..alignment_tools import fft3d_from2d\\n from ..spot_tools.fitting import get_centers\\n ## check inputs\\n # check crop_list:\\n if len(crop_list) < 2:\\n raise IndexError(f\\\"crop_list should at least have 2 elements\\\")\\n elif len(crop_list[0]) != len(single_im_size):\\n raise IndexError(\\\"dimension of crop_list should match single_im_size\\\")\\n # check channels:\\n _all_channels = [str(_ch) for _ch in all_channels]\\n # check bead_channel\\n _bead_channel = str(bead_channel)\\n if _bead_channel not in all_channels:\\n raise ValueError(f\\\"bead channel {_bead_channel} not exist in all channels given:{_all_channels}\\\")\\n # check ref_all_channels\\n if ref_all_channels is None:\\n _ref_all_channels = _all_channels\\n else:\\n _ref_all_channels = [str(_ch) for _ch in ref_all_channels]\\n\\n # check filename file type \\n if isinstance(filename, np.ndarray):\\n if verbose:\\n print(f\\\"-- start aligning given image to\\\", end=' ')\\n _bead_im = filename\\n if np.shape(_bead_im) != tuple(single_im_size):\\n raise IndexError(f\\\"shape of target image:{np.shape(_bead_im)} and single_im_size:{single_im_size} doesn't match!\\\")\\n elif isinstance(filename, str):\\n if verbose:\\n print(f\\\"-- start aligning file {filename} to\\\", end=' ')\\n if not os.path.isfile(filename) or filename.split('.')[-1] != 'dax':\\n raise IOError(f\\\"input filename: {filename} should be a .dax file!\\\")\\n _bead_im = correct_fov_image(filename, [_bead_channel], \\n single_im_size=single_im_size, \\n all_channels=all_channels,\\n num_buffer_frames=num_buffer_frames, \\n num_empty_frames=num_empty_frames, \\n calculate_drift=False, \\n correction_folder=correction_folder,\\n illumination_corr=illumination_corr,\\n bleed_corr=False, chromatic_corr=False,\\n z_shift_corr=False, hot_pixel_corr=True,\\n normalization=False, return_drift=False,\\n verbose=False,\\n )[0]\\n else:\\n raise IOError(f\\\"Wrong input file type, {filename} should be .dax file or np.ndarray\\\")\\n # crop target image:\\n _tar_ims = [_bead_im[tuple([slice(_s[0], _s[-1]) for _s in _c])] for _c in crop_list]\\n # get centers\\n _tar_ct_list = [get_centers(_im, th_seed=th_seed,\\n th_seed_per=th_seed_per, \\n use_percentile=use_percentile,\\n max_num_seeds=max_num_seeds, \\n min_num_seeds=min_num_seeds,\\n **fitting_kwargs,\\n ) for _im in _tar_ims]\\n\\n ## acquire references\\n # case 1: ref_centers and ref_ims are given:\\n if ref_centers is not None and ref_ims is not None:\\n if verbose:\\n print(f\\\"given ref_centers and images, n={len(ref_centers)}\\\")\\n if len(ref_centers) != len(ref_ims):\\n raise IndexError(f\\\"length of ref_centers:{len(ref_centers)} should match length of ref_ims:{len(ref_ims)}\\\")\\n elif len(crop_list) != len(ref_centers):\\n raise IndexError(f\\\"length of crop_list:{len(crop_list)} should match length of ref_centers:{len(ref_centers)}\\\")\\n _ref_ims = ref_ims\\n _ref_ct_list = ref_centers\\n # case 2: ref_filename is given:\\n elif ref_filename is not None:\\n if isinstance(ref_filename, np.ndarray):\\n if verbose:\\n print(f\\\"ref image directly given\\\")\\n _ref_bead_im = ref_filename\\n elif isinstance(ref_filename, str):\\n if verbose:\\n print(f\\\"ref_file: {ref_filename}\\\")\\n _ref_bead_im = old_correct_fov_image(ref_filename, [_bead_channel], \\n single_im_size=single_im_size, \\n all_channels=all_channels,\\n num_buffer_frames=num_buffer_frames,\\n num_empty_frames=num_empty_frames, \\n calculate_drift=False, \\n correction_folder=correction_folder,\\n illumination_corr=illumination_corr,\\n warp_image=False,\\n bleed_corr=False, \\n chromatic_corr=False,\\n z_shift_corr=False, \\n hot_pixel_corr=True,\\n normalization=False, \\n return_drift=False,\\n verbose=False,\\n )[0][0]\\n _ref_ims = []\\n for _c in crop_list:\\n _crop = tuple([slice(int(_s[0]), int(_s[-1])) for _s in _c])\\n _ref_ims.append(_ref_bead_im[_crop])\\n # collect ref_ct_list\\n from ..spot_tools.fitting import select_sparse_centers\\n _ref_ct_list = []\\n for _im in _ref_ims:\\n _cand_cts = get_centers(_im, th_seed=th_seed,\\n th_seed_per=th_seed_per, \\n use_percentile=use_percentile,\\n max_num_seeds=max_num_seeds, \\n min_num_seeds=min_num_seeds,\\n **fitting_kwargs,\\n )\\n _ref_ct_list.append(select_sparse_centers(_cand_cts, \\n distance_th=match_distance_th))\\n else:\\n raise ValueError(f\\\"ref_filename or ref_centers+ref_ims should be given!\\\")\\n \\n # Do alignment\\n _drift_list = []\\n _paired_tar_ct_list = []\\n _paired_ref_ct_list = []\\n # iterate until find good drifts or calculated all cropped images\\n while len(_drift_list) < len(crop_list):\\n # get image\\n _cid = len(_drift_list)\\n # calculate drift\\n _drift, _paired_tar_cts, _paired_ref_cts = align_beads(\\n _tar_ct_list[_cid], _ref_ct_list[_cid], \\n _tar_ims[_cid], _ref_ims[_cid],\\n use_fft=use_fft, \\n fft_filt_size=fft_filt_size, \\n match_distance_th=match_distance_th, \\n check_paired_cts=check_paired_cts,\\n outlier_sigma=outlier_sigma,\\n return_paired_cts=True,\\n verbose=verbose,\\n )\\n # judge whether this matching is successful\\n if len(_paired_tar_cts) == 0:\\n _drift = np.inf * np.ones(len(single_im_size))\\n # append\\n _drift_list.append(_drift)\\n _paired_tar_ct_list.append(_paired_tar_cts)\\n _paired_ref_ct_list.append(_paired_ref_cts)\\n\\n # check if matched well: \\n if len(_drift_list) >=2:\\n if (cdist(_drift[np.newaxis,:], _drift_list[:-1])[0] < good_drift_th).any():\\n break\\n ## select drifts\\n _dists = squareform(pdist(_drift_list))\\n _dists[np.arange(len(_dists)), np.arange(len(_dists))] = np.inf\\n _inds = np.unravel_index(np.argmin(_dists, axis=None), _dists.shape)\\n # get the two that are closest\\n if _dists[_inds] > good_drift_th:\\n _success_flag = False\\n print(f\\\"-- Suspicious Failure: selcted drifts: {_drift_list[_inds[0]]}, {_drift_list[_inds[1]]} are not close enough.\\\")\\n else:\\n _success_flag = True\\n # extract _final_drift and return\\n _final_drift = np.nanmean([_drift_list[_inds[0]], _drift_list[_inds[1]]], axis=0)\\n\\n # return\\n _return_args = [_final_drift, _success_flag]\\n if return_target_ims:\\n _return_args.append(_tar_ims)\\n if return_paired_cts:\\n _return_args.append(_paired_tar_ct_list)\\n _return_args.append(_paired_ref_ct_list)\\n \\n return tuple(_return_args)\",\n \"def _perform_alignment(self, formulatrix_image, beamline_image, formulatrix_points):\\n aligner = ImageAligner(formulatrix_image, beamline_image, self._config_align, self._config_detector)\\n aligned_images = aligner.align()\\n scaled_formulatrix_points = aligner.scale_points(formulatrix_points)\\n self._log_alignment_status(aligned_images)\\n\\n return aligned_images, scaled_formulatrix_points\",\n \"def show_bboxes(img, bounding_boxes=None, facial_landmarks=[]):\\n\\n img_copy = img.copy()\\n draw = ImageDraw.Draw(img_copy)\\n# for b in bounding_boxes:\\n# draw.rectangle([\\n# (b[0], b[1]), (b[2], b[3])\\n# ], outline='white')\\n\\n for p in facial_landmarks:\\n for i in range(106):\\n draw.ellipse([\\n (p[i*2] - 1.0, p[2*i + 1] - 1.0),\\n (p[i*2] + 1.0, p[2*i+1] + 1.0)\\n ], outline='blue')\\n font = ImageFont.truetype(\\\"arial.ttf\\\", 10)\\n draw.text([p[2*i], p[2*i+1]], str(i), font=font)\\n\\n return img_copy\",\n \"def highlight_faces(image, faces, output_filename, terminal_print=True):\\n im = Image.open(image)\\n draw = ImageDraw.Draw(im)\\n\\n for (face_ind, face) in enumerate(faces):\\n\\n # compute emotions\\n list_emotion_scores = [face.sorrow_likelihood,\\n face.joy_likelihood,\\n face.anger_likelihood,\\n face.surprise_likelihood]\\n\\n list_emotions = [\\\"SORROW\\\",\\n \\\"JOY\\\",\\n \\\"ANGER\\\",\\n \\\"SURPRISE\\\"]\\n\\n string_label = generate_string_label(list_emotions, list_emotion_scores)\\n\\n if terminal_print:\\n # print emotions on terminal\\n print(\\\"\\\\n\\\")\\n print(\\\"-----------------------\\\")\\n print(\\\"Face {}\\\".format(face_ind))\\n\\n for (crrt_emotion, crrt_score) in zip(list_emotions, list_emotion_scores):\\n print(\\\"{}: {}\\\".format(crrt_emotion, crrt_score))\\n\\n print(string_label)\\n\\n print(\\\"-----------------------\\\")\\n\\n # draw box around face\\n box = [(vertex.x, vertex.y)\\n for vertex in face.bounding_poly.vertices]\\n draw.line(box + [box[0]], width=5, fill='#00ff00')\\n\\n # add legend in the face box\\n fontsize = 35\\n font = ImageFont.truetype(\\\"/usr/share/fonts/truetype/freefont/FreeMono.ttf\\\", fontsize)\\n\\n offset = 5\\n heigth_text = 40\\n length_text = box[1][0] - box[0][0] - 2 * offset\\n draw.rectangle(((box[0][0] + offset, box[0][1] + offset), (box[0][0] + length_text + offset, box[0][1] + heigth_text + offset)), fill=\\\"black\\\")\\n draw.text((box[0][0] + offset, box[0][1] + offset), string_label, font=font, fill=(255, 255, 255, 255))\\n\\n # highlight significant points\\n point_nbr = 0\\n half_width_sqare = 2\\n\\n list_point_coords = []\\n\\n for point in face.landmarks:\\n x = point.position.x\\n y = point.position.y\\n\\n list_point_coords.append((x, y))\\n\\n draw.rectangle(((x - half_width_sqare, y - half_width_sqare), (x + half_width_sqare, y + half_width_sqare)), fill=\\\"red\\\")\\n\\n # fontsize = 15\\n # font = ImageFont.truetype(\\\"/usr/share/fonts/truetype/freefont/FreeMono.ttf\\\", fontsize)\\n # draw.text((x, y), str(point_nbr), font=font, fill=(255, 255, 0, 0))\\n\\n point_nbr += 1\\n\\n all_lists_points = [\\n [10, 11, 9],\\n [10, 12, 11],\\n [14, 7, 13, 15],\\n [7, 6],\\n [14, 6, 13, 7, 14],\\n [16, 17, 18, 19],\\n [21, 22, 23, 24],\\n [30, 6],\\n ]\\n\\n for crrt_list_points in all_lists_points:\\n draw_line_list_points(draw, crrt_list_points, list_point_coords)\\n\\n draw_line_list_points(draw, [2, 26, 3], list_point_coords, close=False)\\n draw_line_list_points(draw, [4, 27, 5], list_point_coords, close=False)\\n draw_line_list_points(draw, [10, 8, 11], list_point_coords, close=False)\\n\\n im.save(output_filename)\",\n \"def correctMisalign(img, marker, center, compus, scope=100):\\n\\n markerCenter = np.asarray(marker.shape)//2\\n guide = np.asarray([center, compus])\\n landmark = np.zeros(guide.shape)\\n \\n #To run template matching to finder markers\\n result = cv2.matchTemplate(img, marker, 0)\\n result = (1-result/np.max(result))*255\\n M = np.float32([\\n [1, 0, markerCenter[1]] ,\\n [0, 1, markerCenter[0]] ])\\n resultPadded = cv2.warpAffine(result, M, (width, height))\\n \\n mask = np.zeros(resultPadded.shape)\\n\\n for i in range(0, len(guide)):\\n mask[:] = 0\\n mask_xfr = max(0, guide[i,1]-(scope+markerCenter[0]))\\n mask_xto = min(width, guide[i,1]+(scope+markerCenter[0]))\\n mask_yfr = max(0, guide[i,0]-(scope+markerCenter[1]))\\n mask_yto = min(width, guide[i,0]+(scope+markerCenter[1]))\\n mask[mask_xfr:mask_xto, mask_yfr:mask_yto] = 255\\n min_val, max_val, min_loc, landmark[i,:] = \\\\\\n cv2.minMaxLoc(np.multiply(resultPadded, mask))\\n \\n #To shift image\\n shift = guide[0] - landmark[0] \\n M = np.float32([\\n [1, 0, shift[0]] ,\\n [0, 1, shift[1]] ])\\n imgShifted = cv2.warpAffine(img, M, (width, height))\\n \\n #To rescale & rotate image\\n radius = np.linalg.norm(landmark[1,:] - landmark[0,:])\\n scale = np.linalg.norm(guide[1,:] - guide[0,:])/radius\\n cos = (landmark[1,0]-landmark[0,0])/radius\\n theta = np.arccos(cos) / (2 * np.pi) * 360\\n M = cv2.getRotationMatrix2D((guide[0,0],guide[0,1]),-theta,scale)\\n imgModified = cv2.warpAffine(imgShifted,M,(width,height))\\n return imgModified\\n\\n #}}}\",\n \"def align(image):\\n angle = find_angle(image)\\n image = rotate(image, angle)\\n return image\",\n \"def align_faces(frames):\\n align = get_entry('recognition')['face alignment']\\n provider = align['provider']\\n\\n logger = logging.getLogger('alignment')\\n logger.setLevel(logging.INFO)\\n\\n logger.info('alignment provider: ' + provider)\\n if provider == 'opencv':\\n from faceR.alignment import opencv as aligner\\n elif provider == 'dlib':\\n import dlib_al as aligner\\n elif provider == 'mtcnn':\\n from faceR.alignment import mtcnn as aligner\\n elif provider == 'face-boxes':\\n from faceR.alignment import face_boxes as aligner\\n elif provider == 'adas':\\n from faceR.alignment import adas as aligner\\n\\n return aligner.align_faces(frames, align[provider])\",\n \"def _box_face(image, face):\\n draw = PIL.ImageDraw.Draw(image.image)\\n draw.rectangle(face.as_box(), outline=\\\"yellow\\\")\",\n \"def _align(self):\\n\\n shape = np.shape(self.x)\\n\\n # Get angle of direction (cbi: center beam index)\\n # NOTE: This implementation seems to be unstable, because the shot with the center beam index can be NaN\\n # cbi = np.median(np.arange(len(self.x[0, :]))).astype(int)\\n # vec1 = [self.x[0, cbi], self.y[0, cbi], 0.0]\\n # vec2 = [self.x[-1, cbi], self.y[-1, cbi], 0.0]\\n\\n # Alternative implementation with mean over all entries within the line.\\n # -> should be a good approximation of the line center\\n # NOTE: 2019-05-30: Relaxed the criterion even further (mean of first and last 10 scan lines)\\n vec1 = [np.nanmedian(self.x[0:10, :]), np.nanmedian(self.y[0:10, :]), 0.0]\\n vec2 = [np.nanmedian(self.x[-11:-1, :]), np.nanmedian(self.y[-11:-1, :]), 0.0]\\n angle = -1.0*np.arctan((vec2[1]-vec1[1])/(vec2[0]-vec1[0]))\\n\\n # validity check -> Do not rotate if angle is nan\\n if np.isnan(angle):\\n return\\n\\n # Get center point\\n xc = np.nanmedian(self.x)\\n yc = np.nanmedian(self.y)\\n\\n # Reform points\\n points = [self.x.flatten()-xc, self.y.flatten()-yc]\\n\\n # Execute the rotation\\n rot_matrix = np.array([[np.cos(angle), -np.sin(angle)],\\n [np.sin(angle), np.cos(angle)]])\\n points_rotated = rot_matrix.dot(points)\\n self.x = np.reshape(points_rotated[0, :], shape)\\n self.y = np.reshape(points_rotated[1, :], shape)\\n\\n # Save conversion parameters for reuse\\n self._align_parameters = {'center_point': (xc, yc),\\n 'angle': angle,\\n 'rotation_matrix': rot_matrix}\",\n \"def align(self, *, skip_corners=False, return_on_invalid_result=False, warpwarnings=False, **kwargs):\\n #load the images for all HPFs and keep them in memory as long as\\n #the AlignSample is active\\n self.getDAPI()\\n self.logger.info(\\\"starting alignment\\\")\\n\\n weighted_sum_mse = 0.\\n sum_weights = 0.\\n done = set()\\n\\n for i, overlap in enumerate(self.overlaps, start=1):\\n if skip_corners and overlap.tag in [1,3,7,9] :\\n continue\\n self.logger.debug(f\\\"aligning overlap {overlap.n} ({i}/{len(self.overlaps)})\\\")\\n result = None\\n #check if the inverse overlap has already been aligned\\n #(e.g. if the current overlap is between (1, 2), check the overlap between (2, 1))\\n #if so, we don't have to align again\\n if self.inverseoverlapsdictkey(overlap) in done:\\n inverseoverlap = self.overlapsdict[self.inverseoverlapsdictkey(overlap)]\\n if hasattr(inverseoverlap, \\\"result\\\"):\\n result = overlap.getinversealignment(inverseoverlap)\\n #do the alignment\\n if result is None:\\n result = overlap.align(gputhread=self.gputhread, gpufftdict=self.gpufftdict, **kwargs)\\n done.add(self.overlapsdictkey(overlap))\\n\\n #contribution of the mean squared difference after alignment\\n #to the weighted sum\\n if result is not None and result.exit == 0: \\n w = (overlap.cutimages[0].shape[0]*overlap.cutimages[0].shape[1])\\n weighted_sum_mse+=w*result.mse[2]\\n sum_weights+=w\\n else :\\n if result is None:\\n reason = \\\"is None\\\"\\n else:\\n reason = f\\\"has exit status {result.exit}\\\"\\n if return_on_invalid_result :\\n if warpwarnings: self.logger.warningglobal(f'Overlap number {i} alignment result {reason}: returning 1e10!!')\\n return 1e10\\n else :\\n if warpwarnings: self.logger.warningglobal(f'Overlap number {i} alignment result {reason}: adding 1e10 to sum_mse!!')\\n w = (overlap.cutimages[0].shape[0]*overlap.cutimages[0].shape[1])\\n weighted_sum_mse+=w*1e10\\n sum_weights+=w\\n\\n self.logger.info(\\\"finished align loop for \\\"+self.SlideID)\\n return weighted_sum_mse/sum_weights\",\n \"def from_alignment(self, alignment, image=None):\\n self.x = alignment[\\\"x\\\"]\\n self.w = alignment[\\\"w\\\"]\\n self.y = alignment[\\\"y\\\"]\\n self.h = alignment[\\\"h\\\"]\\n self.frame_dims = alignment[\\\"frame_dims\\\"]\\n self.landmarksXY = alignment[\\\"landmarksXY\\\"]\\n if image.any():\\n self.image_to_face(image)\",\n \"def __call__(self, loc, scores, anchors, img_size):\\n anchors = bbox.loc2bbox(anchor)\",\n \"def forward(self, image, dtype=torch.float32):\\n image_shape = image.shape[2:]\\n\\n if image_shape == self.last_shape and image.device in self.last_anchors:\\n return self.last_anchors[image.device]\\n\\n if self.last_shape is None or self.last_shape != image_shape:\\n self.last_shape = image_shape\\n\\n if dtype == torch.float16:\\n dtype = np.float16\\n else:\\n dtype = np.float32\\n\\n boxes_all = []\\n for stride in self.strides:\\n boxes_level = []\\n for scale, ratio in itertools.product(self.scales, self.ratios):\\n if image_shape[1] % stride != 0:\\n raise ValueError('input size must be divided by the stride.')\\n base_anchor_size = self.anchor_scale * stride * scale\\n anchor_size_x_2 = base_anchor_size * ratio[0] / 2.0\\n anchor_size_y_2 = base_anchor_size * ratio[1] / 2.0\\n\\n x = np.arange(stride / 2, image_shape[1], stride)\\n y = np.arange(stride / 2, image_shape[0], stride)\\n xv, yv = np.meshgrid(x, y)\\n xv = xv.reshape(-1)\\n yv = yv.reshape(-1)\\n\\n # y1,x1,y2,x2\\n boxes = np.vstack((yv - anchor_size_y_2, xv - anchor_size_x_2,\\n yv + anchor_size_y_2, xv + anchor_size_x_2))\\n boxes = np.swapaxes(boxes, 0, 1)\\n boxes_level.append(np.expand_dims(boxes, axis=1))\\n # concat anchors on the same level to the reshape NxAx4\\n boxes_level = np.concatenate(boxes_level, axis=1)\\n boxes_all.append(boxes_level.reshape([-1, 4]))\\n\\n anchor_boxes = np.vstack(boxes_all)\\n\\n anchor_boxes = torch.from_numpy(anchor_boxes.astype(dtype)).to(image.device)\\n anchor_boxes = anchor_boxes.unsqueeze(0)\\n\\n # save it for later use to reduce overhead\\n self.last_anchors[image.device] = anchor_boxes\\n return anchor_boxes\",\n \"def center_image_anchor(image):\\n image.anchor_x = image.height/2\\n image.anchor_y = image.height/2\",\n \"def alignCtx(*args, align: bool=True, anchorFirstObject: bool=False, distribute: bool=True,\\n exists: bool=True, history: bool=True, image1: Union[AnyStr, bool]=\\\"\\\", image2:\\n Union[AnyStr, bool]=\\\"\\\", image3: Union[AnyStr, bool]=\\\"\\\", name: AnyStr=\\\"\\\",\\n showAlignTouch: bool=True, q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def __call__(self, src, label):\\r\\n \\\"\\\"\\\"color distort\\\"\\\"\\\"\\r\\n # img = random_color_distort(src)\\r\\n\\r\\n # print(\\\"previous label shape = \\\", label.shape)\\r\\n target = np.zeros(shape=(label.shape[0],))\\r\\n\\r\\n \\\"\\\"\\\"Pyramid Anchor sampling\\\"\\\"\\\"\\r\\n img, boxes, label = self.random_baiducrop(src, label[:, :4], target)\\r\\n # print(\\\"label shape = \\\", label.shape)\\r\\n # print('boxes shape =', boxes.shape)\\r\\n bbox = boxes\\r\\n # img = mx.nd.array(img)\\r\\n\\r\\n \\\"\\\"\\\"color distort\\\"\\\"\\\"\\r\\n img = mx.nd.array(img)\\r\\n img = random_color_distort(img)\\r\\n\\r\\n # \\\"\\\"\\\"random crop, keep aspect ration=1\\\"\\\"\\\"\\r\\n # h, w, _ = img.shape\\r\\n # bbox, crop_size = random_crop_with_constraints(label, (w, h))\\r\\n # x_offset, y_offset, new_width, new_height = crop_size\\r\\n # img = mx.image.fixed_crop(img, x_offset, y_offset, new_width, new_height)\\r\\n\\r\\n \\\"\\\"\\\"resize with random interpolation\\\"\\\"\\\"\\r\\n h, w, _ = img.shape\\r\\n interp = np.random.randint(0, 5)\\r\\n img = gimage.imresize(img, self._width, self._height, interp=interp)\\r\\n bbox = gbbox.resize(bbox, (w, h), (self._width, self._height))\\r\\n\\r\\n \\\"\\\"\\\"random horizontal flip\\\"\\\"\\\"\\r\\n h, w, _ = img.shape\\r\\n img, flips = gimage.random_flip(img, px=0.5)\\r\\n bbox = gbbox.flip(bbox, (w, h), flip_x=flips[0])\\r\\n\\r\\n \\\"\\\"\\\"To Tensor & Normalization\\\"\\\"\\\"\\r\\n img = mx.nd.image.to_tensor(img)\\r\\n img = mx.nd.image.normalize(img, mean=self._mean, std=self._std)\\r\\n\\r\\n if self._anchors is None:\\r\\n return img, bbox\\r\\n\\r\\n # @TODO: generating training target so cpu workers can help reduce the workload on gpu\\r\\n face_anchors, head_anchors, body_anchors = self._anchors\\r\\n gt_bboxes = mx.nd.array(bbox[:, :4]).expand_dims(0)\\r\\n gt_ids = mx.nd.zeros((1, gt_bboxes.shape[1], 1), dtype=gt_bboxes.dtype)\\r\\n\\r\\n face_cls_targets, face_box_targets, _ = self._target_generator(\\r\\n face_anchors, None, gt_bboxes, gt_ids)\\r\\n\\r\\n head_cls_targets, head_box_targets, _ = self._target_generator(\\r\\n head_anchors, None, gt_bboxes, gt_ids)\\r\\n\\r\\n body_cls_targets, body_box_targets, _ = self._target_generator(\\r\\n body_anchors, None, gt_bboxes, gt_ids)\\r\\n\\r\\n return img, \\\\\\r\\n face_cls_targets[0], head_cls_targets[0], body_cls_targets[0], \\\\\\r\\n face_box_targets[0], head_box_targets[0], body_box_targets[0]\",\n \"def render(self, image=False, **kwargs):\\n import matplotlib.pyplot as plt\\n\\n source = self.alignment_transform.source.points\\n target = self.alignment_transform.target.points\\n # a factor by which the minimum and maximum x and y values of the warp\\n # will be increased by.\\n x_margin_factor, y_margin_factor = 0.5, 0.5\\n # the number of x and y samples to take\\n n_x, n_y = 50, 50\\n # {x y}_{min max} is the actual bounds on either source or target\\n # landmarks\\n x_min, y_min = np.vstack([target.min(0), source.min(0)]).min(0)\\n x_max, y_max = np.vstack([target.max(0), source.max(0)]).max(0)\\n x_margin = x_margin_factor * (x_max - x_min)\\n y_margin = y_margin_factor * (y_max - y_min)\\n # {x y}_{min max}_m is the bound once it has been grown by the factor\\n # of the spread in that dimension\\n x_min_m = x_min - x_margin\\n x_max_m = x_max + x_margin\\n y_min_m = y_min - y_margin\\n y_max_m = y_max + y_margin\\n # build sample points for the selected region\\n x = np.linspace(x_min_m, x_max_m, n_x)\\n y = np.linspace(y_min_m, y_max_m, n_y)\\n xx, yy = np.meshgrid(x, y)\\n sample_points = np.concatenate(\\n [xx.reshape([-1, 1]), yy.reshape([-1, 1])], axis=1\\n )\\n warped_points = self.alignment_transform.apply(sample_points)\\n delta = warped_points - sample_points\\n # plot the sample points result\\n x, y, = (\\n 0,\\n 1,\\n )\\n if image:\\n # if we are overlaying points onto an image,\\n # we have to account for the fact that axis 0 is typically\\n # called 'y' and axis 1 is typically called 'x'. Flip them here\\n x, y = y, x\\n plt.quiver(sample_points[:, x], sample_points[:, y], delta[:, x], delta[:, y])\\n delta = target - source\\n # plot how the landmarks move from source to target\\n plt.quiver(\\n source[:, x],\\n source[:, y],\\n delta[:, x],\\n delta[:, y],\\n angles=\\\"xy\\\",\\n scale_units=\\\"xy\\\",\\n scale=1,\\n )\\n # rescale to the bounds\\n plt.xlim((x_min_m, x_max_m))\\n plt.ylim((y_min_m, y_max_m))\\n if image:\\n # if we are overlaying points on an image, axis0 (the 'y' axis)\\n # is flipped.\\n plt.gca().invert_yaxis()\\n return self\",\n \"def img_augmentation(augmentation, img, bbox):\\n\\n # img_copy = img.copy()\\n image_shape = img.shape\\n h, w = image_shape[0:2]\\n\\n # Convert the stochastic sequence of augmenters to a deterministic one.\\n # The deterministic sequence will always apply the exactly same effects to the images.\\n det = augmentation.to_deterministic()\\n img_aug = det.augment_image(img)\\n\\n ia_bbox = list()\\n for bounding_box in bbox:\\n x1, y1, x2, y2 = bounding_box\\n ia_bbox.append(ia.BoundingBox(x1=x1, y1=y1, x2=x2, y2=y2))\\n\\n bbs = ia.BoundingBoxesOnImage(ia_bbox, shape=image_shape)\\n bbs_aug = det.augment_bounding_boxes([bbs])[0]\\n # img = bbs_aug.draw_on_image(img)\\n\\n after_bbox = list()\\n for bounding_box in bbs_aug.bounding_boxes:\\n bbox_list = [bounding_box.x1_int, bounding_box.y1_int, bounding_box.x2_int, bounding_box.y2_int]\\n\\n if bbox_list[0] >= w: bbox_list[0] = w - 1\\n if bbox_list[1] >= h: bbox_list[1] = h - 1\\n if bbox_list[2] >= w: bbox_list[2] = w - 1\\n if bbox_list[3] >= h: bbox_list[3] = h - 1\\n\\n if bbox_list[0] == bbox_list[2] or bbox_list[1] == bbox_list[3]:\\n return img_augmentation(augmentation, img, bbox)\\n\\n bbox_list = list(map(lambda x: max(x, 0), bbox_list))\\n after_bbox.append(bbox_list)\\n\\n assert img_aug.shape == image_shape, \\\"Augmentation shouldn't change image size\\\"\\n\\n return img_aug, after_bbox\",\n \"def _set_anchor_center(img):\\n img.anchor_x = int(img.width / 2)\\n img.anchor_y = int(img.height / 2)\",\n \"def gonio_axis_align():\\n \\n # Invert camera image, so dark pin on light image becomes a peak\\n cam_7.proc1.scale.put(-1)\\n cam_8.proc1.scale.put(-1)\\n \\n # High threshold, so AD centroid doesn't interpret background\\n cam_8ThresholdOld = cam_8.stats4.centroid_threshold.get()\\n cam_8.stats4.centroid_threshold.put(150)\\n cam_7ThresholdOld = cam_7.stats4.centroid_threshold.get()\\n cam_7.stats4.centroid_threshold.put(150)\\n \\n # HiMag\\n # Copy ROI2 geometry (HiMag Mag3) to ROI4 and use ROI4 centroid plugin\\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get())\\n cam_8.roi4.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get())\\n cam_8.roi4.size.x.put(cam_8.roi2.size.x.get() * 0.20)\\n cam_8.roi4.size.y.put(cam_8.roi2.size.y.get())\\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get() + cam_8.roi2.size.x.get()/2 - cam_8.roi4.size.x.get()/2)\\n \\n # LoMag\\n # Copy ROI2 geometry (LoMag Mag1) to ROI4 and use ROI4 centroid plugin\\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get())\\n cam_7.roi4.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get())\\n cam_7.roi4.size.x.put(cam_7.roi2.size.x.get() * 0.05)\\n cam_7.roi4.size.y.put(cam_7.roi2.size.y.get())\\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get() + cam_7.roi2.size.x.get()/2 - cam_7.roi4.size.x.get()/2)\\n \\n centerPinYHiMag0 = centroid_avg(cam_8.stats4)[1]\\n centerPinYLoMag0 = centroid_avg(cam_7.stats4)[1]\\n yield from bps.mvr(gonio.o,180)\\n time.sleep(2)\\n centerPinYHiMag180 = centroid_avg(cam_8.stats4)[1]\\n centerPinYLoMag180 = centroid_avg(cam_7.stats4)[1]\\n centerPinYHiMag = (centerPinYHiMag0 + centerPinYHiMag180)/2\\n centerPinYLoMag = (centerPinYLoMag0 + centerPinYLoMag180)/2\\n\\n centerPinOffsYHiMag = centerPinYHiMag - cam_8.roi4.size.y.get() / 2\\n centerPinOffsYLoMag = centerPinYLoMag - cam_7.roi4.size.y.get() / 2\\n \\n # Correct Mag 3 (cam_8 ROI2)\\n cam_8.roi2.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + centerPinOffsYHiMag)\\n # Correct Mag 4 (cam_8 ROI1)\\n cam_8.roi1.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + (cam_8.roi2.size.y.get()-cam_8.roi1.size.y.get())/2)\\n \\n # Correct Mag 1 (cam_7 ROI2)\\n cam_7.roi2.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + centerPinOffsYLoMag)\\n # Correct Mag 2 (cam_7 ROI3)\\n cam_7.roi3.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + (cam_7.roi2.size.y.get()-cam_7.roi3.size.y.get())/2)\\n\\n # De-invert image\\n cam_7.proc1.scale.put(-1)\\n cam_8.proc1.scale.put(-1)\\n \\n # Set thresold to previous value\\n cam_8.stats4.centroid_threshold.put(cam_8ThresholdOld)\\n cam_7.stats4.centroid_threshold.put(cam_7ThresholdOld)\\n \\n return\",\n \"def image_align(first_image, second_image):\\r\\n\\r\\n high_diff = (second_image.shape[0] - first_image.shape[0]) // 2\\r\\n width_diff = (second_image.shape[1] - first_image.shape[1]) // 2\\r\\n\\r\\n align_image = second_image[high_diff: high_diff + first_image.shape[0],\\r\\n width_diff: width_diff + first_image.shape[1],\\r\\n :]\\r\\n\\r\\n\\r\\n assert align_image.shape == first_image.shape\\r\\n\\r\\n return align_image\",\n \"def face_lm_preprocess(img, detections, scale, padding):\\n # Only handles detections from the 1st image\\n detections = denormalize_detections(detections[0], 128, scale[0], padding[[0, 2]])\\n xc, yc, roi_scale, theta = detection2roi(detections)\\n input_face_lm, affine, _ = extract_roi(img[..., ::-1], xc, yc, theta, roi_scale)\\n centers = np.stack((xc, yc), axis=1)\\n\\n return input_face_lm, affine, centers, theta\",\n \"def add_faces_to_map(bm, faces, group, skip=None):\\n face_map = bm.faces.layers.face_map.active\\n group_index = face_map_index_from_name(group.name.lower())\\n\\n def remove_skipped(f):\\n if skip:\\n skip_index = face_map_index_from_name(skip.name.lower())\\n return not (f[face_map] == skip_index)\\n return True\\n\\n for face in list(filter(remove_skipped, faces)):\\n face[face_map] = group_index\\n\\n obj = bpy.context.object\\n\\n # -- if auto uv map is set, perform UV Mapping for given faces\\n if obj.facemap_materials[group_index].auto_map:\\n map_method = obj.facemap_materials[group_index].uv_mapping_method\\n uv_map_active_editmesh_selection(faces, map_method)\\n\\n # -- if the facemap already has a material assigned, assign the new faces to the material\\n mat = obj.facemap_materials[group_index].material\\n mat_id = [idx for idx, m in enumerate(obj.data.materials) if m == mat]\\n if mat_id:\\n for f in faces:\\n f.material_index = mat_id[-1]\",\n \"def align_image(\\n src_im:np.ndarray, \\n ref_im:np.ndarray, \\n crop_list=None,\\n use_autocorr=True, precision_fold=100, \\n min_good_drifts=3, drift_diff_th=1.,\\n all_channels=_allowed_colors, \\n ref_all_channels=None, \\n drift_channel='488',\\n correction_args={},\\n fitting_args={},\\n match_distance_th=2.,\\n verbose=True, \\n detailed_verbose=False, \\n ):\\n \\n from ..io_tools.load import correct_fov_image\\n from ..spot_tools.fitting import fit_fov_image\\n from ..spot_tools.fitting import select_sparse_centers\\n from skimage.registration import phase_cross_correlation\\n #print(\\\"**\\\", type(src_im), type(ref_im))\\n ## check inputs\\n # correciton keywords\\n _correction_args = {_k:_v for _k,_v in _default_align_corr_args.items()}\\n _correction_args.update(correction_args)\\n # fitting keywords\\n _fitting_args = {_k:_v for _k,_v in _default_align_fitting_args.items()}\\n _fitting_args.update(fitting_args)\\n \\n # check crop_list:\\n if crop_list is None:\\n crop_list = generate_drift_crops(_correction_args['single_im_size'])\\n for _crop in crop_list:\\n if np.shape(np.array(_crop)) != (3,2):\\n raise IndexError(f\\\"crop should be 3x2 np.ndarray.\\\")\\n # check channels\\n _all_channels = [str(_ch) for _ch in all_channels]\\n # check bead_channel\\n _drift_channel = str(drift_channel)\\n if _drift_channel not in all_channels:\\n raise ValueError(f\\\"bead channel {_drift_channel} not exist in all channels given:{_all_channels}\\\")\\n # check ref_all_channels\\n if ref_all_channels is None:\\n _ref_all_channels = _all_channels\\n else:\\n _ref_all_channels = [str(_ch) for _ch in ref_all_channels]\\n \\n ## process source image\\n # define result flag\\n _result_flag = 0\\n # process image\\n if isinstance(src_im, np.ndarray):\\n if verbose:\\n print(f\\\"-- start aligning given source image to\\\", end=' ')\\n _src_im = src_im\\n elif isinstance(src_im, str):\\n if verbose:\\n print(f\\\"-- start aligning file {src_im}.\\\", end=' ')\\n if not os.path.isfile(src_im) or src_im.split('.')[-1] != 'dax':\\n raise IOError(f\\\"input src_im: {src_im} should be a .dax file!\\\")\\n _src_im = correct_fov_image(src_im, [_drift_channel], \\n all_channels=_all_channels,\\n calculate_drift=False, \\n return_drift=False, verbose=detailed_verbose,\\n **_correction_args)[0]\\n else:\\n raise IOError(f\\\"Wrong input file type, {type(src_im)} should be .dax file or np.ndarray\\\")\\n \\n ## process reference image\\n if isinstance(ref_im, np.ndarray):\\n if verbose:\\n print(f\\\"given reference image.\\\")\\n _ref_im = ref_im\\n elif isinstance(ref_im, str):\\n if verbose:\\n print(f\\\"reference file:{ref_im}.\\\")\\n if not os.path.isfile(ref_im) or ref_im.split('.')[-1] != 'dax':\\n raise IOError(f\\\"input ref_im: {ref_im} should be a .dax file!\\\")\\n _ref_im = correct_fov_image(ref_im, [_drift_channel], \\n all_channels=_ref_all_channels,\\n calculate_drift=False, \\n return_drift=False, verbose=detailed_verbose,\\n **_correction_args)[0][0]\\n else:\\n raise IOError(f\\\"Wrong input ref file type, {type(ref_im)} should be .dax file or np.ndarray\\\")\\n\\n if np.shape(_src_im) != np.shape(_ref_im):\\n raise IndexError(f\\\"shape of target image:{np.shape(_src_im)} and reference image:{np.shape(_ref_im)} doesnt match!\\\")\\n\\n ## crop images\\n _crop_src_ims, _crop_ref_ims = [], []\\n for _crop in crop_list:\\n _s = tuple([slice(*np.array(_c,dtype=np.int)) for _c in _crop])\\n _crop_src_ims.append(_src_im[_s])\\n _crop_ref_ims.append(_ref_im[_s])\\n ## align two images\\n _drifts = []\\n for _i, (_sim, _rim) in enumerate(zip(_crop_src_ims, _crop_ref_ims)):\\n _start_time = time.time()\\n if use_autocorr:\\n if detailed_verbose:\\n print(\\\"--- use auto correlation to calculate drift.\\\")\\n # calculate drift with autocorr\\n _dft, _error, _phasediff = phase_cross_correlation(_rim, _sim, \\n upsample_factor=precision_fold)\\n else:\\n if detailed_verbose:\\n print(\\\"--- use beads fitting to calculate drift.\\\")\\n # source\\n _src_spots = fit_fov_image(_sim, _drift_channel, \\n verbose=detailed_verbose,\\n **_fitting_args) # fit source spots\\n _sp_src_cts = select_sparse_centers(_src_spots[:,1:4], match_distance_th) # select sparse source spots\\n # reference\\n _ref_spots = fit_fov_image(_rim, _drift_channel, \\n verbose=detailed_verbose,\\n **_fitting_args)\\n _sp_ref_cts = select_sparse_centers(_ref_spots[:,1:4], match_distance_th, \\n verbose=detailed_verbose) # select sparse ref spots\\n #print(_sp_src_cts, _sp_ref_cts)\\n \\n # align\\n _dft, _paired_src_cts, _paired_ref_cts = align_beads(\\n _sp_src_cts, _sp_ref_cts,\\n _sim, _rim,\\n use_fft=True,\\n match_distance_th=match_distance_th, \\n return_paired_cts=True,\\n verbose=detailed_verbose,\\n )\\n _dft = _dft * -1 # beads center is the opposite as cross correlation\\n # append \\n _drifts.append(_dft) \\n if verbose:\\n print(f\\\"-- drift {_i}: {np.around(_dft, 2)} in {time.time()-_start_time:.3f}s.\\\")\\n\\n # detect variance within existing drifts\\n _mean_dft = np.nanmean(_drifts, axis=0)\\n if len(_drifts) >= min_good_drifts:\\n _dists = np.linalg.norm(_drifts-_mean_dft, axis=1)\\n _kept_drift_inds = np.where(_dists <= drift_diff_th)[0]\\n if len(_kept_drift_inds) >= min_good_drifts:\\n _updated_mean_dft = np.nanmean(np.array(_drifts)[_kept_drift_inds], axis=0)\\n _result_flag += 0\\n if verbose:\\n print(f\\\"--- drifts for crops:{_kept_drift_inds} pass the thresold, exit cycle.\\\")\\n break\\n \\n if '_updated_mean_dft' not in locals():\\n if verbose:\\n print(f\\\"-- return a sub-optimal drift\\\")\\n _drifts = np.array(_drifts)\\n # select top 3 drifts\\n from scipy.spatial.distance import pdist, squareform\\n _dist_mat = squareform(pdist(_drifts))\\n np.fill_diagonal(_dist_mat, np.inf)\\n # select closest pair\\n _sel_inds = np.array(np.unravel_index(np.argmin(_dist_mat), np.shape(_dist_mat)))\\n _sel_drifts = list(_drifts[_sel_inds])\\n # select closest 3rd drift\\n _sel_drifts.append(_drifts[np.argmin(_dist_mat[:, _sel_inds].sum(1))])\\n if detailed_verbose:\\n print(f\\\"--- select drifts: {np.round(_sel_drifts, 2)}\\\")\\n # return mean\\n _updated_mean_dft = np.nanmean(_sel_drifts, axis=0)\\n _result_flag += 1\\n\\n return _updated_mean_dft, _result_flag\",\n \"def find_face(im, bias=None, padding=0, min_padding=0):\\n\\n # Import optional libraries required for face detection\\n import dlib\\n from skimage import io as skimage_io\\n skimage_io.use_plugin('pil')\\n\\n # Check we have already aquired a face detector and if not do so now\\n if not hasattr(Variation, '_face_detector'):\\n Variation._face_detector = dlib.get_frontal_face_detector()\\n\\n # Convert the image to an array that can be read by skimage\\n w, h = im.size\\n skimage_im = numpy.array(im.getdata(), numpy.uint8).reshape(h, w, 3)\\n\\n d = dlib.get_frontal_face_detector()\\n faces = d(skimage_im, 1)\\n\\n # Detect faces\\n faces = Variation._face_detector(skimage_im, 1)\\n\\n # If no faces were detected there's nothing more to do, we return `None`\\n if len(faces) == 0:\\n return\\n\\n # If a face was found apply any bias and padding to it\\n face = faces[0]\\n rect = [face.left(), face.top(), face.right(), face.bottom()]\\n\\n # Apply bias\\n if bias:\\n # Shift the center of the face\\n bias_x = int(face.width() * bias[0])\\n bias_y = int(face.width() * bias[1])\\n rect[0] += bias_x\\n rect[1] += bias_y\\n rect[2] += bias_x\\n rect[3] += bias_y\\n\\n # Apply padding\\n if padding > 0:\\n\\n # Determine the maximum amount of padding that can be applied in any\\n # direction.\\n max_padding = rect[0]\\n max_padding = min(rect[1], max_padding)\\n max_padding = min(rect[2], max_padding)\\n max_padding = min(rect[3], max_padding)\\n\\n # Calculate the padding to apply\\n pad = [\\n int(face.width() * padding),\\n int(face.height() * padding)\\n ]\\n\\n # Ensure that the minimum padding is observed\\n if min_padding > 0:\\n pad = [\\n min(pad[0], max(max_padding, int(pad[0] * min_padding))),\\n min(pad[1], max(max_padding, int(pad[1] * min_padding)))\\n ]\\n\\n # Apply the padding to the face rectangle\\n rect[0] = max(rect[0] - pad[0], 0)\\n rect[1] = max(rect[1] - pad[1], 0)\\n rect[2] = min(rect[2] + pad[0], im.size[0])\\n rect[3] = min(rect[3] + pad[1], im.size[1])\\n\\n return rect\",\n \"def detect_face(self, img):\\n # Fetch face location from the frame with 128 encoding of face landmarks\\n curr_face_loc, name_list, info_list = load_encode_loc(img, self.kwn_names,\\n self.kwn_encoding,\\n self.status_list, self.since_list)\\n print('Current value is ', curr_face_loc, name_list)\\n face_list = []\\n face_area = []\\n print('face loc', curr_face_loc)\\n if len(curr_face_loc):\\n\\n for (top, right, bottom, left), name in zip(curr_face_loc, name_list):\\n print(top, right, bottom, left)\\n cv2.rectangle(img, (top, right), (bottom, left), (0, 255, 2), 2)\\n\\n w = right - left\\n h = bottom - top\\n cx = left + w // 2\\n cy = top + h // 2\\n area = w * h\\n\\n for idx, info in enumerate(info_list):\\n cv2.putText(img, info, (bottom, int(left * idx * 0.2)),\\n cv2.FONT_HERSHEY_COMPLEX, 1,\\n (0, 0, 255), 1)\\n\\n face_list.append([cx, cy])\\n face_area.append(area)\\n\\n i = face_area.index(max(face_area))\\n\\n return img, [face_list[i], face_area[i]]\\n\\n else:\\n return img, [[0, 0], 0]\",\n \"def AlignFieldmaps(self):\\n for entry in self.entry_map['fmap']:\\n info = self.info[entry]\\n\\n# Register the magnitude image at the shortest TR to the T1-IR\\n# structural image.\\n target = self.info[self.norm_src]['imgfile'] + \\\\\\n self.info[self.norm_src]['suffix']\\n source = info['magfile'] + info['suffix']\\n matfile = info['matfile']\\n fmt = '3dAllineate -prefix NULL -1Dmatrix_save %s -base %s ' + \\\\\\n '-source %s -cost mi -warp shift_rotate'\\n cmd = fmt % (info['matfile'], target, source)\\n self.CheckExec(cmd, [info['matfile']])\\n\\n# Convert to unitary matrix (remove scaling component.)\\n cmd = 'cat_matvec -ONELINE %s -P > %s' % \\\\\\n (info['matfile'], info['matfile_unitary'])\\n self.CheckExec(cmd, [info['matfile_unitary']])\\n\\n# Rotate the magnitude image to the new grid.\\n fmt = '3dAllineate -prefix %s -interp cubic -1Dmatrix_apply %s %s'\\n cmd = fmt % (info['magfile_r']+info['suffix'], \\\\\\n info['matfile_unitary'], info['magfile'] + info['suffix'])\\n self.CheckExec(cmd, [info['magfile_r']+info['suffix']])\\n\\n# Rotate the fieldmap to the new grid.\\n fmt = '3dAllineate -prefix %s -interp cubic -1Dmatrix_apply %s %s'\\n cmd = fmt % (info['imgfile_r']+info['suffix'], \\\\\\n info['matfile_unitary'], info['imgfile'] + info['suffix'])\\n self.CheckExec(cmd, [info['imgfile_r']+info['suffix']])\",\n \"def generate_anchor_boxes(image_size, feature_map_size, sizes, scales):\\n image_height, image_width = image_size\\n fm_height, fm_width = feature_map_size\\n height_stride = int(image_height / fm_height)\\n width_stride = int(image_width / fm_width)\\n\\n # Compose horizontal and vertical positions into grid and reshape result into (-1, 2)\\n y_centers = np.arange(0, image_height, height_stride)\\n x_centers = np.arange(0, image_width, width_stride)\\n centers = np.dstack(np.meshgrid(y_centers, x_centers)).reshape((-1, 2))\\n\\n # Creates anchor boxes pyramid. Somewhat vectorized version of itertools.product\\n r_scales = np.repeat([scales], len(sizes), axis=0).ravel()\\n r_sides = np.repeat([sizes], len(scales), axis=1).ravel()\\n ab_pyramid = np.transpose([r_sides / (r_scales ** .5),\\n r_sides * (r_scales ** .5)]).astype(int)\\n\\n # Creates combinations of all anchor boxes centers and sides\\n r_centers = np.repeat(centers, len(ab_pyramid), axis=0)\\n r_ab_pyramid = np.repeat([ab_pyramid], len(centers), axis=0).reshape((-1, 2))\\n return np.hstack((r_centers, r_ab_pyramid))\",\n \"def __scale_and_shift(self, image, landmarks, scale_range, output_size):\\n (x1, y1, x2, y2), new_size, need_pad, (p_x, p_y, p_w, p_h) = self.get_bbox_of_landmarks(\\n image, landmarks, scale_range, shift_rate=0.3)\\n box_image = image[y1:y2, x1:x2]\\n if need_pad:\\n box_image = np.lib.pad(box_image, ((p_y, p_h), (p_x, p_w), (0, 0)), 'constant')\\n box_image = cv2.resize(box_image, (output_size, output_size))\\n landmarks = (landmarks - (x1 - p_x, y1 - p_y)) / (new_size, new_size)\\n return box_image, landmarks\",\n \"def add_boundary_regions(regions=None, faces=['front', 'back', 'left',\\n 'right', 'top', 'bottom']):\\n if faces is None:\\n return regions\\n\\n if regions.ndim not in [2, 3]:\\n raise Exception(\\\"add_boundary_regions works only on 2D and 3D images\\\")\\n\\n if regions.ndim == 2:\\n if set([\\\"bottom\\\", \\\"top\\\"]).intersection(faces):\\n raise Exception(\\\"For 2D images, use 'left', 'right', 'front', 'back' labels\\\")\\n\\n # Map which image slice corresponds to which face\\n face_to_slice = {\\n \\\"left\\\": 0, \\\"right\\\": -1, \\\"front\\\": 0, \\\"back\\\": -1, \\\"bottom\\\": 0, \\\"top\\\": -1\\n }\\n # Map face label to corresponding axis\\n face_to_axis = {\\n \\\"left\\\": 0, \\\"right\\\": 0, \\\"front\\\": 1, \\\"back\\\": 1, \\\"bottom\\\": 2, \\\"top\\\": 2\\n }\\n\\n ndim = regions.ndim\\n indices = []\\n # Note: pad_width format: each elem is [pad_before, pad_after]\\n pad_width = [[0, 0] for i in range(ndim)]\\n # 1. Create indices for boundary faces, ex. bottom\\\" => [:, :, -1]\\n # Note: slice(None) is equivalent to \\\":\\\" in fancy indexing, ex. [0, 0, :]\\n # 2. populate pad_width based on labels\\n for face in faces:\\n temp = [slice(None) for i in range(ndim)]\\n axis = face_to_axis[face]\\n plane = face_to_slice[face]\\n temp[axis] = plane\\n indices.append(tuple(temp))\\n pad_width[axis][plane] = 1 # Pad each face by 1 pixel\\n\\n regions = np.pad(regions, pad_width=pad_width, mode=\\\"edge\\\")\\n\\n # Increment boundary regions to distinguish from internal regions\\n for idx in indices:\\n # Only increment non-background regions (i.e. != 0)\\n non_background = regions[idx] != 0\\n regions[idx][non_background] += regions.max()\\n\\n # Remove connections between boundary regions\\n for idx in indices:\\n regions[idx] *= ~find_boundaries(regions[idx], mode=\\\"outer\\\")\\n\\n # Pad twice to make boundary regions 3-pixel thick -> required for marching_cube\\n regions = np.pad(regions, pad_width=pad_width, mode=\\\"edge\\\")\\n regions = np.pad(regions, pad_width=pad_width, mode=\\\"edge\\\")\\n\\n # Convert pad-induced corners to 0\\n zero_corners(regions, pad_width)\\n\\n # Make labels contiguous\\n regions = make_contiguous(regions)\\n\\n return regions\",\n \"def main():\\n filename = sys.argv[1]\\n aligner = Aligner(cv2.imread(filename))\\n aligned_image = aligner.get_aligned_image()\\n\\n return aligned_image\",\n \"def transform_grouped_faces(bm, faces, prop):\\r\\n face_height = max(map(lambda f: calc_face_dimensions(f)[1], faces))\\r\\n target_height = clamp(prop.height, 0.01, face_height)\\r\\n prop.height = target_height\\r\\n\\r\\n trans_offset = target_height - face_height\\r\\n verts = list({v for f in faces for v in f.verts})\\r\\n top_verts = sort_verts(verts, VEC_UP)[len(verts) // 2 :]\\r\\n bmesh.ops.translate(bm, verts=top_verts, vec=VEC_UP * trans_offset)\\r\\n bmesh.ops.translate(bm, verts=verts, vec=VEC_UP * prop.height)\",\n \"def _merge_face(merge, image, face):\\n scaled = merge.image.resize(face.as_dimension()).convert(\\\"RGBA\\\")\\n image.image = image.image.convert(\\\"RGBA\\\")\\n image.image.paste(scaled, face.as_box(), mask=scaled)\\n return image\",\n \"def soft_align_faces(self):\\n drivers_idx = [self.joints_qpos_map[x] for x in self.drivers]\\n\\n current_angles = self.sim.data.qpos[drivers_idx]\\n straight_angles = rotation.round_to_straight_angles(current_angles)\\n normalized_diff = rotation.normalize_angles(straight_angles - current_angles)\\n\\n # From the largest angle to the smallest\\n for _, idx in reversed(\\n sorted(zip(np.abs(normalized_diff), range(len(normalized_diff))))\\n ):\\n self.rotate_face(idx // 2, idx % 2, normalized_diff[idx])\\n\\n # Align all little cubelets at the end\\n for i in range(27):\\n info = self.cubelet_meta_info[i]\\n\\n if \\\"euler_qpos\\\" in info:\\n mtx = self._cubelet_rotation_matrix(info, self.sim.data.qpos)\\n # Much better alignment than in the euler angle representation\\n # If the cube is close enough to the aligned state it should work\\n mtx = mtx.round()\\n self.sim.data.qpos[info[\\\"euler_qpos\\\"]] = rotation.mat2euler(mtx)\",\n \"def align_image(ref_image, img2transf,\\n n_ref_src=50, n_img_src=70, px_tol=2.):\\n\\n from scipy.ndimage.interpolation import affine_transform\\n\\n try:\\n import sep # noqa\\n except ImportError:\\n source_finder = find_sources\\n else:\\n source_finder = find_sources_with_sep\\n\\n ref_srcs = source_finder(ref_image)[:n_ref_src]\\n img_sources = source_finder(img2transf)[:n_img_src]\\n\\n m = find_affine_transform(ref_srcs, ref_srcs=img_sources,\\n max_pix_tol=px_tol)\\n\\n # SciPy Affine transformation transform a (row,col) pixel according to pT+s\\n # where p is in the _output_ image, T is the rotation and s the translation\\n # offset, so some mathematics is required to put it into a suitable form\\n # In particular, affine_transform() requires the inverse transformation\\n # that registration returns but for (row, col) instead of (x,y)\\n def inverse_transform(m):\\n m_rot_inv = np.linalg.inv(m[:2, :2])\\n m_offset_inv = -m_rot_inv.dot(m[:2, 2])\\n m_inv = np.zeros(m.shape)\\n m_inv[:2, :2] = m_rot_inv\\n m_inv[:2, 2] = m_offset_inv\\n if m.shape == (3, 3):\\n m_inv[2, 2] = 1\\n return m_inv\\n\\n m_inv = inverse_transform(m)\\n # p will transform from (x,y) to (row, col)=(y,x)\\n p = np.array([[0, 1], [1, 0]])\\n mrcinv_rot = p.dot(m_inv[:2, :2]).dot(p)\\n mrcinv_offset = p.dot(m_inv[:2, 2])\\n\\n aligned_image = affine_transform(img2transf, mrcinv_rot,\\n offset=mrcinv_offset,\\n output_shape=ref_image.shape,\\n cval=np.median(img2transf)\\n )\\n if isinstance(img2transf, np.ma.MaskedArray):\\n # it could be that img2transf's mask is just set to False\\n if type(img2transf.mask) is np.ndarray:\\n aligned_image_mask = \\\\\\n affine_transform(img2transf.mask.astype('float32'),\\n mrcinv_rot,\\n offset=mrcinv_offset,\\n output_shape=ref_image.shape,\\n cval=1.0\\n )\\n aligned_image_mask = aligned_image_mask > 0.4\\n aligned_image = np.ma.array(aligned_image, mask=aligned_image_mask)\\n else:\\n # If img2transf is masked array with mask set to false, we\\n # return the same\\n aligned_image = np.ma.array(aligned_image)\\n return aligned_image\",\n \"def draw_and_show_landmarks_and_head_pose(landmarks, image, yaw='unknown', pitch='unknown', roll='unknown', info_text=''):\\n for pos in landmarks:\\n cv2.circle(image, (int(pos[0]), int(pos[1])), 5, (0, 0, 255), -1)\\n cv2.putText(image, 'Yaw: {}'.format(yaw), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)\\n cv2.putText(image, 'Pitch: {}'.format(pitch), (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)\\n cv2.putText(image, 'Roll: {}'.format(roll), (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)\\n cv2.putText(image, info_text, (10, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)\\n\\n if not isinstance(yaw, str) and not isinstance(pitch, str) and not isinstance(roll, str):\\n # Create rotation matrix\\n rotation = Rotation.from_euler('yxz', [-yaw, pitch, roll], degrees=True)\\n rotation_matrix = rotation.as_dcm()\\n # offsets to axis end-points\\n axis_points = np.float32([[50, 0, 0],\\n [0, -50, 0],\\n [0, 0, 50],\\n ])\\n\\n # position in image\\n position = np.array([60, image.shape[0] - 60, 0])\\n\\n axis = np.zeros((3, 3), dtype=float)\\n axis[0] = np.dot(rotation_matrix, axis_points[0]) + position\\n axis[1] = np.dot(rotation_matrix, axis_points[1]) + position\\n axis[2] = np.dot(rotation_matrix, axis_points[2]) + position\\n\\n cv2.rectangle(image,\\n (0, image.shape[0] - 120),\\n (120, image.shape[0]),\\n (255, 255, 255),\\n -1)\\n cv2.line(image, (int(position[0]), int(position[1])), (int(axis[1][0]), int(axis[1][1])), (0, 255, 0), 3)\\n cv2.line(image, (int(position[0]), int(position[1])), (int(axis[0][0]), int(axis[0][1])), (255, 0, 0), 3)\\n cv2.line(image, (int(position[0]), int(position[1])), (int(axis[2][0]), int(axis[2][1])), (0, 0, 255), 3)\\n\\n cv2.imshow('Out', image)\",\n \"def align_image(rgb, thresh=0.02, step=1, channel=1):\\n r = assess_rotations(rgb, thresh=thresh, step=step, channel=channel)\\n rot_id = np.argmax(r['prominences'])\\n best_rotation = step * rot_id\\n n_rows = r['numbers'][rot_id]\\n print(\\\"Optimal rotation angle: {} degrees.\\\".format(best_rotation))\\n print(\\\"Number of rows identified: {}.\\\".format(n_rows))\\n rotated_image = imutils.rotate(rgb, best_rotation)\\n return rotated_image\",\n \"def aligned_landmarks(self):\\n landmarks = AlignerExtract().transform_points(self.landmarksXY,\\n self.aligned[\\\"matrix\\\"],\\n self.aligned[\\\"size\\\"],\\n self.aligned[\\\"padding\\\"])\\n return landmarks\",\n \"def group2mmdetection(group: dict) -> dict:\\n\\n image_id, group = group\\n filename = group['filename'].values[0]\\n fullpath = osp.join(IMG_DIR, filename)\\n assert image_id == osp.basename(filename).split('.')[0]\\n\\n width, height = get_image_size(fullpath)\\n\\n group['XMin'] = group['XMin'] * width\\n group['XMax'] = group['XMax'] * width\\n group['YMin'] = group['YMin'] * height\\n group['YMax'] = group['YMax'] * height\\n\\n bboxes = [np.expand_dims(group[col].values, -1) for col in['XMin', 'YMin', 'XMax', 'YMax']]\\n bboxes = np.concatenate(bboxes, axis=1)\\n #print(bboxes)\\n #print(bboxes.shape)\\n return {\\n 'filename': group['filename'].values[0], #image_id+'.jpg',\\n 'width': width,\\n 'height': height,\\n 'ann': {\\n 'bboxes': np.array(bboxes, dtype=np.float32),\\n 'labels': np.array([stoi[x] for x in group['LabelName'].values]) + 1\\n }\\n }\",\n \"def process_image_bbox(image, bbox, labels, file_name):\\n bounds, classes, scores = postprocessing(bbox, image)\\n image_processed = annotate(image, bounds, classes, scores, labels)\\n image_processed.save(file_name, 'png')\\n return image_processed\",\n \"def center_image_grid_anchors(image_grid):\\n for image in image_grid:\\n center_image_anchor(image)\",\n \"def anchor_target_layer(rpn_cls_score, gt_boxes, im_info, _feat_stride, all_anchors, num_anchors):\\n A = num_anchors\\n total_anchors = all_anchors.shape[0]\\n K = total_anchors / num_anchors\\n\\n # allow boxes to sit over the edge by a small amount\\n _allowed_border = 0\\n\\n # map of shape (..., H, W)\\n height, width = rpn_cls_score.shape[1:3]\\n\\n # only keep anchors inside the image\\n inds_inside = np.where(\\n (all_anchors[:, 0] >= -_allowed_border) &\\n (all_anchors[:, 1] >= -_allowed_border) &\\n (all_anchors[:, 2] < im_info[1] + _allowed_border) & # width\\n (all_anchors[:, 3] < im_info[0] + _allowed_border) # height\\n )[0]\\n\\n # keep only inside anchors\\n anchors = all_anchors[inds_inside, :]\\n\\n # label: 1 is positive, 0 is negative, -1 is dont care\\n labels = np.empty((len(inds_inside),), dtype=np.float32)\\n labels.fill(-1)\\n\\n # overlaps between the anchors and the gt boxes\\n # overlaps (ex, gt)\\n overlaps = bbox_overlaps(\\n np.ascontiguousarray(anchors, dtype=np.float),\\n np.ascontiguousarray(gt_boxes, dtype=np.float))\\n argmax_overlaps = overlaps.argmax(axis=1)\\n max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]\\n gt_argmax_overlaps = overlaps.argmax(axis=0)\\n gt_max_overlaps = overlaps[gt_argmax_overlaps,\\n np.arange(overlaps.shape[1])]\\n gt_argmax_overlaps = np.where(overlaps == gt_max_overlaps)[0]\\n\\n if not cfg.TRAIN.RPN_CLOBBER_POSITIVES:\\n # assign bg labels first so that positive labels can clobber them\\n # first set the negatives\\n labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0\\n\\n # fg label: for each gt, anchor with highest overlap\\n labels[gt_argmax_overlaps] = 1\\n\\n # fg label: above threshold IOU\\n labels[max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = 1\\n\\n if cfg.TRAIN.RPN_CLOBBER_POSITIVES:\\n # assign bg labels last so that negative labels can clobber positives\\n labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0\\n\\n # subsample positive labels if we have too many\\n num_fg = int(cfg.TRAIN.RPN_FG_FRACTION * cfg.TRAIN.RPN_BATCHSIZE)\\n fg_inds = np.where(labels == 1)[0]\\n if len(fg_inds) > num_fg:\\n disable_inds = npr.choice(\\n fg_inds, size=(len(fg_inds) - num_fg), replace=False)\\n labels[disable_inds] = -1\\n\\n # subsample negative labels if we have too many\\n num_bg = cfg.TRAIN.RPN_BATCHSIZE - np.sum(labels == 1)\\n bg_inds = np.where(labels == 0)[0]\\n if len(bg_inds) > num_bg:\\n disable_inds = npr.choice(\\n bg_inds, size=(len(bg_inds) - num_bg), replace=False)\\n labels[disable_inds] = -1\\n\\n bbox_targets = np.zeros((len(inds_inside), 4), dtype=np.float32)\\n bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])\\n\\n bbox_inside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)\\n # only the positive ones have regression targets\\n bbox_inside_weights[labels == 1, :] = np.array(cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS)\\n\\n bbox_outside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)\\n if cfg.TRAIN.RPN_POSITIVE_WEIGHT < 0:\\n # uniform weighting of examples (given non-uniform sampling)\\n num_examples = np.sum(labels >= 0)\\n positive_weights = np.ones((1, 4)) * 1.0 / num_examples\\n negative_weights = np.ones((1, 4)) * 1.0 / num_examples\\n else:\\n assert ((cfg.TRAIN.RPN_POSITIVE_WEIGHT > 0) &\\n (cfg.TRAIN.RPN_POSITIVE_WEIGHT < 1))\\n positive_weights = (cfg.TRAIN.RPN_POSITIVE_WEIGHT /\\n np.sum(labels == 1))\\n negative_weights = ((1.0 - cfg.TRAIN.RPN_POSITIVE_WEIGHT) /\\n np.sum(labels == 0))\\n bbox_outside_weights[labels == 1, :] = positive_weights\\n bbox_outside_weights[labels == 0, :] = negative_weights\\n\\n # map up to original set of anchors\\n labels = _unmap(labels, total_anchors, inds_inside, fill=-1)\\n bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, fill=0)\\n bbox_inside_weights = _unmap(bbox_inside_weights, total_anchors, inds_inside, fill=0)\\n bbox_outside_weights = _unmap(bbox_outside_weights, total_anchors, inds_inside, fill=0)\\n\\n # labels\\n labels = labels.reshape((1, height, width, A)).transpose(0, 3, 1, 2)\\n labels = labels.reshape((1, 1, A * height, width))\\n rpn_labels = labels\\n\\n # bbox_targets\\n bbox_targets = bbox_targets \\\\\\n .reshape((1, height, width, A * 4))\\n\\n rpn_bbox_targets = bbox_targets\\n # bbox_inside_weights\\n bbox_inside_weights = bbox_inside_weights \\\\\\n .reshape((1, height, width, A * 4))\\n\\n rpn_bbox_inside_weights = bbox_inside_weights\\n\\n # bbox_outside_weights\\n bbox_outside_weights = bbox_outside_weights \\\\\\n .reshape((1, height, width, A * 4))\\n\\n rpn_bbox_outside_weights = bbox_outside_weights\\n return rpn_labels, rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights\",\n \"def apply_alignment_matrix(job, matrix):\\n # Get the SVG-style 6-element vector from the 3x3 matrix\\n mat = [matrix[0][0], matrix[1][0], matrix[0][1], matrix[1][1], matrix[0][2], matrix[1][2]]\\n\\n # Only the 'defs' list contains coordinates that need to be transformed\\n defs = job['defs']\\n\\n for one_def in defs:\\n if one_def['kind'] == \\\"image\\\":\\n # TODO: raster images are not supported!\\n # The rest of the code assumes the rows of pixel data are aligned\\n # with the X axis, so handling rotation will require transforming\\n # the entire image and generating new data.\\n pass\\n elif one_def['kind'] == \\\"path\\\":\\n for one_path in one_def['data']:\\n for one_point in one_path:\\n matrixApply(mat, one_point)\",\n \"def process(self, img, enableMouthDetection = Global.DETECT_MOUTH_AREA_FLAG):\\n mouthPos=[]\\n [maxH,maxW,channels] = img.shape\\n facePos = self.faceDetector.detect_biggest(img, self.faceScales, self.faceNeightbors)\\n # print facePos\\n if enableMouthDetection and len(facePos)>0:\\n mouthDetectingArea = adjustRoiWithinRange(facePos[0], facePos[1], facePos[2], facePos[3], 0.1, 0.1, 0.5, -0.3, maxW, maxH)\\n mouthRegionForDetection = getROI(img, mouthDetectingArea)\\n mouthPos = self.mouthDetector.detect_biggest(mouthRegionForDetection, self.mouthScales, self.mouthNeighbors)\\n if len(mouthPos) > 0:\\n mouthPos[0] += mouthDetectingArea[0]\\n mouthPos[1] += mouthDetectingArea[1]\\n return [ facePos, mouthPos]\",\n \"def center_image(image):\\r\\n image.anchor_x = image.width / 2\\r\\n image.anchor_y = image.height / 2\",\n \"def center_image(image):\\r\\n image.anchor_x = image.width / 2\\r\\n image.anchor_y = image.height / 2\",\n \"def assign_landmark_to_box(self, landmarks_pos, boxes):\\n for box in boxes:\\n # extract box corners\\n bottom, right, top, left = box\\n # initialise the counter for each box\\n confirmed_box = 0\\n for feature_pos in landmarks_pos:\\n # extract the feature averaged position\\n mean_w, mean_h = feature_pos\\n # states if the feature position is inside the face box corners\\n if (bottom < mean_h < top\\n and left < mean_w < right):\\n # if the feature is inside we increae the counter\\n confirmed_box = confirmed_box + 1\\n\\n # if every feature is inside the box there is a match\\n if confirmed_box == len(landmarks_pos):\\n print(\\\"0k\\\")\\n return box\\n\\n return None\",\n \"def map_face(self):\\n #Array Order: U0,D1,R2,L3,F4,B5,\\n \\n cube_list = []\\n cube_list = self.cube.definition()\\n \\n for index, cubit in enumerate(self.faces['Up']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index]])\\n for index, cubit in enumerate(self.faces['Ri']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+9]])\\n for index, cubit in enumerate(self.faces['Ft']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+18]])\\n for index, cubit in enumerate(self.faces['Dn']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+27]])\\n for index, cubit in enumerate(self.faces['Le']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+36]])\\n for index, cubit in enumerate(self.faces['Bk']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+45]])\",\n \"def batch_align(image_list, dest_dir=\\\"output\\\"):\\n if not path.exists(dest_dir):\\n mkdir(dest_dir)\\n if path.isdir(dest_dir):\\n print \\\"Aligning %d images, output in %s, this may take a while\\\" % (len(im_list), dest_dir)\\n\\n ref_img = io.imread(image_list[0])\\n r = Parallel(n_jobs=4, backend=\\\"threading\\\", verbose=25)(\\n delayed(find_shift)(io.imread(img), ref_img) for img in image_list[1:])\\n y_shift = map(lambda x: x[0], r)\\n x_shift = map(lambda x: x[1], r)\\n\\n print min(y_shift), max(y_shift), min(x_shift), max(x_shift)\\n crop = [int(min(y_shift)) - 1, int(max(y_shift)) + 1, int(min(x_shift)) - 1, int(max(x_shift)) + 1]\\n\\n correct(ref_img, (0, 0), \\\"%s/%s\\\" % (dest_dir, path.basename(image_list[0])), crop)\\n Parallel(n_jobs=4, backend=\\\"threading\\\", verbose=25)(\\n delayed(correct)(io.imread(img), r[k], \\\"%s/%s\\\" % (dest_dir, path.basename(image_list[k])), crop)\\n for k, img in enumerate(image_list[1:]))\\n else:\\n print \\\"Output dir does not exists or is not a directory : %s\\\" % dest_dir\",\n \"def aligned_face(self):\\n return self.aligned[\\\"face\\\"]\",\n \"def get_landmarks(self, image): # from https://www.paulvangent.com/2016/08/05/emotion-recognition-using-facial-landmarks/\\n # Ask the detector to find the bounding boxes of each face. The 1 in the\\n # second argument indicates that we should upsample the image 1 time. This\\n # will make everything bigger and allow us to detect more faces.\\n detections = self.detector(image, 1)\\n if len(detections) < 1: # Number of faces detected = 0\\n # print(\\\"Number of faces detected: {}\\\".format(len(detections)))\\n return None\\n # Draw Facial Landmarks with the predictor class\\n shape = self.predictor(image, detections[0])\\n xlist = []\\n ylist = []\\n for i in range(68): # Store X and Y coordinates in two lists\\n xlist.append(float(shape.part(i).x))\\n ylist.append(float(shape.part(i).y))\\n\\n landmarks_vectorised = []\\n landmarks_vectorised = self.our_ft_landmark(xlist, ylist)# Extaraction des features\\n\\n xmean = np.mean(xlist)\\n ymean = np.mean(ylist)\\n xcentral = [(x-xmean) for x in xlist]\\n ycentral = [(y-ymean) for y in ylist]\\n \\n for x, y, w, z in zip(xcentral, ycentral, xlist, ylist):\\n landmarks_vectorised.append(w)\\n landmarks_vectorised.append(z)\\n # landmarks_vectorised.append(x)\\n # landmarks_vectorised.append(y)\\n meannp = np.asarray((ymean, xmean))\\n coornp = np.asarray((z, w))\\n dist = np.linalg.norm(coornp-meannp)# Distance euclidienne\\n landmarks_vectorised.append(dist)\\n landmarks_vectorised.append((math.atan2(y, x)*360)/(2*math.pi))# Calcule de l'ongle entre le moyenne et un point\\n\\n return landmarks_vectorised\",\n \"def add_bbox(self, image_path, image_size, obj):\\n\\n if image_path not in self.img_path_2_img_id:\\n self.img_path_2_img_id[image_path] = len(self.img_path_2_img_id)\\n\\n self.annotation['images'].append({\\n \\\"file_name\\\": image_path,\\n \\\"height\\\": image_size[1],\\n \\\"width\\\": image_size[0],\\n \\\"id\\\": self.img_path_2_img_id[image_path]\\n })\\n\\n new_ann_id = len(self.annotation['annotations'])\\n self.img_id_2_ann_id[self.img_path_2_img_id[image_path]].append(new_ann_id)\\n bbox = self.fit_box_in_image(obj['bbox'], image_size)\\n\\n if bbox:\\n self.annotation['annotations'].append({\\n \\\"bbox\\\": bbox, # x, y, w, h\\n \\\"segmentation\\\": obj['segmentation'],\\n \\\"attributes\\\": obj['attributes'],\\n \\\"ignore\\\": 0,\\n \\\"id\\\": new_ann_id,\\n \\\"image_id\\\": self.img_path_2_img_id[image_path],\\n \\\"area\\\": obj['bbox'][2] * obj['bbox'][3],\\n \\\"iscrowd\\\": 1 - int(obj['attributes']['legible']),\\n \\\"category_id\\\": self.label_map['text']\\n })\",\n \"def align(filename, prog, outfile):\\n ra = RunAlign()\\n ra.run_align(filename, prog, outfile)\",\n \"def _vertices2landmarks(self, vertices, faces, lmk_faces_idx, lmk_bary_coords):\\n batch_size, num_verts = vertices.shape[:dd2]\\n lmk_faces = torch.index_select(faces, 0, lmk_faces_idx.view(-1)).view(1, -1, 3).view(batch_size, lmk_faces_idx.shape[1], -1)\\n lmk_faces += torch.arange(batch_size, dtype=torch.long).view(-1, 1, 1) * num_verts\\n lmk_vertices = vertices.view(-1, 3)[lmk_faces]\\n landmarks = torch.einsum('blfi,blf->bli', [lmk_vertices, lmk_bary_coords])\\n return landmarks\",\n \"def detect_face_landmarks(gray_img, detector, predictor):\\r\\n # detect face in the grayscale image\\r\\n rects = detector(gray_img, 1)\\r\\n \\r\\n if len(rects)==0:\\r\\n # if no face was detected, we set the rectangle arbitrarily\\r\\n p = 24\\r\\n rect = dlib.rectangle(p,p,gray_img.shape[0]-p,gray_img.shape[1]-p)\\r\\n else:\\r\\n rect = rects[0]\\r\\n\\r\\n # determine the facial landmarks for the face region\\r\\n face_landmarks = face_utils.shape_to_np(predictor(gray_img, rect))\\r\\n face_landmarks = face_landmarks[17:] # remove landmarks around the face (useless)\\r\\n \\r\\n return face_landmarks\",\n \"def __convert_3d_bbox_to_corners(self, bbox: BBox3D, calib=None):\\n x = bbox.x\\n y = bbox.y\\n z = bbox.z\\n w = bbox.width # y\\n h = bbox.height # z\\n l = bbox.length # x\\n angle = bbox.rotation\\n\\n # convert from Camera 3D coordinates to LIDAR coordinates.\\n if bbox.coordinates == Coordinates.CAM_3D_RECT:\\n if calib is None:\\n print(\\\"WARNING: Visualization is in LIDAR coord & you pass a bbox of camera coord\\\")\\n\\n point = np.array([x, y, z]).reshape(1,3)\\n\\n # convert x, y, z from rectified cam coordinates to velodyne coordinates\\n point = calib.rectified_camera_to_velodyne(point)\\n\\n x = point[0,0]\\n y = point[0,1] \\n # model output is z center but dataset annotations consider z at the bottom \\n z = point[0,2] + h/2\\n\\n # angle in annotations is inverted .. while angle in predictions is correct\\n angle = -angle\\n \\n # convert (x,y,z) from center to top left corner (corner 0)\\n x = x - w/2\\n y = y - l/2\\n z = z + h/2\\n\\n top_corners = np.array([\\n [x, y, z],\\n [x+w, y, z],\\n [x, y+l, z],\\n [x+w, y+l, z]\\n ])\\n\\n # same coordinates but z = z_top - box_height\\n bottom_corners = top_corners - np.array([0,0, h])\\n\\n # concatinate \\n corners = np.concatenate((top_corners,bottom_corners), axis=0)\\n\\n # 3x3 Rotation Matrix along z \\n cosa = cos(angle)\\n sina = sin(angle)\\n R = np.array([\\n [cosa, -sina, 0],\\n [sina, cosa, 0],\\n [0, 0, 1]\\n ])\\n\\n # Translate the box to origin to perform rotation\\n center = np.array([x+w/2, y+l/2, z-h/2])\\n centered_corners = corners - center\\n\\n # Rotate\\n rotated_corners = np.dot( R, centered_corners.T ).T\\n\\n # Translate it back to its position\\n corners = rotated_corners + center\\n\\n # output of sin & cos sometimes is e-17 instead of 0\\n corners = np.round(corners, decimals=10)\\n\\n return corners\",\n \"def center_image(image):\\n image.anchor_x = image.width/2\\n image.anchor_y = image.height/2\",\n \"def inset_face_with_scale_offset(bm, face, scale_y, scale_x, offx=0, offy=0, offz=0):\\n cuts = 2\\n scale = cuts + 1\\n scale_y *= scale\\n scale_x *= scale\\n\\n do_vertical = scale_y < scale\\n do_horizontal = scale_x < scale\\n\\n if not do_horizontal and not do_vertical:\\n return face\\n\\n face.select = False\\n verts = subdivide_flagged_edges(\\n bm, face, do_horizontal, do_vertical, scale_x, scale_y\\n )\\n offset_flagged_verts(bm, verts, do_horizontal, do_vertical, offx, offy, offz)\\n return face_with_verts(bm, verts)\",\n \"def plot_faces(img, w, h, B, hist_h, hist_hT, R, name_img, mode_color=\\\"RGB\\\", Q=256, g_mask=False, nb_angles=1, nb_scales=1):\\n img_skin = convert_colors_probalities(img, hist_h, hist_hT, Q, mode_color)\\n #print(img_skin.shape)\\n set_face = recognition_function(img_skin, w, h, B, g_mask=g_mask, nb_angles=nb_angles, nb_scales=nb_scales)\\n draw_faces(img, set_face, \\\"raw_\\\"+name_img, (212, 85, 186))\\n if cluster_ellipse(set_face, R) != {}:\\n set_face = cluster_ellipse(set_face, R)\\n else:\\n set_face = non_maximum_suppression(set_face, R)\\n draw_faces(img, set_face, name_img, (212, 85, 186))\",\n \"def align(args) :\\n from aligner import align_reads\\n align_reads(args)\",\n \"def forward(self, bbox, anchor, width, height):\\n F = mx.nd\\n with autograd.pause():\\n # anchor with shape (N, 4)\\n a_xmin, a_ymin, a_xmax, a_ymax = self._bbox_split(anchor)\\n # invalid anchor mask with shape (N, 1)\\n imask = (\\n (a_xmin >= -self._allowed_border) *\\n (a_ymin >= -self._allowed_border) *\\n (a_xmax <= (width + self._allowed_border)) *\\n (a_ymax <= (height + self._allowed_border))) <= 0\\n imask = mx.nd.array(np.where(imask.asnumpy() > 0)[0], ctx=anchor.context)\\n\\n # calculate ious between (N, 4) anchors and (M, 4) bbox ground-truths\\n # ious is (N, M)\\n ious = F.contrib.box_iou(anchor, bbox, format='corner').transpose((1, 0, 2))\\n ious[:, imask, :] = -1\\n matches = self._matcher(ious)\\n samples = self._sampler(matches, ious)\\n samples = samples.as_in_context(anchor.context)\\n # training targets for RPN\\n cls_target, _ = self._cls_encoder(samples)\\n box_target, box_mask = self._box_encoder(\\n samples, matches, anchor.expand_dims(axis=0), bbox)\\n return cls_target, box_target, box_mask\",\n \"def put_text(img: np.ndarray,\\n bbox: Tuple[float, float, float, float],\\n person: Person,\\n all_frames_cnt: int) -> np.ndarray:\\n x, y, w, h = bbox\\n\\n pivot_img_size = 112\\n resolution_x = img.shape[1];\\n\\n overlay = img.copy()\\n opacity = 0.4\\n\\n img = cv2.rectangle(img, (x, y), (x + w, y + h), (67, 67, 67), 1)\\n if x + w + pivot_img_size < resolution_x:\\n # right\\n cv2.rectangle(img, (x + w, y), (x + w + pivot_img_size + 20, y + h), (64, 64, 64), cv2.FILLED)\\n cv2.addWeighted(overlay, opacity, img, 1 - opacity, 0, img)\\n\\n elif x - pivot_img_size > 0:\\n # left\\n cv2.rectangle(img, (x - pivot_img_size - 20, y), (x, y + h), (64, 64, 64), cv2.FILLED)\\n cv2.addWeighted(overlay, opacity, img, 1 - opacity, 0, img)\\n\\n gender_label = person.gender\\n race_label = person.race\\n age_label = person.age\\n num_frames = person.percent_in_video(all_frames_cnt)\\n\\n attributes = [gender_label, race_label, age_label, num_frames]\\n\\n for index, attribute in enumerate(attributes):\\n if x + w + pivot_img_size < resolution_x:\\n\\n text_location_y = y + 20 + (index + 1) * 20\\n text_location_x = x + w\\n\\n if text_location_y < y + h:\\n cv2.putText(img, attribute, (text_location_x + 10, text_location_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\\n (255, 255, 255), 1)\\n\\n elif x - pivot_img_size > 0:\\n\\n text_location_y = y + 20 + (index + 1) * 20\\n text_location_x = x - pivot_img_size\\n\\n if text_location_y <= y + h:\\n cv2.putText(img, attribute, (text_location_x + 10, text_location_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\\n (255, 255, 255), 1)\\n\\n return img\",\n \"def marksimilar(image, clust, size):\\n global opt\\n blocks = []\\n if clust:\\n draw = ImageDraw.Draw(image)\\n mask = Image.new('RGB', (size,size), 'cyan')\\n for cl in clust:\\n for x,y in cl:\\n \\tim = image.crop((x,y,x+size,y+size))\\n \\tim = Image.blend(im,mask,0.5)\\n \\tblocks.append((x,y,im))\\n for bl in blocks:\\n \\tx,y,im = bl\\n \\timage.paste(im,(x,y,x+size,y+size))\\n if int(opt.imauto):\\n for cl in clust:\\n cx1 = min([cx for cx,cy in cl])\\n cy1 = min([cy for cx,cy in cl])\\n cx2 = max([cx for cx,cy in cl]) + block_len\\n cy2 = max([cy for cx,cy in cl]) + block_len\\n draw.rectangle([cx1,cy1,cx2,cy2],outline=\\\"magenta\\\")\\n return image\",\n \"def beam_align():\\n\\n # do nothing if there is a sample mounted to avoid collisions\\n if smart_magnet.sample_detect.get() == 0:\\n raise Exception(\\\"Sample mounted on gonio! Avoided collision\\\")\\n\\n # wait for attenuators to finish moving\\n yield from bps.abs_set(mxatten, 0.002)\\n yield from bps.sleep(5)\\n\\n # transition to BL and open shutter\\n yield from bps.abs_set(gov_rbt, \\\"BL\\\", wait=True)\\n yield from bps.mv(sht.r, 0)\\n\\n yield from bps.abs_set(rot_aligner.cam_hi.cam_mode, \\\"beam_align\\\")\\n\\n # which direction, x pos. pitch beam outboard (-), y pos. pitch beam up (+)\\n scan_uid = yield from bp.count([rot_aligner.cam_hi], 1)\\n centroid_x, centroid_y = (\\n db[scan_uid].table()[rot_aligner.cam_hi.cv1.outputs.output1.name][1],\\n db[scan_uid].table()[rot_aligner.cam_hi.cv1.outputs.output2.name][1],\\n )\\n\\n if np.isclose(0, centroid_x) or np.isclose(0, centroid_y):\\n raise Exception(\\\"No centroid detected!\\\")\\n\\n yield from bps.abs_set(kbt.hor.delta_px, (centroid_x - 320))\\n yield from bps.abs_set(kbt.ver.delta_px, -(centroid_y - 256))\\n\\n def lin_reg(independent, dependent, goal, **kwargs) -> float:\\n b = dependent\\n A = np.matrix([[pos, 1] for pos in independent])\\n p = (\\n np.linalg.inv(A.transpose() * A)\\n * A.transpose()\\n * np.matrix(b.to_numpy()).transpose()\\n )\\n best = (goal - p[1]) / p[0]\\n return best\\n\\n for axis, signal, center in (\\n kbt.hor,\\n rot_aligner.cam_hi.cv1.outputs.output1,\\n 320,\\n ), (kbt.ver, rot_aligner.cam_hi.cv1.outputs.output2, 256):\\n # skip if we are within 1 um\\n if abs(axis.delta_px.get()) > 2:\\n scan_uid = yield from rel_scan_no_reset(\\n [rot_aligner.cam_hi],\\n axis,\\n 0,\\n 0.4 * -(axis.delta_px.get() / abs(axis.delta_px.get())),\\n 10,\\n )\\n scan_df = db[scan_uid].table()\\n best_voltage = lin_reg(\\n scan_df[axis.readback.name],\\n scan_df[signal.name],\\n center,\\n )\\n yield from bps.mv(axis, best_voltage)\\n yield from bps.sleep(1)\\n\\n # close shutters and reset attenuators for manual viewing\\n yield from bps.mv(sht.r, 20)\",\n \"def draw_bbox(img, bbox: list,\\n gca_axes: SubplotBase = None,\\n label: str = None,\\n color: str = \\\"#00ffff\\\") -> SubplotBase:\\n\\n cx, cy, w, h = bbox\\n\\n if not gca_axes:\\n gca_axes = plt.gca()\\n\\n top_bottom_pt = ((cx - w/2) * img.size[0],\\n (cy - h/2) * img.size[1])\\n\\n gca_axes.add_patch(plt.Rectangle(top_bottom_pt,\\n w * img.size[0], h * img.size[1],\\n color=color, fill=False, linewidth=2))\\n\\n font = {'color': 'white',\\n 'weight': 'bold',\\n 'size': 16}\\n\\n if label:\\n gca_axes.text(top_bottom_pt[0], top_bottom_pt[1], label,\\n fontdict=font,\\n bbox={'facecolor': '#00abab', 'alpha': 1})\\n\\n return gca_axes\",\n \"def compute_transform(self, image_pair, figure):\\t\\n\\t\\timage_pair = [int(image_pair[1]), int(image_pair[3])]\\n\\t\\tindices = np.where(np.all(np.abs(self.Matches[\\\"image_pairs\\\"][0] - image_pair) == 0, axis=1)) \\n\\t\\tfeature_pairs = self.Matches[\\\"image_match_pairs\\\"][0][indices[0][0]]\\n\\t\\tfeature_pair_scores = self.Matches[\\\"image_feature_scores\\\"][0][indices[0][0]] \\n\\n\\t\\ti1_loc = self.Database[\\\"image_locs\\\"][np.where(np.array(self.Database[\\\"image_idx\\\"]) == image_pair[0])[0][0]]\\n\\t\\ti2_loc = self.Database[\\\"image_locs\\\"][np.where(np.array(self.Database[\\\"image_idx\\\"]) == image_pair[1])[0][0]]\\n\\n\\t\\tself.image1 = cv2.cvtColor(extract_image(figure, i1_loc), cv2.COLOR_BGR2GRAY)\\n\\t\\tself.image2 = cv2.cvtColor(extract_image(figure, i2_loc), cv2.COLOR_BGR2GRAY)\\n\\t\\t# self.image1 = extract_image(figure, i1_loc)\\n\\t\\t# self.image2 = extract_image(figure, i2_loc)\\n\\n\\t\\tself.match_alignment = {}; self.match_alignment_scores = {}\\n\\t\\tfor pair, score in zip(feature_pairs, feature_pair_scores):\\n\\t\\t\\ti1 = self.Database[\\\"image_idx\\\"][pair[0]]\\n\\t\\t\\ti2 = self.Database[\\\"image_idx\\\"][pair[1]]\\n\\n\\t\\t\\tif i1 == image_pair[0]:\\n\\t\\t\\t\\ttarget = pair[0] \\n\\t\\t\\t\\tstart = pair[1]\\n\\t\\t\\t\\tif target not in self.match_alignment.keys():\\n\\t\\t\\t\\t\\tself.init_match_alignment(target)\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttarget = pair[1]\\n\\t\\t\\t\\tstart = pair[0]\\t\\t\\t\\t\\n\\t\\t\\t\\tif target not in self.match_alignment.keys():\\n\\t\\t\\t\\t\\tself.init_match_alignment(target)\\n\\n\\t\\t\\t# get ellipse and convert to three cardinal points\\n\\t\\t\\ttarget_ellipse = self.Database[\\\"orientation\\\"][target]\\n\\t\\t\\tstart_ellipse = self.Database[\\\"orientation\\\"][start]\\n\\t\\t\\ttarget_points, target_params = utils.ellipse2points(target_ellipse)\\n\\t\\t\\tstart_points, start_params = utils.ellipse2points(start_ellipse)\\n\\n\\t\\t\\t# compute angle between Major axes\\n\\t\\t\\trotation_angle = int(np.abs(target_params[0] - start_params[0]))\\n\\t\\t\\treflection_truth = target_params[1] * start_params[1]\\n\\t\\t\\tif reflection_truth > 0:\\n\\t\\t\\t\\treflection_truth = \\\"No\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\treflection_truth = \\\"Yes\\\"\\n\\t\\t\\tresolution_perc = round(((target_params[2] / start_params[2]) - 1), 1)\\n\\n\\t\\t\\t# extract features for histogram matching\\n\\t\\t\\ttarget_bloc = self.Database[\\\"blot_locs\\\"][target]\\n\\t\\t\\tstart_bloc = self.Database[\\\"blot_locs\\\"][start]\\n\\t\\t\\ttarget_feature = extract_image(self.image1, target_bloc, ex=5)\\n\\t\\t\\tfinal_feature = extract_image(self.image2, start_bloc, ex=5) \\n\\n\\t\\t\\t#find affine transform to match\\n\\t\\t\\tif self.AFFINE:\\n\\t\\t\\t\\tT = utils.compute_affine(start_points, target_points)\\n\\t\\t\\t\\timage2_warped = cv2.warpAffine(self.image2.copy(), T, (self.image1.shape[1], self.image1.shape[0]))\\n\\t\\t\\t\\tfinal_feature = extract_image(image2_warped, target_bloc, ex=5)\\n\\t\\t\\t\\n\\t\\t\\t# match hist\\n\\t\\t\\tif self.CONTRAST:\\n\\t\\t\\t\\tfinal_feature = utils.histogram_match(final_feature, target_feature)\\n\\n\\t\\t\\tself.match_alignment[target].append((final_feature, start, rotation_angle, reflection_truth, \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t resolution_perc, score))\\n\\t\\t\\tself.match_alignment_scores[target].append(score)\",\n \"def faceRecognition(image):\\r\\n faceLandmarks = [[],[],[]]\\r\\n face_landmarks_list = face_recognition.face_landmarks(image)\\r\\n if len(face_landmarks_list)>0:\\r\\n if len(face_landmarks_list[0]['left_eye'])>0:\\r\\n leftEyePos = [tuple(map(lambda i: int(i/32),i)) for i in face_landmarks_list[0]['left_eye']]\\r\\n for i in set(leftEyePos):\\r\\n if leftEyePos.count(i)>=len(leftEyePos)//len(set(leftEyePos)):\\r\\n faceLandmarks[0] += [i,]\\r\\n if len(face_landmarks_list[0]['right_eye'])>0:\\r\\n rightEyePos = [tuple(map(lambda i: int(i/32),i)) for i in face_landmarks_list[0]['right_eye']]\\r\\n for i in set(rightEyePos):\\r\\n if rightEyePos.count(i)>=len(rightEyePos)//len(set(rightEyePos)):\\r\\n faceLandmarks[1] += [i,]\\r\\n if len(face_landmarks_list[0]['top_lip'])>0:\\r\\n mouthPos = [tuple(map(lambda i: int(i/32),i)) for i in (face_landmarks_list[0]['top_lip']+face_landmarks_list[0]['bottom_lip'])]\\r\\n for i in set(mouthPos):\\r\\n if mouthPos.count(i)>=len(mouthPos)//len(set(mouthPos)):\\r\\n faceLandmarks[2] += [i,]\\r\\n return faceLandmarks\",\n \"def image_to_face(self, image):\\n self.image = image[self.y: self.y + self.h,\\n self.x: self.x + self.w]\",\n \"def apply_mapping(mask, mapping):\\n _, F = mapping.shape\\n aligned_mask = np.zeros_like(mask)\\n for f in range(F):\\n aligned_mask[:, f, :] = mask[mapping[:, f], f, :]\\n return aligned_mask\",\n \"def test_align(self):\\n al = align(self.amp1, self.amp2).m\\n\\n # Both objects are already centered, so should be close to origin (allowing for some inaccuracy)\\n self.assertAlmostEqual(al.vert.mean(axis=0)[0], 0, delta=TestAlign.DELTA)\\n self.assertAlmostEqual(al.vert.mean(axis=0)[1], 0, delta=TestAlign.DELTA)\\n self.assertAlmostEqual(al.vert.mean(axis=0)[2], 0, delta=TestAlign.DELTA)\",\n \"def detectFaceAndClassify(faceNet, faceMaskClassifier, testImagePath, threshold):\\n # load the input test image from disk\\n image = cv2.imread(testImagePath)\\n # making a copy of image and finding the image spatial dimensions\\n orig = image.copy()\\n (h, w) = image.shape[:2]\\n\\n # construct a blob from the image to pass to the network\\n # using standard weights for the face detection model for image preprocessing\\n blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), (104.0, 177.0, 123.0))\\n\\n # obtain the face detections by passing the blob through the network\\n print(\\\"computing face detections...\\\")\\n faceNet.setInput(blob)\\n faceDetections = faceNet.forward()\\n\\n # loop over the detections to classify them and form bounding boxes and labels\\n for i in range(0, faceDetections.shape[2]):\\n # extract only confident detections using the confidence/probability\\n # associated with the detection\\n confidence = faceDetections[0, 0, i, 2]\\n\\n # filter out weak detections by ensuring the confidence is\\n # greater than the minimum confidence 0.5 or input variable\\n if confidence > threshold:\\n # extract bounding box dimensions and face Region of intrest for classification\\n faceROI, startX, startY, endX, endY = extractBoxAndFaceROI(image, faceDetections, itemNum=i,\\n height=h, width=w)\\n\\n faceROI = np.expand_dims(faceROI, axis=0)\\n\\n # Passing the pre-processed image with classification model to check if there is a mask or not\\n (mask, withoutMask) = faceMaskClassifier.predict(faceROI)[0]\\n # (mask, withoutMask) = faceMaskClassifier.predict(faceROI)\\n\\n # find the class and associated colour to use for the bounding box and text\\n label = \\\"Mask\\\" if mask > withoutMask else \\\"No Mask\\\"\\n color = (0, 255, 0) if label == \\\"Mask\\\" else (0, 0, 255)\\n\\n # include the probability of prediction in the label of the bounding box\\n label = \\\"{}: {:.2f}%\\\".format(label, max(mask, withoutMask) * 100)\\n\\n # forming bounding box rectangle and display the label the output image frame\\n cv2.putText(image, label, (startX, startY - 10),\\n cv2.FONT_HERSHEY_COMPLEX, 0.45, color, 2)\\n cv2.rectangle(image, (startX, startY), (endX, endY), color, 2)\\n\\n # show the output image\\n cv2.imshow(\\\"Output\\\", image)\\n # display the image still a key is pressed, when key is pressed program is terminated\\n cv2.waitKey(0)\",\n \"def facial_landmarks(img):\\n detector = dlib.get_frontal_face_detector()\\n predictor = dlib.shape_predictor('/home/aditya/Desktop/stuff/ComputerVision-CMSC733/FaceSwap/scripts/traditional/shape_predictor_68_face_landmarks.dat')\\n grayscale_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n rectangles = detector(grayscale_image, 1)\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n\\n facial_points = []\\n no_of_faces = len(rectangles)\\n for (i, rect) in enumerate(rectangles):\\n\\n shape = predictor(grayscale_image, rect)\\n shape = face_utils.shape_to_np(shape)\\n (x, y, w, h) = face_utils.rect_to_bb(rect)\\n\\n cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)\\n\\n for (x, y) in shape:\\n cv2.circle(img, (x, y), 2, (0, 0, 255), -1)\\n facial_points.append((x, y))\\n\\n return no_of_faces, facial_points\",\n \"def apply_mask(face: np.array, mask: np.array) -> np.array:\\n mask_h, mask_w, _ = mask.shape\\n face_h, face_w, _ = face.shape\\n\\n # Resize the mask to fit on face\\n factor = min(face_h / mask_h, face_w / mask_w)\\n new_mask_w = int(factor * mask_w)\\n new_mask_h = int(factor * mask_h)\\n new_mask_shape = (new_mask_w, new_mask_h)\\n resized_mask = cv2.resize(mask, new_mask_shape)\\n\\n # Add mask to face - ensure mask is centered\\n face_with_mask = face.copy()\\n non_white_pixels = (resized_mask < 250).all(axis=2)\\n off_h = int((face_h - new_mask_h) / 2)\\n off_w = int((face_w - new_mask_w) / 2)\\n face_with_mask[off_h: off_h+new_mask_h, off_w: off_w+new_mask_w][non_white_pixels] = \\\\\\n resized_mask[non_white_pixels]\\n\\n return face_with_mask\",\n \"def convert_roi_align(g, op, block):\\n\\n rois = g.get_node(op.input(\\\"ROIs\\\")[0])\\n spatial_scale = op.attr(\\\"spatial_scale\\\")\\n if op.attr(\\\"aligned\\\"):\\n offset = _expr.const(0.5, dtype=\\\"float32\\\")\\n roi_offset = _op.divide(offset, _expr.const(spatial_scale, dtype=\\\"float32\\\"))\\n rois = _op.subtract(rois, roi_offset)\\n num_rois = infer_shape(rois)[0]\\n zero_node = _expr.const(0, dtype=\\\"int32\\\")\\n batch_index = _op.full(zero_node, [num_rois, 1], dtype=\\\"float32\\\")\\n rois = _op.concatenate([batch_index, rois], axis=1)\\n out = _op.vision.roi_align(\\n g.get_node(op.input(\\\"X\\\")[0]),\\n rois,\\n pooled_size=[op.attr(\\\"pooled_height\\\"), op.attr(\\\"pooled_width\\\")],\\n spatial_scale=spatial_scale,\\n sample_ratio=op.attr(\\\"sampling_ratio\\\"),\\n mode=\\\"avg\\\",\\n )\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def rpn_anchor_boxes(image_size, *args, **kwargs):\\n anchor_boxes = generate_anchor_boxes(image_size, *args, **kwargs)\\n valid_ab_indices = valid_anchor_boxes(anchor_boxes, image_size)\\n return anchor_boxes, valid_ab_indices\",\n \"def detect_landmarks(img, return_face_pos=False):\\n model_path = f\\\"{MODELS_PATH}/Keypoint Detection/shape_predictor_68_face_landmarks.dat\\\"\\n\\n detector = dlib.get_frontal_face_detector()\\n predictor = dlib.shape_predictor(model_path)\\n\\n rect = detector(img)\\n shape = predictor(img, rect[0])\\n\\n coords = np.zeros((68, 2), dtype='int')\\n for i in range(0, 68):\\n coords[i] = (shape.part(i).x, shape.part(i).y)\\n\\n if return_face_pos:\\n return coords, rect\\n else:\\n return coords\",\n \"def load_and_align_data(image_paths, image_size, margin, gpu_memory_fraction):\\n\\n minsize = 20 # minimum size of face\\n threshold = [ 0.6, 0.7, 0.7 ] # three steps's threshold\\n factor = 0.709 # scale factor\\n \\n print('Creating networks and loading parameters')\\n with tf.Graph().as_default() as g:\\n sess = tf.Session(graph=g, config=tf.ConfigProto(log_device_placement=False))\\n with sess.as_default():\\n pnet, rnet, onet = detect_face.create_mtcnn(sess, _files.model_dir)\\n\\n nrof_samples = len(image_paths)\\n img_list = [None] * nrof_samples\\n for i in xrange(nrof_samples):\\n img = misc.imread(os.path.expanduser(image_paths[i]))\\n img_size = np.asarray(img.shape)[0:2]\\n bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)\\n det = np.squeeze(bounding_boxes[0, 0:4])\\n bb = np.zeros(4, dtype=np.int32)\\n bb[0] = np.maximum(det[0] - margin / 2, 0)\\n bb[1] = np.maximum(det[1] - margin / 2, 0)\\n bb[2] = np.minimum(det[2] + margin / 2, img_size[1])\\n bb[3] = np.minimum(det[3] + margin / 2, img_size[0])\\n cropped = img[bb[1]:bb[3], bb[0]:bb[2], :]\\n aligned = misc.imresize(cropped, (image_size, image_size), interp='bilinear')\\n prewhitened = facenet.prewhiten(aligned)\\n img_list[i] = prewhitened\\n images = np.stack(img_list)\\n \\n return images\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6571622","0.65087074","0.6424263","0.63643926","0.62261367","0.62224346","0.6209903","0.60258204","0.6018538","0.58878434","0.5757735","0.56468785","0.552677","0.5469069","0.53907555","0.5254516","0.5184894","0.5080917","0.50786936","0.50399625","0.5037215","0.50154394","0.49946553","0.49753574","0.4925867","0.49086583","0.4892576","0.48759267","0.48668587","0.48511785","0.4830659","0.47913352","0.47576305","0.47406104","0.47388682","0.47309965","0.4711721","0.47072384","0.47008288","0.469278","0.46911266","0.469009","0.46441174","0.464355","0.46376476","0.46329007","0.463238","0.46299425","0.4615568","0.46079642","0.45984155","0.457202","0.45655558","0.45291418","0.4526865","0.45173207","0.4511377","0.45078254","0.4502138","0.44759685","0.44737518","0.44706073","0.44536027","0.44395787","0.4430598","0.44268158","0.4416515","0.44108686","0.44108686","0.44057843","0.4397932","0.439722","0.43811074","0.43754432","0.43735173","0.4373208","0.43638772","0.4360461","0.43600404","0.4347613","0.43391895","0.43279505","0.43180174","0.43169007","0.43141004","0.43119776","0.43061158","0.42948097","0.42869735","0.42816237","0.42792794","0.4278993","0.4274634","0.4273305","0.42711312","0.4271108","0.4265989","0.42654586","0.42619702","0.4260745"],"string":"[\n \"0.6571622\",\n \"0.65087074\",\n \"0.6424263\",\n \"0.63643926\",\n \"0.62261367\",\n \"0.62224346\",\n \"0.6209903\",\n \"0.60258204\",\n \"0.6018538\",\n \"0.58878434\",\n \"0.5757735\",\n \"0.56468785\",\n \"0.552677\",\n \"0.5469069\",\n \"0.53907555\",\n \"0.5254516\",\n \"0.5184894\",\n \"0.5080917\",\n \"0.50786936\",\n \"0.50399625\",\n \"0.5037215\",\n \"0.50154394\",\n \"0.49946553\",\n \"0.49753574\",\n \"0.4925867\",\n \"0.49086583\",\n \"0.4892576\",\n \"0.48759267\",\n \"0.48668587\",\n \"0.48511785\",\n \"0.4830659\",\n \"0.47913352\",\n \"0.47576305\",\n \"0.47406104\",\n \"0.47388682\",\n \"0.47309965\",\n \"0.4711721\",\n \"0.47072384\",\n \"0.47008288\",\n \"0.469278\",\n \"0.46911266\",\n \"0.469009\",\n \"0.46441174\",\n \"0.464355\",\n \"0.46376476\",\n \"0.46329007\",\n \"0.463238\",\n \"0.46299425\",\n \"0.4615568\",\n \"0.46079642\",\n \"0.45984155\",\n \"0.457202\",\n \"0.45655558\",\n \"0.45291418\",\n \"0.4526865\",\n \"0.45173207\",\n \"0.4511377\",\n \"0.45078254\",\n \"0.4502138\",\n \"0.44759685\",\n \"0.44737518\",\n \"0.44706073\",\n \"0.44536027\",\n \"0.44395787\",\n \"0.4430598\",\n \"0.44268158\",\n \"0.4416515\",\n \"0.44108686\",\n \"0.44108686\",\n \"0.44057843\",\n \"0.4397932\",\n \"0.439722\",\n \"0.43811074\",\n \"0.43754432\",\n \"0.43735173\",\n \"0.4373208\",\n \"0.43638772\",\n \"0.4360461\",\n \"0.43600404\",\n \"0.4347613\",\n \"0.43391895\",\n \"0.43279505\",\n \"0.43180174\",\n \"0.43169007\",\n \"0.43141004\",\n \"0.43119776\",\n \"0.43061158\",\n \"0.42948097\",\n \"0.42869735\",\n \"0.42816237\",\n \"0.42792794\",\n \"0.4278993\",\n \"0.4274634\",\n \"0.4273305\",\n \"0.42711312\",\n \"0.4271108\",\n \"0.4265989\",\n \"0.42654586\",\n \"0.42619702\",\n \"0.4260745\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7130995"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":25595,"cells":{"query":{"kind":"string","value":"Gets console output text from a specific job build"},"document":{"kind":"string","value":"def get_console_text(self):\n console_text_api = '/consoleText'\n return self._api_request(self.url + console_text_api)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_build_line(latest_build):\n proc = Popen([\"osg-koji\", \"buildinfo\", latest_build],\n stdout=PIPE)\n build_line = proc.stdout.readline().decode(\"latin-1\").strip()\n ret = proc.wait()\n if ret != 0 or not build_line:\n return\n return build_line","def general_job_info(self, jobid=None, output=False):\n\n self.check_all_jobs()\n\n if jobid is None:\n print(\"Job Summary:\\n\"\n \"There are {0} jobs with phase: COMPLETED.\\n\"\n \"There are {1} jobs with phase: ERROR.\\n\"\n \"There are {2} jobs with phase: ABORTED.\\n\"\n \"There are {3} jobs with phase: PENDING.\\n\"\n \"There are {4} jobs with phase: EXECUTING.\\n\"\n \"There are {5} jobs with phase: QUEUED.\\n\"\n \"Try providing a jobid for the job you'd like to \"\n \"know more about.\\n To see a list of all jobs, use \"\n \"`check_all_jobs()`.\"\n .format(self.job_dict.values().count('COMPLETED'),\n self.job_dict.values().count('ERROR'),\n self.job_dict.values().count('ABORTED'),\n self.job_dict.values().count('PENDING'),\n self.job_dict.values().count('EXECUTING'),\n self.job_dict.values().count('QUEUED')))\n return\n else:\n response_list = [self._request(\n 'GET', CosmoSim.QUERY_URL + \"/{}\".format(jobid),\n auth=(self.username, self.password), cache=False)]\n\n if response_list[0].ok is False:\n log.error('Must provide a valid jobid.')\n return\n else:\n self.response_dict_current = {}\n self.response_dict_current[jobid] = (\n self._generate_response_dict(response_list[0]))\n\n if output is True:\n dictkeys = self.response_dict_current.keys()\n print(self.response_dict_current[dictkeys[0]]['content'])\n return\n else:\n return","def get_job_output(job_id: Optional[pulumi.Input[str]] = None,\n location: Optional[pulumi.Input[str]] = None,\n project: Optional[pulumi.Input[Optional[str]]] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetJobResult]:\n ...","def job_output(self, job_id):\n\n url = self.base_url + \"/ml-service/phoenix-ml/output/findBy?jobId={0}\".format(job_id)\n headers = {\"ApiKey\": self.api_key}\n response = requests.get(url=url, headers=headers)\n return response.json()","def get_text(self):\n return self.output.getvalue()","def build_show_log(ctx, args):\n for build_id in args:\n data = ctx.obj.get_build_log_by_build_id(build_id)\n click.echo(data.text)","def generateReleaseRunOut(self, job):\n pass","def get_job_information(run_id):\n cmd = [github_cli, 'run', 'view', str(run_id), '--json', 'jobs']\n with subprocess.Popen(cmd, stdout=subprocess.PIPE) as p:\n result, err = p.communicate()\n print(err)\n return json.loads(result)['jobs']","def getHeader():\n system, host, release, version, machine = os.uname()\n\n return \"# output generated by %s\\n# job started at %s on %s -- %s\\n# pid: %i, system: %s %s %s %s\" %\\\n (\" \".join(sys.argv),\n time.asctime(time.localtime(time.time())),\n host,\n global_id,\n os.getpid(),\n system, release, version, machine)","def get_job(self) -> Dict[Text, Text]:\n request = self._client.projects().jobs().get(name=self._job_name)\n return request.execute()","def get_text(self):\n\n return self.output['text']","def describe_text_translation_job(JobId=None):\n pass","def job_full_command(job_id):\n return subprocess.check_output(['at', '-c', job_id], text=True, encoding='latin-1')","def get_json_job_details(buildurl):\n return requests.get(buildurl + \"/api/json\").json()","def get_build(self):\n return self.bot_data_file[\"build\"]","def get_job_name(self) -> Text:\n return self._job_name","def RetrievePipelineToolStatus( raiseOnExitCode=False ):\n global submissionInfo\n\n scenePath = NodegraphAPI.GetSourceFile()\n\n jobWriterPath = os.path.join(submissionInfo[\"RepoDirs\"][\"submission/Integration/Main\"], \"JobWriter.py\")\n argArray = [\"-ExecuteScript\", jobWriterPath, \"Katana\", \"--status\", \"--scene-path\", scenePath]\n statusMessage = CallDeadlineCommand(argArray, hideWindow=False, raiseOnExitCode=raiseOnExitCode)\n return statusMessage","def _job_id_or_out(out):\n\n stdout = re.sub(\"[^0-9]\", \"\", str(out))\n if not stdout:\n stdout = out\n return stdout","def getoutput(cmd):\n return getstatusoutput(cmd)[1]","def getJobName():\n return os.environ['LCATR_JOB']","def _print_logs_info(job_id, project_id):\n print(\"\\nJob submitted successfully.\")\n print(\"Your job ID is: \", job_id)\n print(\"\\nPlease access your training job information here:\")\n print(\n \"https://console.cloud.google.com/mlengine/jobs/{}?project={}\".format(\n job_id, project_id))\n print(\"\\nPlease access your training job logs here: \"\n \"https://console.cloud.google.com/logs/viewer?resource=ml_job%2F\"\n \"job_id%2F{}&interval=NO_LIMIT&project={}\\n\".format(\n job_id, project_id))","def result_stdout(result):\n return result[1][0]","def build_command_line( self, job ):\n commands = job.get_command_line()\n # All job runners currently handle this case which should never\n # occur\n if not commands:\n return None\n return commands","def job(self) -> str:\n return self._job","def job(self) -> str:\n return self._job","def task_stdout(self, task_id):\n result, _ = self.task_collect(task_id, wait=False)\n return result['shards'][0]['output']","def stdout(username, root_wf_id, wf_id, job_id, job_instance_id):\n dashboard = Dashboard(g.master_db_url, root_wf_id, wf_id)\n text = dashboard.get_stdout(wf_id, job_id, job_instance_id)\n\n if text.stdout_text == None:\n return 'No stdout for workflow ' + wf_id + ' job-id ' + job_id\n else:\n return '<pre>%s</pre>' % utils.unquote(text.stdout_text)","def fetch_exe_from_jenkins():\n base_job_url = os.environ.get(\"JENKINS_JOB_URL\")\n if not base_job_url:\n print \"Jenkins job URL for the builder is not specified.\"\n sys.exit(-1)\n\n build_json = json.loads(requests.get(\"%s/api/json\" % base_job_url).text)\n last_build = build_json['lastCompletedBuild']['number']\n print \"Last build ID: %d\" % last_build\n\n job_url = '%s/%d' % (base_job_url, last_build)\n last_build_json = json.loads(requests.get(\"%s/api/json\" % job_url).text)\n if len(last_build_json['artifacts']) == 0:\n error(\"No artifacts found!\")\n\n artifact_url = \"%s/artifact/%s\" % (job_url, last_build_json['artifacts'][0]['relativePath'])\n file_name = last_build_json['artifacts'][0]['fileName']\n print \"Tribler installer url: %s\" % artifact_url\n\n # Download the file\n file_path = os.path.join(os.environ.get('WORKSPACE'), file_name)\n download_response = requests.get(artifact_url, stream=True)\n download_response.raise_for_status()\n\n with open(file_path, 'wb') as handle:\n for block in download_response.iter_content(1024):\n handle.write(block)\n\n return file_path","def get_output(command):\n if is_debug_environment():\n dir_name = get_test_dir_argument()\n filename = '{}.txt'.format(command)\n full_path = os.path.join(dir_name, filename)\n if os.path.isfile(full_path):\n with open(full_path) as f:\n return f.read()\n raise IOError(\"File {} is not found\".format(full_path))\n else:\n import cli\n result = cli.cli(command)\n i = 0\n # Occasionally, cli library returns an empty output, in this case we try multiple time\n while result.count('\\n') <= 2 and i < 3:\n result = cli.cli(command)\n i += 1\n return result","async def get_jobs(jobId: int) -> str: \n return mngr.getJob(str(jobId))","def get_latest_build(tag, package):\n proc = Popen([\"osg-koji\", \"-q\", \"list-tagged\", \"--latest\", tag, package],\n stdout=PIPE)\n out = proc.communicate()[0] or b''\n ret = proc.returncode\n\n latest_build_line = out.decode(\"latin-1\").strip()\n\n if ret != 0 or not latest_build_line:\n return\n\n return latest_build_line.split()[0]","def job_subtitle(self, job):\n return str(job)[:max(8, self._project_min_len_unique_id())]","def output(self):\n text_list = self.q(css='#output').text\n\n if len(text_list) < 1:\n return None\n return text_list[0]","def getBuild():","def qoutput(self):\n jobid = self.jobid()\n ou = os.path.join(self.directory, jobid + '.OU')\n if not self.in_queue() and os.path.exists(ou):\n with open(ou) as f:\n return f.read()\n else:\n return \"In queue or no output found.\"","def get(self):\n return self.stdout.get()","def get_output(self):\n return self.cmd_output","def output(self) -> pulumi.Output[Optional['outputs.JobStepOutputResponse']]:\n return pulumi.get(self, \"output\")","def fetch_executable_from_jenkins():\n\n base_job_url = os.environ.get('JENKINS_JOB_URL')\n if not base_job_url:\n error('Jenkins job URL for the builder is not specified.')\n\n build_json = json.loads(requests.get('%s/api/json'\n % base_job_url).text)\n last_build = build_json['lastCompletedBuild']['number']\n print 'Last build ID: %d' % last_build\n\n job_url = '%s/%d' % (base_job_url, last_build)\n last_build_json = json.loads(requests.get('%s/api/json'\n % job_url).text)\n if not last_build_json['artifacts']:\n error('No artifacts found!')\n\n artifacts_deb = [artifact for artifact in\n last_build_json['artifacts'] if '.dmg'\n in artifact['fileName']]\n artifact_url = '%s/artifact/%s' % (job_url,\n artifacts_deb[0]['relativePath'])\n file_name = artifacts_deb[0]['fileName']\n print 'Tribler installer url: %s' % artifact_url\n\n # Download the file\n file_path = os.path.join(os.environ.get('WORKSPACE'), file_name)\n download_response = requests.get(artifact_url, stream=True)\n download_response.raise_for_status()\n\n with open(file_path, 'wb') as handle:\n for block in download_response.iter_content(1024):\n handle.write(block)\n\n return file_path","def get_output(self):\n if self._is_started and self._is_terminated:\n job_f = self._outerr_files.replace('%J', str(self._jobid))\n job_out_f = job_f + '.out'\n job_err_f = job_f + '.err'\n job_out = \"\"\n if self.out is None and self.err is None:\n try:\n with open(job_out_f, 'r') as f:\n job_out = f.read()\n except FileNotFoundError:\n sys.stderr.write(\"File not found : {0}\\n\".format(job_out_f))\n sys.stderr.flush()\n job_err = \"\"\n try:\n with open(job_err_f, 'r') as f:\n job_err = f.read()\n except FileNotFoundError:\n sys.stderr.write(\"File not found : {0}\\n\".format(job_err_f))\n sys.stderr.flush()\n self.out, self.err = job_out, job_err\n return(self.out, self.err)\n else:\n return(None, None)","def cli(ctx, job_id):\n return ctx.gi.jobs.get_inputs(job_id)","def html_message_formatter(mode, name, build, results, master_status):\n result = Results[results]\n\n limit_lines = 80\n text = list()\n text.append(u'<h4>Build status: %s</h4>' % result.upper())\n text.append(u'<table cellspacing=\"10\"><tr>')\n text.append(u\"<td>Buildslave for this Build:</td><td><b>%s</b></td></tr>\" % build.getSlavename())\n if master_status.getURLForThing(build):\n text.append(u'<tr><td>Complete logs for all build steps:</td><td><a href=\"%s\">%s</a></td></tr>'\n % (master_status.getURLForThing(build),\n master_status.getURLForThing(build))\n )\n text.append(u'<tr><td>Build Reason:</td><td>%s</td></tr>' % build.getReason())\n source = u\"\"\n for ss in build.getSourceStamps():\n if ss.codebase:\n source += u'%s: ' % ss.codebase\n if ss.branch:\n source += u\"[branch %s] \" % ss.branch\n if ss.revision:\n source += ss.revision\n else:\n source += u\"HEAD\"\n if ss.patch:\n source += u\" (plus patch)\"\n if ss.patch_info: # add patch comment\n source += u\" (%s)\" % ss.patch_info[1]\n text.append(u\"<tr><td>Build Source Stamp:</td><td><b>%s</b></td></tr>\" % source)\n text.append(u\"<tr><td>Blamelist:</td><td>%s</td></tr>\" % \",\".join(build.getResponsibleUsers()))\n text.append(u'</table>')\n if ss.changes:\n text.append(u'<h4>Recent Changes:</h4>')\n for c in ss.changes:\n cd = c.asDict()\n when = datetime.datetime.fromtimestamp(cd['when'] ).ctime()\n text.append(u'<table cellspacing=\"10\">')\n text.append(u'<tr><td>Repository:</td><td>%s</td></tr>' % cd['repository'] )\n text.append(u'<tr><td>Project:</td><td>%s</td></tr>' % cd['project'] )\n text.append(u'<tr><td>Time:</td><td>%s</td></tr>' % when)\n text.append(u'<tr><td>Changed by:</td><td>%s</td></tr>' % cd['who'] )\n text.append(u'<tr><td>Comments:</td><td>%s</td></tr>' % cd['comments'] )\n text.append(u'</table>')\n files = cd['files']\n if files:\n text.append(u'<table cellspacing=\"10\"><tr><th align=\"left\">Files</th></tr>')\n for file in files:\n text.append(u'<tr><td>%s:</td></tr>' % file['name'] )\n text.append(u'</table>')\n text.append(u'<br>')\n # get all the steps in build in reversed order\n rev_steps = reversed(build.getSteps())\n # find the last step that finished\n for step in rev_steps:\n if step.isFinished():\n break\n # get logs for the last finished step\n if step.isFinished():\n logs = step.getLogs()\n # No step finished, loop just exhausted itself; so as a special case we fetch all logs\n else:\n logs = build.getLogs()\n # logs within a step are in reverse order. Search back until we find stdio\n for log in reversed(logs):\n if log.getName() == 'stdio':\n break\n name = \"%s.%s\" % (log.getStep().getName(), log.getName())\n status, dummy = log.getStep().getResults()\n content = log.getText().splitlines() # Note: can be VERY LARGE\n url = u'%s/steps/%s/logs/%s' % (master_status.getURLForThing(build),\n log.getStep().getName(),\n log.getName())\n\n text.append(u'<i>Detailed log of last build step:</i> <a href=\"%s\">%s</a>'\n % (url, url))\n text.append(u'<br>')\n text.append(u'<h4>Last %d lines of \"%s\"</h4>' % (limit_lines, name))\n unilist = list()\n for line in content[len(content)-limit_lines:]:\n unilist.append(cgi.escape(unicode(line,'utf-8')))\n text.append(u'<pre>')\n text.extend(unilist)\n text.append(u'</pre>')\n text.append(u'<br><br>')\n text.append(u'<b>-The Buildbot</b>')\n return {\n 'body': u\"\\n\".join(text),\n 'type': 'html'\n }","def get_output_string(command):\n out_put = command.replace(\"\\n\", \"\")\n return out_put","def run_tool(args, quiet=False):\n pipe = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\n result = \"\"\n for line in iter(pipe.stdout.readline, \"\"):\n if not line and pipe.poll() is not None:\n break\n output = line.decode(encoding='UTF-8').rstrip()\n if output != \"\":\n if not quiet:\n print(\"\\t * \" + output)\n result = output\n return result","def _get_job_tree_text(job_tree, property):\n # Check to prevent AttributeError: 'NoneType' object has no attribute 'text'\n try:\n return job_tree.find(property).text\n except AttributeError:\n return \"\"","def get_last_successful_build_nr(jenkins_url, job_name):\n return execute_command(\n f\"wget -qO- {jenkins_url}/{job_name}/lastSuccessfulBuild/buildNumber\"\n )","def output(self) -> Optional[pulumi.Input['JobStepOutputArgs']]:\n return pulumi.get(self, \"output\")","def get_commit_message():\n return shell_output('git log HEAD -1 --pretty=%B')","def get_test_summary(self):\n\n last_line = 'None'\n cmd = ['catkin_test_results', 'build/%s' % self.name ]\n try:\n process = subprocess.Popen(cmd,\n stdout=subprocess.PIPE, \n stderr=subprocess.PIPE,\n universal_newlines=True)\n stdout, stderr = process.communicate()\n # Extract the summary line\n # Summary: 0 tests, 0 errors, 0 failures, 0 skipped\n last_line = stdout.strip().split('\\n')[-1]\n finally:\n return last_line","def get_stdout(self):\n return self._get_log('stdout')","def build_report(self, msg=''):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\ts = '\\n'\n\t\ts += '################################################################################\\n'\n\t\ts += '# COMMAND HISTORY BEGIN ' + shutit_global.shutit_global_object.build_id + '\\n'\n\t\ts += self.get_commands()\n\t\ts += '# COMMAND HISTORY END ' + shutit_global.shutit_global_object.build_id + '\\n'\n\t\ts += '################################################################################\\n'\n\t\ts += '################################################################################\\n'\n\t\ts += '# BUILD REPORT FOR BUILD BEGIN ' + shutit_global.shutit_global_object.build_id + '\\n'\n\t\ts += '# ' + msg + '\\n'\n\t\tif self.build['report'] != '':\n\t\t\ts += self.build['report'] + '\\n'\n\t\telse:\n\t\t\ts += '# Nothing to report\\n'\n\t\tif 'container_id' in self.target:\n\t\t\ts += '# CONTAINER_ID: ' + self.target['container_id'] + '\\n'\n\t\ts += '# BUILD REPORT FOR BUILD END ' + shutit_global.shutit_global_object.build_id + '\\n'\n\t\ts += '###############################################################################\\n'\n\t\ts += '# INVOKING COMMAND WAS: ' + sys.executable\n\t\tfor arg in sys.argv:\n\t\t\ts += ' ' + arg\n\t\ts += '\\n'\n\t\ts += '###############################################################################\\n'\n\t\treturn s","def get_logs(job_key):\n job = Job.fetch(job_key, connection=conn)\n if job.is_finished:\n logs = job.result\n elif job.is_failed:\n logs = job.exc_info\n else:\n logs = \"Task is still running\"\n return str(logs), 200","def describe_compilation_job(CompilationJobName=None):\n pass","def job_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"job_id\")","def GetBuildInfo(builder_name, build_num):\n url = '%s/json/builders/%s/builds/%s' % (BUILD_MASTER_URL,\n builder_name,\n build_num)\n return json.load(urllib2.urlopen(url))","def output(self):\n queue_type = self.queue_type\n queue_options = self.queue_options\n jobname = self.jobname\n emtopath = self.emtopath\n\n line = batch_head(jobname=jobname, latpath=emtopath, runtime=self.runtime, \n account=self.account, queue_type=queue_type, queue_options=queue_options)\n \n self.use_module = False\n if self.slurm_options is not None:\n for tmp in self.slurm_options:\n if 'module load emto' in tmp:\n self.use_module = True\n break\n line += \"\\n\"\n\n sub_module = [\"kgrn_cpa\", \"kfcd_cpa\"]\n sub_module_run = [self.runKGRN, self.runKFCD]\n file_type = [self.KGRN_file_type, self.KFCD_file_type]\n output_file_ext = [\"kgrn\", \"kfcd\"]\n\n #elapsed_time = \"/usr/bin/time \"\n elapsed_time = \"\"\n if self.parallel is True:\n sub_module = [\"kgrn_omp\", \"kfcd_cpa\"]\n\n if which(\"kfcd_cpa\") is not None:\n self.use_module = True\n if not self.use_module:\n module_path = [os.path.join(self.EMTOdir, module_i) for module_i in sub_module]\n else:\n module_path = sub_module\n\n for i in range(0, len(sub_module)):\n if sub_module_run[i]:\n runStr = [elapsed_time, module_path[i], \"<\", \n os.path.join(emtopath, jobname + \".\" + file_type[i]), \">\",\n os.path.join(emtopath, jobname + \"_\" + output_file_ext[i] + \".output\")]\n line += \" \".join(runStr).strip() + \"\\n\"\n\n return line","def examine_job(self):\n if self.data is None:\n print(\"Could not download job id\", self.job_id)\n return\n self.duration = self.read_data(\"duration\")\n self.between_commands = self.read_data(\"between_commands\")\n\n print(\"---\")\n print(\"test_id: {}\".format(self.job_id))\n print(\"duration:\")\n Job.print_results(self.duration)\n print(\"between_commands:\")\n Job.print_results(self.between_commands)\n print(\"\")","def stdout(self):\n if self.dm.fileExists(self.proc):\n try:\n t = self.dm.pullFile(self.proc)\n except DMError:\n # we currently don't retry properly in the pullFile\n # function in dmSUT, so an error here is not necessarily\n # the end of the world\n return ''\n newLogContent = t[self.stdoutlen:]\n self.stdoutlen = len(t)\n # Match the test filepath from the last TEST-START line found in the new\n # log content. These lines are in the form:\n # 1234 INFO TEST-START | /filepath/we/wish/to/capture.html\\n\n testStartFilenames = re.findall(r\"TEST-START \\| ([^\\s]*)\", newLogContent)\n if testStartFilenames:\n self.lastTestSeen = testStartFilenames[-1]\n return newLogContent.strip('\\n').strip()\n else:\n return ''","def get_console_output(self):\r\n return self.connection.get_console_output(self.id)","def _get_description(actor, commit, run_id):\n return (\"Requested by @%s on commit %s\\n\" % (actor, commit) +\n \"Last updated: %s \\n\" % _get_datetime() +\n \"**[View integration test log & download artifacts](https://github.com/firebase/firebase-cpp-sdk/actions/runs/%s)**\\n\" % run_id)","def get_cargo_input() -> str:\n results = subprocess.run([\"cargo\", \"check\"], capture_output=True)\n if results.returncode == 0:\n print(\"Cargo check found no errors. Exiting\")\n quit()\n if results.returncode != 101:\n print(\"Cargo check returned an unexpected error!\")\n show_help()\n if b\"could not find\" in results.stderr:\n print(\"Cargo.toml not found in this directory!\")\n show_help()\n return results.stderr.decode('utf-8')\n # FIXME","def get_last_completed_build_number(jenkins_url, job_name):\n return execute_command(\n f\"wget -qO- {jenkins_url}/{job_name}/lastCompletedBuild/buildNumber\"\n )","def text(self):\n text = ''\n for run in self.runs:\n text += run.text\n return text","def getCompilerOutput(uname):\n fname = os.path.join(webapp.config['UPLOADED_BUILD_DEST'], uname, 'output').encode('utf8')\n if os.path.exists(fname):\n stdout_file = open(fname, 'r')\n output = unicode(stdout_file.read(), 'utf-8')\n stdout_file.close()\n return output\n else:\n return returnError(\"Output not available for \" + uname, 404)","def grab_posting_txt(driver, job, idx):\n\n job_link = job.find_element_by_class_name('jobLink')\n job_link.send_keys(Keys.ENTER)\n job_link.send_keys(Keys.ESCAPE)\n\n try: \n print job.find_element_by_class_name('reviews-tab-link').text\n except: \n pass\n\n time.sleep(random.randint(3, 7))\n texts = driver.find_elements_by_class_name('jobDescriptionContent')\n return texts[idx].text","def get_output(self):\r\n return self._api.get_output()","def get_job_overview_string(self, mission):\n\n # get statuses\n job_status, task_status = self.get_job_status(mission)\n\n s = \"Job status: {}\".format(job_status)\n\n if job_status != \"N/A\":\n s += \"\\n\"\n s += \"Tasks status: \"\n s += \"{} active; \".format(task_status[\"active\"])\n s += \"{} running; \".format(task_status[\"running\"])\n s += \"{} succeeded; \".format(task_status[\"succeeded\"])\n s += \"{} failed;\".format(task_status[\"failed\"])\n\n return s","def test_main_output(self, capsys):\n args = self.args.copy()\n args[\"out_file\"] = \"text.txt\"\n UI.main(**args)\n captured = capsys.readouterr().out\n assert \"Results written to text.txt\" in captured","def GetBuildID(build_bot, date):\n day = '{day:02d}'.format(day=date%100)\n mon = MONTHS[date/100%100]\n date_string = mon + ' ' + day\n if build_bot in WATERFALL_BUILDERS:\n url = 'https://uberchromegw.corp.google.com/i/chromeos/' + \\\n 'builders/%s?numbuilds=200' % build_bot\n if build_bot in ROTATING_BUILDERS:\n url = 'https://uberchromegw.corp.google.com/i/chromiumos.tryserver/' + \\\n 'builders/%s?numbuilds=200' % build_bot\n command = 'sso_client %s' %url\n retval = 1\n retry_time = 3\n while retval and retry_time:\n retval, output, _ = \\\n command_executer.GetCommandExecuter().RunCommandWOutput(command, \\\n print_to_console=False)\n retry_time -= 1\n\n if retval:\n return []\n\n out = output.split('\\n')\n line_num = 0\n build_id = []\n # Parse the output like this\n # <td>Dec 14 10:55</td>\n # <td class=\"revision\">??</td>\n # <td failure</td><td><a href=\"../builders/gcc_toolchain/builds/109\">#109</a>\n while line_num < len(out):\n if date_string in out[line_num]:\n if line_num + 2 < len(out):\n build_num_line = out[line_num + 2]\n raw_num = re.findall(r'builds/\\d+', build_num_line)\n # raw_num is ['builds/109'] in the example.\n if raw_num:\n build_id.append(int(raw_num[0].split('/')[1]))\n line_num += 1\n return build_id","def job(name):\n current_app.logger.info(\"Running custom job: {}\".format(name))","def get_console_output(instance_id):\n ec2 = boto3.resource('ec2')\n ec2_instance = ec2.Instance(instance_id)\n json_output = ec2_instance.console_output()\n\n return json_output.get('Output', '')","def get_log_text(nipype_output_files):\n execution_log = get_nipype_report(get_nipype_report_filename(\n nipype_output_files))\n return execution_log","def _get_job_status(self):\n total_hits = session.query(BoxHit).filter_by(training_job_id=self.id).count()\n num_hits_left = session.query(BoxHit).filter_by(training_job_id=self.id, outstanding=True).count()\n total_urls = self.num_urls\n num_urls_left = session.query(VideoTrainingURL).filter_by(job=self, processed=False).count()\n faces_obtained = MTurkBox.query.filter_by(label=self.evaluator.target_label, result=True).count()\n return '\\n'.join([\n '------------- Stats for Job ID: %s -------------' % str(self.id) ,\n 'Job for Label : %s' % self.label.name,\n 'Total URLs : %d' % total_urls,\n 'Total HITs : %d' % total_hits,\n 'unprocessed URLS : %d' % num_urls_left,\n 'outstanding Hits : %d' % num_hits_left,\n 'Job Finish Status : %s' % self.finished,\n 'Faces Obtained : %d' % faces_obtained,\n ]) + '\\n'","def output(self) -> Optional[str]:\n return self.__output","def log_build(self, build):\n with self._conn.begin():\n if build.status:\n build_id = self._conn.execute(\n \"VALUES (log_build_success(%s, %s, %s, %s, %s, %s, \"\n \"CAST(%s AS files ARRAY), CAST(%s AS dependencies ARRAY)\"\n \"))\",\n (\n build.package,\n build.version,\n build.slave_id,\n build.duration,\n build.abi_tag,\n sanitize(build.output),\n [(\n file.filename,\n None,\n file.filesize,\n file.filehash,\n file.package_tag,\n file.package_version_tag,\n file.py_version_tag,\n file.abi_tag,\n file.platform_tag,\n file.requires_python,\n )\n for file in build.files.values()],\n [(\n file.filename,\n tool,\n dependency,\n )\n for file in build.files.values()\n for tool, dependencies in file.dependencies.items()\n for dependency in dependencies]\n )).scalar()\n else:\n build_id = self._conn.execute(\n \"VALUES (log_build_failure(%s, %s, %s, %s, %s, %s))\",\n (\n build.package,\n build.version,\n build.slave_id,\n build.duration,\n build.abi_tag,\n sanitize(build.output),\n )).scalar()\n build.logged(build_id)","def get_build_progress_info(self, build_id):\n pass","def get_text_at_stage(self, stage: str):\n for transformation in self.transform_history:\n if transformation.stage == stage:\n return transformation.text","def _get_output(self):\n return self.__output","def _get_output(self):\n return self.__output","def _get_output(self):\n return self.__output","def _get_output(self):\n return self.__output","def _get_output(self):\n return self.__output","def _get_output(self):\n return self.__output","def get_by_build_job(self, job: Union[JobSubmissionResponse, UUID], *,\n timeout: float = 15 * 60) -> GemTable:\n if isinstance(job, JobSubmissionResponse):\n job_id = job.job_id\n else:\n job_id = job # pragma: no cover\n path = 'projects/{}/execution/job-status'.format(self.project_id)\n params = {'job_id': job_id}\n start_time = time()\n while True:\n response = self.session.get_resource(path=path, params=params)\n status: JobStatusResponse = JobStatusResponse.build(response)\n if status.status in ['Success', 'Failure']:\n break\n elif time() - start_time < timeout:\n logger.info('Build job still in progress, polling status again in 2 seconds.')\n sleep(2)\n else:\n logger.error('Build job exceeded user timeout of {} seconds.'.format(timeout))\n logger.debug('Last status: {}'.format(status.dump()))\n raise TimeoutError('Build job {} timed out.'.format(job_id))\n if status.status == 'Failure':\n logger.debug('Job terminated with Failure status: {}'.format(status.dump()))\n for task in status.tasks:\n if task.status == 'Failure':\n logger.error('Task {} failed with reason \"{}\"'.format(\n task.id, task.failure_reason))\n raise RuntimeError('Job {} terminated with Failure status.'.format(job_id))\n else:\n table_id = status.output['display_table_id']\n table_version = status.output['display_table_version']\n warning_blob = status.output.get('table_warnings')\n warnings = json.loads(warning_blob) if warning_blob is not None else []\n if warnings:\n warn_lines = ['Table build completed with warnings:']\n for warning in warnings:\n limited_results = warning.get('limited_results', [])\n warn_lines.extend(limited_results)\n total_count = warning.get('total_count', 0)\n if total_count > len(limited_results):\n warn_lines.append('and {} more similar.'\n .format(total_count - len(limited_results)))\n logger.warning('\\n\\t'.join(warn_lines))\n return self.get(table_id, table_version)","def build_job(self, name, parameters=None, build_timeout=30, name_suffix=''):\n queue_item_id = self._server.build_job(name, parameters)\n logger.debug(\n 'Triggered build with queue item {queue_item}'.format(queue_item=queue_item_id))\n build_executable = wait_for(\n lambda: self._server.get_queue_item(queue_item_id).get('executable'),\n timeout=5,\n poll_interval=0.1)\n build_number = build_executable['number']\n logger.debug(\n \"Build of '{job}/{build_number}' started\".format(job=name, build_number=build_number))\n\n def get_build_info():\n build_info = self._server.get_build_info(name, build_number)\n if build_info.get('result'):\n return build_info\n else:\n return False\n\n build_info = wait_for(get_build_info, timeout=build_timeout)\n logger.debug(\n \"Build of '{job}/{build_number}' completed'\".format(\n job=name, build_number=build_number))\n\n def get_console_log():\n console_log = self._server.get_build_console_output(name, build_number)\n if 'Finished: {result}'.format(result=build_info['result']) in console_log:\n return console_log\n else:\n return False\n\n console_log = wait_for(get_console_log, timeout=10, poll_interval=1.0)\n\n # Get build info again to make sure everything including artifacts are included\n build_info = self._server.get_build_info(name, build_number)\n\n for line in console_log.split('\\n'):\n logger.debug(\n '{name}{name_suffix}: {line}'.format(name=name, name_suffix=name_suffix, line=line))\n return BuildInfo(\n build_number, build_info['result'], console_log,\n [artifact['relativePath'] for artifact in build_info['artifacts']])","def get_snapshot_build_desc(self):\n return self.shard_build_desc","def getBuild(number):","def getBuild(number):","def get_buildinfo():\n path = os.path.join(SCRIPT_DIR, \"..\", DISTRIBUTION, \"buildinfo.json\")\n return json.load(open(path, \"rb\"))","def get_batch_name(joblist):\n\tfin = open(joblist[0], 'r'); file = fin.read(); fin.close()\n\tbatch_name = re.search(r\"#PBS\\s+-N\\s+(.*)\", file).group(1)\n\tprint(\"\\033[34m------------------------------------\\033[0m\\nCurrent \\033[35mbatch_name\\033[0m: {}\".format(batch_name))\n\tprint(\"Please enter the \\033[35mbatch_name\\033[0m of the job:\", end=\" \")\n\tbatch_name_input = input()\n\tbatch_name = batch_name_input if batch_name_input != \"\" else batch_name\n\treturn batch_name","def script_execution_get() -> str | None:\n if (data := script_execution_cv.get()) is None:\n return None\n return data.script_execution","def output(index: int = 0) -> str:\n return outputs()[index]","def output(self) -> str:\n return self.stdout","def get_current_project(self):\n\n try:\n command = self._oc_command([\"project\", \"-q\"])\n output = run_cmd(command, return_output=True)\n except subprocess.CalledProcessError as ex:\n raise ConuException(\"Failed to obtain current project name : %s\" % ex)\n\n try:\n return output.rstrip() # remove '\\n'\n except IndexError:\n raise ConuException(\"Failed to obtain project name\")","def output(cmd):\n return subprocess.check_output(cmd, shell=True)","def get_output(self):\n return self.output","def get_output(self):\n return self.output","def info(self, jobid):\n return self.rpc.call(MsfRpcMethod.JobInfo, [jobid])","def get_job_description(self, job, context=None):\n return self._client.call_method(\n 'UserAndJobState.get_job_description',\n [job], self._service_ver, context)","def display_pipeline_log(ctx,\n pipeline_name,\n username,\n password,\n ip_address,\n interactive):\n slab_logger.info('Displaying %s log' % pipeline_name)\n if not username:\n username = ctx.get_username()\n if not password:\n password = ctx.get_password(interactive)\n if not password or not username:\n slab_logger.error(\"Username is %s and password is %s. \"\n \"Please, set the correct value for both and retry.\" %\n (username, password))\n sys.exit(1)\n stages_url = \"http://{0}/go/api/pipelines/{1}/stages.xml\"\n # Find latest run info\n res = requests.get(stages_url.format(ip_address, pipeline_name),\n auth=HTTPBasicAuth(username, password))\n soup = BeautifulSoup(res.content, \"html.parser\")\n try:\n latest_job_info_url = soup.findAll(\n 'entry')[0].findAll('link')[0]['href']\n except Exception as ex:\n slab_logger.error(\"Internal error occurred. Please, check arguments supplied.\")\n slab_logger.error(\"Error details : %s \" % (ex))\n sys.exit(1)\n\n # Find all the job info for that run\n latest_job_info_url = latest_job_info_url.replace(\"gocd_java_server\",\n ip_address)\n job_info_res = requests.get(latest_job_info_url,\n auth=HTTPBasicAuth(username, password))\n soup = BeautifulSoup(job_info_res.content, \"html.parser\")\n job_urls = soup.findAll('job')\n\n # for each of the job, pull the log and display the log\n for job_url in job_urls:\n job_url['href'] = job_url['href'].replace(\"gocd_java_server\",\n ip_address)\n job_url_res = requests.get(job_url['href'],\n auth=HTTPBasicAuth(username, password))\n soup = BeautifulSoup(job_url_res.content, \"html.parser\")\n log_url = soup.find('artifacts')['baseuri']\n log_url = log_url.replace(\"gocd_java_server\", ip_address)\n log_url_res = requests.get(log_url + \"/cruise-output/console.log\",\n auth=HTTPBasicAuth(username, password))\n soup = BeautifulSoup(log_url_res.content, \"html.parser\")\n print \"\\n\\n-------------------Printing job log for pipeline : \", \\\n log_url, \"-------------------------\"\n print soup\n print \"\\n\\n-------------------End of job log for pipeline : \", \\\n log_url, \"-------------------------\"","def compilation_log_display(autotex_log: str, submission_id: int,\n compilation_status: str) -> str:\n # Don't do anything when log not generated\n if re.search(r'No log available.', autotex_log):\n return autotex_log\n\n # Create summary information detailing runs and markup key.\n\n run_summary = (\"If you are attempting to compile \"\n \"with a specific engine (PDFLaTeX, LaTeX, \\nTeX) please \"\n \"carefully review the appropriate log below.\\n\\n\"\n )\n\n # Key to highlighting\n\n key_summary = \"\"\n #(\n # \"Key: \\n\"\n # \"\\t<span class=\\\"tex-fatal\\\">Severe warnings/errors.</span>'\\n\"\n # \"\\t<span class=\\\"tex-danger\\\">Warnings deemed important</span>'\\n\"\n # \"\\t<span class=\\\"tex-warning\\\">General warnings/errors from packages.</span>'\\n\"\n\n # \"\\t<span class=\\\"tex-ignore\\\">Warnings/Errors deemed unimportant. \"\n # \"Example: undefined references in first TeX run.</span>'\\n\"\n # \"\\t<span class=\\\"tex-success\\\">Indicates positive event, does not guarantee overall success</span>\\n\"\n # \"\\t<span class=\\\"tex-info\\\">Informational markup</span>\\n\"\n\n # \"\\n\"\n # \"\\tNote: Almost all marked up messages are generated by TeX \\n\\tengine \"\n # \"or packages. The help or suggested highlights below \\n\\tmay be add to assist submitter.\\n\\n\"\n # \"\\t<span class=\\\"tex-help\\\">References to arXiv help pages or other documentation.</span>\\n\"\n # \"\\t<span class=\\\"tex-suggestion\\\">Recommended solution based on \"\n # \"previous experience.</span>\\n\"\n # \"\\n\\n\"\n # )\n\n run_summary = run_summary + (\n f\"Summary of TeX runs:\\n\\n\"\n )\n\n new_log = ''\n\n last_run_for_engine = {}\n\n # TODO : THIS LIKELY BECOMES ITS OWN ROUTINE\n\n # Lets figure out what we have in terms of TeX runs\n #\n # Pattern is 'Running (engine) for the (run number) time'\n #\n # ~~~~~~~~~~~ Running hpdflatex for the first time ~~~~~~~~\n # ~~~~~~~~~~~ Running latex for the first time ~~~~~~~~\n run_regex = re.compile(r'\\~+\\sRunning (.*) for the (.*) time\\s\\~+',\n re.IGNORECASE | re.MULTILINE)\n\n hits = run_regex.findall(autotex_log)\n\n enable_markup = []\n disable_markup = []\n\n success_last_engine = ''\n success_last_run = ''\n\n for run in hits:\n (engine, run) = run\n\n run_summary = run_summary + f\"\\tRunning {engine} for {run} time.\" + '\\n'\n\n # Keep track of finaly run in the event compilation succeeded\n success_last_engine = engine\n success_last_run = run\n\n last_run_for_engine[engine] = run\n\n # Now, when we see a normal TeX run, we will eliminate the hypertex run.\n # Since normal run and hypertex run a basically identical this eliminates\n # unnecessary cruft. When hypertex run succeed it will be displayed and\n # marked up appropriately.\n\n if engine == PDFLATEX:\n disable_markup.append(DISABLE_HPDFLATEX)\n enable_markup.append(ENABLE_PDFLATEX)\n if engine == LATEX:\n disable_markup.append(DISABLE_HLATEX)\n enable_markup.append(ENABLE_LATEX)\n if engine == TEX:\n disable_markup.append(DISABLE_HTEX)\n enable_markup.append(ENABLE_TEX)\n\n run_summary = run_summary + '\\n'\n\n for e, r in last_run_for_engine.items():\n run_summary = run_summary + f\"\\tLast run for engine {e} is {r}\\n\"\n\n # Ignore lines that we know submitters are not interested in or that\n # contain little useful value\n\n skip_markup = []\n\n current_engine = ''\n current_run = ''\n\n last_run = False\n\n # Filters [css class, regex, run spec]\n #\n # Parameters:\n #\n # css class: class to use for highlighting matching text\n #\n # regex: regular expression that sucks up everything you want to highlight\n #\n # run spec: specifies when to start applying filter\n # OR apply to last run.\n #\n # Possible Values: first, second, third, fourth, last\n #\n # Examples:\n # 'first' - starts applying filter on first run.\n # 'last' - applies filter to last run of each particular engine.\n # 'third' - applies filter starting on third run.\n #\n # run spec of 'second' will apply filter on second, third, ...\n # run spec of 'last' will apply ONLY on last run for each engine.\n #\n # Order: Filters are applied in order they appear in list.\n #\n # If you desire different highlighting for the same string match\n # you must make sure the least restrictive filter is after more\n # restrictive filter.\n #\n # Apply: Only one filter will be applied to a line from the log.\n #\n filters = [\n\n # Examples (these highlight random text at beginning of autotex log)\n # ['suggestion', r':.*PATH.*', 'second'], # Note ORDER is critical here\n # ['help', r':.*PATH.*', 'first'], # otherwise this rule trumps all PATH rules\n # ['suggestion', r'Set working directory to.*', ''],\n # ['ignore', 'Setting unix time to current time.*', ''],\n # ['help','Using source archive.*',''],\n # ['info', r'Using directory .* for processing.', ''],\n # ['warning', r'Copied file .* into working directory.', ''],\n # ['danger', 'nostamp: will not stamp PostScript', ''],\n # ['danger', r'TeX/AutoTeX.pm', ''],\n # ['fatal', r'override', ''],\n\n # Help - use to highlight links to help pages (or external references)\n # ['help', 'http://arxiv.org/help/.*', ''],\n\n # Individual filters are ordered by priority, more important highlighting first.\n\n ['ignore', r\"get arXiv to do 4 passes\\: Label\\(s\\) may have changed\", ''],\n\n # Abort [uses 'fatal' class for markup and then disables other markup.\n ['abort', r'Fatal fontspec error: \"cannot-use-pdftex\"', ''],\n ['abort', r'The fontspec package requires either XeTeX or LuaTeX.', ''],\n ['abort', r'{cannot-use-pdftex}', ''],\n\n # These should be abort level errors but we are not set up to support\n # multiple errors of this type at the moment.\n ['fatal', '\\*\\*\\* AutoTeX ABORTING \\*\\*\\*', ''],\n ['fatal', '.*AutoTeX returned error: missfont.log present.', ''],\n ['fatal', 'dvips: Font .* not found; characters will be left blank.', ''],\n ['fatal', '.*missfont.log present.', ''],\n\n # Fatal\n ['fatal', r'Fatal .* error', ''],\n ['fatal', 'fatal', ''],\n\n # Danger\n ['danger', r'file (.*) not found', ''],\n ['danger', 'failed', ''],\n ['danger', 'emergency stop', ''],\n ['danger', 'not allowed', ''],\n ['danger', 'does not exist', ''],\n\n # TODO: Built execution priority into regex filter specification to\n # TODO: avoid having to worry about order of filters in this list.\n # Must run before warning regexes run\n ['danger', 'Package rerunfilecheck Warning:.*', 'last'],\n ['danger', '.*\\(rerunfilecheck\\).*', 'last'],\n ['danger', 'rerun', 'last'],\n\n # Warnings\n ['warning', r'Citation.*undefined', 'last'], # needs to be 'last'\n ['warning', r'Reference.*undefined', 'last'], # needs to be 'last'\n ['warning', r'No .* file', ''],\n ['warning', 'warning', 'second'],\n ['warning', 'unsupported', ''],\n ['warning', 'unable', ''],\n ['warning', 'ignore', ''],\n ['warning', 'undefined', 'second'],\n\n # Informational\n ['info', r'\\~+\\sRunning.*\\s\\~+', ''],\n ['info', r'(\\*\\*\\* Using TeX Live 2016 \\*\\*\\*)', ''],\n\n # Success\n ['success', r'(Extracting files from archive:)', ''],\n ['success', r'Successfully created PDF file:', ''],\n ['success', r'\\*\\* AutoTeX job completed. \\*\\*', ''],\n\n # Ignore\n # needs to be after 'warning' above that highlight same text\n ['ignore', r'Reference.*undefined', 'first'],\n ['ignore', r'Citation.*undefined', 'first'],\n ['ignore', 'warning', 'first'],\n ['ignore', 'undefined', 'first'],\n ]\n\n # Try to create summary containing errors deemed important for user\n # to address.\n error_summary = ''\n\n # Keep track of any errors we've already added to error_summary\n abort_any_further_markup = False\n have_detected_xetex_luatex = False\n have_detected_emergency_stop = False\n have_detected_missing_file = False\n have_detected_missing_font_markup = False\n have_detected_rerun_markup = False\n\n # Collect some state about\n\n final_run_had_errors = False\n final_run_had_warnings = False\n\n line_by_line = autotex_log.splitlines()\n\n # Enable markup. Program will turn off markup for extraneous run.\n markup_enabled = True\n\n for line in line_by_line:\n\n # Escape any HTML contained in the log\n line = html.escape(line)\n\n # Disable markup for TeX runs we do not want to mark up\n for regex in disable_markup:\n\n if re.search(regex, line, re.IGNORECASE):\n markup_enabled = False\n # new_log = new_log + f\"DISABLE MARKUP:{line}\\n\"\n break\n\n # Enable markiup for runs that user is interested in\n for regex in enable_markup:\n\n if re.search(regex, line, re.IGNORECASE):\n markup_enabled = True\n # new_log = new_log + f\"ENABLE MARKUP:{line}\\n\"\n # key_summary = key_summary + \"\\tRun: \" + re.search(regex, line, re.IGNORECASE).group() + '\\n'\n found = run_regex.search(line)\n if found:\n current_engine = found.group(1)\n current_run = found.group(2)\n # new_log = new_log + f\"Set engine:{current_engine} Run:{current_run}\\n\"\n\n if current_engine and current_run:\n if last_run_for_engine[current_engine] == current_run:\n # new_log = new_log + f\"LAST RUN:{current_engine} Run:{current_run}\\n\"\n last_run = True\n break\n\n # In the event we are not disabling/enabling markup\n if re.search(run_regex, line):\n found = run_regex.search(line)\n if found:\n current_engine = found.group(1)\n current_run = found.group(2)\n if last_run_for_engine[current_engine] == current_run:\n # new_log = new_log + f\"LAST RUN:{current_engine} Run:{current_run}\\n\"\n last_run = True\n\n # Disable markup for TeX runs that we are not interested in.\n if not markup_enabled:\n continue\n\n # We are not done with this line until there is a match\n done_with_line = False\n\n for regex in skip_markup:\n if re.search(regex, line, re.IGNORECASE):\n done_with_line = True\n new_log = new_log + f\"Skip line {line}\\n\"\n break\n\n if done_with_line:\n continue\n\n # Ignore, Info, Help, Warning, Danger, Fatal\n for level, filter, run in filters:\n regex = r'(' + filter + r')'\n\n # when we encounter fatal error limit highlighting to fatal\n # messages\n if abort_any_further_markup and level not in ['fatal', 'abort']:\n continue\n\n if not run:\n run = 'first'\n\n # if last_run and run and current_run and re.search('Package rerunfilecheck Warning', line):\n # if re.search('Package rerunfilecheck Warning', line):\n #new_log = new_log + (\n # f\"Settings: RUN:{run}:{RUN_ORDER.index(run)} \"\n # f\" CURRENT:{current_run}:{RUN_ORDER.index(current_run)}:\"\n # f\"Last:{last_run_for_engine[current_engine]} Filter:{filter}\" + '\\n')\n\n if run and current_run \\\n and ((RUN_ORDER.index(run) > RUN_ORDER.index(current_run)\n or (run == 'last' and current_run != last_run_for_engine[current_engine]))):\n # if re.search('Package rerunfilecheck Warning', line):\n # new_log = new_log + f\"NOT RIGHT RUN LEVEL: SKIP:{filter}\" + '\\n'\n continue\n\n actual_level = level\n if level == 'abort':\n level = 'fatal'\n\n if re.search(regex, line, re.IGNORECASE):\n line = re.sub(regex, rf'<span class=\"tex-{level}\">\\1</span>',\n line, flags=re.IGNORECASE)\n\n # Try to determine if there are problems with a successful compiliation\n if compilation_status == 'succeeded' \\\n and current_engine == success_last_engine \\\n and current_run == success_last_run:\n\n if level == 'warning':\n final_run_had_warnings = True\n if level == 'danger' or level == 'fatal':\n final_run_had_errors = True\n\n # Currently XeTeX/LuaTeX are the only full abort case.\n if not abort_any_further_markup and actual_level == 'abort' \\\n and (re.search('Fatal fontspec error: \"cannot-use-pdftex\"', line)\n or re.search(\"The fontspec package requires either XeTeX or LuaTeX.\", line)\n or re.search(\"{cannot-use-pdftex}\", line)):\n\n if error_summary == '':\n error_summary = initialize_error_summary()\n else:\n error_summary = error_summary + '\\n'\n\n error_summary = error_summary + (\n \"\\t<li>At the current time arXiv does not support XeTeX/LuaTeX.\\n\\n\"\n '\\tIf you believe that your submission requires a compilation '\n 'method \\n\\tunsupported by arXiv, please contact '\n '<span class=\\\"tex-help\\\">help@arxiv.org</span> for '\n '\\n\\tmore information and provide us with this '\n f'submit/{submission_id} identifier.</li>')\n\n have_detected_xetex_luatex = True\n abort_any_further_markup = True\n\n # Hack alert - Cringe - Handle missfont while I'm working on converter.\n # TODO: Need to formalize detecting errors that need to be\n # TODO: reported in error summary\n if not have_detected_missing_font_markup and level == 'fatal' \\\n and re.search(\"missfont.log present\", line):\n\n if error_summary == '':\n error_summary = initialize_error_summary()\n else:\n error_summary = error_summary + '\\n'\n\n error_summary = error_summary + (\n \"\\t<li>A font required by your paper is not available. \"\n \"You may try to \\n\\tinclude a non-standard font or \"\n \"substitue an alternative font. \\n\\tSee <span \"\n \"class=\\\"tex-help\\\"><a href=\\\"https://arxiv.org/\"\n \"help/00README#fontmap\\\">Custom Fontmaps</a></span>. If \"\n \"this is due to a problem with \\n\\tour system, please \"\n \"contact <span class=\\\"tex-help\\\">help@arxiv.org</span>\"\n \" with details \\n\\tand provide us with this \"\n f'submission identifier: submit/{submission_id}.'\n '</li>')\n\n have_detected_missing_font_markup = True\n\n # Hack alert - detect common problem where we need another TeX run\n if not have_detected_rerun_markup and level == 'danger' \\\n and re.search(\"rerunfilecheck|rerun\", line) \\\n and not re.search(r\"get arXiv to do 4 passes\\: Label\\(s\\) may have changed\", line) \\\n and not re.search(r\"oberdiek\", line):\n\n if error_summary == '':\n error_summary = initialize_error_summary()\n else:\n error_summary = error_summary + '\\n'\n\n error_summary = error_summary + (\n \"\\t<li>Analysis of the compilation log indicates \"\n \"your submission \\n\\tmay need an additional TeX run. \"\n \"Please add the following line \\n\\tto your source in \"\n \"order to force an additional TeX run:\\n\\n\"\n \"\\t<span class=\\\"tex-help\\\">\\\\typeout{get arXiv \"\n \"to do 4 passes: Label(s) may have changed. Rerun}</span>\"\n \"\\n\\n\\tAdd the above line just before <span \"\n \"class=\\\"tex-help\\\">\\end{document}</span> directive.\"\n \"/li>\")\n\n # Significant enough that we should turn on warning\n final_run_had_warnings = True\n\n # Only do this once\n have_detected_rerun_markup = True\n\n # Missing file needs to be kicked up in visibility and displayed in\n # compilation summary.\n #\n # There is an issue with the AutoTeX log where parts of the log\n # may be getting truncated. Therefore, for this error, we will\n # report the error if it occurs during any run.\n #\n # We might want to refine the activiation criteria for this\n # warning once the issue is resolved with truncated log.\n if not have_detected_missing_file and level == 'danger' \\\n and re.search('file (.*) not found', line, re.IGNORECASE):\n\n if error_summary == '':\n error_summary = initialize_error_summary()\n else:\n error_summary = error_summary + '\\n'\n\n error_summary = error_summary + (\n \"<li>\\tA file required by your submission was not found.\"\n f\"\\n\\t{line}\\n\\tPlease upload any missing files, or \"\n \"correct any file naming issues, and then reprocess\"\n \" your submission.</li>\")\n\n # Don't activate this so we can see bug I created above...\n have_detected_missing_file = True\n\n # Emergency stop tends to hand-in-hand with the file not found error.\n # If we havve already reported on the file not found error then\n # we won't add yet another warning about emergency stop.\n if not have_detected_missing_file and not have_detected_emergency_stop and level == 'danger' \\\n and re.search('emergency stop', line, re.IGNORECASE):\n\n if error_summary == '':\n error_summary = initialize_error_summary()\n else:\n error_summary = error_summary + '\\n'\n\n error_summary = error_summary + (\n \"\\t<li>We detected an emergency stop during one of the TeX\"\n \" compilation runs. Please review the compilation log\"\n \" to determie whether there is a serious issue with \"\n \"your submission source.</li>\")\n\n have_detected_emergency_stop = True\n\n # We found a match so we are finished with this line\n break\n\n # Append line to new marked up log\n new_log = new_log + line + '\\n'\n\n if error_summary:\n error_summary = finalize_error_summary(error_summary)\n\n # Now that we are done highlighting the autotex log we are able to roughly\n # determine/refine the status of a successful compilation.\n # Note that all submissions in 'Failed' status have warnings/errors we are not\n # sure about. When status is 'Succeeded' we are only concerned with warnings in\n # last run.\n status_class = 'success'\n if compilation_status == 'failed':\n status_class = 'fatal'\n if have_detected_xetex_luatex:\n display_status = \"Failed: XeTeX/LuaTeX are not supported at current time.\"\n elif have_detected_missing_file:\n display_status = \"Failed: File not found.\"\n else:\n display_status = \"Failed\"\n elif compilation_status == 'succeeded':\n if final_run_had_errors and not final_run_had_warnings:\n display_status = (\"Succeeded with possible errors. \"\n \"\\n\\t\\tBe sure to carefully inspect log (see below).\")\n status_class = 'danger'\n elif not final_run_had_errors and final_run_had_warnings:\n display_status = (\"Succeeded with warnings. We recommend that you \"\n \"\\n\\t\\tinspect the log (see below).\")\n status_class = 'warning'\n elif final_run_had_errors and final_run_had_warnings:\n display_status = (\"Succeeded with (possibly significant) errors and \"\n \"warnings. \\n\\t\\tPlease be sure to carefully inspect \"\n \"log (see below).\")\n status_class = 'danger'\n else:\n display_status = f\"Succeeded!\"\n status_class = 'success'\n else:\n status_class = 'warning'\n display_status = \"Succeeded with warnings\"\n\n status_line = f\"\\nProcessing Status: <span class=\\\"tex-{status_class}\\\">{display_status}</span>\\n\\n\"\n\n # Put together a nice report, list TeX runs, markup info, and marked up log.\n # In future we can add 'Recommendation' section or collect critical errors.\n new_log = run_summary + status_line + error_summary + key_summary \\\n + '\\n\\n<b>Marked Up Log:</b>\\n\\n' + new_log\n\n return new_log"],"string":"[\n \"def get_build_line(latest_build):\\n proc = Popen([\\\"osg-koji\\\", \\\"buildinfo\\\", latest_build],\\n stdout=PIPE)\\n build_line = proc.stdout.readline().decode(\\\"latin-1\\\").strip()\\n ret = proc.wait()\\n if ret != 0 or not build_line:\\n return\\n return build_line\",\n \"def general_job_info(self, jobid=None, output=False):\\n\\n self.check_all_jobs()\\n\\n if jobid is None:\\n print(\\\"Job Summary:\\\\n\\\"\\n \\\"There are {0} jobs with phase: COMPLETED.\\\\n\\\"\\n \\\"There are {1} jobs with phase: ERROR.\\\\n\\\"\\n \\\"There are {2} jobs with phase: ABORTED.\\\\n\\\"\\n \\\"There are {3} jobs with phase: PENDING.\\\\n\\\"\\n \\\"There are {4} jobs with phase: EXECUTING.\\\\n\\\"\\n \\\"There are {5} jobs with phase: QUEUED.\\\\n\\\"\\n \\\"Try providing a jobid for the job you'd like to \\\"\\n \\\"know more about.\\\\n To see a list of all jobs, use \\\"\\n \\\"`check_all_jobs()`.\\\"\\n .format(self.job_dict.values().count('COMPLETED'),\\n self.job_dict.values().count('ERROR'),\\n self.job_dict.values().count('ABORTED'),\\n self.job_dict.values().count('PENDING'),\\n self.job_dict.values().count('EXECUTING'),\\n self.job_dict.values().count('QUEUED')))\\n return\\n else:\\n response_list = [self._request(\\n 'GET', CosmoSim.QUERY_URL + \\\"/{}\\\".format(jobid),\\n auth=(self.username, self.password), cache=False)]\\n\\n if response_list[0].ok is False:\\n log.error('Must provide a valid jobid.')\\n return\\n else:\\n self.response_dict_current = {}\\n self.response_dict_current[jobid] = (\\n self._generate_response_dict(response_list[0]))\\n\\n if output is True:\\n dictkeys = self.response_dict_current.keys()\\n print(self.response_dict_current[dictkeys[0]]['content'])\\n return\\n else:\\n return\",\n \"def get_job_output(job_id: Optional[pulumi.Input[str]] = None,\\n location: Optional[pulumi.Input[str]] = None,\\n project: Optional[pulumi.Input[Optional[str]]] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetJobResult]:\\n ...\",\n \"def job_output(self, job_id):\\n\\n url = self.base_url + \\\"/ml-service/phoenix-ml/output/findBy?jobId={0}\\\".format(job_id)\\n headers = {\\\"ApiKey\\\": self.api_key}\\n response = requests.get(url=url, headers=headers)\\n return response.json()\",\n \"def get_text(self):\\n return self.output.getvalue()\",\n \"def build_show_log(ctx, args):\\n for build_id in args:\\n data = ctx.obj.get_build_log_by_build_id(build_id)\\n click.echo(data.text)\",\n \"def generateReleaseRunOut(self, job):\\n pass\",\n \"def get_job_information(run_id):\\n cmd = [github_cli, 'run', 'view', str(run_id), '--json', 'jobs']\\n with subprocess.Popen(cmd, stdout=subprocess.PIPE) as p:\\n result, err = p.communicate()\\n print(err)\\n return json.loads(result)['jobs']\",\n \"def getHeader():\\n system, host, release, version, machine = os.uname()\\n\\n return \\\"# output generated by %s\\\\n# job started at %s on %s -- %s\\\\n# pid: %i, system: %s %s %s %s\\\" %\\\\\\n (\\\" \\\".join(sys.argv),\\n time.asctime(time.localtime(time.time())),\\n host,\\n global_id,\\n os.getpid(),\\n system, release, version, machine)\",\n \"def get_job(self) -> Dict[Text, Text]:\\n request = self._client.projects().jobs().get(name=self._job_name)\\n return request.execute()\",\n \"def get_text(self):\\n\\n return self.output['text']\",\n \"def describe_text_translation_job(JobId=None):\\n pass\",\n \"def job_full_command(job_id):\\n return subprocess.check_output(['at', '-c', job_id], text=True, encoding='latin-1')\",\n \"def get_json_job_details(buildurl):\\n return requests.get(buildurl + \\\"/api/json\\\").json()\",\n \"def get_build(self):\\n return self.bot_data_file[\\\"build\\\"]\",\n \"def get_job_name(self) -> Text:\\n return self._job_name\",\n \"def RetrievePipelineToolStatus( raiseOnExitCode=False ):\\n global submissionInfo\\n\\n scenePath = NodegraphAPI.GetSourceFile()\\n\\n jobWriterPath = os.path.join(submissionInfo[\\\"RepoDirs\\\"][\\\"submission/Integration/Main\\\"], \\\"JobWriter.py\\\")\\n argArray = [\\\"-ExecuteScript\\\", jobWriterPath, \\\"Katana\\\", \\\"--status\\\", \\\"--scene-path\\\", scenePath]\\n statusMessage = CallDeadlineCommand(argArray, hideWindow=False, raiseOnExitCode=raiseOnExitCode)\\n return statusMessage\",\n \"def _job_id_or_out(out):\\n\\n stdout = re.sub(\\\"[^0-9]\\\", \\\"\\\", str(out))\\n if not stdout:\\n stdout = out\\n return stdout\",\n \"def getoutput(cmd):\\n return getstatusoutput(cmd)[1]\",\n \"def getJobName():\\n return os.environ['LCATR_JOB']\",\n \"def _print_logs_info(job_id, project_id):\\n print(\\\"\\\\nJob submitted successfully.\\\")\\n print(\\\"Your job ID is: \\\", job_id)\\n print(\\\"\\\\nPlease access your training job information here:\\\")\\n print(\\n \\\"https://console.cloud.google.com/mlengine/jobs/{}?project={}\\\".format(\\n job_id, project_id))\\n print(\\\"\\\\nPlease access your training job logs here: \\\"\\n \\\"https://console.cloud.google.com/logs/viewer?resource=ml_job%2F\\\"\\n \\\"job_id%2F{}&interval=NO_LIMIT&project={}\\\\n\\\".format(\\n job_id, project_id))\",\n \"def result_stdout(result):\\n return result[1][0]\",\n \"def build_command_line( self, job ):\\n commands = job.get_command_line()\\n # All job runners currently handle this case which should never\\n # occur\\n if not commands:\\n return None\\n return commands\",\n \"def job(self) -> str:\\n return self._job\",\n \"def job(self) -> str:\\n return self._job\",\n \"def task_stdout(self, task_id):\\n result, _ = self.task_collect(task_id, wait=False)\\n return result['shards'][0]['output']\",\n \"def stdout(username, root_wf_id, wf_id, job_id, job_instance_id):\\n dashboard = Dashboard(g.master_db_url, root_wf_id, wf_id)\\n text = dashboard.get_stdout(wf_id, job_id, job_instance_id)\\n\\n if text.stdout_text == None:\\n return 'No stdout for workflow ' + wf_id + ' job-id ' + job_id\\n else:\\n return '<pre>%s</pre>' % utils.unquote(text.stdout_text)\",\n \"def fetch_exe_from_jenkins():\\n base_job_url = os.environ.get(\\\"JENKINS_JOB_URL\\\")\\n if not base_job_url:\\n print \\\"Jenkins job URL for the builder is not specified.\\\"\\n sys.exit(-1)\\n\\n build_json = json.loads(requests.get(\\\"%s/api/json\\\" % base_job_url).text)\\n last_build = build_json['lastCompletedBuild']['number']\\n print \\\"Last build ID: %d\\\" % last_build\\n\\n job_url = '%s/%d' % (base_job_url, last_build)\\n last_build_json = json.loads(requests.get(\\\"%s/api/json\\\" % job_url).text)\\n if len(last_build_json['artifacts']) == 0:\\n error(\\\"No artifacts found!\\\")\\n\\n artifact_url = \\\"%s/artifact/%s\\\" % (job_url, last_build_json['artifacts'][0]['relativePath'])\\n file_name = last_build_json['artifacts'][0]['fileName']\\n print \\\"Tribler installer url: %s\\\" % artifact_url\\n\\n # Download the file\\n file_path = os.path.join(os.environ.get('WORKSPACE'), file_name)\\n download_response = requests.get(artifact_url, stream=True)\\n download_response.raise_for_status()\\n\\n with open(file_path, 'wb') as handle:\\n for block in download_response.iter_content(1024):\\n handle.write(block)\\n\\n return file_path\",\n \"def get_output(command):\\n if is_debug_environment():\\n dir_name = get_test_dir_argument()\\n filename = '{}.txt'.format(command)\\n full_path = os.path.join(dir_name, filename)\\n if os.path.isfile(full_path):\\n with open(full_path) as f:\\n return f.read()\\n raise IOError(\\\"File {} is not found\\\".format(full_path))\\n else:\\n import cli\\n result = cli.cli(command)\\n i = 0\\n # Occasionally, cli library returns an empty output, in this case we try multiple time\\n while result.count('\\\\n') <= 2 and i < 3:\\n result = cli.cli(command)\\n i += 1\\n return result\",\n \"async def get_jobs(jobId: int) -> str: \\n return mngr.getJob(str(jobId))\",\n \"def get_latest_build(tag, package):\\n proc = Popen([\\\"osg-koji\\\", \\\"-q\\\", \\\"list-tagged\\\", \\\"--latest\\\", tag, package],\\n stdout=PIPE)\\n out = proc.communicate()[0] or b''\\n ret = proc.returncode\\n\\n latest_build_line = out.decode(\\\"latin-1\\\").strip()\\n\\n if ret != 0 or not latest_build_line:\\n return\\n\\n return latest_build_line.split()[0]\",\n \"def job_subtitle(self, job):\\n return str(job)[:max(8, self._project_min_len_unique_id())]\",\n \"def output(self):\\n text_list = self.q(css='#output').text\\n\\n if len(text_list) < 1:\\n return None\\n return text_list[0]\",\n \"def getBuild():\",\n \"def qoutput(self):\\n jobid = self.jobid()\\n ou = os.path.join(self.directory, jobid + '.OU')\\n if not self.in_queue() and os.path.exists(ou):\\n with open(ou) as f:\\n return f.read()\\n else:\\n return \\\"In queue or no output found.\\\"\",\n \"def get(self):\\n return self.stdout.get()\",\n \"def get_output(self):\\n return self.cmd_output\",\n \"def output(self) -> pulumi.Output[Optional['outputs.JobStepOutputResponse']]:\\n return pulumi.get(self, \\\"output\\\")\",\n \"def fetch_executable_from_jenkins():\\n\\n base_job_url = os.environ.get('JENKINS_JOB_URL')\\n if not base_job_url:\\n error('Jenkins job URL for the builder is not specified.')\\n\\n build_json = json.loads(requests.get('%s/api/json'\\n % base_job_url).text)\\n last_build = build_json['lastCompletedBuild']['number']\\n print 'Last build ID: %d' % last_build\\n\\n job_url = '%s/%d' % (base_job_url, last_build)\\n last_build_json = json.loads(requests.get('%s/api/json'\\n % job_url).text)\\n if not last_build_json['artifacts']:\\n error('No artifacts found!')\\n\\n artifacts_deb = [artifact for artifact in\\n last_build_json['artifacts'] if '.dmg'\\n in artifact['fileName']]\\n artifact_url = '%s/artifact/%s' % (job_url,\\n artifacts_deb[0]['relativePath'])\\n file_name = artifacts_deb[0]['fileName']\\n print 'Tribler installer url: %s' % artifact_url\\n\\n # Download the file\\n file_path = os.path.join(os.environ.get('WORKSPACE'), file_name)\\n download_response = requests.get(artifact_url, stream=True)\\n download_response.raise_for_status()\\n\\n with open(file_path, 'wb') as handle:\\n for block in download_response.iter_content(1024):\\n handle.write(block)\\n\\n return file_path\",\n \"def get_output(self):\\n if self._is_started and self._is_terminated:\\n job_f = self._outerr_files.replace('%J', str(self._jobid))\\n job_out_f = job_f + '.out'\\n job_err_f = job_f + '.err'\\n job_out = \\\"\\\"\\n if self.out is None and self.err is None:\\n try:\\n with open(job_out_f, 'r') as f:\\n job_out = f.read()\\n except FileNotFoundError:\\n sys.stderr.write(\\\"File not found : {0}\\\\n\\\".format(job_out_f))\\n sys.stderr.flush()\\n job_err = \\\"\\\"\\n try:\\n with open(job_err_f, 'r') as f:\\n job_err = f.read()\\n except FileNotFoundError:\\n sys.stderr.write(\\\"File not found : {0}\\\\n\\\".format(job_err_f))\\n sys.stderr.flush()\\n self.out, self.err = job_out, job_err\\n return(self.out, self.err)\\n else:\\n return(None, None)\",\n \"def cli(ctx, job_id):\\n return ctx.gi.jobs.get_inputs(job_id)\",\n \"def html_message_formatter(mode, name, build, results, master_status):\\n result = Results[results]\\n\\n limit_lines = 80\\n text = list()\\n text.append(u'<h4>Build status: %s</h4>' % result.upper())\\n text.append(u'<table cellspacing=\\\"10\\\"><tr>')\\n text.append(u\\\"<td>Buildslave for this Build:</td><td><b>%s</b></td></tr>\\\" % build.getSlavename())\\n if master_status.getURLForThing(build):\\n text.append(u'<tr><td>Complete logs for all build steps:</td><td><a href=\\\"%s\\\">%s</a></td></tr>'\\n % (master_status.getURLForThing(build),\\n master_status.getURLForThing(build))\\n )\\n text.append(u'<tr><td>Build Reason:</td><td>%s</td></tr>' % build.getReason())\\n source = u\\\"\\\"\\n for ss in build.getSourceStamps():\\n if ss.codebase:\\n source += u'%s: ' % ss.codebase\\n if ss.branch:\\n source += u\\\"[branch %s] \\\" % ss.branch\\n if ss.revision:\\n source += ss.revision\\n else:\\n source += u\\\"HEAD\\\"\\n if ss.patch:\\n source += u\\\" (plus patch)\\\"\\n if ss.patch_info: # add patch comment\\n source += u\\\" (%s)\\\" % ss.patch_info[1]\\n text.append(u\\\"<tr><td>Build Source Stamp:</td><td><b>%s</b></td></tr>\\\" % source)\\n text.append(u\\\"<tr><td>Blamelist:</td><td>%s</td></tr>\\\" % \\\",\\\".join(build.getResponsibleUsers()))\\n text.append(u'</table>')\\n if ss.changes:\\n text.append(u'<h4>Recent Changes:</h4>')\\n for c in ss.changes:\\n cd = c.asDict()\\n when = datetime.datetime.fromtimestamp(cd['when'] ).ctime()\\n text.append(u'<table cellspacing=\\\"10\\\">')\\n text.append(u'<tr><td>Repository:</td><td>%s</td></tr>' % cd['repository'] )\\n text.append(u'<tr><td>Project:</td><td>%s</td></tr>' % cd['project'] )\\n text.append(u'<tr><td>Time:</td><td>%s</td></tr>' % when)\\n text.append(u'<tr><td>Changed by:</td><td>%s</td></tr>' % cd['who'] )\\n text.append(u'<tr><td>Comments:</td><td>%s</td></tr>' % cd['comments'] )\\n text.append(u'</table>')\\n files = cd['files']\\n if files:\\n text.append(u'<table cellspacing=\\\"10\\\"><tr><th align=\\\"left\\\">Files</th></tr>')\\n for file in files:\\n text.append(u'<tr><td>%s:</td></tr>' % file['name'] )\\n text.append(u'</table>')\\n text.append(u'<br>')\\n # get all the steps in build in reversed order\\n rev_steps = reversed(build.getSteps())\\n # find the last step that finished\\n for step in rev_steps:\\n if step.isFinished():\\n break\\n # get logs for the last finished step\\n if step.isFinished():\\n logs = step.getLogs()\\n # No step finished, loop just exhausted itself; so as a special case we fetch all logs\\n else:\\n logs = build.getLogs()\\n # logs within a step are in reverse order. Search back until we find stdio\\n for log in reversed(logs):\\n if log.getName() == 'stdio':\\n break\\n name = \\\"%s.%s\\\" % (log.getStep().getName(), log.getName())\\n status, dummy = log.getStep().getResults()\\n content = log.getText().splitlines() # Note: can be VERY LARGE\\n url = u'%s/steps/%s/logs/%s' % (master_status.getURLForThing(build),\\n log.getStep().getName(),\\n log.getName())\\n\\n text.append(u'<i>Detailed log of last build step:</i> <a href=\\\"%s\\\">%s</a>'\\n % (url, url))\\n text.append(u'<br>')\\n text.append(u'<h4>Last %d lines of \\\"%s\\\"</h4>' % (limit_lines, name))\\n unilist = list()\\n for line in content[len(content)-limit_lines:]:\\n unilist.append(cgi.escape(unicode(line,'utf-8')))\\n text.append(u'<pre>')\\n text.extend(unilist)\\n text.append(u'</pre>')\\n text.append(u'<br><br>')\\n text.append(u'<b>-The Buildbot</b>')\\n return {\\n 'body': u\\\"\\\\n\\\".join(text),\\n 'type': 'html'\\n }\",\n \"def get_output_string(command):\\n out_put = command.replace(\\\"\\\\n\\\", \\\"\\\")\\n return out_put\",\n \"def run_tool(args, quiet=False):\\n pipe = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\\n result = \\\"\\\"\\n for line in iter(pipe.stdout.readline, \\\"\\\"):\\n if not line and pipe.poll() is not None:\\n break\\n output = line.decode(encoding='UTF-8').rstrip()\\n if output != \\\"\\\":\\n if not quiet:\\n print(\\\"\\\\t * \\\" + output)\\n result = output\\n return result\",\n \"def _get_job_tree_text(job_tree, property):\\n # Check to prevent AttributeError: 'NoneType' object has no attribute 'text'\\n try:\\n return job_tree.find(property).text\\n except AttributeError:\\n return \\\"\\\"\",\n \"def get_last_successful_build_nr(jenkins_url, job_name):\\n return execute_command(\\n f\\\"wget -qO- {jenkins_url}/{job_name}/lastSuccessfulBuild/buildNumber\\\"\\n )\",\n \"def output(self) -> Optional[pulumi.Input['JobStepOutputArgs']]:\\n return pulumi.get(self, \\\"output\\\")\",\n \"def get_commit_message():\\n return shell_output('git log HEAD -1 --pretty=%B')\",\n \"def get_test_summary(self):\\n\\n last_line = 'None'\\n cmd = ['catkin_test_results', 'build/%s' % self.name ]\\n try:\\n process = subprocess.Popen(cmd,\\n stdout=subprocess.PIPE, \\n stderr=subprocess.PIPE,\\n universal_newlines=True)\\n stdout, stderr = process.communicate()\\n # Extract the summary line\\n # Summary: 0 tests, 0 errors, 0 failures, 0 skipped\\n last_line = stdout.strip().split('\\\\n')[-1]\\n finally:\\n return last_line\",\n \"def get_stdout(self):\\n return self._get_log('stdout')\",\n \"def build_report(self, msg=''):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\ts = '\\\\n'\\n\\t\\ts += '################################################################################\\\\n'\\n\\t\\ts += '# COMMAND HISTORY BEGIN ' + shutit_global.shutit_global_object.build_id + '\\\\n'\\n\\t\\ts += self.get_commands()\\n\\t\\ts += '# COMMAND HISTORY END ' + shutit_global.shutit_global_object.build_id + '\\\\n'\\n\\t\\ts += '################################################################################\\\\n'\\n\\t\\ts += '################################################################################\\\\n'\\n\\t\\ts += '# BUILD REPORT FOR BUILD BEGIN ' + shutit_global.shutit_global_object.build_id + '\\\\n'\\n\\t\\ts += '# ' + msg + '\\\\n'\\n\\t\\tif self.build['report'] != '':\\n\\t\\t\\ts += self.build['report'] + '\\\\n'\\n\\t\\telse:\\n\\t\\t\\ts += '# Nothing to report\\\\n'\\n\\t\\tif 'container_id' in self.target:\\n\\t\\t\\ts += '# CONTAINER_ID: ' + self.target['container_id'] + '\\\\n'\\n\\t\\ts += '# BUILD REPORT FOR BUILD END ' + shutit_global.shutit_global_object.build_id + '\\\\n'\\n\\t\\ts += '###############################################################################\\\\n'\\n\\t\\ts += '# INVOKING COMMAND WAS: ' + sys.executable\\n\\t\\tfor arg in sys.argv:\\n\\t\\t\\ts += ' ' + arg\\n\\t\\ts += '\\\\n'\\n\\t\\ts += '###############################################################################\\\\n'\\n\\t\\treturn s\",\n \"def get_logs(job_key):\\n job = Job.fetch(job_key, connection=conn)\\n if job.is_finished:\\n logs = job.result\\n elif job.is_failed:\\n logs = job.exc_info\\n else:\\n logs = \\\"Task is still running\\\"\\n return str(logs), 200\",\n \"def describe_compilation_job(CompilationJobName=None):\\n pass\",\n \"def job_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"job_id\\\")\",\n \"def GetBuildInfo(builder_name, build_num):\\n url = '%s/json/builders/%s/builds/%s' % (BUILD_MASTER_URL,\\n builder_name,\\n build_num)\\n return json.load(urllib2.urlopen(url))\",\n \"def output(self):\\n queue_type = self.queue_type\\n queue_options = self.queue_options\\n jobname = self.jobname\\n emtopath = self.emtopath\\n\\n line = batch_head(jobname=jobname, latpath=emtopath, runtime=self.runtime, \\n account=self.account, queue_type=queue_type, queue_options=queue_options)\\n \\n self.use_module = False\\n if self.slurm_options is not None:\\n for tmp in self.slurm_options:\\n if 'module load emto' in tmp:\\n self.use_module = True\\n break\\n line += \\\"\\\\n\\\"\\n\\n sub_module = [\\\"kgrn_cpa\\\", \\\"kfcd_cpa\\\"]\\n sub_module_run = [self.runKGRN, self.runKFCD]\\n file_type = [self.KGRN_file_type, self.KFCD_file_type]\\n output_file_ext = [\\\"kgrn\\\", \\\"kfcd\\\"]\\n\\n #elapsed_time = \\\"/usr/bin/time \\\"\\n elapsed_time = \\\"\\\"\\n if self.parallel is True:\\n sub_module = [\\\"kgrn_omp\\\", \\\"kfcd_cpa\\\"]\\n\\n if which(\\\"kfcd_cpa\\\") is not None:\\n self.use_module = True\\n if not self.use_module:\\n module_path = [os.path.join(self.EMTOdir, module_i) for module_i in sub_module]\\n else:\\n module_path = sub_module\\n\\n for i in range(0, len(sub_module)):\\n if sub_module_run[i]:\\n runStr = [elapsed_time, module_path[i], \\\"<\\\", \\n os.path.join(emtopath, jobname + \\\".\\\" + file_type[i]), \\\">\\\",\\n os.path.join(emtopath, jobname + \\\"_\\\" + output_file_ext[i] + \\\".output\\\")]\\n line += \\\" \\\".join(runStr).strip() + \\\"\\\\n\\\"\\n\\n return line\",\n \"def examine_job(self):\\n if self.data is None:\\n print(\\\"Could not download job id\\\", self.job_id)\\n return\\n self.duration = self.read_data(\\\"duration\\\")\\n self.between_commands = self.read_data(\\\"between_commands\\\")\\n\\n print(\\\"---\\\")\\n print(\\\"test_id: {}\\\".format(self.job_id))\\n print(\\\"duration:\\\")\\n Job.print_results(self.duration)\\n print(\\\"between_commands:\\\")\\n Job.print_results(self.between_commands)\\n print(\\\"\\\")\",\n \"def stdout(self):\\n if self.dm.fileExists(self.proc):\\n try:\\n t = self.dm.pullFile(self.proc)\\n except DMError:\\n # we currently don't retry properly in the pullFile\\n # function in dmSUT, so an error here is not necessarily\\n # the end of the world\\n return ''\\n newLogContent = t[self.stdoutlen:]\\n self.stdoutlen = len(t)\\n # Match the test filepath from the last TEST-START line found in the new\\n # log content. These lines are in the form:\\n # 1234 INFO TEST-START | /filepath/we/wish/to/capture.html\\\\n\\n testStartFilenames = re.findall(r\\\"TEST-START \\\\| ([^\\\\s]*)\\\", newLogContent)\\n if testStartFilenames:\\n self.lastTestSeen = testStartFilenames[-1]\\n return newLogContent.strip('\\\\n').strip()\\n else:\\n return ''\",\n \"def get_console_output(self):\\r\\n return self.connection.get_console_output(self.id)\",\n \"def _get_description(actor, commit, run_id):\\n return (\\\"Requested by @%s on commit %s\\\\n\\\" % (actor, commit) +\\n \\\"Last updated: %s \\\\n\\\" % _get_datetime() +\\n \\\"**[View integration test log & download artifacts](https://github.com/firebase/firebase-cpp-sdk/actions/runs/%s)**\\\\n\\\" % run_id)\",\n \"def get_cargo_input() -> str:\\n results = subprocess.run([\\\"cargo\\\", \\\"check\\\"], capture_output=True)\\n if results.returncode == 0:\\n print(\\\"Cargo check found no errors. Exiting\\\")\\n quit()\\n if results.returncode != 101:\\n print(\\\"Cargo check returned an unexpected error!\\\")\\n show_help()\\n if b\\\"could not find\\\" in results.stderr:\\n print(\\\"Cargo.toml not found in this directory!\\\")\\n show_help()\\n return results.stderr.decode('utf-8')\\n # FIXME\",\n \"def get_last_completed_build_number(jenkins_url, job_name):\\n return execute_command(\\n f\\\"wget -qO- {jenkins_url}/{job_name}/lastCompletedBuild/buildNumber\\\"\\n )\",\n \"def text(self):\\n text = ''\\n for run in self.runs:\\n text += run.text\\n return text\",\n \"def getCompilerOutput(uname):\\n fname = os.path.join(webapp.config['UPLOADED_BUILD_DEST'], uname, 'output').encode('utf8')\\n if os.path.exists(fname):\\n stdout_file = open(fname, 'r')\\n output = unicode(stdout_file.read(), 'utf-8')\\n stdout_file.close()\\n return output\\n else:\\n return returnError(\\\"Output not available for \\\" + uname, 404)\",\n \"def grab_posting_txt(driver, job, idx):\\n\\n job_link = job.find_element_by_class_name('jobLink')\\n job_link.send_keys(Keys.ENTER)\\n job_link.send_keys(Keys.ESCAPE)\\n\\n try: \\n print job.find_element_by_class_name('reviews-tab-link').text\\n except: \\n pass\\n\\n time.sleep(random.randint(3, 7))\\n texts = driver.find_elements_by_class_name('jobDescriptionContent')\\n return texts[idx].text\",\n \"def get_output(self):\\r\\n return self._api.get_output()\",\n \"def get_job_overview_string(self, mission):\\n\\n # get statuses\\n job_status, task_status = self.get_job_status(mission)\\n\\n s = \\\"Job status: {}\\\".format(job_status)\\n\\n if job_status != \\\"N/A\\\":\\n s += \\\"\\\\n\\\"\\n s += \\\"Tasks status: \\\"\\n s += \\\"{} active; \\\".format(task_status[\\\"active\\\"])\\n s += \\\"{} running; \\\".format(task_status[\\\"running\\\"])\\n s += \\\"{} succeeded; \\\".format(task_status[\\\"succeeded\\\"])\\n s += \\\"{} failed;\\\".format(task_status[\\\"failed\\\"])\\n\\n return s\",\n \"def test_main_output(self, capsys):\\n args = self.args.copy()\\n args[\\\"out_file\\\"] = \\\"text.txt\\\"\\n UI.main(**args)\\n captured = capsys.readouterr().out\\n assert \\\"Results written to text.txt\\\" in captured\",\n \"def GetBuildID(build_bot, date):\\n day = '{day:02d}'.format(day=date%100)\\n mon = MONTHS[date/100%100]\\n date_string = mon + ' ' + day\\n if build_bot in WATERFALL_BUILDERS:\\n url = 'https://uberchromegw.corp.google.com/i/chromeos/' + \\\\\\n 'builders/%s?numbuilds=200' % build_bot\\n if build_bot in ROTATING_BUILDERS:\\n url = 'https://uberchromegw.corp.google.com/i/chromiumos.tryserver/' + \\\\\\n 'builders/%s?numbuilds=200' % build_bot\\n command = 'sso_client %s' %url\\n retval = 1\\n retry_time = 3\\n while retval and retry_time:\\n retval, output, _ = \\\\\\n command_executer.GetCommandExecuter().RunCommandWOutput(command, \\\\\\n print_to_console=False)\\n retry_time -= 1\\n\\n if retval:\\n return []\\n\\n out = output.split('\\\\n')\\n line_num = 0\\n build_id = []\\n # Parse the output like this\\n # <td>Dec 14 10:55</td>\\n # <td class=\\\"revision\\\">??</td>\\n # <td failure</td><td><a href=\\\"../builders/gcc_toolchain/builds/109\\\">#109</a>\\n while line_num < len(out):\\n if date_string in out[line_num]:\\n if line_num + 2 < len(out):\\n build_num_line = out[line_num + 2]\\n raw_num = re.findall(r'builds/\\\\d+', build_num_line)\\n # raw_num is ['builds/109'] in the example.\\n if raw_num:\\n build_id.append(int(raw_num[0].split('/')[1]))\\n line_num += 1\\n return build_id\",\n \"def job(name):\\n current_app.logger.info(\\\"Running custom job: {}\\\".format(name))\",\n \"def get_console_output(instance_id):\\n ec2 = boto3.resource('ec2')\\n ec2_instance = ec2.Instance(instance_id)\\n json_output = ec2_instance.console_output()\\n\\n return json_output.get('Output', '')\",\n \"def get_log_text(nipype_output_files):\\n execution_log = get_nipype_report(get_nipype_report_filename(\\n nipype_output_files))\\n return execution_log\",\n \"def _get_job_status(self):\\n total_hits = session.query(BoxHit).filter_by(training_job_id=self.id).count()\\n num_hits_left = session.query(BoxHit).filter_by(training_job_id=self.id, outstanding=True).count()\\n total_urls = self.num_urls\\n num_urls_left = session.query(VideoTrainingURL).filter_by(job=self, processed=False).count()\\n faces_obtained = MTurkBox.query.filter_by(label=self.evaluator.target_label, result=True).count()\\n return '\\\\n'.join([\\n '------------- Stats for Job ID: %s -------------' % str(self.id) ,\\n 'Job for Label : %s' % self.label.name,\\n 'Total URLs : %d' % total_urls,\\n 'Total HITs : %d' % total_hits,\\n 'unprocessed URLS : %d' % num_urls_left,\\n 'outstanding Hits : %d' % num_hits_left,\\n 'Job Finish Status : %s' % self.finished,\\n 'Faces Obtained : %d' % faces_obtained,\\n ]) + '\\\\n'\",\n \"def output(self) -> Optional[str]:\\n return self.__output\",\n \"def log_build(self, build):\\n with self._conn.begin():\\n if build.status:\\n build_id = self._conn.execute(\\n \\\"VALUES (log_build_success(%s, %s, %s, %s, %s, %s, \\\"\\n \\\"CAST(%s AS files ARRAY), CAST(%s AS dependencies ARRAY)\\\"\\n \\\"))\\\",\\n (\\n build.package,\\n build.version,\\n build.slave_id,\\n build.duration,\\n build.abi_tag,\\n sanitize(build.output),\\n [(\\n file.filename,\\n None,\\n file.filesize,\\n file.filehash,\\n file.package_tag,\\n file.package_version_tag,\\n file.py_version_tag,\\n file.abi_tag,\\n file.platform_tag,\\n file.requires_python,\\n )\\n for file in build.files.values()],\\n [(\\n file.filename,\\n tool,\\n dependency,\\n )\\n for file in build.files.values()\\n for tool, dependencies in file.dependencies.items()\\n for dependency in dependencies]\\n )).scalar()\\n else:\\n build_id = self._conn.execute(\\n \\\"VALUES (log_build_failure(%s, %s, %s, %s, %s, %s))\\\",\\n (\\n build.package,\\n build.version,\\n build.slave_id,\\n build.duration,\\n build.abi_tag,\\n sanitize(build.output),\\n )).scalar()\\n build.logged(build_id)\",\n \"def get_build_progress_info(self, build_id):\\n pass\",\n \"def get_text_at_stage(self, stage: str):\\n for transformation in self.transform_history:\\n if transformation.stage == stage:\\n return transformation.text\",\n \"def _get_output(self):\\n return self.__output\",\n \"def _get_output(self):\\n return self.__output\",\n \"def _get_output(self):\\n return self.__output\",\n \"def _get_output(self):\\n return self.__output\",\n \"def _get_output(self):\\n return self.__output\",\n \"def _get_output(self):\\n return self.__output\",\n \"def get_by_build_job(self, job: Union[JobSubmissionResponse, UUID], *,\\n timeout: float = 15 * 60) -> GemTable:\\n if isinstance(job, JobSubmissionResponse):\\n job_id = job.job_id\\n else:\\n job_id = job # pragma: no cover\\n path = 'projects/{}/execution/job-status'.format(self.project_id)\\n params = {'job_id': job_id}\\n start_time = time()\\n while True:\\n response = self.session.get_resource(path=path, params=params)\\n status: JobStatusResponse = JobStatusResponse.build(response)\\n if status.status in ['Success', 'Failure']:\\n break\\n elif time() - start_time < timeout:\\n logger.info('Build job still in progress, polling status again in 2 seconds.')\\n sleep(2)\\n else:\\n logger.error('Build job exceeded user timeout of {} seconds.'.format(timeout))\\n logger.debug('Last status: {}'.format(status.dump()))\\n raise TimeoutError('Build job {} timed out.'.format(job_id))\\n if status.status == 'Failure':\\n logger.debug('Job terminated with Failure status: {}'.format(status.dump()))\\n for task in status.tasks:\\n if task.status == 'Failure':\\n logger.error('Task {} failed with reason \\\"{}\\\"'.format(\\n task.id, task.failure_reason))\\n raise RuntimeError('Job {} terminated with Failure status.'.format(job_id))\\n else:\\n table_id = status.output['display_table_id']\\n table_version = status.output['display_table_version']\\n warning_blob = status.output.get('table_warnings')\\n warnings = json.loads(warning_blob) if warning_blob is not None else []\\n if warnings:\\n warn_lines = ['Table build completed with warnings:']\\n for warning in warnings:\\n limited_results = warning.get('limited_results', [])\\n warn_lines.extend(limited_results)\\n total_count = warning.get('total_count', 0)\\n if total_count > len(limited_results):\\n warn_lines.append('and {} more similar.'\\n .format(total_count - len(limited_results)))\\n logger.warning('\\\\n\\\\t'.join(warn_lines))\\n return self.get(table_id, table_version)\",\n \"def build_job(self, name, parameters=None, build_timeout=30, name_suffix=''):\\n queue_item_id = self._server.build_job(name, parameters)\\n logger.debug(\\n 'Triggered build with queue item {queue_item}'.format(queue_item=queue_item_id))\\n build_executable = wait_for(\\n lambda: self._server.get_queue_item(queue_item_id).get('executable'),\\n timeout=5,\\n poll_interval=0.1)\\n build_number = build_executable['number']\\n logger.debug(\\n \\\"Build of '{job}/{build_number}' started\\\".format(job=name, build_number=build_number))\\n\\n def get_build_info():\\n build_info = self._server.get_build_info(name, build_number)\\n if build_info.get('result'):\\n return build_info\\n else:\\n return False\\n\\n build_info = wait_for(get_build_info, timeout=build_timeout)\\n logger.debug(\\n \\\"Build of '{job}/{build_number}' completed'\\\".format(\\n job=name, build_number=build_number))\\n\\n def get_console_log():\\n console_log = self._server.get_build_console_output(name, build_number)\\n if 'Finished: {result}'.format(result=build_info['result']) in console_log:\\n return console_log\\n else:\\n return False\\n\\n console_log = wait_for(get_console_log, timeout=10, poll_interval=1.0)\\n\\n # Get build info again to make sure everything including artifacts are included\\n build_info = self._server.get_build_info(name, build_number)\\n\\n for line in console_log.split('\\\\n'):\\n logger.debug(\\n '{name}{name_suffix}: {line}'.format(name=name, name_suffix=name_suffix, line=line))\\n return BuildInfo(\\n build_number, build_info['result'], console_log,\\n [artifact['relativePath'] for artifact in build_info['artifacts']])\",\n \"def get_snapshot_build_desc(self):\\n return self.shard_build_desc\",\n \"def getBuild(number):\",\n \"def getBuild(number):\",\n \"def get_buildinfo():\\n path = os.path.join(SCRIPT_DIR, \\\"..\\\", DISTRIBUTION, \\\"buildinfo.json\\\")\\n return json.load(open(path, \\\"rb\\\"))\",\n \"def get_batch_name(joblist):\\n\\tfin = open(joblist[0], 'r'); file = fin.read(); fin.close()\\n\\tbatch_name = re.search(r\\\"#PBS\\\\s+-N\\\\s+(.*)\\\", file).group(1)\\n\\tprint(\\\"\\\\033[34m------------------------------------\\\\033[0m\\\\nCurrent \\\\033[35mbatch_name\\\\033[0m: {}\\\".format(batch_name))\\n\\tprint(\\\"Please enter the \\\\033[35mbatch_name\\\\033[0m of the job:\\\", end=\\\" \\\")\\n\\tbatch_name_input = input()\\n\\tbatch_name = batch_name_input if batch_name_input != \\\"\\\" else batch_name\\n\\treturn batch_name\",\n \"def script_execution_get() -> str | None:\\n if (data := script_execution_cv.get()) is None:\\n return None\\n return data.script_execution\",\n \"def output(index: int = 0) -> str:\\n return outputs()[index]\",\n \"def output(self) -> str:\\n return self.stdout\",\n \"def get_current_project(self):\\n\\n try:\\n command = self._oc_command([\\\"project\\\", \\\"-q\\\"])\\n output = run_cmd(command, return_output=True)\\n except subprocess.CalledProcessError as ex:\\n raise ConuException(\\\"Failed to obtain current project name : %s\\\" % ex)\\n\\n try:\\n return output.rstrip() # remove '\\\\n'\\n except IndexError:\\n raise ConuException(\\\"Failed to obtain project name\\\")\",\n \"def output(cmd):\\n return subprocess.check_output(cmd, shell=True)\",\n \"def get_output(self):\\n return self.output\",\n \"def get_output(self):\\n return self.output\",\n \"def info(self, jobid):\\n return self.rpc.call(MsfRpcMethod.JobInfo, [jobid])\",\n \"def get_job_description(self, job, context=None):\\n return self._client.call_method(\\n 'UserAndJobState.get_job_description',\\n [job], self._service_ver, context)\",\n \"def display_pipeline_log(ctx,\\n pipeline_name,\\n username,\\n password,\\n ip_address,\\n interactive):\\n slab_logger.info('Displaying %s log' % pipeline_name)\\n if not username:\\n username = ctx.get_username()\\n if not password:\\n password = ctx.get_password(interactive)\\n if not password or not username:\\n slab_logger.error(\\\"Username is %s and password is %s. \\\"\\n \\\"Please, set the correct value for both and retry.\\\" %\\n (username, password))\\n sys.exit(1)\\n stages_url = \\\"http://{0}/go/api/pipelines/{1}/stages.xml\\\"\\n # Find latest run info\\n res = requests.get(stages_url.format(ip_address, pipeline_name),\\n auth=HTTPBasicAuth(username, password))\\n soup = BeautifulSoup(res.content, \\\"html.parser\\\")\\n try:\\n latest_job_info_url = soup.findAll(\\n 'entry')[0].findAll('link')[0]['href']\\n except Exception as ex:\\n slab_logger.error(\\\"Internal error occurred. Please, check arguments supplied.\\\")\\n slab_logger.error(\\\"Error details : %s \\\" % (ex))\\n sys.exit(1)\\n\\n # Find all the job info for that run\\n latest_job_info_url = latest_job_info_url.replace(\\\"gocd_java_server\\\",\\n ip_address)\\n job_info_res = requests.get(latest_job_info_url,\\n auth=HTTPBasicAuth(username, password))\\n soup = BeautifulSoup(job_info_res.content, \\\"html.parser\\\")\\n job_urls = soup.findAll('job')\\n\\n # for each of the job, pull the log and display the log\\n for job_url in job_urls:\\n job_url['href'] = job_url['href'].replace(\\\"gocd_java_server\\\",\\n ip_address)\\n job_url_res = requests.get(job_url['href'],\\n auth=HTTPBasicAuth(username, password))\\n soup = BeautifulSoup(job_url_res.content, \\\"html.parser\\\")\\n log_url = soup.find('artifacts')['baseuri']\\n log_url = log_url.replace(\\\"gocd_java_server\\\", ip_address)\\n log_url_res = requests.get(log_url + \\\"/cruise-output/console.log\\\",\\n auth=HTTPBasicAuth(username, password))\\n soup = BeautifulSoup(log_url_res.content, \\\"html.parser\\\")\\n print \\\"\\\\n\\\\n-------------------Printing job log for pipeline : \\\", \\\\\\n log_url, \\\"-------------------------\\\"\\n print soup\\n print \\\"\\\\n\\\\n-------------------End of job log for pipeline : \\\", \\\\\\n log_url, \\\"-------------------------\\\"\",\n \"def compilation_log_display(autotex_log: str, submission_id: int,\\n compilation_status: str) -> str:\\n # Don't do anything when log not generated\\n if re.search(r'No log available.', autotex_log):\\n return autotex_log\\n\\n # Create summary information detailing runs and markup key.\\n\\n run_summary = (\\\"If you are attempting to compile \\\"\\n \\\"with a specific engine (PDFLaTeX, LaTeX, \\\\nTeX) please \\\"\\n \\\"carefully review the appropriate log below.\\\\n\\\\n\\\"\\n )\\n\\n # Key to highlighting\\n\\n key_summary = \\\"\\\"\\n #(\\n # \\\"Key: \\\\n\\\"\\n # \\\"\\\\t<span class=\\\\\\\"tex-fatal\\\\\\\">Severe warnings/errors.</span>'\\\\n\\\"\\n # \\\"\\\\t<span class=\\\\\\\"tex-danger\\\\\\\">Warnings deemed important</span>'\\\\n\\\"\\n # \\\"\\\\t<span class=\\\\\\\"tex-warning\\\\\\\">General warnings/errors from packages.</span>'\\\\n\\\"\\n\\n # \\\"\\\\t<span class=\\\\\\\"tex-ignore\\\\\\\">Warnings/Errors deemed unimportant. \\\"\\n # \\\"Example: undefined references in first TeX run.</span>'\\\\n\\\"\\n # \\\"\\\\t<span class=\\\\\\\"tex-success\\\\\\\">Indicates positive event, does not guarantee overall success</span>\\\\n\\\"\\n # \\\"\\\\t<span class=\\\\\\\"tex-info\\\\\\\">Informational markup</span>\\\\n\\\"\\n\\n # \\\"\\\\n\\\"\\n # \\\"\\\\tNote: Almost all marked up messages are generated by TeX \\\\n\\\\tengine \\\"\\n # \\\"or packages. The help or suggested highlights below \\\\n\\\\tmay be add to assist submitter.\\\\n\\\\n\\\"\\n # \\\"\\\\t<span class=\\\\\\\"tex-help\\\\\\\">References to arXiv help pages or other documentation.</span>\\\\n\\\"\\n # \\\"\\\\t<span class=\\\\\\\"tex-suggestion\\\\\\\">Recommended solution based on \\\"\\n # \\\"previous experience.</span>\\\\n\\\"\\n # \\\"\\\\n\\\\n\\\"\\n # )\\n\\n run_summary = run_summary + (\\n f\\\"Summary of TeX runs:\\\\n\\\\n\\\"\\n )\\n\\n new_log = ''\\n\\n last_run_for_engine = {}\\n\\n # TODO : THIS LIKELY BECOMES ITS OWN ROUTINE\\n\\n # Lets figure out what we have in terms of TeX runs\\n #\\n # Pattern is 'Running (engine) for the (run number) time'\\n #\\n # ~~~~~~~~~~~ Running hpdflatex for the first time ~~~~~~~~\\n # ~~~~~~~~~~~ Running latex for the first time ~~~~~~~~\\n run_regex = re.compile(r'\\\\~+\\\\sRunning (.*) for the (.*) time\\\\s\\\\~+',\\n re.IGNORECASE | re.MULTILINE)\\n\\n hits = run_regex.findall(autotex_log)\\n\\n enable_markup = []\\n disable_markup = []\\n\\n success_last_engine = ''\\n success_last_run = ''\\n\\n for run in hits:\\n (engine, run) = run\\n\\n run_summary = run_summary + f\\\"\\\\tRunning {engine} for {run} time.\\\" + '\\\\n'\\n\\n # Keep track of finaly run in the event compilation succeeded\\n success_last_engine = engine\\n success_last_run = run\\n\\n last_run_for_engine[engine] = run\\n\\n # Now, when we see a normal TeX run, we will eliminate the hypertex run.\\n # Since normal run and hypertex run a basically identical this eliminates\\n # unnecessary cruft. When hypertex run succeed it will be displayed and\\n # marked up appropriately.\\n\\n if engine == PDFLATEX:\\n disable_markup.append(DISABLE_HPDFLATEX)\\n enable_markup.append(ENABLE_PDFLATEX)\\n if engine == LATEX:\\n disable_markup.append(DISABLE_HLATEX)\\n enable_markup.append(ENABLE_LATEX)\\n if engine == TEX:\\n disable_markup.append(DISABLE_HTEX)\\n enable_markup.append(ENABLE_TEX)\\n\\n run_summary = run_summary + '\\\\n'\\n\\n for e, r in last_run_for_engine.items():\\n run_summary = run_summary + f\\\"\\\\tLast run for engine {e} is {r}\\\\n\\\"\\n\\n # Ignore lines that we know submitters are not interested in or that\\n # contain little useful value\\n\\n skip_markup = []\\n\\n current_engine = ''\\n current_run = ''\\n\\n last_run = False\\n\\n # Filters [css class, regex, run spec]\\n #\\n # Parameters:\\n #\\n # css class: class to use for highlighting matching text\\n #\\n # regex: regular expression that sucks up everything you want to highlight\\n #\\n # run spec: specifies when to start applying filter\\n # OR apply to last run.\\n #\\n # Possible Values: first, second, third, fourth, last\\n #\\n # Examples:\\n # 'first' - starts applying filter on first run.\\n # 'last' - applies filter to last run of each particular engine.\\n # 'third' - applies filter starting on third run.\\n #\\n # run spec of 'second' will apply filter on second, third, ...\\n # run spec of 'last' will apply ONLY on last run for each engine.\\n #\\n # Order: Filters are applied in order they appear in list.\\n #\\n # If you desire different highlighting for the same string match\\n # you must make sure the least restrictive filter is after more\\n # restrictive filter.\\n #\\n # Apply: Only one filter will be applied to a line from the log.\\n #\\n filters = [\\n\\n # Examples (these highlight random text at beginning of autotex log)\\n # ['suggestion', r':.*PATH.*', 'second'], # Note ORDER is critical here\\n # ['help', r':.*PATH.*', 'first'], # otherwise this rule trumps all PATH rules\\n # ['suggestion', r'Set working directory to.*', ''],\\n # ['ignore', 'Setting unix time to current time.*', ''],\\n # ['help','Using source archive.*',''],\\n # ['info', r'Using directory .* for processing.', ''],\\n # ['warning', r'Copied file .* into working directory.', ''],\\n # ['danger', 'nostamp: will not stamp PostScript', ''],\\n # ['danger', r'TeX/AutoTeX.pm', ''],\\n # ['fatal', r'override', ''],\\n\\n # Help - use to highlight links to help pages (or external references)\\n # ['help', 'http://arxiv.org/help/.*', ''],\\n\\n # Individual filters are ordered by priority, more important highlighting first.\\n\\n ['ignore', r\\\"get arXiv to do 4 passes\\\\: Label\\\\(s\\\\) may have changed\\\", ''],\\n\\n # Abort [uses 'fatal' class for markup and then disables other markup.\\n ['abort', r'Fatal fontspec error: \\\"cannot-use-pdftex\\\"', ''],\\n ['abort', r'The fontspec package requires either XeTeX or LuaTeX.', ''],\\n ['abort', r'{cannot-use-pdftex}', ''],\\n\\n # These should be abort level errors but we are not set up to support\\n # multiple errors of this type at the moment.\\n ['fatal', '\\\\*\\\\*\\\\* AutoTeX ABORTING \\\\*\\\\*\\\\*', ''],\\n ['fatal', '.*AutoTeX returned error: missfont.log present.', ''],\\n ['fatal', 'dvips: Font .* not found; characters will be left blank.', ''],\\n ['fatal', '.*missfont.log present.', ''],\\n\\n # Fatal\\n ['fatal', r'Fatal .* error', ''],\\n ['fatal', 'fatal', ''],\\n\\n # Danger\\n ['danger', r'file (.*) not found', ''],\\n ['danger', 'failed', ''],\\n ['danger', 'emergency stop', ''],\\n ['danger', 'not allowed', ''],\\n ['danger', 'does not exist', ''],\\n\\n # TODO: Built execution priority into regex filter specification to\\n # TODO: avoid having to worry about order of filters in this list.\\n # Must run before warning regexes run\\n ['danger', 'Package rerunfilecheck Warning:.*', 'last'],\\n ['danger', '.*\\\\(rerunfilecheck\\\\).*', 'last'],\\n ['danger', 'rerun', 'last'],\\n\\n # Warnings\\n ['warning', r'Citation.*undefined', 'last'], # needs to be 'last'\\n ['warning', r'Reference.*undefined', 'last'], # needs to be 'last'\\n ['warning', r'No .* file', ''],\\n ['warning', 'warning', 'second'],\\n ['warning', 'unsupported', ''],\\n ['warning', 'unable', ''],\\n ['warning', 'ignore', ''],\\n ['warning', 'undefined', 'second'],\\n\\n # Informational\\n ['info', r'\\\\~+\\\\sRunning.*\\\\s\\\\~+', ''],\\n ['info', r'(\\\\*\\\\*\\\\* Using TeX Live 2016 \\\\*\\\\*\\\\*)', ''],\\n\\n # Success\\n ['success', r'(Extracting files from archive:)', ''],\\n ['success', r'Successfully created PDF file:', ''],\\n ['success', r'\\\\*\\\\* AutoTeX job completed. \\\\*\\\\*', ''],\\n\\n # Ignore\\n # needs to be after 'warning' above that highlight same text\\n ['ignore', r'Reference.*undefined', 'first'],\\n ['ignore', r'Citation.*undefined', 'first'],\\n ['ignore', 'warning', 'first'],\\n ['ignore', 'undefined', 'first'],\\n ]\\n\\n # Try to create summary containing errors deemed important for user\\n # to address.\\n error_summary = ''\\n\\n # Keep track of any errors we've already added to error_summary\\n abort_any_further_markup = False\\n have_detected_xetex_luatex = False\\n have_detected_emergency_stop = False\\n have_detected_missing_file = False\\n have_detected_missing_font_markup = False\\n have_detected_rerun_markup = False\\n\\n # Collect some state about\\n\\n final_run_had_errors = False\\n final_run_had_warnings = False\\n\\n line_by_line = autotex_log.splitlines()\\n\\n # Enable markup. Program will turn off markup for extraneous run.\\n markup_enabled = True\\n\\n for line in line_by_line:\\n\\n # Escape any HTML contained in the log\\n line = html.escape(line)\\n\\n # Disable markup for TeX runs we do not want to mark up\\n for regex in disable_markup:\\n\\n if re.search(regex, line, re.IGNORECASE):\\n markup_enabled = False\\n # new_log = new_log + f\\\"DISABLE MARKUP:{line}\\\\n\\\"\\n break\\n\\n # Enable markiup for runs that user is interested in\\n for regex in enable_markup:\\n\\n if re.search(regex, line, re.IGNORECASE):\\n markup_enabled = True\\n # new_log = new_log + f\\\"ENABLE MARKUP:{line}\\\\n\\\"\\n # key_summary = key_summary + \\\"\\\\tRun: \\\" + re.search(regex, line, re.IGNORECASE).group() + '\\\\n'\\n found = run_regex.search(line)\\n if found:\\n current_engine = found.group(1)\\n current_run = found.group(2)\\n # new_log = new_log + f\\\"Set engine:{current_engine} Run:{current_run}\\\\n\\\"\\n\\n if current_engine and current_run:\\n if last_run_for_engine[current_engine] == current_run:\\n # new_log = new_log + f\\\"LAST RUN:{current_engine} Run:{current_run}\\\\n\\\"\\n last_run = True\\n break\\n\\n # In the event we are not disabling/enabling markup\\n if re.search(run_regex, line):\\n found = run_regex.search(line)\\n if found:\\n current_engine = found.group(1)\\n current_run = found.group(2)\\n if last_run_for_engine[current_engine] == current_run:\\n # new_log = new_log + f\\\"LAST RUN:{current_engine} Run:{current_run}\\\\n\\\"\\n last_run = True\\n\\n # Disable markup for TeX runs that we are not interested in.\\n if not markup_enabled:\\n continue\\n\\n # We are not done with this line until there is a match\\n done_with_line = False\\n\\n for regex in skip_markup:\\n if re.search(regex, line, re.IGNORECASE):\\n done_with_line = True\\n new_log = new_log + f\\\"Skip line {line}\\\\n\\\"\\n break\\n\\n if done_with_line:\\n continue\\n\\n # Ignore, Info, Help, Warning, Danger, Fatal\\n for level, filter, run in filters:\\n regex = r'(' + filter + r')'\\n\\n # when we encounter fatal error limit highlighting to fatal\\n # messages\\n if abort_any_further_markup and level not in ['fatal', 'abort']:\\n continue\\n\\n if not run:\\n run = 'first'\\n\\n # if last_run and run and current_run and re.search('Package rerunfilecheck Warning', line):\\n # if re.search('Package rerunfilecheck Warning', line):\\n #new_log = new_log + (\\n # f\\\"Settings: RUN:{run}:{RUN_ORDER.index(run)} \\\"\\n # f\\\" CURRENT:{current_run}:{RUN_ORDER.index(current_run)}:\\\"\\n # f\\\"Last:{last_run_for_engine[current_engine]} Filter:{filter}\\\" + '\\\\n')\\n\\n if run and current_run \\\\\\n and ((RUN_ORDER.index(run) > RUN_ORDER.index(current_run)\\n or (run == 'last' and current_run != last_run_for_engine[current_engine]))):\\n # if re.search('Package rerunfilecheck Warning', line):\\n # new_log = new_log + f\\\"NOT RIGHT RUN LEVEL: SKIP:{filter}\\\" + '\\\\n'\\n continue\\n\\n actual_level = level\\n if level == 'abort':\\n level = 'fatal'\\n\\n if re.search(regex, line, re.IGNORECASE):\\n line = re.sub(regex, rf'<span class=\\\"tex-{level}\\\">\\\\1</span>',\\n line, flags=re.IGNORECASE)\\n\\n # Try to determine if there are problems with a successful compiliation\\n if compilation_status == 'succeeded' \\\\\\n and current_engine == success_last_engine \\\\\\n and current_run == success_last_run:\\n\\n if level == 'warning':\\n final_run_had_warnings = True\\n if level == 'danger' or level == 'fatal':\\n final_run_had_errors = True\\n\\n # Currently XeTeX/LuaTeX are the only full abort case.\\n if not abort_any_further_markup and actual_level == 'abort' \\\\\\n and (re.search('Fatal fontspec error: \\\"cannot-use-pdftex\\\"', line)\\n or re.search(\\\"The fontspec package requires either XeTeX or LuaTeX.\\\", line)\\n or re.search(\\\"{cannot-use-pdftex}\\\", line)):\\n\\n if error_summary == '':\\n error_summary = initialize_error_summary()\\n else:\\n error_summary = error_summary + '\\\\n'\\n\\n error_summary = error_summary + (\\n \\\"\\\\t<li>At the current time arXiv does not support XeTeX/LuaTeX.\\\\n\\\\n\\\"\\n '\\\\tIf you believe that your submission requires a compilation '\\n 'method \\\\n\\\\tunsupported by arXiv, please contact '\\n '<span class=\\\\\\\"tex-help\\\\\\\">help@arxiv.org</span> for '\\n '\\\\n\\\\tmore information and provide us with this '\\n f'submit/{submission_id} identifier.</li>')\\n\\n have_detected_xetex_luatex = True\\n abort_any_further_markup = True\\n\\n # Hack alert - Cringe - Handle missfont while I'm working on converter.\\n # TODO: Need to formalize detecting errors that need to be\\n # TODO: reported in error summary\\n if not have_detected_missing_font_markup and level == 'fatal' \\\\\\n and re.search(\\\"missfont.log present\\\", line):\\n\\n if error_summary == '':\\n error_summary = initialize_error_summary()\\n else:\\n error_summary = error_summary + '\\\\n'\\n\\n error_summary = error_summary + (\\n \\\"\\\\t<li>A font required by your paper is not available. \\\"\\n \\\"You may try to \\\\n\\\\tinclude a non-standard font or \\\"\\n \\\"substitue an alternative font. \\\\n\\\\tSee <span \\\"\\n \\\"class=\\\\\\\"tex-help\\\\\\\"><a href=\\\\\\\"https://arxiv.org/\\\"\\n \\\"help/00README#fontmap\\\\\\\">Custom Fontmaps</a></span>. If \\\"\\n \\\"this is due to a problem with \\\\n\\\\tour system, please \\\"\\n \\\"contact <span class=\\\\\\\"tex-help\\\\\\\">help@arxiv.org</span>\\\"\\n \\\" with details \\\\n\\\\tand provide us with this \\\"\\n f'submission identifier: submit/{submission_id}.'\\n '</li>')\\n\\n have_detected_missing_font_markup = True\\n\\n # Hack alert - detect common problem where we need another TeX run\\n if not have_detected_rerun_markup and level == 'danger' \\\\\\n and re.search(\\\"rerunfilecheck|rerun\\\", line) \\\\\\n and not re.search(r\\\"get arXiv to do 4 passes\\\\: Label\\\\(s\\\\) may have changed\\\", line) \\\\\\n and not re.search(r\\\"oberdiek\\\", line):\\n\\n if error_summary == '':\\n error_summary = initialize_error_summary()\\n else:\\n error_summary = error_summary + '\\\\n'\\n\\n error_summary = error_summary + (\\n \\\"\\\\t<li>Analysis of the compilation log indicates \\\"\\n \\\"your submission \\\\n\\\\tmay need an additional TeX run. \\\"\\n \\\"Please add the following line \\\\n\\\\tto your source in \\\"\\n \\\"order to force an additional TeX run:\\\\n\\\\n\\\"\\n \\\"\\\\t<span class=\\\\\\\"tex-help\\\\\\\">\\\\\\\\typeout{get arXiv \\\"\\n \\\"to do 4 passes: Label(s) may have changed. Rerun}</span>\\\"\\n \\\"\\\\n\\\\n\\\\tAdd the above line just before <span \\\"\\n \\\"class=\\\\\\\"tex-help\\\\\\\">\\\\end{document}</span> directive.\\\"\\n \\\"/li>\\\")\\n\\n # Significant enough that we should turn on warning\\n final_run_had_warnings = True\\n\\n # Only do this once\\n have_detected_rerun_markup = True\\n\\n # Missing file needs to be kicked up in visibility and displayed in\\n # compilation summary.\\n #\\n # There is an issue with the AutoTeX log where parts of the log\\n # may be getting truncated. Therefore, for this error, we will\\n # report the error if it occurs during any run.\\n #\\n # We might want to refine the activiation criteria for this\\n # warning once the issue is resolved with truncated log.\\n if not have_detected_missing_file and level == 'danger' \\\\\\n and re.search('file (.*) not found', line, re.IGNORECASE):\\n\\n if error_summary == '':\\n error_summary = initialize_error_summary()\\n else:\\n error_summary = error_summary + '\\\\n'\\n\\n error_summary = error_summary + (\\n \\\"<li>\\\\tA file required by your submission was not found.\\\"\\n f\\\"\\\\n\\\\t{line}\\\\n\\\\tPlease upload any missing files, or \\\"\\n \\\"correct any file naming issues, and then reprocess\\\"\\n \\\" your submission.</li>\\\")\\n\\n # Don't activate this so we can see bug I created above...\\n have_detected_missing_file = True\\n\\n # Emergency stop tends to hand-in-hand with the file not found error.\\n # If we havve already reported on the file not found error then\\n # we won't add yet another warning about emergency stop.\\n if not have_detected_missing_file and not have_detected_emergency_stop and level == 'danger' \\\\\\n and re.search('emergency stop', line, re.IGNORECASE):\\n\\n if error_summary == '':\\n error_summary = initialize_error_summary()\\n else:\\n error_summary = error_summary + '\\\\n'\\n\\n error_summary = error_summary + (\\n \\\"\\\\t<li>We detected an emergency stop during one of the TeX\\\"\\n \\\" compilation runs. Please review the compilation log\\\"\\n \\\" to determie whether there is a serious issue with \\\"\\n \\\"your submission source.</li>\\\")\\n\\n have_detected_emergency_stop = True\\n\\n # We found a match so we are finished with this line\\n break\\n\\n # Append line to new marked up log\\n new_log = new_log + line + '\\\\n'\\n\\n if error_summary:\\n error_summary = finalize_error_summary(error_summary)\\n\\n # Now that we are done highlighting the autotex log we are able to roughly\\n # determine/refine the status of a successful compilation.\\n # Note that all submissions in 'Failed' status have warnings/errors we are not\\n # sure about. When status is 'Succeeded' we are only concerned with warnings in\\n # last run.\\n status_class = 'success'\\n if compilation_status == 'failed':\\n status_class = 'fatal'\\n if have_detected_xetex_luatex:\\n display_status = \\\"Failed: XeTeX/LuaTeX are not supported at current time.\\\"\\n elif have_detected_missing_file:\\n display_status = \\\"Failed: File not found.\\\"\\n else:\\n display_status = \\\"Failed\\\"\\n elif compilation_status == 'succeeded':\\n if final_run_had_errors and not final_run_had_warnings:\\n display_status = (\\\"Succeeded with possible errors. \\\"\\n \\\"\\\\n\\\\t\\\\tBe sure to carefully inspect log (see below).\\\")\\n status_class = 'danger'\\n elif not final_run_had_errors and final_run_had_warnings:\\n display_status = (\\\"Succeeded with warnings. We recommend that you \\\"\\n \\\"\\\\n\\\\t\\\\tinspect the log (see below).\\\")\\n status_class = 'warning'\\n elif final_run_had_errors and final_run_had_warnings:\\n display_status = (\\\"Succeeded with (possibly significant) errors and \\\"\\n \\\"warnings. \\\\n\\\\t\\\\tPlease be sure to carefully inspect \\\"\\n \\\"log (see below).\\\")\\n status_class = 'danger'\\n else:\\n display_status = f\\\"Succeeded!\\\"\\n status_class = 'success'\\n else:\\n status_class = 'warning'\\n display_status = \\\"Succeeded with warnings\\\"\\n\\n status_line = f\\\"\\\\nProcessing Status: <span class=\\\\\\\"tex-{status_class}\\\\\\\">{display_status}</span>\\\\n\\\\n\\\"\\n\\n # Put together a nice report, list TeX runs, markup info, and marked up log.\\n # In future we can add 'Recommendation' section or collect critical errors.\\n new_log = run_summary + status_line + error_summary + key_summary \\\\\\n + '\\\\n\\\\n<b>Marked Up Log:</b>\\\\n\\\\n' + new_log\\n\\n return new_log\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6886761","0.6039708","0.60122496","0.60070854","0.60053575","0.5946325","0.5929492","0.5887831","0.5874886","0.58744806","0.58705306","0.5813472","0.5802365","0.5799912","0.5730037","0.5696503","0.56834877","0.56523955","0.56515515","0.56502163","0.56331104","0.5629142","0.5609509","0.5601098","0.5601098","0.559939","0.5589234","0.55827796","0.55812854","0.5534337","0.55256104","0.5510004","0.5479184","0.54738075","0.5471049","0.54591393","0.5457055","0.54519135","0.54336745","0.54308295","0.54250073","0.5418398","0.541686","0.5411466","0.5406261","0.54039884","0.5402514","0.5398913","0.5394731","0.5391474","0.53899854","0.53800935","0.53786474","0.53596425","0.5354089","0.5346717","0.5333992","0.53226334","0.53218496","0.5299385","0.52926666","0.5292271","0.5278529","0.5271459","0.52609414","0.52602404","0.5259842","0.52593744","0.5259251","0.52569425","0.5251223","0.5247252","0.5245957","0.5242618","0.5237638","0.52315205","0.52286065","0.5218122","0.5218122","0.5218122","0.5218122","0.5218122","0.5218122","0.5215421","0.52141654","0.52070755","0.5199703","0.5199703","0.51978236","0.5188821","0.518851","0.51857513","0.51847476","0.51843995","0.5179177","0.51787305","0.51787305","0.5171493","0.5171023","0.51709133","0.5164245"],"string":"[\n \"0.6886761\",\n \"0.6039708\",\n \"0.60122496\",\n \"0.60070854\",\n \"0.60053575\",\n \"0.5946325\",\n \"0.5929492\",\n \"0.5887831\",\n \"0.5874886\",\n \"0.58744806\",\n \"0.58705306\",\n \"0.5813472\",\n \"0.5802365\",\n \"0.5799912\",\n \"0.5730037\",\n \"0.5696503\",\n \"0.56834877\",\n \"0.56523955\",\n \"0.56515515\",\n \"0.56502163\",\n \"0.56331104\",\n \"0.5629142\",\n \"0.5609509\",\n \"0.5601098\",\n \"0.5601098\",\n \"0.559939\",\n \"0.5589234\",\n \"0.55827796\",\n \"0.55812854\",\n \"0.5534337\",\n \"0.55256104\",\n \"0.5510004\",\n \"0.5479184\",\n \"0.54738075\",\n \"0.5471049\",\n \"0.54591393\",\n \"0.5457055\",\n \"0.54519135\",\n \"0.54336745\",\n \"0.54308295\",\n \"0.54250073\",\n \"0.5418398\",\n \"0.541686\",\n \"0.5411466\",\n \"0.5406261\",\n \"0.54039884\",\n \"0.5402514\",\n \"0.5398913\",\n \"0.5394731\",\n \"0.5391474\",\n \"0.53899854\",\n \"0.53800935\",\n \"0.53786474\",\n \"0.53596425\",\n \"0.5354089\",\n \"0.5346717\",\n \"0.5333992\",\n \"0.53226334\",\n \"0.53218496\",\n \"0.5299385\",\n \"0.52926666\",\n \"0.5292271\",\n \"0.5278529\",\n \"0.5271459\",\n \"0.52609414\",\n \"0.52602404\",\n \"0.5259842\",\n \"0.52593744\",\n \"0.5259251\",\n \"0.52569425\",\n \"0.5251223\",\n \"0.5247252\",\n \"0.5245957\",\n \"0.5242618\",\n \"0.5237638\",\n \"0.52315205\",\n \"0.52286065\",\n \"0.5218122\",\n \"0.5218122\",\n \"0.5218122\",\n \"0.5218122\",\n \"0.5218122\",\n \"0.5218122\",\n \"0.5215421\",\n \"0.52141654\",\n \"0.52070755\",\n \"0.5199703\",\n \"0.5199703\",\n \"0.51978236\",\n \"0.5188821\",\n \"0.518851\",\n \"0.51857513\",\n \"0.51847476\",\n \"0.51843995\",\n \"0.5179177\",\n \"0.51787305\",\n \"0.51787305\",\n \"0.5171493\",\n \"0.5171023\",\n \"0.51709133\",\n \"0.5164245\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":25596,"cells":{"query":{"kind":"string","value":"Gets the prepopulated environment variables for the job build"},"document":{"kind":"string","value":"def get_env_vars(self):\n env_vars_api = '/injectedEnvVars/api/json'\n env_vars_json = self._api_request(self.url + env_vars_api)\n try:\n env_vars_json = json.loads(env_vars_json)\n return env_vars_json['envMap']\n except JSONDecodeError:\n return None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def build_env_vars(self):\n return _untag_env_vars(self._tagged_env_vars, build=True)","def environment_variables(\n self,\n ) -> typing.Optional[\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\n ]:\n return self._values.get(\"environment_variables\")","def environment_variables(\n self,\n ) -> typing.Optional[\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\n ]:\n return self._values.get(\"environment_variables\")","def environment_variables(\n self,\n ) -> typing.Optional[\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\n ]:\n return self._values.get(\"environment_variables\")","def environment_variables(\n self,\n ) -> typing.Optional[\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\n ]:\n return self._values.get(\"environment_variables\")","def _parse_jenkins_env_vars():\n # TODO find a way to get the socket number of\n os_cpu_socket = 'true'\n\n metadata = {\n 'jenkins': {\n 'jenkins_job_id': os.environ['BUILD_ID'],\n },\n 'github': {\n 'git_branch': os.environ['GIT_BRANCH'],\n 'git_commit_id': os.environ['GIT_COMMIT'],\n },\n 'environment': {\n 'os_version': ' '.join(distro.linux_distribution()),\n 'cpu_number': os.cpu_count(),\n 'cpu_socket': os_cpu_socket\n }\n }\n return metadata","def get_environment() -> dict:\n go_path = subprocess.check_output([\"go\", \"env\", \"GOPATH\"]).decode().strip()\n setup_script_path = f\"{go_path}/src/github.com/harmony-one/harmony/scripts/setup_bls_build_flags.sh\"\n response = subprocess.check_output([\"bash\", setup_script_path, \"-v\"], timeout=5)\n environment = json.loads(response)\n environment[\"HOME\"] = os.environ.get(\"HOME\")\n return environment","def getEnvironmentVars(self):\n my_env = os.environ.copy()\n my_env[\"MODE\"] = self.model.mode\n my_env[\"ALGORITHM\"] = self.model.algorithm\n my_env[\"INPUT_FILE\"] = self.model.inputFile\n my_env[\"TARGET_FILE\"] = self.model.targetFile\n my_env[\"DEVICE\"] = self.model.device\n my_env[\"SIZE\"] = str(self.model.size)\n my_env[\"ROLE\"] = self.model.role\n my_env[\"WAIT_SIZE\"] = str(self.model.waitSize)\n my_env[\"STEP_SIZE\"] = str(self.model.stepSize)\n my_env[\"TUI_CONNECTION\"] = str(True)\n return my_env","def getEnvironmentVars(var):\n \n if var['pbs-jobid'] is None:\n var['pbs-jobid'] = os.getenv(\"PBS_JOBID\")\n if var['pbs-jobid'] is None:\n logger.error(\"ERROR: Environment Variable PBS_JOBID not found!\")\n exit(1)\n\n return var","def _GetEnvironmentVars(benchmark_spec):\n return ' '.join([\n 'NUM_GPUS=%s' % benchmark_spec.total_gpus,\n 'OMP_NUM_THREADS=%s' % benchmark_spec.cpus_per_rank\n ])","def get_environmentals(self):\n for k, v in utils.slurm_envs(default.SBATCH_VARS_FOR_WORKFLOW).items():\n setattr(self, k, v)","def _generate_environment(self):\n envvars = {}\n for key in self.envvars:\n try:\n envvars[key] = os.environ[key]\n except KeyError:\n continue\n\n # Warn the user that we cannot support secrets\n if envvars:\n logger.warning(\"This API does not support environment secrets.\")\n return envvars","def _computeEnvVars(parent):\n result = {}\n requiredVars = [\n \"PATH\",\n \"PYTHONPATH\",\n \"LD_LIBRARY_PATH\",\n \"LD_PRELOAD\",\n \"DYLD_LIBRARY_PATH\",\n \"DYLD_INSERT_LIBRARIES\",\n ]\n\n optionalVars = [\n \"PYTHONHASHSEED\",\n \"KRB5_KTNAME\",\n \"ORACLE_HOME\",\n \"VERSIONER_PYTHON_PREFER_32_BIT\",\n ]\n\n for varname in requiredVars:\n result[varname] = parent.get(varname, \"\")\n for varname in optionalVars:\n if varname in parent:\n result[varname] = parent[varname]\n\n # Worker's stdXXX are piped, which ends up setting their encoding to None;\n # Have them inherit the master's encoding, even when being piped.\n result[\"PYTHONIOENCODING\"] = sys.stdout.encoding or \"UTF-8\"\n\n return result","def build_vars(self):\n return self._build_vars","def env_vars(self):\n return _untag_env_vars(self._tagged_env_vars, build=False)","def build_env(self, job, private_data_dir, private_data_files=None):\n env = super(RunJob, self).build_env(job, private_data_dir, private_data_files=private_data_files)\n if private_data_files is None:\n private_data_files = {}\n # Set environment variables needed for inventory and job event\n # callbacks to work.\n env['JOB_ID'] = str(job.pk)\n env['INVENTORY_ID'] = str(job.inventory.pk)\n if job.project:\n env['PROJECT_REVISION'] = job.project.scm_revision\n env['ANSIBLE_RETRY_FILES_ENABLED'] = \"False\"\n env['MAX_EVENT_RES'] = str(settings.MAX_EVENT_RES_DATA)\n if hasattr(settings, 'AWX_ANSIBLE_CALLBACK_PLUGINS') and settings.AWX_ANSIBLE_CALLBACK_PLUGINS:\n env['ANSIBLE_CALLBACK_PLUGINS'] = ':'.join(settings.AWX_ANSIBLE_CALLBACK_PLUGINS)\n env['AWX_HOST'] = settings.TOWER_URL_BASE\n\n # Create a directory for ControlPath sockets that is unique to each job\n cp_dir = os.path.join(private_data_dir, 'cp')\n if not os.path.exists(cp_dir):\n os.mkdir(cp_dir, 0o700)\n # FIXME: more elegant way to manage this path in container\n env['ANSIBLE_SSH_CONTROL_PATH_DIR'] = '/runner/cp'\n\n # Set environment variables for cloud credentials.\n cred_files = private_data_files.get('credentials', {})\n for cloud_cred in job.cloud_credentials:\n if cloud_cred and cloud_cred.credential_type.namespace == 'openstack' and cred_files.get(cloud_cred, ''):\n env['OS_CLIENT_CONFIG_FILE'] = to_container_path(cred_files.get(cloud_cred, ''), private_data_dir)\n\n for network_cred in job.network_credentials:\n env['ANSIBLE_NET_USERNAME'] = network_cred.get_input('username', default='')\n env['ANSIBLE_NET_PASSWORD'] = network_cred.get_input('password', default='')\n\n ssh_keyfile = cred_files.get(network_cred, '')\n if ssh_keyfile:\n env['ANSIBLE_NET_SSH_KEYFILE'] = ssh_keyfile\n\n authorize = network_cred.get_input('authorize', default=False)\n env['ANSIBLE_NET_AUTHORIZE'] = str(int(authorize))\n if authorize:\n env['ANSIBLE_NET_AUTH_PASS'] = network_cred.get_input('authorize_password', default='')\n\n path_vars = (\n ('ANSIBLE_COLLECTIONS_PATHS', 'collections_paths', 'requirements_collections', '~/.ansible/collections:/usr/share/ansible/collections'),\n ('ANSIBLE_ROLES_PATH', 'roles_path', 'requirements_roles', '~/.ansible/roles:/usr/share/ansible/roles:/etc/ansible/roles'),\n ('ANSIBLE_COLLECTIONS_PATH', 'collections_path', 'requirements_collections', '~/.ansible/collections:/usr/share/ansible/collections'),\n )\n\n config_values = read_ansible_config(os.path.join(private_data_dir, 'project'), list(map(lambda x: x[1], path_vars)))\n\n for env_key, config_setting, folder, default in path_vars:\n paths = default.split(':')\n if env_key in env:\n for path in env[env_key].split(':'):\n if path not in paths:\n paths = [env[env_key]] + paths\n elif config_setting in config_values:\n for path in config_values[config_setting].split(':'):\n if path not in paths:\n paths = [config_values[config_setting]] + paths\n paths = [os.path.join(CONTAINER_ROOT, folder)] + paths\n env[env_key] = os.pathsep.join(paths)\n\n return env","def get_environment_vars():\n return {env: os.environ[env] for env in\n params.ENV_DIRS if env in os.environ}","def get_env_vars():\n return [EnvVar(name=k, value=v) for (k, v) in os.environ.items() if k.startswith('LEAPP_') and k not in ENV_IGNORE]","def _get_environment_variables(cluster):\n # Make environment variables for the shell commands\n shell_env = {}\n shell_env[\"OMP_NUM_THREADS\"] = cluster.num_vcores\n shell_env[\"GRAPHLAB_MEMORY_LIMIT_IN_MB\"] = cluster.container_size * .8\n shell_env[\"TURI_PORT_START\"] = cluster.start_port\n shell_env[\"TURI_PORT_END\"] = cluster.end_port\n # Overwrite environment for SFrame cache capacity. Being conservative, we use default 1/5 of the container size.\n for key in ['GRAPHLAB_FILEIO_MAXIMUM_CACHE_CAPACITY', 'GRAPHLAB_FILEIO_MAXIMUM_CACHE_CAPACITY_PER_FILE']:\n if key in os.environ:\n shell_env[key] = os.environ[key]\n else:\n shell_env[key] = cluster.container_size * 1024 * 1024 * .2\n\n # Overwrite environment for SFrame cache file location.\n if cluster.node_tmp_dir:\n shell_env['GRAPHLAB_CACHE_FILE_LOCATIONS'] = cluster.node_tmp_dir\n if cluster.hdfs_tmp_dir:\n shell_env['GRAPHLAB_CACHE_FILE_HDFS_LOCATION'] = cluster.hdfs_tmp_dir\n return shell_env","def get_env_vars():\n env_vars = []\n leapp_vars = {k: v for (k, v) in os.environ.items() if k.startswith('LEAPP_') and k not in ENV_IGNORE}\n for k, v in leapp_vars.items():\n if k in ENV_MAPPING:\n env_vars.append(EnvVar(name=ENV_MAPPING.get(k), value=v))\n continue\n env_vars.append(EnvVar(name=k, value=v))\n\n return env_vars","def _set_ci_environment_variables(parent_shell):\n variables_to_set = {\n \"JOBSTAMPS_ALWAYS_USE_HASHES\": \"1\",\n \"CLINT_FORCE_COLOR\": \"1\",\n \"PYTHONDONTWRITEBYTECODE\": \"1\"\n }\n\n for key, value in variables_to_set.items():\n os.environ[key] = value\n parent_shell.overwrite_environment_variable(key, value)","def environment_variables(self) -> Optional[pulumi.Input['GatewayPropertiesEnvironmentVariablesArgs']]:\n return pulumi.get(self, \"environment_variables\")","def _get_env(self):\n env = {}\n for k, v in os.environ.items():\n k = k.decode() if isinstance(k, bytes) else k\n v = v.decode() if isinstance(v, bytes) else v\n env[k] = v\n return list(env.items())","def copy_environment_variables(self) -> typing.Optional[typing.List[str]]:\n return self._values.get(\"copy_environment_variables\")","def copy_environment_variables(self) -> typing.Optional[typing.List[str]]:\n return self._values.get(\"copy_environment_variables\")","def copy_environment_variables(self) -> typing.Optional[typing.List[str]]:\n return self._values.get(\"copy_environment_variables\")","def copy_environment_variables(self) -> typing.Optional[typing.List[str]]:\n return self._values.get(\"copy_environment_variables\")","def augmented_environment(self):\n env = os.environ.copy()\n env.update(self.environ)\n return env","def environment_variables(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:\n return pulumi.get(self, \"environment_variables\")","def _get_input_from_env():\n try:\n params = {\n 'repo': {\n 'owner': os.environ['DRONE_REPO_OWNER'],\n 'name': os.environ['DRONE_REPO_NAME'],\n 'full_name': os.environ['DRONE_REPO'],\n 'link_url': os.environ['DRONE_REPO_LINK'],\n 'clone_url': os.environ['DRONE_REMOTE_URL']\n },\n 'build': {\n 'number': os.environ['DRONE_BUILD_NUMBER'],\n 'event': os.environ['DRONE_BUILD_EVENT'],\n 'branch': os.environ['DRONE_BRANCH'],\n 'commit': os.environ['DRONE_COMMIT'],\n 'ref': os.environ['DRONE_COMMIT_REF'],\n 'author': os.environ['DRONE_COMMIT_AUTHOR'],\n 'author_email': os.environ['DRONE_COMMIT_AUTHOR_EMAIL']\n },\n 'workspace': {\n 'root': os.environ['DRONE_WORKSPACE'],\n 'path': os.environ['DRONE_WORKSPACE']\n },\n 'vargs': {\n key[7:].lower(): value\n for key, value in os.environ.items()\n if key.startswith('PLUGIN_')\n }\n }\n except KeyError:\n raise ValueError(\n \"Envronment variables were misconfigured.\")\n return json.dumps(params)","def concourse_env(self) -> Dict[str, str]:\n concourse_env_dict = {}\n for attr in self.__fields__.values():\n if attr.field_info.extra.get(\"concourse_env_var\"):\n attr_val = self.dict()[attr.name]\n if attr_val is not None:\n val_transform = attr.field_info.extra.get(\"env_transform\") or str\n concourse_env_dict[\n attr.field_info.extra.get(\"concourse_env_var\")\n ] = val_transform(attr_val)\n return concourse_env_dict","def env_vars(self):\n if self._m.spec and self._m.spec.container:\n return k8s_object.ListAsDictionaryWrapper(\n self._m.spec.container.env, self._messages.EnvVar)","def get(self):\n \n # read the env variables and store them\n for var in self._vars.itervalues():\n var.get()","def default_environment():\n return dict(_VARS)","def get_environment_configuration():\n\n try:\n time_limit = int(os.getenv('AUTOBOT_POST_TIMELIMIT'))\n except TypeError:\n time_limit = None\n\n # if we're using Redis Labs\n redis_cloud_url = os.getenv('REDISCLOUD_URL')\n\n if redis_cloud_url:\n url = urlparse.urlparse(redis_cloud_url)\n redis_host = url.hostname\n redis_port = url.port\n redis_password = url.password\n else:\n redis_host = os.getenv('AUTOBOT_REDIS_URL')\n redis_port = os.getenv('AUTOBOT_REDIS_PORT')\n redis_password = None\n\n override = {\n REDDIT_USERNAME: os.getenv('AUTOBOT_REDDIT_USERNAME'),\n REDDIT_PASSWORD: os.getenv('AUTOBOT_REDDIT_PASSWORD'),\n SUBREDDIT: os.getenv('AUTOBOT_SUBREDDIT'),\n CLIENT_ID: os.getenv('AUTOBOT_CLIENT_ID'),\n CLIENT_SECRET: os.getenv('AUTOBOT_CLIENT_SECRET'),\n POST_TIMELIMIT: time_limit,\n REDIS_BACKEND: os.getenv('AUTOBOT_REDIS_BACKEND'),\n REDIS_URL: redis_host,\n REDIS_PORT: redis_port,\n REDIS_PASSWORD: redis_password,\n ROLLBAR_ACCESS_TOKEN: os.getenv('ROLLBAR_ACCESS_TOKEN'),\n ROLLBAR_ENVIRONMENT: os.getenv('ROLLBAR_ENVIRONMENT')\n }\n\n # remove all the 'None' valued things\n return {k: v for k, v in override.items() if v is not None}","def prepare_env(args: argparse.Namespace) -> None:\n if os.environ.get(\"KATSDP_LOG_GELF_ADDRESS\"):\n extra = load_json_dict(os.environ.get(\"KATSDP_LOG_GELF_EXTRA\", \"{}\"))\n extra[\"subarray_product_id\"] = args.subarray_product_id\n os.environ[\"KATSDP_LOG_GELF_EXTRA\"] = json.dumps(extra)\n if not os.environ.get(\"KATSDP_LOG_GELF_LOCALNAME\"):\n os.environ[\"KATSDP_LOG_GELF_LOCALNAME\"] = args.external_hostname","def __MakeEnvironment(self):\n environment= os.environ.copy()\n\n for key, value in self.__context.items():\n if type(value) is str:\n name = \"QMV_\" + key.replace(\".\", \"__\")\n environment[name]= value\n\n return environment","def get_undercloud_env_vars():\n\n # Handle backward compatibile OSCI enviornment variables\n _vars = {}\n _vars['net_id'] = os.environ.get('NET_ID')\n _vars['external_dns'] = os.environ.get('NAMESERVER')\n _vars['default_gateway'] = os.environ.get('GATEWAY')\n _vars['external_net_cidr'] = os.environ.get('CIDR_EXT')\n\n # Take FIP_RANGE and create start and end floating ips\n _fip_range = os.environ.get('FIP_RANGE')\n if _fip_range and ':' in _fip_range:\n _vars['start_floating_ip'] = os.environ.get('FIP_RANGE').split(':')[0]\n _vars['end_floating_ip'] = os.environ.get('FIP_RANGE').split(':')[1]\n\n # Env var naming consistent with zaza.configure.network functions takes\n # priority. Override backward compatible settings.\n _keys = ['default_gateway',\n 'start_floating_ip',\n 'end_floating_ip',\n 'external_dns',\n 'external_net_cidr']\n for _key in _keys:\n _val = os.environ.get(_key)\n if _val:\n _vars[_key] = _val\n\n # Remove keys and items with a None value\n for k, v in list(_vars.items()):\n if not v:\n del _vars[k]\n\n return _vars","def update_environ():\n\n # Environment variables to set.\n BASE = os.getcwd()\n PLUGINS = os.path.join(BASE, 'lib')\n RESOURCES = os.path.join(BASE, 'res')\n MODELS = os.path.join(RESOURCES, 'models')\n\n # Set the vaue to '' to set the var to ''.\n # Anything else will be added to current var value.\n minimapper_env = {\n 'GAZEBO_RESOURCE_PATH': RESOURCES,\n 'GAZEBO_MODEL_PATH': MODELS,\n 'GAZEBO_PLUGIN_PATH': PLUGINS,\n 'GAZEBO_MODEL_DATABASE_URI': None\n }\n\n # Conditionally set environment variables.\n env = os.environ.copy()\n for key, val in minimapper_env.items():\n if val is None:\n env[key] = ''\n elif key not in env:\n env[key] = val\n elif key in env and val not in env[key]:\n env[key] = val + ':' + env[key]\n\n return env","def user_env_file(self, job=None) -> list:\n logger = getLogger(__name__)\n result = []\n # Look if any env file or variables were defined in the step/dag\n if job:\n (_, env_filename) = mkstemp(prefix=\"aiscalator_\", text=True)\n with open(env_filename, mode=\"w\") as env_file:\n # concatenate all the env files and variables into one\n for env in job:\n if isinstance(env, pyhocon.config_tree.ConfigTree):\n for k in env.keys():\n env_file.write(k + '=' + env.get(k) + '\\n')\n elif os.path.isfile(os.path.join(self.root_dir(), env)):\n with open(os.path.join(self.root_dir(), env),\n mode=\"r\") as file:\n for line in file:\n env_file.write(line)\n else:\n msg = (\"Undefined env\" + env +\n \": expecting a dict of environment variables\" +\n \" or path to environment configuration file.\")\n logger.warning(\"Warning %s\", msg)\n result.append(env_filename)\n # TODO look in user config if env file has been redefined\n result.append(\n os.path.join(self.app_config_home(), \"config\", \".env\")\n )\n return result","def _preload_existing_vars(prefix: str) -> Store:\n if not prefix:\n # If prefix is empty just return all the env variables.\n return environ\n\n prefixed = {}\n\n # Prefix is not empty, do the search and replacement:\n for env_name, env_value in environ.items():\n if not env_name.startswith(prefix):\n # Skip vars with no prefix.\n continue\n\n prefixed[env_name.replace(prefix, '', 1)] = env_value\n\n return prefixed","def get_environ():\n # Manually set environment.\n if FLAGS.env is not None:\n return BasicEnvironment.from_json(open(FLAGS.env, \"r\").read())\n\n if FLAGS.data_folder is None:\n data_folder = FLAGS.dataset\n else:\n data_folder = FLAGS.data_folder\n exp_id = \"exp_\" + FLAGS.dataset + \"_\" + FLAGS.model\n if FLAGS.id is None:\n exp_id = gen_id(exp_id)\n else:\n exp_id = FLAGS.id\n return BasicEnvironment(\n device=get_device(FLAGS.gpu),\n dataset=FLAGS.dataset,\n data_folder=data_folder,\n logs_folder=FLAGS.logs,\n save_folder=FLAGS.results,\n run_validation=FLAGS.validation,\n verbose=FLAGS.verbose,\n exp_id=exp_id,\n description=FLAGS.description,\n valid_num_fold=FLAGS.valid_num_fold,\n valid_fold_id=FLAGS.valid_fold_id)","def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EnvVarArgs']]]]:\n return pulumi.get(self, \"env\")","def env(self): # type: () -> t.List[str]\n return self.config['Env']","def _preload_specific_vars(env_keys: Set[str]) -> Store:\n specified = {}\n\n for env_name, env_value in environ.items():\n if env_name not in env_keys:\n # Skip vars that have not been requested.\n continue\n\n specified[env_name] = env_value\n\n return specified","def user_env(self):\n\n # FIXME I think the JPY_ variables have been deprecated in JupyterHub\n # since 0.7.2, we should replace them. Can we figure this out?\n\n env = super(EC2Spawner, self).get_env()\n env.update(dict(\n JUPYTERHUB_PREFIX=self.hub.server.base_url,\n Name='Jupyter',\n PATH=self.path\n ))\n\n if self.notebook_dir:\n env['NOTEBOOK_DIR'] = self.notebook_dir\n\n hub_api_url = self.hub.api_url\n if self.hub_api_url != '':\n hub_api_url = self.hub_api_url\n\n env['JPY_HUB_API_URL'] = hub_api_url\n env['JUPYTERHUB_API_URL'] = hub_api_url\n\n self.log.debug(\"Env built: {}\".format(env))\n return env","def set_env(self, propagated_env_vars={}):\n os.environ['BUILD_ROOT'] = self.build_root\n # This is how we tell run-test.sh what set of C++ binaries to use for mini-clusters in Java\n # tests.\n for env_var_name, env_var_value in propagated_env_vars.iteritems():\n os.environ[env_var_name] = env_var_value","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _init_env_variables(self):\n raise NotImplementedError()","def _set_environment_vars(self):\n os.environ[\"PATH\"] = os.path.join(self.source_folder, \"depot_tools\") + os.pathsep + os.environ[\"PATH\"]\n os.environ[\"DEPOT_TOOLS_PATH\"] = os.path.join(self.source_folder, \"depot_tools\")\n if tools.os_info.is_windows:\n os.environ[\"DEPOT_TOOLS_WIN_TOOLCHAIN\"] = \"0\"\n os.environ[\"GYP_MSVS_VERSION\"] = \"2017\" if str(self.settings.compiler.version) == \"15\" else \"2019\"","def read_environ():\n\n environ = {}\n environ['BASEDIR'] = os.environ['TS_BASEDIR']\n environ['CONFIG_NL'] = os.environ['TS_CONFIG_NL']\n environ['NL_TS_SWITCH'] = os.environ['TS_NL_TS_SWITCH']\n environ['DT_FILE'] = os.environ['TS_DT_FILE']\n environ['REFOUTDIR'] = os.environ['TS_REFOUTDIR']\n environ['VERBOSE'] = os.environ['TS_VERBOSE']\n environ['RUNDIR'] = os.environ['TS_RUNDIR']\n environ['LOGFILE'] = os.environ['TS_LOGFILE']\n environ['NAMELISTDIR'] = os.environ['TS_NAMELISTDIR']\n environ['TOLERANCE'] = os.environ['TS_TOLERANCE']\n environ['FORCEMATCH'] = os.environ['TS_FORCEMATCH']\n environ['TUNING_ITERATIONS'] = os.environ['TS_TUNING_ITERATIONS']\n environ['TUNE_THRESHOLDS'] = os.environ['TS_TUNE_THRESHOLDS']\n environ['RESET_THRESHOLDS'] = os.environ['TS_RESET_THRESHOLDS']\n environ['ICON'] = os.environ['TS_ICON']\n environ['YUFILE'] = os.environ['TS_YUFILE']\n return environ","def _setenv(self):\n tokens = {}\n tokens[\"CT_TIMESTAMP\"] = self._timestamp\n tokens[\"CT_SUBMITTER\"] = self._node.name()\n # tokens[\"CT_HIPBASE\"] = self._file[\"hipbase\"]\n tokens[\"CT_SCENE\"] = self._scene\n tokens[\"CT_PROJECT\"] = self.project_name\n\n for token in tokens:\n hou.putenv(token, tokens[token])\n\n return tokens","def _create_extra_environment(self):\n return {}","def get_command_env(self) -> Sequence[Mapping[str, str]]:\n return [\n {\"name\": \"DAGSTER_COMPRESSED_EXECUTE_STEP_ARGS\", \"value\": self._get_compressed_args()},\n ]","def getEnvironment(self):\n pass","def env_vars(prefix):\n return {k: v for k, v in os.environ.items() if k.startswith(prefix)}","def _setup_env(self):\n\n os.environ['GIT_NAME'] = statiki.GIT_NAME\n os.environ['GIT_EMAIL'] = statiki.GIT_EMAIL\n os.environ['GH_TOKEN'] = 'this-is-a-bogus-token:password'\n os.environ['TRAVIS_REPO_SLUG'] = TEST_REPO\n\n return","def read_environment(self):\n # Setup credentials\n if os.getenv(\"DO_API_TOKEN\"):\n self.api_token = os.getenv(\"DO_API_TOKEN\")\n if os.getenv(\"DO_API_KEY\"):\n self.api_token = os.getenv(\"DO_API_KEY\")","def awx_meta_vars(self):\n r = {}\n for name in JOB_VARIABLE_PREFIXES:\n r['{}_job_id'.format(name)] = self.pk\n r['{}_job_launch_type'.format(name)] = self.launch_type\n\n created_by = getattr_dne(self, 'created_by')\n\n wj = self.get_workflow_job()\n if wj:\n schedule = getattr_dne(wj, 'schedule')\n for name in JOB_VARIABLE_PREFIXES:\n r['{}_workflow_job_id'.format(name)] = wj.pk\n r['{}_workflow_job_name'.format(name)] = wj.name\n r['{}_workflow_job_launch_type'.format(name)] = wj.launch_type\n if schedule:\n r['{}_parent_job_schedule_id'.format(name)] = schedule.pk\n r['{}_parent_job_schedule_name'.format(name)] = schedule.name\n\n if not created_by:\n schedule = getattr_dne(self, 'schedule')\n if schedule:\n for name in JOB_VARIABLE_PREFIXES:\n r['{}_schedule_id'.format(name)] = schedule.pk\n r['{}_schedule_name'.format(name)] = schedule.name\n\n if created_by:\n for name in JOB_VARIABLE_PREFIXES:\n r['{}_user_id'.format(name)] = created_by.pk\n r['{}_user_name'.format(name)] = created_by.username\n r['{}_user_email'.format(name)] = created_by.email\n r['{}_user_first_name'.format(name)] = created_by.first_name\n r['{}_user_last_name'.format(name)] = created_by.last_name\n\n inventory = getattr_dne(self, 'inventory')\n if inventory:\n for name in JOB_VARIABLE_PREFIXES:\n r['{}_inventory_id'.format(name)] = inventory.pk\n r['{}_inventory_name'.format(name)] = inventory.name\n\n return r","def environment(self):\n return self._environ","def __get_vars(self):\n if self.resolved_vars:\n return self.resolved_vars\n return self.config_vars","def env(self) -> Optional[Sequence['_core.v1.outputs.EnvVarPatch']]:\n return pulumi.get(self, \"env\")","def parse_env():\n os_env = {}\n try:\n os_env[\"github_token\"] = os.environ[\"GITHUB_TOKEN\"]\n os_env[\"github_repository\"] = os.environ[\"GITHUB_REPOSITORY\"]\n os_env[\"threshold\"] = int(os.environ[\"THRESHOLD\"])\n os_env[\"slack_channel\"] = os.environ[\"SLACK_CHANNEL\"]\n os_env[\"slack_token\"] = os.environ[\"SLACK_TOKEN\"]\n os_env[\"sleep_interval\"] = int(os.environ[\"SLEEP_INTERVAL\"])\n return os_env\n except KeyError as e:\n logging.error(f\"failed to retrieve variable from env: {e}\")\n return {}","def collect_env():\n env_info = mmengine_collect_env()\n\n # MMEngine does not add the hipcc compiler information when collecting\n # environment information, so it is added here. When MMEngine v0.3.0 is\n # released, the code here can be removed.\n cuda_available = torch.cuda.is_available()\n if cuda_available and env_info.get('NVCC') == 'Not Available':\n CUDA_HOME = env_info['CUDA_HOME']\n if CUDA_HOME is not None and osp.isdir(CUDA_HOME):\n if CUDA_HOME == '/opt/rocm':\n try:\n nvcc = osp.join(CUDA_HOME, 'hip/bin/hipcc')\n nvcc = subprocess.check_output(\n f'\"{nvcc}\" --version', shell=True)\n nvcc = nvcc.decode('utf-8').strip()\n release = nvcc.rfind('HIP version:')\n build = nvcc.rfind('')\n nvcc = nvcc[release:build].strip()\n except subprocess.SubprocessError:\n nvcc = 'Not Available'\n else:\n try:\n nvcc = osp.join(CUDA_HOME, 'bin/nvcc')\n nvcc = subprocess.check_output(f'\"{nvcc}\" -V', shell=True)\n nvcc = nvcc.decode('utf-8').strip()\n release = nvcc.rfind('Cuda compilation tools')\n build = nvcc.rfind('Build ')\n nvcc = nvcc[release:build].strip()\n except subprocess.SubprocessError:\n nvcc = 'Not Available'\n env_info['NVCC'] = nvcc\n\n env_info['MMCV'] = mmcv.__version__\n\n try:\n from mmcv.ops import get_compiler_version, get_compiling_cuda_version\n except ModuleNotFoundError:\n env_info['MMCV Compiler'] = 'n/a'\n env_info['MMCV CUDA Compiler'] = 'n/a'\n else:\n env_info['MMCV Compiler'] = get_compiler_version()\n env_info['MMCV CUDA Compiler'] = get_compiling_cuda_version()\n\n return env_info","def get_formatted_env_vars() -> str:\n res = \"\"\n for k, v in os.environ.items():\n res += '{0}={1}\\n'.format(k, v)\n return res","def set_envs(self):\n # pylint:disable=protected-access\n # Need to call sys.__getframe() to get the filename and method/func\n # for logging information.\n\n # Useful for logging\n # Logging output: TIME UTC |TYPE (DEBUG, INFO, WARNING, etc.) |\n # [File : function]| Message\n cur_filename = sys._getframe().f_code.co_filename\n cur_function = sys._getframe().f_code.co_name\n\n self.logger.info('Setting env variables from config file...')\n # Set all the environment variables that are needed by the\n # MET config file.\n\n tmp_amodel = self.c_dict['AMODEL']\n if tmp_amodel:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_amodel_str = str(tmp_amodel).replace(\"\\'\", \"\\\"\")\n tmp_amodel = ''.join(tmp_amodel_str.split())\n self.add_env_var('AMODEL', tmp_amodel)\n else:\n self.add_env_var('AMODEL', \"[]\")\n\n tmp_bmodel = self.c_dict['BMODEL']\n if tmp_bmodel:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_bmodel_str = str(tmp_bmodel).replace(\"\\'\", \"\\\"\")\n tmp_bmodel = ''.join(tmp_bmodel_str.split())\n self.add_env_var('BMODEL', tmp_bmodel)\n else:\n self.add_env_var('BMODEL', \"[]\")\n\n tmp_desc = self.c_dict['DESC']\n if tmp_desc:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_desc_str = str(tmp_desc).replace(\"\\'\", \"\\\"\")\n tmp_desc = ''.join(tmp_desc_str.split())\n self.add_env_var('DESC', tmp_desc)\n else:\n self.add_env_var('DESC', \"[]\")\n\n tmp_storm_id = self.c_dict['STORM_ID']\n if tmp_storm_id:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_storm_id_str = str(tmp_storm_id).replace(\"\\'\", \"\\\"\")\n tmp_storm_id = ''.join(tmp_storm_id_str.split())\n self.add_env_var('STORM_ID', tmp_storm_id)\n else:\n self.add_env_var('STORM_ID', \"[]\")\n\n tmp_basin = self.c_dict['BASIN']\n if tmp_basin:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_basin_str = str(tmp_basin).replace(\"\\'\", \"\\\"\")\n tmp_basin = ''.join(tmp_basin_str.split())\n self.add_env_var('BASIN', tmp_basin)\n else:\n self.add_env_var('BASIN', \"[]\")\n\n tmp_cyclone = self.c_dict['CYCLONE']\n if tmp_cyclone:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_cyclone_str = str(tmp_cyclone).replace(\"\\'\", \"\\\"\")\n tmp_cyclone = ''.join(tmp_cyclone_str.strip())\n self.add_env_var('CYCLONE', tmp_cyclone)\n else:\n self.add_env_var('CYCLONE', \"[]\")\n\n tmp_storm_name = self.c_dict['STORM_NAME']\n if tmp_storm_name:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_storm_name_str = str(tmp_storm_name).replace(\"\\'\", \"\\\"\")\n tmp_storm_name = ''.join(tmp_storm_name_str.strip())\n self.add_env_var('STORM_NAME', tmp_storm_name)\n else:\n self.add_env_var('STORM_NAME', \"[]\")\n\n if self.c_dict['INIT_BEG']:\n self.add_env_var('INIT_BEG', self.c_dict['INIT_BEG'])\n else:\n self.add_env_var('INIT_BEG', \"\")\n\n if self.c_dict['INIT_END']:\n self.add_env_var('INIT_END', self.c_dict['INIT_END'])\n else:\n self.add_env_var('INIT_END', \"\")\n\n tmp_init_include = self.c_dict['INIT_INCLUDE']\n if tmp_init_include:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_init_include_str = str(tmp_init_include).replace(\"\\'\", \"\\\"\")\n tmp_init_include = ''.join(tmp_init_include_str.strip())\n self.add_env_var('INIT_INCLUDE', tmp_init_include)\n else:\n self.add_env_var('INIT_INCLUDE', \"[]\")\n\n tmp_init_exclude = self.c_dict['INIT_EXCLUDE']\n if tmp_init_exclude:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_init_exclude_str = str(tmp_init_exclude).replace(\"\\'\", \"\\\"\")\n tmp_init_exclude = ''.join(tmp_init_exclude_str.strip())\n self.add_env_var('INIT_EXCLUDE', tmp_init_exclude)\n else:\n self.add_env_var('INIT_EXCLUDE', \"[]\")\n\n tmp_init_hour = self.c_dict['INIT_HOUR']\n if tmp_init_hour:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_init_hour_str = str(tmp_init_hour).replace(\"\\'\", \"\\\"\")\n tmp_init_hour = ''.join(tmp_init_hour_str.split())\n self.add_env_var('INIT_HOUR', tmp_init_hour)\n else:\n self.add_env_var('INIT_HOUR', \"[]\")\n\n tmp_valid_begin = self.c_dict['VALID_BEG']\n if tmp_valid_begin:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_valid_begin_str = str(tmp_valid_begin).replace(\"\\'\", \"\\\"\")\n tmp_valid_begin = ''.join(tmp_valid_begin_str.strip())\n self.add_env_var('VALID_BEG', tmp_valid_begin)\n else:\n self.add_env_var('VALID_BEG', '')\n\n tmp_valid_end = self.c_dict['VALID_END']\n if tmp_valid_end:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_valid_end_str = str(tmp_valid_end).replace(\"\\'\", \"\\\"\")\n tmp_valid_end = ''.join(tmp_valid_end_str.strip())\n self.add_env_var('VALID_END', tmp_valid_end)\n else:\n self.add_env_var('VALID_END', \"\")\n\n tmp_valid_include = self.c_dict['VALID_INCLUDE']\n if tmp_valid_include:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_valid_include_str = str(tmp_valid_include).replace(\"\\'\", \"\\\"\")\n tmp_valid_include = ''.join(tmp_valid_include_str.strip())\n self.add_env_var('VALID_INCLUDE', tmp_valid_include)\n else:\n self.add_env_var('VALID_INCLUDE', \"[]\")\n\n tmp_valid_exclude = self.c_dict['VALID_EXCLUDE']\n if tmp_valid_exclude:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_valid_exclude_str = str(tmp_valid_exclude).replace(\"\\'\", \"\\\"\")\n tmp_valid_exclude = ''.join(tmp_valid_exclude_str.strip())\n self.add_env_var('VALID_EXCLUDE', tmp_valid_exclude)\n else:\n self.add_env_var('VALID_EXCLUDE', \"[]\")\n\n tmp_valid_hour = self.c_dict['VALID_HOUR']\n if tmp_valid_hour:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_valid_hour_str = str(tmp_valid_hour).replace(\"\\'\", \"\\\"\")\n tmp_valid_hour = ''.join(tmp_valid_hour_str.strip())\n self.add_env_var('VALID_HOUR', tmp_valid_hour)\n else:\n self.add_env_var('VALID_HOUR', \"[]\")\n\n tmp_lead_req = self.c_dict['LEAD_REQ']\n if tmp_lead_req:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_lead_req_str = str(tmp_lead_req).replace(\"\\'\", \"\\\"\")\n tmp_lead_req = ''.join(tmp_lead_req_str.strip())\n self.add_env_var('LEAD_REQ', tmp_lead_req)\n else:\n self.add_env_var('LEAD_REQ', \"[]\")\n\n tmp_lead = self.c_dict['LEAD']\n if tmp_lead:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_lead_str = str(tmp_lead).replace(\"\\'\", \"\\\"\")\n tmp_lead = ''.join(tmp_lead_str.strip())\n self.add_env_var('LEAD', tmp_lead)\n else:\n self.add_env_var('LEAD', \"[]\")\n\n tmp_init_mask = self.c_dict['INIT_MASK']\n if tmp_init_mask:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_init_mask_str = str(tmp_init_mask).replace(\"\\'\", \"\\\"\")\n tmp_init_mask = ''.join(tmp_init_mask_str.strip())\n self.add_env_var('INIT_MASK', tmp_init_mask)\n else:\n self.add_env_var('INIT_MASK', \"[]\")\n\n tmp_valid_mask = self.c_dict['VALID_MASK']\n if tmp_valid_mask:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_valid_mask_str = str(tmp_valid_mask).replace(\"\\'\", \"\\\"\")\n tmp_valid_mask = ''.join(tmp_valid_mask_str.strip())\n self.add_env_var('VALID_MASK', tmp_valid_mask)\n else:\n self.add_env_var('VALID_MASK', \"[]\")\n\n tmp_track_watch_warn = self.c_dict['TRACK_WATCH_WARN']\n if tmp_track_watch_warn:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_track_watch_warn_str = str(tmp_track_watch_warn).replace(\"\\'\",\n \"\\\"\")\n tmp_track_watch_warn = ''.join(tmp_track_watch_warn_str.strip())\n self.add_env_var('TRACK_WATCH_WARN', tmp_track_watch_warn)\n else:\n self.add_env_var('TRACK_WATCH_WARN', \"[]\")\n\n tmp_column_thresh_name = self.c_dict['COLUMN_THRESH_NAME']\n if tmp_column_thresh_name:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_column_thresh_name_str = str(tmp_column_thresh_name).replace(\n \"\\'\", \"\\\"\")\n tmp_column_thresh_name = ''.join(tmp_column_thresh_name_str.strip())\n self.add_env_var('COLUMN_THRESH_NAME', tmp_column_thresh_name)\n else:\n self.add_env_var('COLUMN_THRESH_NAME', \"[]\")\n\n tmp_column_thresh_val = self.c_dict['COLUMN_THRESH_VAL']\n if tmp_column_thresh_val:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_column_thresh_val_str = str(tmp_column_thresh_val).replace(\"\\'\",\n \"\\\"\")\n tmp_column_thresh_val = ''.join(tmp_column_thresh_val_str.strip())\n self.add_env_var('COLUMN_THRESH_VAL', tmp_column_thresh_val)\n else:\n self.add_env_var('COLUMN_THRESH_VAL', \"[]\")\n\n tmp_column_str_name = self.c_dict['COLUMN_STR_NAME']\n if tmp_column_str_name:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_column_str_name = str(tmp_column_str_name).replace(\"\\'\",\n \"\\\"\")\n tmp_column_str_name = ''.join(tmp_column_str_name.strip())\n self.add_env_var('COLUMN_STR_NAME', tmp_column_str_name)\n else:\n self.add_env_var('COLUMN_STR_NAME', \"[]\")\n\n tmp_column_str_val = self.c_dict['COLUMN_STR_VAL']\n if tmp_column_str_val:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_column_str_val_str = str(tmp_column_str_val).replace(\"\\'\", \"\\\"\")\n tmp_column_str_val = ''.join(tmp_column_str_val_str.strip())\n self.add_env_var('COLUMN_STR_VAL', tmp_column_str_val)\n else:\n self.add_env_var('COLUMN_STR_VAL', \"[]\")\n\n tmp_init_thresh_name = self.c_dict['INIT_THRESH_NAME']\n if tmp_init_thresh_name:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_init_thresh_name_str = str(tmp_init_thresh_name).replace(\"\\'\",\n \"\\\"\")\n tmp_init_thresh_name = ''.join(tmp_init_thresh_name_str.strip())\n\n self.add_env_var('INIT_THRESH_NAME', tmp_init_thresh_name)\n\n else:\n self.add_env_var('INIT_THRESH_NAME', \"[]\")\n\n tmp_init_thresh_val = self.c_dict['INIT_THRESH_VAL']\n if tmp_init_thresh_val:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_init_thresh_val_str = str(tmp_init_thresh_val).replace(\"\\'\",\n \"\\\"\")\n tmp_init_thresh_val = ''.join(tmp_init_thresh_val_str.strip())\n self.add_env_var('INIT_THRESH_VAL', tmp_init_thresh_val)\n else:\n self.add_env_var('INIT_THRESH_VAL', \"[]\")\n\n tmp_init_str_name = self.c_dict['INIT_STR_NAME']\n if tmp_init_str_name:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_init_str_name_str = str(tmp_init_str_name).replace(\"\\'\", \"\\\"\")\n tmp_init_str_name = ''.join(tmp_init_str_name_str.strip())\n self.add_env_var('INIT_STR_NAME', tmp_init_str_name)\n else:\n self.add_env_var('INIT_STR_NAME', \"[]\")\n\n tmp_init_str_val = self.c_dict['INIT_STR_VAL']\n if tmp_init_str_val:\n # Replace any single quotes with double quotes and remove any\n # whitespace\n tmp_init_str_val_str = str(tmp_init_str_val).replace(\"\\'\", \"\\\"\")\n tmp_init_str_val = ''.join(tmp_init_str_val_str.strip())\n self.add_env_var('INIT_STR_VAL', tmp_init_str_val)\n else:\n self.add_env_var('INIT_STR_VAL', \"[]\")\n\n # boolean values for WATER_ONLY\n if self.c_dict['WATER_ONLY']:\n flag = \"TRUE\"\n else:\n flag = \"FALSE\"\n self.add_env_var('WATER_ONLY', flag)\n\n # boolean value for LANDFALL\n if self.c_dict['LANDFALL']:\n flag = \"TRUE\"\n else:\n flag = \"FALSE\"\n self.add_env_var('LANDFALL', flag)\n\n if self.c_dict['LANDFALL_BEG']:\n self.add_env_var('LANDFALL_BEG',\n self.c_dict['LANDFALL_BEG'])\n else:\n # Set to default\n self.add_env_var('LANDFALL_BEG', '-24')\n\n if self.c_dict['LANDFALL_END']:\n self.add_env_var('LANDFALL_END',\n self.c_dict['LANDFALL_END'])\n else:\n # Set to default\n self.add_env_var('LANDFALL_END', '00')\n\n # boolean value for MATCH_POINTS\n if self.c_dict['MATCH_POINTS'] == 'true':\n flag = \"TRUE\"\n else:\n flag = \"FALSE\"\n self.add_env_var('MATCH_POINTS', flag)\n\n if self.c_dict['CONFIG_FILE']:\n self.add_env_var('CONFIG_FILE',\n self.c_dict['CONFIG_FILE'])\n else:\n self.log_error(\n cur_filename + '|' + cur_function +\n ': no MET TC-Stat config file found. Exiting')\n sys.exit(1)\n\n jobs_list_tmp = self.c_dict['JOBS_LIST']\n if jobs_list_tmp:\n # MET is expecting a string\n jobs_list_str = '\"' + jobs_list_tmp + '\"'\n self.add_env_var('JOBS', jobs_list_str)\n else:\n self.log_error('No jobs list defined. Please check your METplus'\n 'config file. Exiting...')\n sys.exit(1)\n return 0","def test_get_environment_string(self):\n pass","def compute_env_var(self):\n return COMPUTE_SETTINGS_VARNAME","def MakeEnvironment(self, context):\n\n # Start with any environment variables that are already present\n # in the environment.\n environment = os.environ.copy()\n # Copy context variables into the environment.\n for key, value in context.items():\n name = \"QMV_\" + key\n environment[name] = value\n return environment","def _all_env_vars_to_dict(self):\n all_env_vars = {}\n for k, v in self.env.items():\n c_vars = {}\n for x, y in v['vars'].items():\n c_vars[f'{k}_{x}'] = y['value']\n all_env_vars = {**all_env_vars, **c_vars}\n return all_env_vars","def wrapper_environment(args):\n\n return {\n ENVIRONMENT_KEY: json.dumps({\n 'verbose': args.verbose,\n 'cc': shlex.split(args.cc),\n 'cxx': shlex.split(args.cxx)\n })\n }","def env(self):\n return spack.schema.environment.parse(self.conf.get(\"environment\", {}))","def collect_env():\n env_info = {}\n env_info['sys.platform'] = sys.platform\n env_info['Python'] = sys.version.replace('\\n', '')\n\n cuda_available = torch.cuda.is_available()\n env_info['CUDA available'] = cuda_available\n\n if cuda_available:\n devices = defaultdict(list)\n for k in range(torch.cuda.device_count()):\n devices[torch.cuda.get_device_name(k)].append(str(k))\n for name, device_ids in devices.items():\n env_info['GPU ' + ','.join(device_ids)] = name\n\n from mmcv.utils.parrots_wrapper import _get_cuda_home\n CUDA_HOME = _get_cuda_home()\n env_info['CUDA_HOME'] = CUDA_HOME\n\n if CUDA_HOME is not None and osp.isdir(CUDA_HOME):\n try:\n nvcc = osp.join(CUDA_HOME, 'bin/nvcc')\n nvcc = subprocess.check_output(f'\"{nvcc}\" -V', shell=True)\n nvcc = nvcc.decode('utf-8').strip()\n release = nvcc.rfind('Cuda compilation tools')\n build = nvcc.rfind('Build ')\n nvcc = nvcc[release:build].strip()\n except subprocess.SubprocessError:\n nvcc = 'Not Available'\n env_info['NVCC'] = nvcc\n\n try:\n # Check C++ Compiler.\n # For Unix-like, sysconfig has 'CC' variable like 'gcc -pthread ...',\n # indicating the compiler used, we use this to get the compiler name\n import sysconfig\n cc = sysconfig.get_config_var('CC')\n if cc:\n cc = osp.basename(cc.split()[0])\n cc_info = subprocess.check_output(f'{cc} --version', shell=True)\n env_info['GCC'] = cc_info.decode('utf-8').partition(\n '\\n')[0].strip()\n else:\n # on Windows, cl.exe is not in PATH. We need to find the path.\n # distutils.ccompiler.new_compiler() returns a msvccompiler\n # object and after initialization, path to cl.exe is found.\n import locale\n import os\n from distutils.ccompiler import new_compiler\n ccompiler = new_compiler()\n ccompiler.initialize()\n cc = subprocess.check_output(\n f'{ccompiler.cc}', stderr=subprocess.STDOUT, shell=True)\n encoding = os.device_encoding(\n sys.stdout.fileno()) or locale.getpreferredencoding()\n env_info['MSVC'] = cc.decode(encoding).partition('\\n')[0].strip()\n env_info['GCC'] = 'n/a'\n except subprocess.CalledProcessError:\n env_info['GCC'] = 'n/a'\n\n env_info['PyTorch'] = torch.__version__\n env_info['PyTorch compiling details'] = get_build_config()\n\n try:\n import torchvision\n env_info['TorchVision'] = torchvision.__version__\n except ModuleNotFoundError:\n pass\n\n env_info['OpenCV'] = cv2.__version__\n\n env_info['MMCV'] = mmcv.__version__\n\n try:\n from mmcv.ops import get_compiler_version, get_compiling_cuda_version\n except ModuleNotFoundError:\n env_info['MMCV Compiler'] = 'n/a'\n env_info['MMCV CUDA Compiler'] = 'n/a'\n else:\n env_info['MMCV Compiler'] = get_compiler_version()\n env_info['MMCV CUDA Compiler'] = get_compiling_cuda_version()\n\n return env_info","def load_env_variables(self, environment):\n env_dir = os.path.join(self.__get_environments_root_dir(), environment)\n return read_and_combine_yamls_in_dir(env_dir)","def get_os_env():\n env = os.environ\n# print(\"env \\n\" , env)\n return env","def dist_env():\n trainer_id = int(os.getenv(\"PADDLE_TRAINER_ID\", \"0\"))\n num_trainers = 1\n training_role = os.getenv(\"PADDLE_TRAINING_ROLE\", \"TRAINER\")\n assert (training_role == \"PSERVER\" or training_role == \"TRAINER\")\n\n # - PADDLE_TRAINER_ENDPOINTS means nccl2 mode.\n # - PADDLE_PSERVER_ENDPOINTS means pserver mode.\n # - PADDLE_CURRENT_ENDPOINT means current process endpoint.\n trainer_endpoints = os.getenv(\"PADDLE_TRAINER_ENDPOINTS\")\n pserver_endpoints = os.getenv(\"PADDLE_PSERVER_ENDPOINTS\")\n current_endpoint = os.getenv(\"PADDLE_CURRENT_ENDPOINT\")\n if trainer_endpoints:\n trainer_endpoints = trainer_endpoints.split(\",\")\n num_trainers = len(trainer_endpoints)\n elif pserver_endpoints:\n num_trainers = int(os.getenv(\"PADDLE_TRAINERS_NUM\"))\n\n return {\n \"trainer_id\": trainer_id,\n \"num_trainers\": num_trainers,\n \"current_endpoint\": current_endpoint,\n \"training_role\": training_role,\n \"pserver_endpoints\": pserver_endpoints,\n \"trainer_endpoints\": trainer_endpoints\n }","def get_elinos_environment():\n result = {}\n for key in (\"project\", \"cdk\", \"target\"):\n var = \"ELINOS_\" + key.upper()\n if var in os.environ:\n result[key] = os.environ[var]\n else:\n warn(\"%s not set\" % var)\n result[key] = None\n\n if result[\"project\"] is not None:\n result[\"xenomai\"] = glob.glob(result[\"project\"] + \"/xenomai-[0-9.]*\")\n else:\n result[\"xenomai\"] = []\n\n return result","def get_current_environment():\n # Search for the environment variable set by the hutch python setup\n env = os.getenv('CONDA_ENVNAME')\n # Otherwise look for built-in Conda environment variables\n if not env:\n env = os.getenv('CONDA_DEFAULT_ENV')\n # Check the top level PYTHONPATH to see if we have packages installed in\n # development mode\n dev = os.getenv('PYTHONPATH')\n if dev:\n try:\n dev_pkgs = os.listdir(dev)\n except FileNotFoundError:\n logger.debug(\"No dev folder found\")\n dev_pkgs = list()\n else:\n dev_pkgs = list()\n return env, dev_pkgs","def build_env(self, instance, private_data_dir, private_data_files=None):\n env = {}\n # Add ANSIBLE_* settings to the subprocess environment.\n for attr in dir(settings):\n if attr == attr.upper() and attr.startswith('ANSIBLE_'):\n env[attr] = str(getattr(settings, attr))\n # Also set environment variables configured in AWX_TASK_ENV setting.\n for key, value in settings.AWX_TASK_ENV.items():\n env[key] = str(value)\n\n env['AWX_PRIVATE_DATA_DIR'] = private_data_dir\n\n if self.instance.execution_environment is None:\n raise RuntimeError(f'The {self.model.__name__} could not run because there is no Execution Environment.')\n\n return env","def _build_env(self, args):\n env = os.environ.copy()\n env['ANSIBLE_CONFIG'] = os.path.join(ANSIBLE_DIR, 'ansible.cfg')\n if hasattr(args, 'stdout_callback'):\n env['ANSIBLE_STDOUT_CALLBACK'] = args.stdout_callback\n return env","def _prepare_publish_environments():\n env = copy.deepcopy(os.environ)\n\n project_name = os.getenv(\"AVALON_PROJECT\")\n asset_name = os.getenv(\"AVALON_ASSET\")\n\n env[\"AVALON_PROJECT\"] = project_name\n env[\"AVALON_ASSET\"] = asset_name\n env[\"AVALON_TASK\"] = os.getenv(\"AVALON_TASK\")\n env[\"AVALON_WORKDIR\"] = os.getenv(\"AVALON_WORKDIR\")\n env[\"AVALON_APP\"] = f\"hosts.{publish_host}\"\n env[\"AVALON_APP_NAME\"] = \"celaction/local\"\n\n env[\"PYBLISH_HOSTS\"] = publish_host\n\n os.environ.update(env)","def environment_properties(self) -> Optional[pulumi.Input['ApplicationApplicationConfigurationEnvironmentPropertiesArgs']]:\n return pulumi.get(self, \"environment_properties\")","def init_vars(self):\n\n load_dotenv()\n self.smart_cube = True if os.environ.get(\"SMART_CUBE\") == \"True\" else False\n self.gen_parsed_to_cubedb = True if os.environ.get(\"GEN_PARSED_TO_CUBEDB\") == \"True\" else False\n self.name_of_solve = os.environ.get(\"NAME_OF_SOLVE\")\n self.time_solve = os.environ.get(\"TIME_SOLVE\")\n self.comms_unparsed_bool = True if os.environ.get(\"COMMS_UNPARSED\") == \"True\" else False\n self.gen_with_move_count = True if os.environ.get(\"GEN_WITH_MOVE_COUNT\") == \"True\" else False\n self.diff_to_solved_state = float(os.environ.get(\"DIFF_BETWEEN_ALGS\"))\n self.parse_to_lp = True if os.environ.get(\"PARSE_TO_LETTER_PAIR\") == \"True\" else False\n self.gen_with_moves = True if os.environ.get(\"GEN_WITH_MOVE_COUNT\") == \"True\" else False\n self.buffer_ed = self.get_buffer_ed(os.environ.get(\"EDGES_BUFFER\"))\n self.buffer_cor = self.get_buffer_cor(os.environ.get(\"CORNER_BUFFER\"))\n self.path_to_lp = os.environ.get(\"PATH_LETTER_PAIR_FILE\")\n self.dict_lp = self.load_letter_pairs_dict()","def global_jinja_env():\n return _ENV","def env_from(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EnvFromSourceArgs']]]]:\n return pulumi.get(self, \"env_from\")","def env_config():\n # setup\n env = {'ELB_GCP_PROJECT': 'expected-gcp-project',\n 'ELB_GCP_REGION': 'expected-gcp-region',\n 'ELB_GCP_ZONE': 'expected-gcp-zone',\n 'ELB_BATCH_LEN': '93',\n 'ELB_CLUSTER_NAME': 'expected-cluster-name',\n 'ELB_RESULTS': 'gs://expected-results',\n 'ELB_USE_PREEMPTIBLE': 'true',\n 'ELB_BID_PERCENTAGE': '91'}\n\n for var_name in env:\n os.environ[var_name] = str(env[var_name])\n\n yield env\n\n # cleanup\n for var_name in env:\n # os.unsetenv does not work on every system\n del os.environ[var_name]","def get_env_copy(self):\n if self._env:\n return cloudpickle.loads(cloudpickle.dumps(self._env))\n else:\n return None","def env(self):\n return self._env","def get_env(self, loop):\n env = getattr(self.app, 'env', None)\n if not env:\n env = self.environment(self.app, loop, self.host, self.port)\n self.app.env = env\n return env","def _prepend_env_paths(content, names):\n export_env_vars = ['export %(k)s=%(v)s:${%(k)s}' %dict(\n k=name, v=os.environ.get(name, '')) for name in names]\n return '\\n'.join(export_env_vars + [content])","def environ(self):\n return dict(environment=request.environ)","def environ(self):\n return dict(environment=request.environ)","def environ(self):\n return dict(environment=request.environ)","def constructor_env_variables(loader, node):\n value = loader.construct_scalar(node)\n match = pattern.findall(value) # to find all env variables in line\n if match:\n full_value = value\n for g in match:\n full_value = full_value.replace(\n f'${{{g}}}', os.environ.get(g, g)\n )\n return full_value\n return value","def setup_environment(self):\n self.run_command(\"cd {}\".format(quote(str(self.builddir))))\n env_vars = self._build_env_variables_string()\n if env_vars:\n env_vars = quote(env_vars)\n command = \"{} DISTRO={} MACHINE={} . {} build-{}\".format(\n env_vars,\n quote(self.distro),\n quote(self.machine),\n quote(self.init_env_file),\n quote(self.distro),\n )\n self.run_command(command)","def _build_jupyter_env(kedro_env: str) -> Dict[str, Any]:\n if not kedro_env:\n return {}\n jupyter_env = os.environ.copy()\n jupyter_env[KEDRO_ENV_VAR] = kedro_env\n return {\"env\": jupyter_env}"],"string":"[\n \"def build_env_vars(self):\\n return _untag_env_vars(self._tagged_env_vars, build=True)\",\n \"def environment_variables(\\n self,\\n ) -> typing.Optional[\\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\\n ]:\\n return self._values.get(\\\"environment_variables\\\")\",\n \"def environment_variables(\\n self,\\n ) -> typing.Optional[\\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\\n ]:\\n return self._values.get(\\\"environment_variables\\\")\",\n \"def environment_variables(\\n self,\\n ) -> typing.Optional[\\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\\n ]:\\n return self._values.get(\\\"environment_variables\\\")\",\n \"def environment_variables(\\n self,\\n ) -> typing.Optional[\\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\\n ]:\\n return self._values.get(\\\"environment_variables\\\")\",\n \"def _parse_jenkins_env_vars():\\n # TODO find a way to get the socket number of\\n os_cpu_socket = 'true'\\n\\n metadata = {\\n 'jenkins': {\\n 'jenkins_job_id': os.environ['BUILD_ID'],\\n },\\n 'github': {\\n 'git_branch': os.environ['GIT_BRANCH'],\\n 'git_commit_id': os.environ['GIT_COMMIT'],\\n },\\n 'environment': {\\n 'os_version': ' '.join(distro.linux_distribution()),\\n 'cpu_number': os.cpu_count(),\\n 'cpu_socket': os_cpu_socket\\n }\\n }\\n return metadata\",\n \"def get_environment() -> dict:\\n go_path = subprocess.check_output([\\\"go\\\", \\\"env\\\", \\\"GOPATH\\\"]).decode().strip()\\n setup_script_path = f\\\"{go_path}/src/github.com/harmony-one/harmony/scripts/setup_bls_build_flags.sh\\\"\\n response = subprocess.check_output([\\\"bash\\\", setup_script_path, \\\"-v\\\"], timeout=5)\\n environment = json.loads(response)\\n environment[\\\"HOME\\\"] = os.environ.get(\\\"HOME\\\")\\n return environment\",\n \"def getEnvironmentVars(self):\\n my_env = os.environ.copy()\\n my_env[\\\"MODE\\\"] = self.model.mode\\n my_env[\\\"ALGORITHM\\\"] = self.model.algorithm\\n my_env[\\\"INPUT_FILE\\\"] = self.model.inputFile\\n my_env[\\\"TARGET_FILE\\\"] = self.model.targetFile\\n my_env[\\\"DEVICE\\\"] = self.model.device\\n my_env[\\\"SIZE\\\"] = str(self.model.size)\\n my_env[\\\"ROLE\\\"] = self.model.role\\n my_env[\\\"WAIT_SIZE\\\"] = str(self.model.waitSize)\\n my_env[\\\"STEP_SIZE\\\"] = str(self.model.stepSize)\\n my_env[\\\"TUI_CONNECTION\\\"] = str(True)\\n return my_env\",\n \"def getEnvironmentVars(var):\\n \\n if var['pbs-jobid'] is None:\\n var['pbs-jobid'] = os.getenv(\\\"PBS_JOBID\\\")\\n if var['pbs-jobid'] is None:\\n logger.error(\\\"ERROR: Environment Variable PBS_JOBID not found!\\\")\\n exit(1)\\n\\n return var\",\n \"def _GetEnvironmentVars(benchmark_spec):\\n return ' '.join([\\n 'NUM_GPUS=%s' % benchmark_spec.total_gpus,\\n 'OMP_NUM_THREADS=%s' % benchmark_spec.cpus_per_rank\\n ])\",\n \"def get_environmentals(self):\\n for k, v in utils.slurm_envs(default.SBATCH_VARS_FOR_WORKFLOW).items():\\n setattr(self, k, v)\",\n \"def _generate_environment(self):\\n envvars = {}\\n for key in self.envvars:\\n try:\\n envvars[key] = os.environ[key]\\n except KeyError:\\n continue\\n\\n # Warn the user that we cannot support secrets\\n if envvars:\\n logger.warning(\\\"This API does not support environment secrets.\\\")\\n return envvars\",\n \"def _computeEnvVars(parent):\\n result = {}\\n requiredVars = [\\n \\\"PATH\\\",\\n \\\"PYTHONPATH\\\",\\n \\\"LD_LIBRARY_PATH\\\",\\n \\\"LD_PRELOAD\\\",\\n \\\"DYLD_LIBRARY_PATH\\\",\\n \\\"DYLD_INSERT_LIBRARIES\\\",\\n ]\\n\\n optionalVars = [\\n \\\"PYTHONHASHSEED\\\",\\n \\\"KRB5_KTNAME\\\",\\n \\\"ORACLE_HOME\\\",\\n \\\"VERSIONER_PYTHON_PREFER_32_BIT\\\",\\n ]\\n\\n for varname in requiredVars:\\n result[varname] = parent.get(varname, \\\"\\\")\\n for varname in optionalVars:\\n if varname in parent:\\n result[varname] = parent[varname]\\n\\n # Worker's stdXXX are piped, which ends up setting their encoding to None;\\n # Have them inherit the master's encoding, even when being piped.\\n result[\\\"PYTHONIOENCODING\\\"] = sys.stdout.encoding or \\\"UTF-8\\\"\\n\\n return result\",\n \"def build_vars(self):\\n return self._build_vars\",\n \"def env_vars(self):\\n return _untag_env_vars(self._tagged_env_vars, build=False)\",\n \"def build_env(self, job, private_data_dir, private_data_files=None):\\n env = super(RunJob, self).build_env(job, private_data_dir, private_data_files=private_data_files)\\n if private_data_files is None:\\n private_data_files = {}\\n # Set environment variables needed for inventory and job event\\n # callbacks to work.\\n env['JOB_ID'] = str(job.pk)\\n env['INVENTORY_ID'] = str(job.inventory.pk)\\n if job.project:\\n env['PROJECT_REVISION'] = job.project.scm_revision\\n env['ANSIBLE_RETRY_FILES_ENABLED'] = \\\"False\\\"\\n env['MAX_EVENT_RES'] = str(settings.MAX_EVENT_RES_DATA)\\n if hasattr(settings, 'AWX_ANSIBLE_CALLBACK_PLUGINS') and settings.AWX_ANSIBLE_CALLBACK_PLUGINS:\\n env['ANSIBLE_CALLBACK_PLUGINS'] = ':'.join(settings.AWX_ANSIBLE_CALLBACK_PLUGINS)\\n env['AWX_HOST'] = settings.TOWER_URL_BASE\\n\\n # Create a directory for ControlPath sockets that is unique to each job\\n cp_dir = os.path.join(private_data_dir, 'cp')\\n if not os.path.exists(cp_dir):\\n os.mkdir(cp_dir, 0o700)\\n # FIXME: more elegant way to manage this path in container\\n env['ANSIBLE_SSH_CONTROL_PATH_DIR'] = '/runner/cp'\\n\\n # Set environment variables for cloud credentials.\\n cred_files = private_data_files.get('credentials', {})\\n for cloud_cred in job.cloud_credentials:\\n if cloud_cred and cloud_cred.credential_type.namespace == 'openstack' and cred_files.get(cloud_cred, ''):\\n env['OS_CLIENT_CONFIG_FILE'] = to_container_path(cred_files.get(cloud_cred, ''), private_data_dir)\\n\\n for network_cred in job.network_credentials:\\n env['ANSIBLE_NET_USERNAME'] = network_cred.get_input('username', default='')\\n env['ANSIBLE_NET_PASSWORD'] = network_cred.get_input('password', default='')\\n\\n ssh_keyfile = cred_files.get(network_cred, '')\\n if ssh_keyfile:\\n env['ANSIBLE_NET_SSH_KEYFILE'] = ssh_keyfile\\n\\n authorize = network_cred.get_input('authorize', default=False)\\n env['ANSIBLE_NET_AUTHORIZE'] = str(int(authorize))\\n if authorize:\\n env['ANSIBLE_NET_AUTH_PASS'] = network_cred.get_input('authorize_password', default='')\\n\\n path_vars = (\\n ('ANSIBLE_COLLECTIONS_PATHS', 'collections_paths', 'requirements_collections', '~/.ansible/collections:/usr/share/ansible/collections'),\\n ('ANSIBLE_ROLES_PATH', 'roles_path', 'requirements_roles', '~/.ansible/roles:/usr/share/ansible/roles:/etc/ansible/roles'),\\n ('ANSIBLE_COLLECTIONS_PATH', 'collections_path', 'requirements_collections', '~/.ansible/collections:/usr/share/ansible/collections'),\\n )\\n\\n config_values = read_ansible_config(os.path.join(private_data_dir, 'project'), list(map(lambda x: x[1], path_vars)))\\n\\n for env_key, config_setting, folder, default in path_vars:\\n paths = default.split(':')\\n if env_key in env:\\n for path in env[env_key].split(':'):\\n if path not in paths:\\n paths = [env[env_key]] + paths\\n elif config_setting in config_values:\\n for path in config_values[config_setting].split(':'):\\n if path not in paths:\\n paths = [config_values[config_setting]] + paths\\n paths = [os.path.join(CONTAINER_ROOT, folder)] + paths\\n env[env_key] = os.pathsep.join(paths)\\n\\n return env\",\n \"def get_environment_vars():\\n return {env: os.environ[env] for env in\\n params.ENV_DIRS if env in os.environ}\",\n \"def get_env_vars():\\n return [EnvVar(name=k, value=v) for (k, v) in os.environ.items() if k.startswith('LEAPP_') and k not in ENV_IGNORE]\",\n \"def _get_environment_variables(cluster):\\n # Make environment variables for the shell commands\\n shell_env = {}\\n shell_env[\\\"OMP_NUM_THREADS\\\"] = cluster.num_vcores\\n shell_env[\\\"GRAPHLAB_MEMORY_LIMIT_IN_MB\\\"] = cluster.container_size * .8\\n shell_env[\\\"TURI_PORT_START\\\"] = cluster.start_port\\n shell_env[\\\"TURI_PORT_END\\\"] = cluster.end_port\\n # Overwrite environment for SFrame cache capacity. Being conservative, we use default 1/5 of the container size.\\n for key in ['GRAPHLAB_FILEIO_MAXIMUM_CACHE_CAPACITY', 'GRAPHLAB_FILEIO_MAXIMUM_CACHE_CAPACITY_PER_FILE']:\\n if key in os.environ:\\n shell_env[key] = os.environ[key]\\n else:\\n shell_env[key] = cluster.container_size * 1024 * 1024 * .2\\n\\n # Overwrite environment for SFrame cache file location.\\n if cluster.node_tmp_dir:\\n shell_env['GRAPHLAB_CACHE_FILE_LOCATIONS'] = cluster.node_tmp_dir\\n if cluster.hdfs_tmp_dir:\\n shell_env['GRAPHLAB_CACHE_FILE_HDFS_LOCATION'] = cluster.hdfs_tmp_dir\\n return shell_env\",\n \"def get_env_vars():\\n env_vars = []\\n leapp_vars = {k: v for (k, v) in os.environ.items() if k.startswith('LEAPP_') and k not in ENV_IGNORE}\\n for k, v in leapp_vars.items():\\n if k in ENV_MAPPING:\\n env_vars.append(EnvVar(name=ENV_MAPPING.get(k), value=v))\\n continue\\n env_vars.append(EnvVar(name=k, value=v))\\n\\n return env_vars\",\n \"def _set_ci_environment_variables(parent_shell):\\n variables_to_set = {\\n \\\"JOBSTAMPS_ALWAYS_USE_HASHES\\\": \\\"1\\\",\\n \\\"CLINT_FORCE_COLOR\\\": \\\"1\\\",\\n \\\"PYTHONDONTWRITEBYTECODE\\\": \\\"1\\\"\\n }\\n\\n for key, value in variables_to_set.items():\\n os.environ[key] = value\\n parent_shell.overwrite_environment_variable(key, value)\",\n \"def environment_variables(self) -> Optional[pulumi.Input['GatewayPropertiesEnvironmentVariablesArgs']]:\\n return pulumi.get(self, \\\"environment_variables\\\")\",\n \"def _get_env(self):\\n env = {}\\n for k, v in os.environ.items():\\n k = k.decode() if isinstance(k, bytes) else k\\n v = v.decode() if isinstance(v, bytes) else v\\n env[k] = v\\n return list(env.items())\",\n \"def copy_environment_variables(self) -> typing.Optional[typing.List[str]]:\\n return self._values.get(\\\"copy_environment_variables\\\")\",\n \"def copy_environment_variables(self) -> typing.Optional[typing.List[str]]:\\n return self._values.get(\\\"copy_environment_variables\\\")\",\n \"def copy_environment_variables(self) -> typing.Optional[typing.List[str]]:\\n return self._values.get(\\\"copy_environment_variables\\\")\",\n \"def copy_environment_variables(self) -> typing.Optional[typing.List[str]]:\\n return self._values.get(\\\"copy_environment_variables\\\")\",\n \"def augmented_environment(self):\\n env = os.environ.copy()\\n env.update(self.environ)\\n return env\",\n \"def environment_variables(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"environment_variables\\\")\",\n \"def _get_input_from_env():\\n try:\\n params = {\\n 'repo': {\\n 'owner': os.environ['DRONE_REPO_OWNER'],\\n 'name': os.environ['DRONE_REPO_NAME'],\\n 'full_name': os.environ['DRONE_REPO'],\\n 'link_url': os.environ['DRONE_REPO_LINK'],\\n 'clone_url': os.environ['DRONE_REMOTE_URL']\\n },\\n 'build': {\\n 'number': os.environ['DRONE_BUILD_NUMBER'],\\n 'event': os.environ['DRONE_BUILD_EVENT'],\\n 'branch': os.environ['DRONE_BRANCH'],\\n 'commit': os.environ['DRONE_COMMIT'],\\n 'ref': os.environ['DRONE_COMMIT_REF'],\\n 'author': os.environ['DRONE_COMMIT_AUTHOR'],\\n 'author_email': os.environ['DRONE_COMMIT_AUTHOR_EMAIL']\\n },\\n 'workspace': {\\n 'root': os.environ['DRONE_WORKSPACE'],\\n 'path': os.environ['DRONE_WORKSPACE']\\n },\\n 'vargs': {\\n key[7:].lower(): value\\n for key, value in os.environ.items()\\n if key.startswith('PLUGIN_')\\n }\\n }\\n except KeyError:\\n raise ValueError(\\n \\\"Envronment variables were misconfigured.\\\")\\n return json.dumps(params)\",\n \"def concourse_env(self) -> Dict[str, str]:\\n concourse_env_dict = {}\\n for attr in self.__fields__.values():\\n if attr.field_info.extra.get(\\\"concourse_env_var\\\"):\\n attr_val = self.dict()[attr.name]\\n if attr_val is not None:\\n val_transform = attr.field_info.extra.get(\\\"env_transform\\\") or str\\n concourse_env_dict[\\n attr.field_info.extra.get(\\\"concourse_env_var\\\")\\n ] = val_transform(attr_val)\\n return concourse_env_dict\",\n \"def env_vars(self):\\n if self._m.spec and self._m.spec.container:\\n return k8s_object.ListAsDictionaryWrapper(\\n self._m.spec.container.env, self._messages.EnvVar)\",\n \"def get(self):\\n \\n # read the env variables and store them\\n for var in self._vars.itervalues():\\n var.get()\",\n \"def default_environment():\\n return dict(_VARS)\",\n \"def get_environment_configuration():\\n\\n try:\\n time_limit = int(os.getenv('AUTOBOT_POST_TIMELIMIT'))\\n except TypeError:\\n time_limit = None\\n\\n # if we're using Redis Labs\\n redis_cloud_url = os.getenv('REDISCLOUD_URL')\\n\\n if redis_cloud_url:\\n url = urlparse.urlparse(redis_cloud_url)\\n redis_host = url.hostname\\n redis_port = url.port\\n redis_password = url.password\\n else:\\n redis_host = os.getenv('AUTOBOT_REDIS_URL')\\n redis_port = os.getenv('AUTOBOT_REDIS_PORT')\\n redis_password = None\\n\\n override = {\\n REDDIT_USERNAME: os.getenv('AUTOBOT_REDDIT_USERNAME'),\\n REDDIT_PASSWORD: os.getenv('AUTOBOT_REDDIT_PASSWORD'),\\n SUBREDDIT: os.getenv('AUTOBOT_SUBREDDIT'),\\n CLIENT_ID: os.getenv('AUTOBOT_CLIENT_ID'),\\n CLIENT_SECRET: os.getenv('AUTOBOT_CLIENT_SECRET'),\\n POST_TIMELIMIT: time_limit,\\n REDIS_BACKEND: os.getenv('AUTOBOT_REDIS_BACKEND'),\\n REDIS_URL: redis_host,\\n REDIS_PORT: redis_port,\\n REDIS_PASSWORD: redis_password,\\n ROLLBAR_ACCESS_TOKEN: os.getenv('ROLLBAR_ACCESS_TOKEN'),\\n ROLLBAR_ENVIRONMENT: os.getenv('ROLLBAR_ENVIRONMENT')\\n }\\n\\n # remove all the 'None' valued things\\n return {k: v for k, v in override.items() if v is not None}\",\n \"def prepare_env(args: argparse.Namespace) -> None:\\n if os.environ.get(\\\"KATSDP_LOG_GELF_ADDRESS\\\"):\\n extra = load_json_dict(os.environ.get(\\\"KATSDP_LOG_GELF_EXTRA\\\", \\\"{}\\\"))\\n extra[\\\"subarray_product_id\\\"] = args.subarray_product_id\\n os.environ[\\\"KATSDP_LOG_GELF_EXTRA\\\"] = json.dumps(extra)\\n if not os.environ.get(\\\"KATSDP_LOG_GELF_LOCALNAME\\\"):\\n os.environ[\\\"KATSDP_LOG_GELF_LOCALNAME\\\"] = args.external_hostname\",\n \"def __MakeEnvironment(self):\\n environment= os.environ.copy()\\n\\n for key, value in self.__context.items():\\n if type(value) is str:\\n name = \\\"QMV_\\\" + key.replace(\\\".\\\", \\\"__\\\")\\n environment[name]= value\\n\\n return environment\",\n \"def get_undercloud_env_vars():\\n\\n # Handle backward compatibile OSCI enviornment variables\\n _vars = {}\\n _vars['net_id'] = os.environ.get('NET_ID')\\n _vars['external_dns'] = os.environ.get('NAMESERVER')\\n _vars['default_gateway'] = os.environ.get('GATEWAY')\\n _vars['external_net_cidr'] = os.environ.get('CIDR_EXT')\\n\\n # Take FIP_RANGE and create start and end floating ips\\n _fip_range = os.environ.get('FIP_RANGE')\\n if _fip_range and ':' in _fip_range:\\n _vars['start_floating_ip'] = os.environ.get('FIP_RANGE').split(':')[0]\\n _vars['end_floating_ip'] = os.environ.get('FIP_RANGE').split(':')[1]\\n\\n # Env var naming consistent with zaza.configure.network functions takes\\n # priority. Override backward compatible settings.\\n _keys = ['default_gateway',\\n 'start_floating_ip',\\n 'end_floating_ip',\\n 'external_dns',\\n 'external_net_cidr']\\n for _key in _keys:\\n _val = os.environ.get(_key)\\n if _val:\\n _vars[_key] = _val\\n\\n # Remove keys and items with a None value\\n for k, v in list(_vars.items()):\\n if not v:\\n del _vars[k]\\n\\n return _vars\",\n \"def update_environ():\\n\\n # Environment variables to set.\\n BASE = os.getcwd()\\n PLUGINS = os.path.join(BASE, 'lib')\\n RESOURCES = os.path.join(BASE, 'res')\\n MODELS = os.path.join(RESOURCES, 'models')\\n\\n # Set the vaue to '' to set the var to ''.\\n # Anything else will be added to current var value.\\n minimapper_env = {\\n 'GAZEBO_RESOURCE_PATH': RESOURCES,\\n 'GAZEBO_MODEL_PATH': MODELS,\\n 'GAZEBO_PLUGIN_PATH': PLUGINS,\\n 'GAZEBO_MODEL_DATABASE_URI': None\\n }\\n\\n # Conditionally set environment variables.\\n env = os.environ.copy()\\n for key, val in minimapper_env.items():\\n if val is None:\\n env[key] = ''\\n elif key not in env:\\n env[key] = val\\n elif key in env and val not in env[key]:\\n env[key] = val + ':' + env[key]\\n\\n return env\",\n \"def user_env_file(self, job=None) -> list:\\n logger = getLogger(__name__)\\n result = []\\n # Look if any env file or variables were defined in the step/dag\\n if job:\\n (_, env_filename) = mkstemp(prefix=\\\"aiscalator_\\\", text=True)\\n with open(env_filename, mode=\\\"w\\\") as env_file:\\n # concatenate all the env files and variables into one\\n for env in job:\\n if isinstance(env, pyhocon.config_tree.ConfigTree):\\n for k in env.keys():\\n env_file.write(k + '=' + env.get(k) + '\\\\n')\\n elif os.path.isfile(os.path.join(self.root_dir(), env)):\\n with open(os.path.join(self.root_dir(), env),\\n mode=\\\"r\\\") as file:\\n for line in file:\\n env_file.write(line)\\n else:\\n msg = (\\\"Undefined env\\\" + env +\\n \\\": expecting a dict of environment variables\\\" +\\n \\\" or path to environment configuration file.\\\")\\n logger.warning(\\\"Warning %s\\\", msg)\\n result.append(env_filename)\\n # TODO look in user config if env file has been redefined\\n result.append(\\n os.path.join(self.app_config_home(), \\\"config\\\", \\\".env\\\")\\n )\\n return result\",\n \"def _preload_existing_vars(prefix: str) -> Store:\\n if not prefix:\\n # If prefix is empty just return all the env variables.\\n return environ\\n\\n prefixed = {}\\n\\n # Prefix is not empty, do the search and replacement:\\n for env_name, env_value in environ.items():\\n if not env_name.startswith(prefix):\\n # Skip vars with no prefix.\\n continue\\n\\n prefixed[env_name.replace(prefix, '', 1)] = env_value\\n\\n return prefixed\",\n \"def get_environ():\\n # Manually set environment.\\n if FLAGS.env is not None:\\n return BasicEnvironment.from_json(open(FLAGS.env, \\\"r\\\").read())\\n\\n if FLAGS.data_folder is None:\\n data_folder = FLAGS.dataset\\n else:\\n data_folder = FLAGS.data_folder\\n exp_id = \\\"exp_\\\" + FLAGS.dataset + \\\"_\\\" + FLAGS.model\\n if FLAGS.id is None:\\n exp_id = gen_id(exp_id)\\n else:\\n exp_id = FLAGS.id\\n return BasicEnvironment(\\n device=get_device(FLAGS.gpu),\\n dataset=FLAGS.dataset,\\n data_folder=data_folder,\\n logs_folder=FLAGS.logs,\\n save_folder=FLAGS.results,\\n run_validation=FLAGS.validation,\\n verbose=FLAGS.verbose,\\n exp_id=exp_id,\\n description=FLAGS.description,\\n valid_num_fold=FLAGS.valid_num_fold,\\n valid_fold_id=FLAGS.valid_fold_id)\",\n \"def env(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EnvVarArgs']]]]:\\n return pulumi.get(self, \\\"env\\\")\",\n \"def env(self): # type: () -> t.List[str]\\n return self.config['Env']\",\n \"def _preload_specific_vars(env_keys: Set[str]) -> Store:\\n specified = {}\\n\\n for env_name, env_value in environ.items():\\n if env_name not in env_keys:\\n # Skip vars that have not been requested.\\n continue\\n\\n specified[env_name] = env_value\\n\\n return specified\",\n \"def user_env(self):\\n\\n # FIXME I think the JPY_ variables have been deprecated in JupyterHub\\n # since 0.7.2, we should replace them. Can we figure this out?\\n\\n env = super(EC2Spawner, self).get_env()\\n env.update(dict(\\n JUPYTERHUB_PREFIX=self.hub.server.base_url,\\n Name='Jupyter',\\n PATH=self.path\\n ))\\n\\n if self.notebook_dir:\\n env['NOTEBOOK_DIR'] = self.notebook_dir\\n\\n hub_api_url = self.hub.api_url\\n if self.hub_api_url != '':\\n hub_api_url = self.hub_api_url\\n\\n env['JPY_HUB_API_URL'] = hub_api_url\\n env['JUPYTERHUB_API_URL'] = hub_api_url\\n\\n self.log.debug(\\\"Env built: {}\\\".format(env))\\n return env\",\n \"def set_env(self, propagated_env_vars={}):\\n os.environ['BUILD_ROOT'] = self.build_root\\n # This is how we tell run-test.sh what set of C++ binaries to use for mini-clusters in Java\\n # tests.\\n for env_var_name, env_var_value in propagated_env_vars.iteritems():\\n os.environ[env_var_name] = env_var_value\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _init_env_variables(self):\\n raise NotImplementedError()\",\n \"def _set_environment_vars(self):\\n os.environ[\\\"PATH\\\"] = os.path.join(self.source_folder, \\\"depot_tools\\\") + os.pathsep + os.environ[\\\"PATH\\\"]\\n os.environ[\\\"DEPOT_TOOLS_PATH\\\"] = os.path.join(self.source_folder, \\\"depot_tools\\\")\\n if tools.os_info.is_windows:\\n os.environ[\\\"DEPOT_TOOLS_WIN_TOOLCHAIN\\\"] = \\\"0\\\"\\n os.environ[\\\"GYP_MSVS_VERSION\\\"] = \\\"2017\\\" if str(self.settings.compiler.version) == \\\"15\\\" else \\\"2019\\\"\",\n \"def read_environ():\\n\\n environ = {}\\n environ['BASEDIR'] = os.environ['TS_BASEDIR']\\n environ['CONFIG_NL'] = os.environ['TS_CONFIG_NL']\\n environ['NL_TS_SWITCH'] = os.environ['TS_NL_TS_SWITCH']\\n environ['DT_FILE'] = os.environ['TS_DT_FILE']\\n environ['REFOUTDIR'] = os.environ['TS_REFOUTDIR']\\n environ['VERBOSE'] = os.environ['TS_VERBOSE']\\n environ['RUNDIR'] = os.environ['TS_RUNDIR']\\n environ['LOGFILE'] = os.environ['TS_LOGFILE']\\n environ['NAMELISTDIR'] = os.environ['TS_NAMELISTDIR']\\n environ['TOLERANCE'] = os.environ['TS_TOLERANCE']\\n environ['FORCEMATCH'] = os.environ['TS_FORCEMATCH']\\n environ['TUNING_ITERATIONS'] = os.environ['TS_TUNING_ITERATIONS']\\n environ['TUNE_THRESHOLDS'] = os.environ['TS_TUNE_THRESHOLDS']\\n environ['RESET_THRESHOLDS'] = os.environ['TS_RESET_THRESHOLDS']\\n environ['ICON'] = os.environ['TS_ICON']\\n environ['YUFILE'] = os.environ['TS_YUFILE']\\n return environ\",\n \"def _setenv(self):\\n tokens = {}\\n tokens[\\\"CT_TIMESTAMP\\\"] = self._timestamp\\n tokens[\\\"CT_SUBMITTER\\\"] = self._node.name()\\n # tokens[\\\"CT_HIPBASE\\\"] = self._file[\\\"hipbase\\\"]\\n tokens[\\\"CT_SCENE\\\"] = self._scene\\n tokens[\\\"CT_PROJECT\\\"] = self.project_name\\n\\n for token in tokens:\\n hou.putenv(token, tokens[token])\\n\\n return tokens\",\n \"def _create_extra_environment(self):\\n return {}\",\n \"def get_command_env(self) -> Sequence[Mapping[str, str]]:\\n return [\\n {\\\"name\\\": \\\"DAGSTER_COMPRESSED_EXECUTE_STEP_ARGS\\\", \\\"value\\\": self._get_compressed_args()},\\n ]\",\n \"def getEnvironment(self):\\n pass\",\n \"def env_vars(prefix):\\n return {k: v for k, v in os.environ.items() if k.startswith(prefix)}\",\n \"def _setup_env(self):\\n\\n os.environ['GIT_NAME'] = statiki.GIT_NAME\\n os.environ['GIT_EMAIL'] = statiki.GIT_EMAIL\\n os.environ['GH_TOKEN'] = 'this-is-a-bogus-token:password'\\n os.environ['TRAVIS_REPO_SLUG'] = TEST_REPO\\n\\n return\",\n \"def read_environment(self):\\n # Setup credentials\\n if os.getenv(\\\"DO_API_TOKEN\\\"):\\n self.api_token = os.getenv(\\\"DO_API_TOKEN\\\")\\n if os.getenv(\\\"DO_API_KEY\\\"):\\n self.api_token = os.getenv(\\\"DO_API_KEY\\\")\",\n \"def awx_meta_vars(self):\\n r = {}\\n for name in JOB_VARIABLE_PREFIXES:\\n r['{}_job_id'.format(name)] = self.pk\\n r['{}_job_launch_type'.format(name)] = self.launch_type\\n\\n created_by = getattr_dne(self, 'created_by')\\n\\n wj = self.get_workflow_job()\\n if wj:\\n schedule = getattr_dne(wj, 'schedule')\\n for name in JOB_VARIABLE_PREFIXES:\\n r['{}_workflow_job_id'.format(name)] = wj.pk\\n r['{}_workflow_job_name'.format(name)] = wj.name\\n r['{}_workflow_job_launch_type'.format(name)] = wj.launch_type\\n if schedule:\\n r['{}_parent_job_schedule_id'.format(name)] = schedule.pk\\n r['{}_parent_job_schedule_name'.format(name)] = schedule.name\\n\\n if not created_by:\\n schedule = getattr_dne(self, 'schedule')\\n if schedule:\\n for name in JOB_VARIABLE_PREFIXES:\\n r['{}_schedule_id'.format(name)] = schedule.pk\\n r['{}_schedule_name'.format(name)] = schedule.name\\n\\n if created_by:\\n for name in JOB_VARIABLE_PREFIXES:\\n r['{}_user_id'.format(name)] = created_by.pk\\n r['{}_user_name'.format(name)] = created_by.username\\n r['{}_user_email'.format(name)] = created_by.email\\n r['{}_user_first_name'.format(name)] = created_by.first_name\\n r['{}_user_last_name'.format(name)] = created_by.last_name\\n\\n inventory = getattr_dne(self, 'inventory')\\n if inventory:\\n for name in JOB_VARIABLE_PREFIXES:\\n r['{}_inventory_id'.format(name)] = inventory.pk\\n r['{}_inventory_name'.format(name)] = inventory.name\\n\\n return r\",\n \"def environment(self):\\n return self._environ\",\n \"def __get_vars(self):\\n if self.resolved_vars:\\n return self.resolved_vars\\n return self.config_vars\",\n \"def env(self) -> Optional[Sequence['_core.v1.outputs.EnvVarPatch']]:\\n return pulumi.get(self, \\\"env\\\")\",\n \"def parse_env():\\n os_env = {}\\n try:\\n os_env[\\\"github_token\\\"] = os.environ[\\\"GITHUB_TOKEN\\\"]\\n os_env[\\\"github_repository\\\"] = os.environ[\\\"GITHUB_REPOSITORY\\\"]\\n os_env[\\\"threshold\\\"] = int(os.environ[\\\"THRESHOLD\\\"])\\n os_env[\\\"slack_channel\\\"] = os.environ[\\\"SLACK_CHANNEL\\\"]\\n os_env[\\\"slack_token\\\"] = os.environ[\\\"SLACK_TOKEN\\\"]\\n os_env[\\\"sleep_interval\\\"] = int(os.environ[\\\"SLEEP_INTERVAL\\\"])\\n return os_env\\n except KeyError as e:\\n logging.error(f\\\"failed to retrieve variable from env: {e}\\\")\\n return {}\",\n \"def collect_env():\\n env_info = mmengine_collect_env()\\n\\n # MMEngine does not add the hipcc compiler information when collecting\\n # environment information, so it is added here. When MMEngine v0.3.0 is\\n # released, the code here can be removed.\\n cuda_available = torch.cuda.is_available()\\n if cuda_available and env_info.get('NVCC') == 'Not Available':\\n CUDA_HOME = env_info['CUDA_HOME']\\n if CUDA_HOME is not None and osp.isdir(CUDA_HOME):\\n if CUDA_HOME == '/opt/rocm':\\n try:\\n nvcc = osp.join(CUDA_HOME, 'hip/bin/hipcc')\\n nvcc = subprocess.check_output(\\n f'\\\"{nvcc}\\\" --version', shell=True)\\n nvcc = nvcc.decode('utf-8').strip()\\n release = nvcc.rfind('HIP version:')\\n build = nvcc.rfind('')\\n nvcc = nvcc[release:build].strip()\\n except subprocess.SubprocessError:\\n nvcc = 'Not Available'\\n else:\\n try:\\n nvcc = osp.join(CUDA_HOME, 'bin/nvcc')\\n nvcc = subprocess.check_output(f'\\\"{nvcc}\\\" -V', shell=True)\\n nvcc = nvcc.decode('utf-8').strip()\\n release = nvcc.rfind('Cuda compilation tools')\\n build = nvcc.rfind('Build ')\\n nvcc = nvcc[release:build].strip()\\n except subprocess.SubprocessError:\\n nvcc = 'Not Available'\\n env_info['NVCC'] = nvcc\\n\\n env_info['MMCV'] = mmcv.__version__\\n\\n try:\\n from mmcv.ops import get_compiler_version, get_compiling_cuda_version\\n except ModuleNotFoundError:\\n env_info['MMCV Compiler'] = 'n/a'\\n env_info['MMCV CUDA Compiler'] = 'n/a'\\n else:\\n env_info['MMCV Compiler'] = get_compiler_version()\\n env_info['MMCV CUDA Compiler'] = get_compiling_cuda_version()\\n\\n return env_info\",\n \"def get_formatted_env_vars() -> str:\\n res = \\\"\\\"\\n for k, v in os.environ.items():\\n res += '{0}={1}\\\\n'.format(k, v)\\n return res\",\n \"def set_envs(self):\\n # pylint:disable=protected-access\\n # Need to call sys.__getframe() to get the filename and method/func\\n # for logging information.\\n\\n # Useful for logging\\n # Logging output: TIME UTC |TYPE (DEBUG, INFO, WARNING, etc.) |\\n # [File : function]| Message\\n cur_filename = sys._getframe().f_code.co_filename\\n cur_function = sys._getframe().f_code.co_name\\n\\n self.logger.info('Setting env variables from config file...')\\n # Set all the environment variables that are needed by the\\n # MET config file.\\n\\n tmp_amodel = self.c_dict['AMODEL']\\n if tmp_amodel:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_amodel_str = str(tmp_amodel).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_amodel = ''.join(tmp_amodel_str.split())\\n self.add_env_var('AMODEL', tmp_amodel)\\n else:\\n self.add_env_var('AMODEL', \\\"[]\\\")\\n\\n tmp_bmodel = self.c_dict['BMODEL']\\n if tmp_bmodel:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_bmodel_str = str(tmp_bmodel).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_bmodel = ''.join(tmp_bmodel_str.split())\\n self.add_env_var('BMODEL', tmp_bmodel)\\n else:\\n self.add_env_var('BMODEL', \\\"[]\\\")\\n\\n tmp_desc = self.c_dict['DESC']\\n if tmp_desc:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_desc_str = str(tmp_desc).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_desc = ''.join(tmp_desc_str.split())\\n self.add_env_var('DESC', tmp_desc)\\n else:\\n self.add_env_var('DESC', \\\"[]\\\")\\n\\n tmp_storm_id = self.c_dict['STORM_ID']\\n if tmp_storm_id:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_storm_id_str = str(tmp_storm_id).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_storm_id = ''.join(tmp_storm_id_str.split())\\n self.add_env_var('STORM_ID', tmp_storm_id)\\n else:\\n self.add_env_var('STORM_ID', \\\"[]\\\")\\n\\n tmp_basin = self.c_dict['BASIN']\\n if tmp_basin:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_basin_str = str(tmp_basin).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_basin = ''.join(tmp_basin_str.split())\\n self.add_env_var('BASIN', tmp_basin)\\n else:\\n self.add_env_var('BASIN', \\\"[]\\\")\\n\\n tmp_cyclone = self.c_dict['CYCLONE']\\n if tmp_cyclone:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_cyclone_str = str(tmp_cyclone).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_cyclone = ''.join(tmp_cyclone_str.strip())\\n self.add_env_var('CYCLONE', tmp_cyclone)\\n else:\\n self.add_env_var('CYCLONE', \\\"[]\\\")\\n\\n tmp_storm_name = self.c_dict['STORM_NAME']\\n if tmp_storm_name:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_storm_name_str = str(tmp_storm_name).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_storm_name = ''.join(tmp_storm_name_str.strip())\\n self.add_env_var('STORM_NAME', tmp_storm_name)\\n else:\\n self.add_env_var('STORM_NAME', \\\"[]\\\")\\n\\n if self.c_dict['INIT_BEG']:\\n self.add_env_var('INIT_BEG', self.c_dict['INIT_BEG'])\\n else:\\n self.add_env_var('INIT_BEG', \\\"\\\")\\n\\n if self.c_dict['INIT_END']:\\n self.add_env_var('INIT_END', self.c_dict['INIT_END'])\\n else:\\n self.add_env_var('INIT_END', \\\"\\\")\\n\\n tmp_init_include = self.c_dict['INIT_INCLUDE']\\n if tmp_init_include:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_init_include_str = str(tmp_init_include).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_init_include = ''.join(tmp_init_include_str.strip())\\n self.add_env_var('INIT_INCLUDE', tmp_init_include)\\n else:\\n self.add_env_var('INIT_INCLUDE', \\\"[]\\\")\\n\\n tmp_init_exclude = self.c_dict['INIT_EXCLUDE']\\n if tmp_init_exclude:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_init_exclude_str = str(tmp_init_exclude).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_init_exclude = ''.join(tmp_init_exclude_str.strip())\\n self.add_env_var('INIT_EXCLUDE', tmp_init_exclude)\\n else:\\n self.add_env_var('INIT_EXCLUDE', \\\"[]\\\")\\n\\n tmp_init_hour = self.c_dict['INIT_HOUR']\\n if tmp_init_hour:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_init_hour_str = str(tmp_init_hour).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_init_hour = ''.join(tmp_init_hour_str.split())\\n self.add_env_var('INIT_HOUR', tmp_init_hour)\\n else:\\n self.add_env_var('INIT_HOUR', \\\"[]\\\")\\n\\n tmp_valid_begin = self.c_dict['VALID_BEG']\\n if tmp_valid_begin:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_valid_begin_str = str(tmp_valid_begin).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_valid_begin = ''.join(tmp_valid_begin_str.strip())\\n self.add_env_var('VALID_BEG', tmp_valid_begin)\\n else:\\n self.add_env_var('VALID_BEG', '')\\n\\n tmp_valid_end = self.c_dict['VALID_END']\\n if tmp_valid_end:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_valid_end_str = str(tmp_valid_end).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_valid_end = ''.join(tmp_valid_end_str.strip())\\n self.add_env_var('VALID_END', tmp_valid_end)\\n else:\\n self.add_env_var('VALID_END', \\\"\\\")\\n\\n tmp_valid_include = self.c_dict['VALID_INCLUDE']\\n if tmp_valid_include:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_valid_include_str = str(tmp_valid_include).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_valid_include = ''.join(tmp_valid_include_str.strip())\\n self.add_env_var('VALID_INCLUDE', tmp_valid_include)\\n else:\\n self.add_env_var('VALID_INCLUDE', \\\"[]\\\")\\n\\n tmp_valid_exclude = self.c_dict['VALID_EXCLUDE']\\n if tmp_valid_exclude:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_valid_exclude_str = str(tmp_valid_exclude).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_valid_exclude = ''.join(tmp_valid_exclude_str.strip())\\n self.add_env_var('VALID_EXCLUDE', tmp_valid_exclude)\\n else:\\n self.add_env_var('VALID_EXCLUDE', \\\"[]\\\")\\n\\n tmp_valid_hour = self.c_dict['VALID_HOUR']\\n if tmp_valid_hour:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_valid_hour_str = str(tmp_valid_hour).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_valid_hour = ''.join(tmp_valid_hour_str.strip())\\n self.add_env_var('VALID_HOUR', tmp_valid_hour)\\n else:\\n self.add_env_var('VALID_HOUR', \\\"[]\\\")\\n\\n tmp_lead_req = self.c_dict['LEAD_REQ']\\n if tmp_lead_req:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_lead_req_str = str(tmp_lead_req).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_lead_req = ''.join(tmp_lead_req_str.strip())\\n self.add_env_var('LEAD_REQ', tmp_lead_req)\\n else:\\n self.add_env_var('LEAD_REQ', \\\"[]\\\")\\n\\n tmp_lead = self.c_dict['LEAD']\\n if tmp_lead:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_lead_str = str(tmp_lead).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_lead = ''.join(tmp_lead_str.strip())\\n self.add_env_var('LEAD', tmp_lead)\\n else:\\n self.add_env_var('LEAD', \\\"[]\\\")\\n\\n tmp_init_mask = self.c_dict['INIT_MASK']\\n if tmp_init_mask:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_init_mask_str = str(tmp_init_mask).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_init_mask = ''.join(tmp_init_mask_str.strip())\\n self.add_env_var('INIT_MASK', tmp_init_mask)\\n else:\\n self.add_env_var('INIT_MASK', \\\"[]\\\")\\n\\n tmp_valid_mask = self.c_dict['VALID_MASK']\\n if tmp_valid_mask:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_valid_mask_str = str(tmp_valid_mask).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_valid_mask = ''.join(tmp_valid_mask_str.strip())\\n self.add_env_var('VALID_MASK', tmp_valid_mask)\\n else:\\n self.add_env_var('VALID_MASK', \\\"[]\\\")\\n\\n tmp_track_watch_warn = self.c_dict['TRACK_WATCH_WARN']\\n if tmp_track_watch_warn:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_track_watch_warn_str = str(tmp_track_watch_warn).replace(\\\"\\\\'\\\",\\n \\\"\\\\\\\"\\\")\\n tmp_track_watch_warn = ''.join(tmp_track_watch_warn_str.strip())\\n self.add_env_var('TRACK_WATCH_WARN', tmp_track_watch_warn)\\n else:\\n self.add_env_var('TRACK_WATCH_WARN', \\\"[]\\\")\\n\\n tmp_column_thresh_name = self.c_dict['COLUMN_THRESH_NAME']\\n if tmp_column_thresh_name:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_column_thresh_name_str = str(tmp_column_thresh_name).replace(\\n \\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_column_thresh_name = ''.join(tmp_column_thresh_name_str.strip())\\n self.add_env_var('COLUMN_THRESH_NAME', tmp_column_thresh_name)\\n else:\\n self.add_env_var('COLUMN_THRESH_NAME', \\\"[]\\\")\\n\\n tmp_column_thresh_val = self.c_dict['COLUMN_THRESH_VAL']\\n if tmp_column_thresh_val:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_column_thresh_val_str = str(tmp_column_thresh_val).replace(\\\"\\\\'\\\",\\n \\\"\\\\\\\"\\\")\\n tmp_column_thresh_val = ''.join(tmp_column_thresh_val_str.strip())\\n self.add_env_var('COLUMN_THRESH_VAL', tmp_column_thresh_val)\\n else:\\n self.add_env_var('COLUMN_THRESH_VAL', \\\"[]\\\")\\n\\n tmp_column_str_name = self.c_dict['COLUMN_STR_NAME']\\n if tmp_column_str_name:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_column_str_name = str(tmp_column_str_name).replace(\\\"\\\\'\\\",\\n \\\"\\\\\\\"\\\")\\n tmp_column_str_name = ''.join(tmp_column_str_name.strip())\\n self.add_env_var('COLUMN_STR_NAME', tmp_column_str_name)\\n else:\\n self.add_env_var('COLUMN_STR_NAME', \\\"[]\\\")\\n\\n tmp_column_str_val = self.c_dict['COLUMN_STR_VAL']\\n if tmp_column_str_val:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_column_str_val_str = str(tmp_column_str_val).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_column_str_val = ''.join(tmp_column_str_val_str.strip())\\n self.add_env_var('COLUMN_STR_VAL', tmp_column_str_val)\\n else:\\n self.add_env_var('COLUMN_STR_VAL', \\\"[]\\\")\\n\\n tmp_init_thresh_name = self.c_dict['INIT_THRESH_NAME']\\n if tmp_init_thresh_name:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_init_thresh_name_str = str(tmp_init_thresh_name).replace(\\\"\\\\'\\\",\\n \\\"\\\\\\\"\\\")\\n tmp_init_thresh_name = ''.join(tmp_init_thresh_name_str.strip())\\n\\n self.add_env_var('INIT_THRESH_NAME', tmp_init_thresh_name)\\n\\n else:\\n self.add_env_var('INIT_THRESH_NAME', \\\"[]\\\")\\n\\n tmp_init_thresh_val = self.c_dict['INIT_THRESH_VAL']\\n if tmp_init_thresh_val:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_init_thresh_val_str = str(tmp_init_thresh_val).replace(\\\"\\\\'\\\",\\n \\\"\\\\\\\"\\\")\\n tmp_init_thresh_val = ''.join(tmp_init_thresh_val_str.strip())\\n self.add_env_var('INIT_THRESH_VAL', tmp_init_thresh_val)\\n else:\\n self.add_env_var('INIT_THRESH_VAL', \\\"[]\\\")\\n\\n tmp_init_str_name = self.c_dict['INIT_STR_NAME']\\n if tmp_init_str_name:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_init_str_name_str = str(tmp_init_str_name).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_init_str_name = ''.join(tmp_init_str_name_str.strip())\\n self.add_env_var('INIT_STR_NAME', tmp_init_str_name)\\n else:\\n self.add_env_var('INIT_STR_NAME', \\\"[]\\\")\\n\\n tmp_init_str_val = self.c_dict['INIT_STR_VAL']\\n if tmp_init_str_val:\\n # Replace any single quotes with double quotes and remove any\\n # whitespace\\n tmp_init_str_val_str = str(tmp_init_str_val).replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tmp_init_str_val = ''.join(tmp_init_str_val_str.strip())\\n self.add_env_var('INIT_STR_VAL', tmp_init_str_val)\\n else:\\n self.add_env_var('INIT_STR_VAL', \\\"[]\\\")\\n\\n # boolean values for WATER_ONLY\\n if self.c_dict['WATER_ONLY']:\\n flag = \\\"TRUE\\\"\\n else:\\n flag = \\\"FALSE\\\"\\n self.add_env_var('WATER_ONLY', flag)\\n\\n # boolean value for LANDFALL\\n if self.c_dict['LANDFALL']:\\n flag = \\\"TRUE\\\"\\n else:\\n flag = \\\"FALSE\\\"\\n self.add_env_var('LANDFALL', flag)\\n\\n if self.c_dict['LANDFALL_BEG']:\\n self.add_env_var('LANDFALL_BEG',\\n self.c_dict['LANDFALL_BEG'])\\n else:\\n # Set to default\\n self.add_env_var('LANDFALL_BEG', '-24')\\n\\n if self.c_dict['LANDFALL_END']:\\n self.add_env_var('LANDFALL_END',\\n self.c_dict['LANDFALL_END'])\\n else:\\n # Set to default\\n self.add_env_var('LANDFALL_END', '00')\\n\\n # boolean value for MATCH_POINTS\\n if self.c_dict['MATCH_POINTS'] == 'true':\\n flag = \\\"TRUE\\\"\\n else:\\n flag = \\\"FALSE\\\"\\n self.add_env_var('MATCH_POINTS', flag)\\n\\n if self.c_dict['CONFIG_FILE']:\\n self.add_env_var('CONFIG_FILE',\\n self.c_dict['CONFIG_FILE'])\\n else:\\n self.log_error(\\n cur_filename + '|' + cur_function +\\n ': no MET TC-Stat config file found. Exiting')\\n sys.exit(1)\\n\\n jobs_list_tmp = self.c_dict['JOBS_LIST']\\n if jobs_list_tmp:\\n # MET is expecting a string\\n jobs_list_str = '\\\"' + jobs_list_tmp + '\\\"'\\n self.add_env_var('JOBS', jobs_list_str)\\n else:\\n self.log_error('No jobs list defined. Please check your METplus'\\n 'config file. Exiting...')\\n sys.exit(1)\\n return 0\",\n \"def test_get_environment_string(self):\\n pass\",\n \"def compute_env_var(self):\\n return COMPUTE_SETTINGS_VARNAME\",\n \"def MakeEnvironment(self, context):\\n\\n # Start with any environment variables that are already present\\n # in the environment.\\n environment = os.environ.copy()\\n # Copy context variables into the environment.\\n for key, value in context.items():\\n name = \\\"QMV_\\\" + key\\n environment[name] = value\\n return environment\",\n \"def _all_env_vars_to_dict(self):\\n all_env_vars = {}\\n for k, v in self.env.items():\\n c_vars = {}\\n for x, y in v['vars'].items():\\n c_vars[f'{k}_{x}'] = y['value']\\n all_env_vars = {**all_env_vars, **c_vars}\\n return all_env_vars\",\n \"def wrapper_environment(args):\\n\\n return {\\n ENVIRONMENT_KEY: json.dumps({\\n 'verbose': args.verbose,\\n 'cc': shlex.split(args.cc),\\n 'cxx': shlex.split(args.cxx)\\n })\\n }\",\n \"def env(self):\\n return spack.schema.environment.parse(self.conf.get(\\\"environment\\\", {}))\",\n \"def collect_env():\\n env_info = {}\\n env_info['sys.platform'] = sys.platform\\n env_info['Python'] = sys.version.replace('\\\\n', '')\\n\\n cuda_available = torch.cuda.is_available()\\n env_info['CUDA available'] = cuda_available\\n\\n if cuda_available:\\n devices = defaultdict(list)\\n for k in range(torch.cuda.device_count()):\\n devices[torch.cuda.get_device_name(k)].append(str(k))\\n for name, device_ids in devices.items():\\n env_info['GPU ' + ','.join(device_ids)] = name\\n\\n from mmcv.utils.parrots_wrapper import _get_cuda_home\\n CUDA_HOME = _get_cuda_home()\\n env_info['CUDA_HOME'] = CUDA_HOME\\n\\n if CUDA_HOME is not None and osp.isdir(CUDA_HOME):\\n try:\\n nvcc = osp.join(CUDA_HOME, 'bin/nvcc')\\n nvcc = subprocess.check_output(f'\\\"{nvcc}\\\" -V', shell=True)\\n nvcc = nvcc.decode('utf-8').strip()\\n release = nvcc.rfind('Cuda compilation tools')\\n build = nvcc.rfind('Build ')\\n nvcc = nvcc[release:build].strip()\\n except subprocess.SubprocessError:\\n nvcc = 'Not Available'\\n env_info['NVCC'] = nvcc\\n\\n try:\\n # Check C++ Compiler.\\n # For Unix-like, sysconfig has 'CC' variable like 'gcc -pthread ...',\\n # indicating the compiler used, we use this to get the compiler name\\n import sysconfig\\n cc = sysconfig.get_config_var('CC')\\n if cc:\\n cc = osp.basename(cc.split()[0])\\n cc_info = subprocess.check_output(f'{cc} --version', shell=True)\\n env_info['GCC'] = cc_info.decode('utf-8').partition(\\n '\\\\n')[0].strip()\\n else:\\n # on Windows, cl.exe is not in PATH. We need to find the path.\\n # distutils.ccompiler.new_compiler() returns a msvccompiler\\n # object and after initialization, path to cl.exe is found.\\n import locale\\n import os\\n from distutils.ccompiler import new_compiler\\n ccompiler = new_compiler()\\n ccompiler.initialize()\\n cc = subprocess.check_output(\\n f'{ccompiler.cc}', stderr=subprocess.STDOUT, shell=True)\\n encoding = os.device_encoding(\\n sys.stdout.fileno()) or locale.getpreferredencoding()\\n env_info['MSVC'] = cc.decode(encoding).partition('\\\\n')[0].strip()\\n env_info['GCC'] = 'n/a'\\n except subprocess.CalledProcessError:\\n env_info['GCC'] = 'n/a'\\n\\n env_info['PyTorch'] = torch.__version__\\n env_info['PyTorch compiling details'] = get_build_config()\\n\\n try:\\n import torchvision\\n env_info['TorchVision'] = torchvision.__version__\\n except ModuleNotFoundError:\\n pass\\n\\n env_info['OpenCV'] = cv2.__version__\\n\\n env_info['MMCV'] = mmcv.__version__\\n\\n try:\\n from mmcv.ops import get_compiler_version, get_compiling_cuda_version\\n except ModuleNotFoundError:\\n env_info['MMCV Compiler'] = 'n/a'\\n env_info['MMCV CUDA Compiler'] = 'n/a'\\n else:\\n env_info['MMCV Compiler'] = get_compiler_version()\\n env_info['MMCV CUDA Compiler'] = get_compiling_cuda_version()\\n\\n return env_info\",\n \"def load_env_variables(self, environment):\\n env_dir = os.path.join(self.__get_environments_root_dir(), environment)\\n return read_and_combine_yamls_in_dir(env_dir)\",\n \"def get_os_env():\\n env = os.environ\\n# print(\\\"env \\\\n\\\" , env)\\n return env\",\n \"def dist_env():\\n trainer_id = int(os.getenv(\\\"PADDLE_TRAINER_ID\\\", \\\"0\\\"))\\n num_trainers = 1\\n training_role = os.getenv(\\\"PADDLE_TRAINING_ROLE\\\", \\\"TRAINER\\\")\\n assert (training_role == \\\"PSERVER\\\" or training_role == \\\"TRAINER\\\")\\n\\n # - PADDLE_TRAINER_ENDPOINTS means nccl2 mode.\\n # - PADDLE_PSERVER_ENDPOINTS means pserver mode.\\n # - PADDLE_CURRENT_ENDPOINT means current process endpoint.\\n trainer_endpoints = os.getenv(\\\"PADDLE_TRAINER_ENDPOINTS\\\")\\n pserver_endpoints = os.getenv(\\\"PADDLE_PSERVER_ENDPOINTS\\\")\\n current_endpoint = os.getenv(\\\"PADDLE_CURRENT_ENDPOINT\\\")\\n if trainer_endpoints:\\n trainer_endpoints = trainer_endpoints.split(\\\",\\\")\\n num_trainers = len(trainer_endpoints)\\n elif pserver_endpoints:\\n num_trainers = int(os.getenv(\\\"PADDLE_TRAINERS_NUM\\\"))\\n\\n return {\\n \\\"trainer_id\\\": trainer_id,\\n \\\"num_trainers\\\": num_trainers,\\n \\\"current_endpoint\\\": current_endpoint,\\n \\\"training_role\\\": training_role,\\n \\\"pserver_endpoints\\\": pserver_endpoints,\\n \\\"trainer_endpoints\\\": trainer_endpoints\\n }\",\n \"def get_elinos_environment():\\n result = {}\\n for key in (\\\"project\\\", \\\"cdk\\\", \\\"target\\\"):\\n var = \\\"ELINOS_\\\" + key.upper()\\n if var in os.environ:\\n result[key] = os.environ[var]\\n else:\\n warn(\\\"%s not set\\\" % var)\\n result[key] = None\\n\\n if result[\\\"project\\\"] is not None:\\n result[\\\"xenomai\\\"] = glob.glob(result[\\\"project\\\"] + \\\"/xenomai-[0-9.]*\\\")\\n else:\\n result[\\\"xenomai\\\"] = []\\n\\n return result\",\n \"def get_current_environment():\\n # Search for the environment variable set by the hutch python setup\\n env = os.getenv('CONDA_ENVNAME')\\n # Otherwise look for built-in Conda environment variables\\n if not env:\\n env = os.getenv('CONDA_DEFAULT_ENV')\\n # Check the top level PYTHONPATH to see if we have packages installed in\\n # development mode\\n dev = os.getenv('PYTHONPATH')\\n if dev:\\n try:\\n dev_pkgs = os.listdir(dev)\\n except FileNotFoundError:\\n logger.debug(\\\"No dev folder found\\\")\\n dev_pkgs = list()\\n else:\\n dev_pkgs = list()\\n return env, dev_pkgs\",\n \"def build_env(self, instance, private_data_dir, private_data_files=None):\\n env = {}\\n # Add ANSIBLE_* settings to the subprocess environment.\\n for attr in dir(settings):\\n if attr == attr.upper() and attr.startswith('ANSIBLE_'):\\n env[attr] = str(getattr(settings, attr))\\n # Also set environment variables configured in AWX_TASK_ENV setting.\\n for key, value in settings.AWX_TASK_ENV.items():\\n env[key] = str(value)\\n\\n env['AWX_PRIVATE_DATA_DIR'] = private_data_dir\\n\\n if self.instance.execution_environment is None:\\n raise RuntimeError(f'The {self.model.__name__} could not run because there is no Execution Environment.')\\n\\n return env\",\n \"def _build_env(self, args):\\n env = os.environ.copy()\\n env['ANSIBLE_CONFIG'] = os.path.join(ANSIBLE_DIR, 'ansible.cfg')\\n if hasattr(args, 'stdout_callback'):\\n env['ANSIBLE_STDOUT_CALLBACK'] = args.stdout_callback\\n return env\",\n \"def _prepare_publish_environments():\\n env = copy.deepcopy(os.environ)\\n\\n project_name = os.getenv(\\\"AVALON_PROJECT\\\")\\n asset_name = os.getenv(\\\"AVALON_ASSET\\\")\\n\\n env[\\\"AVALON_PROJECT\\\"] = project_name\\n env[\\\"AVALON_ASSET\\\"] = asset_name\\n env[\\\"AVALON_TASK\\\"] = os.getenv(\\\"AVALON_TASK\\\")\\n env[\\\"AVALON_WORKDIR\\\"] = os.getenv(\\\"AVALON_WORKDIR\\\")\\n env[\\\"AVALON_APP\\\"] = f\\\"hosts.{publish_host}\\\"\\n env[\\\"AVALON_APP_NAME\\\"] = \\\"celaction/local\\\"\\n\\n env[\\\"PYBLISH_HOSTS\\\"] = publish_host\\n\\n os.environ.update(env)\",\n \"def environment_properties(self) -> Optional[pulumi.Input['ApplicationApplicationConfigurationEnvironmentPropertiesArgs']]:\\n return pulumi.get(self, \\\"environment_properties\\\")\",\n \"def init_vars(self):\\n\\n load_dotenv()\\n self.smart_cube = True if os.environ.get(\\\"SMART_CUBE\\\") == \\\"True\\\" else False\\n self.gen_parsed_to_cubedb = True if os.environ.get(\\\"GEN_PARSED_TO_CUBEDB\\\") == \\\"True\\\" else False\\n self.name_of_solve = os.environ.get(\\\"NAME_OF_SOLVE\\\")\\n self.time_solve = os.environ.get(\\\"TIME_SOLVE\\\")\\n self.comms_unparsed_bool = True if os.environ.get(\\\"COMMS_UNPARSED\\\") == \\\"True\\\" else False\\n self.gen_with_move_count = True if os.environ.get(\\\"GEN_WITH_MOVE_COUNT\\\") == \\\"True\\\" else False\\n self.diff_to_solved_state = float(os.environ.get(\\\"DIFF_BETWEEN_ALGS\\\"))\\n self.parse_to_lp = True if os.environ.get(\\\"PARSE_TO_LETTER_PAIR\\\") == \\\"True\\\" else False\\n self.gen_with_moves = True if os.environ.get(\\\"GEN_WITH_MOVE_COUNT\\\") == \\\"True\\\" else False\\n self.buffer_ed = self.get_buffer_ed(os.environ.get(\\\"EDGES_BUFFER\\\"))\\n self.buffer_cor = self.get_buffer_cor(os.environ.get(\\\"CORNER_BUFFER\\\"))\\n self.path_to_lp = os.environ.get(\\\"PATH_LETTER_PAIR_FILE\\\")\\n self.dict_lp = self.load_letter_pairs_dict()\",\n \"def global_jinja_env():\\n return _ENV\",\n \"def env_from(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EnvFromSourceArgs']]]]:\\n return pulumi.get(self, \\\"env_from\\\")\",\n \"def env_config():\\n # setup\\n env = {'ELB_GCP_PROJECT': 'expected-gcp-project',\\n 'ELB_GCP_REGION': 'expected-gcp-region',\\n 'ELB_GCP_ZONE': 'expected-gcp-zone',\\n 'ELB_BATCH_LEN': '93',\\n 'ELB_CLUSTER_NAME': 'expected-cluster-name',\\n 'ELB_RESULTS': 'gs://expected-results',\\n 'ELB_USE_PREEMPTIBLE': 'true',\\n 'ELB_BID_PERCENTAGE': '91'}\\n\\n for var_name in env:\\n os.environ[var_name] = str(env[var_name])\\n\\n yield env\\n\\n # cleanup\\n for var_name in env:\\n # os.unsetenv does not work on every system\\n del os.environ[var_name]\",\n \"def get_env_copy(self):\\n if self._env:\\n return cloudpickle.loads(cloudpickle.dumps(self._env))\\n else:\\n return None\",\n \"def env(self):\\n return self._env\",\n \"def get_env(self, loop):\\n env = getattr(self.app, 'env', None)\\n if not env:\\n env = self.environment(self.app, loop, self.host, self.port)\\n self.app.env = env\\n return env\",\n \"def _prepend_env_paths(content, names):\\n export_env_vars = ['export %(k)s=%(v)s:${%(k)s}' %dict(\\n k=name, v=os.environ.get(name, '')) for name in names]\\n return '\\\\n'.join(export_env_vars + [content])\",\n \"def environ(self):\\n return dict(environment=request.environ)\",\n \"def environ(self):\\n return dict(environment=request.environ)\",\n \"def environ(self):\\n return dict(environment=request.environ)\",\n \"def constructor_env_variables(loader, node):\\n value = loader.construct_scalar(node)\\n match = pattern.findall(value) # to find all env variables in line\\n if match:\\n full_value = value\\n for g in match:\\n full_value = full_value.replace(\\n f'${{{g}}}', os.environ.get(g, g)\\n )\\n return full_value\\n return value\",\n \"def setup_environment(self):\\n self.run_command(\\\"cd {}\\\".format(quote(str(self.builddir))))\\n env_vars = self._build_env_variables_string()\\n if env_vars:\\n env_vars = quote(env_vars)\\n command = \\\"{} DISTRO={} MACHINE={} . {} build-{}\\\".format(\\n env_vars,\\n quote(self.distro),\\n quote(self.machine),\\n quote(self.init_env_file),\\n quote(self.distro),\\n )\\n self.run_command(command)\",\n \"def _build_jupyter_env(kedro_env: str) -> Dict[str, Any]:\\n if not kedro_env:\\n return {}\\n jupyter_env = os.environ.copy()\\n jupyter_env[KEDRO_ENV_VAR] = kedro_env\\n return {\\\"env\\\": jupyter_env}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71218103","0.6978689","0.6978689","0.6978689","0.6978689","0.6962417","0.6928234","0.6838894","0.6718607","0.6701541","0.67005","0.6680116","0.6649582","0.66316056","0.6587881","0.65733594","0.6556599","0.64912426","0.63936","0.63538235","0.6329612","0.632008","0.6302709","0.6297883","0.6297883","0.6297883","0.6297883","0.6277506","0.625459","0.62459993","0.6233562","0.6225838","0.6197401","0.61880344","0.61355364","0.6132028","0.61161","0.6113471","0.6107454","0.60897547","0.6085886","0.6085715","0.60225457","0.60162413","0.60062575","0.6005569","0.6005093","0.59854066","0.59854066","0.59854066","0.59854066","0.59854066","0.59854066","0.5976208","0.59672105","0.5963311","0.5950686","0.59447885","0.59095573","0.5908788","0.5908238","0.58876824","0.58804715","0.58790976","0.58768","0.58653814","0.5854928","0.58513737","0.5825477","0.58241314","0.5809568","0.5801297","0.5800471","0.5791205","0.57908386","0.57862675","0.5784133","0.57830346","0.57819283","0.5774332","0.5769387","0.5759429","0.5748658","0.57441664","0.5733082","0.5727899","0.57145286","0.5708764","0.5707717","0.5707674","0.56990397","0.5686262","0.5684098","0.5681051","0.56786454","0.56786454","0.56786454","0.5673762","0.5673346","0.5665396"],"string":"[\n \"0.71218103\",\n \"0.6978689\",\n \"0.6978689\",\n \"0.6978689\",\n \"0.6978689\",\n \"0.6962417\",\n \"0.6928234\",\n \"0.6838894\",\n \"0.6718607\",\n \"0.6701541\",\n \"0.67005\",\n \"0.6680116\",\n \"0.6649582\",\n \"0.66316056\",\n \"0.6587881\",\n \"0.65733594\",\n \"0.6556599\",\n \"0.64912426\",\n \"0.63936\",\n \"0.63538235\",\n \"0.6329612\",\n \"0.632008\",\n \"0.6302709\",\n \"0.6297883\",\n \"0.6297883\",\n \"0.6297883\",\n \"0.6297883\",\n \"0.6277506\",\n \"0.625459\",\n \"0.62459993\",\n \"0.6233562\",\n \"0.6225838\",\n \"0.6197401\",\n \"0.61880344\",\n \"0.61355364\",\n \"0.6132028\",\n \"0.61161\",\n \"0.6113471\",\n \"0.6107454\",\n \"0.60897547\",\n \"0.6085886\",\n \"0.6085715\",\n \"0.60225457\",\n \"0.60162413\",\n \"0.60062575\",\n \"0.6005569\",\n \"0.6005093\",\n \"0.59854066\",\n \"0.59854066\",\n \"0.59854066\",\n \"0.59854066\",\n \"0.59854066\",\n \"0.59854066\",\n \"0.5976208\",\n \"0.59672105\",\n \"0.5963311\",\n \"0.5950686\",\n \"0.59447885\",\n \"0.59095573\",\n \"0.5908788\",\n \"0.5908238\",\n \"0.58876824\",\n \"0.58804715\",\n \"0.58790976\",\n \"0.58768\",\n \"0.58653814\",\n \"0.5854928\",\n \"0.58513737\",\n \"0.5825477\",\n \"0.58241314\",\n \"0.5809568\",\n \"0.5801297\",\n \"0.5800471\",\n \"0.5791205\",\n \"0.57908386\",\n \"0.57862675\",\n \"0.5784133\",\n \"0.57830346\",\n \"0.57819283\",\n \"0.5774332\",\n \"0.5769387\",\n \"0.5759429\",\n \"0.5748658\",\n \"0.57441664\",\n \"0.5733082\",\n \"0.5727899\",\n \"0.57145286\",\n \"0.5708764\",\n \"0.5707717\",\n \"0.5707674\",\n \"0.56990397\",\n \"0.5686262\",\n \"0.5684098\",\n \"0.5681051\",\n \"0.56786454\",\n \"0.56786454\",\n \"0.56786454\",\n \"0.5673762\",\n \"0.5673346\",\n \"0.5665396\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5978486"},"document_rank":{"kind":"string","value":"53"}}},{"rowIdx":25597,"cells":{"query":{"kind":"string","value":"Return a bs4 object containing all the tags in doc of the URL"},"document":{"kind":"string","value":"def _grab_tags(self, url):\n a = self._api_request(url)\n return bs4.BeautifulSoup(a,features=\"html.parser\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_soup(url):\n return BeautifulSoup(requests.get(url).content, 'lxml')","def getSoup(url):\n return BeautifulSoup(getHtml(url), 'lxml')","def find_tag_urls(r):\n parser = MyHTMLParser()\n parser.feed(r)\n return parser.url_list","def request(self, url):\r\n\r\n req = self.get(url)\r\n soup = BeautifulSoup(req.content, \"lxml\")\r\n return soup","def get_soup(url):\n\tr = requests.get(url)\n\tdata = r.text\n\tsoup = BeautifulSoup(data, \"lxml\")\n\treturn soup","def get_soup(url):\n response = requests.get(url)\n soup = BeautifulSoup(response.text, 'html.parser')\n return soup","def request(url):\n response=requests.get(url)\n soup=BeautifulSoup(response.content,\"lxml\")\n return soup","def get_soup(url: str):\n response = requests.get(url)\n\n return BeautifulSoup(response.content, \"html.parser\")","def get_soup(url):\r\n page=requests.get(url)\r\n soup = BeautifulSoup(page.text.encode(\"utf-8\"), 'html.parser')\r\n return soup","def get_tags(self):\r\n self.tags = []\r\n for tag in self.soup.find_all('dl'):\r\n name = tag.dt.contents[0]\r\n\r\n # getting info about tag\r\n info = ''\r\n for p in tag.dd.find_all('p'):\r\n info += p.getText() + ' '\r\n\r\n # getting reference link and code snippet\r\n a_tags = tag.dd.find_all('a')\r\n example_id = a_tags[1]['href'].replace('#', '') # code snippet\r\n example = self.soup.find('div', {'id': example_id}).getText()\r\n\r\n # url reference (from HTML5Doctor if exists)\r\n reference = ''\r\n try:\r\n reference = tag.dt.span.a['href'] # url for HTML5Doctor\r\n except:\r\n reference = a_tags[0]['href'] # url for W3C\r\n\r\n reference = 'http://html5doctor.com/element-index/#' + name\r\n new_tag = Tag(name, info, reference, example)\r\n self.tags.append(new_tag)\r\n logger.info('Tag parsed: %s' % new_tag.name)","def make_soup(url):\r\n htmlFile = urllib.request.urlopen(url).read()\r\n soup = BeautifulSoup(htmlFile)\r\n return soup","def _get_soup_object(url: str) -> bs4.BeautifulSoup:\n request_result=requests.get(url)\n soup = bs4.BeautifulSoup(request_result.text, \"html.parser\")\n return soup","def get_document(url):\n req = requests.get(url)\n doc = BeautifulSoup(req.content, \"html.parser\")\n return doc","def get_soup(url: str) -> BeautifulSoup:\n html = get_html(url)\n soup = BeautifulSoup(html, 'lxml')\n return soup","def get_soup(url):\n\tresponse = urlopen(url)\n\thtml = response.read()\n\tsoup = BeautifulSoup(html, \"html.parser\")\n\tresponse.close()\n\treturn soup","def _soup(self, url):\n r = self.session.get(url)\n r.raise_for_status()\n html = Soup(r.text, 'lxml') # lxml is fastert than html.parser\n r.close()\n return html","def getLinks(self, url, tag = \"a\", attr = \"href\"): \n try: \n response = open(self.filename(url)).read() #read from the file\n except IOError:\n raise IOError\n parsed_url = urlparse(url)\n domain = parsed_url[0] + '://' + parsed_url[1]\n \n try:\n soup = BeautifulSoup.BeautifulSoup(response)\n l = soup.findAll(tag, href = True)\n except Exception:\n raise Exception\n links = []\n \n for tag in l:\n link = str(tag[attr]) #convert the link to a string\n purl = urlparse(link)\n if purl[1] == '': #if the link is relative make it absolute\n link = domain+link\n #check if the extension is that of a document \n if splitext(link)[1] in self._invalidExt: \n self.docs_list.append(link)\n \n #append only the html link\n links.append(link)\n \n \n \n return list(set(links)) #returns only distinct links","def get_soup(url):\n opener = urllib2.build_opener()\n request = urllib2.Request(url);\n request.add_header('User-Agent','Mozilla/6.0 (Windows NT 6.2; WOW64; rv:16.0.1) Gecko/20121011 Firefox/16.0.1');\n data = opener.open(request).read(); \n return BeautifulSoup(data);","def get_tags(html_soup):\n \n tags = html_soup.findAll('a', attrs = {\"class\" : \"tag\"})\n all_tags = []\n for i in tags:\n all_tags.append(i.get_text())\n \n return all_tags","def get_html_parser(url):\n response = requests.get(url)\n return BeautifulSoup(response.content, 'html.parser')","def _get_tags(self, res):\n doc = pq(res.content)\n return (doc('[property=\"og:title\"]').attr('content'),\n doc('[property=\"og:image\"]').attr('content'),\n doc('[name=\"description\"]').attr('content'))","def make_file_soup(self):\n soup = BeautifulSoup(self.html, 'html.parser')\n return soup","def page_soup(url):\n html = requests.get(url).text\n return bs(html, 'html.parser')","def get_content(self):\n response = requests.get(self.url)\n soup = BeautifulSoup(response.text, \"html.parser\")\n return soup","def load_data(url: str):\n\n page = requests.get(url=url)\n soup = BeautifulSoup(page.content, 'html.parser')\n return soup","def get_article(url):\n \n r = requests.get(url) \n html_soup = BeautifulSoup(r.content, 'lxml')\n return html_soup","def _get_soup(self, url):\n\n # generate a random header \n headers = {'User-Agent': self._random_user_agent()}\n # send a request and get the soup\n response = requests.get(url, headers=headers)\n results = response.content\n if not response.status_code == 404:\n soup = BeautifulSoup(results, 'lxml')\n return soup","def soup(url):\n handle = ''\n max_tries = 10\n for i in range(max_tries):\n try:\n handle = urlopen(url)\n handle = handle.read()\n break\n except:\n logging.exception('urlopen failed (attempt %d)', i + 1)\n if i == max_tries - 1:\n logging.error('the maximum urlopen attempts have been reached')\n raise\n time.sleep(1)\n\n s = BeautifulSoup(handle)\n return s","def make_soup(self):\n req = urllib.request.Request(\n url,\n data=None,\n headers={\n 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36'\n }\n )\n f = urllib.request.urlopen(self.html)\n soupdata = BeautifulSoup(f, \"html.parser\")\n return soupdata","def get_url_soup(url):\n r = requests.get(url)\n if r.status_code != 200:\n raise Exception(\"Paper request failed '%s'\" % url)\n return get_soup(r.content)","def get_html_content(self, url):\n\n req = urllib2.Request(url, headers=self.HEADER)\n page = urllib2.urlopen(req)\n soup = BeautifulSoup(page)\n\n return soup","def get_soup_from_url(url, parser='html.parser'):\n r = requests.get(url)\n r.raise_for_status()\n soup = bs4.BeautifulSoup(r.text, parser)\n return soup","def soupify(html):\n return BeautifulSoup(html, \"html.parser\")","def parse_source(html, encoding='utf-8'):\n return BeautifulSoup(html, from_encoding=encoding)","def return_beautiful_soup_object(url: str) -> bs4.BeautifulSoup:\n html_filename, headers = urllib.request.urlretrieve(url)\n with open(html_filename) as file:\n soup = BeautifulSoup(file, 'html.parser')\n file.close()\n return soup","def make_request(url):\r\n req = requests.get(url, headers)\r\n soup = BeautifulSoup (req.content, \"html5lib\")\r\n return soup","def create_soup(u):\n req = requests.get(u)\n html = req.text\n s = BeautifulSoup(html, \"html.parser\")\n return s","def soup_given_url(given_url):\n url = given_url\n content = urllib.request.urlopen(url)\n soup = BeautifulSoup(content, \"html.parser\")\n return soup","def getHTML(self):\n html = requests.get(self.URL).text\n soup = BeautifulSoup(html, \"lxml\")\n return soup","def make_soup(url, params=None):\n\n r = requests.get(url, params=params)\n if r.status_code != requests.codes.ok:\n raise Exception('Error: status code is %s for URL: %s' %\n (str(r.status_code), url))\n\n contents = r.content\n \n soup = BeautifulSoup(contents, parser, from_encoding='iso-8859-1')\n return soup","def get_site_tags(html, tags=[\"a\"]):\n soup = BeautifulSoup(html)\n\n # For each of the wanted tags, parse out the tags from the web-page\n links = list()\n for t in tags:\n links.extend(soup.find_all(t))\n return links","def soup(self):\n if not self._soup:\n resp = requests.get(self.url)\n if not resp.ok:\n logging.warning('Status of request is not ok.')\n self._soup = BeautifulSoup(resp.content, 'html.parser')\n\n return self._soup","def load_website(self):\n# r = urllib.request.urlopen(self.url).read()\n r = requests.get(self.url).content \n self.soup = bs(r, \"lxml\")","def hot_soup(url, payload={}):\r\n response = query(url, payload)\r\n soup = BeautifulSoup(response.content, 'html.parser')\r\n return soup","def parse(url, conf):\n try:\n result = []\n html = urlopen(url)\n dom = soupparser.fromstring(html)\n items = dom.xpath(conf['xpath'])\n\n for item in items:\n result.append(conf['parse_func'](item.getchildren()))\n return result\n except Exception , e:\n raise e","def itag_of_soup(soup):\n if isinstance(soup, bs4.element.NavigableString):\n return str(soup)\n to_return = Tag([itag_of_soup(content) for content in soup.contents])\n to_return.soup = soup\n return to_return","def parse(url, parser='html5lib', **kwargs):\n return bs4.BeautifulSoup(SESSION.get(url).content, features=parser, **kwargs)","def gather_current(url=URL):\n page = requests.get(url)\n soup = BeautifulSoup(page.content, 'html.parser')\n return soup","def tags(self):\r\n url = '{0}/tags/'.format(self.get_url())\r\n request = http.Request('GET', url)\r\n\r\n return request, parsers.parse_json","def get_soup(url, using_TOR = False):\n try:\n request = get_request(url, using_TOR = using_TOR)\n if request == None:\n logger.debug(\"Request is empty, don't create soup.\")\n return None\n soup = BeautifulSoup(request, 'html.parser')\n return soup\n except Exception as error:\n #logger.warn(traceback.format_exc())\n raise\n return None","def _html(url: str) -> BeautifulSoup:\n with urllib3.PoolManager() as manager:\n res = manager.request(\"GET\", url, headers={\"User-Agent\": ua.chrome})\n if res.status != 200:\n raise Exception(res.status)\n soup = BeautifulSoup(res.data, \"html.parser\")\n return soup","def create_soup(url):\n ua = UserAgent()\n user_agent = {'User-agent': ua.random}\n response_text = requests.get(url, headers=user_agent).text\n soup = BeautifulSoup(response_text, 'html5lib')\n return soup","def getAllHTMLTags(self, html, tag):\n soup = BeautifulSoup(html, 'html.parser')\n content = soup.find_all(tag)\n return content","def getHTML(url):\n\n time.sleep(2.00)\n html = urllib2.urlopen(url,timeout=10).read()\n urllib2.urlopen(url).close()\n\n soup = BeautifulSoup(html)\n\n return soup","def get_soup(self, url):\n if self.session is None:\n return BeautifulSoup(requests.get(url).content, features=\"xml\")\n else:\n return BeautifulSoup(self.session.get(url).content, features=\"xml\")","def parse(self):\n if not os.path.exists(self.file):\n raise Exception(\"File not found\")\n f = open(self.file)\n\n content = f.read()\n soup = BeautifulSoup(content, \"html.parser\")\n if self.prefix:\n css_selector = \"a[href^='\"+self.prefix+\"']\"\n else:\n css_selector = 'a'\n links = soup.select(css_selector)\n return [item['href'] for item in links]","def get_docs_html_content(url):\n # Relevant tags\n want_tags = ['p', 'h1', 'h2', 'h3', 'div']\n # Relevant classes and ids for div elements\n want_divs = ['variablelist', 'aws-note', 'YAML']\n # Get request to amazon\n response = requests.get(url, proxies=urllib.getproxies())\n # Parse the raw HTML\n parsed = html.fromstring(response.text)\n # Print out the HTML elements we want\n try:\n main_content = parsed.get_element_by_id(\"main-col-body\")\n except KeyError:\n print(\"Sorry! Did not find a document.\")\n print(url)\n exit(1)\n content = []\n for el in main_content:\n if (el.tag not in want_tags) or \\\n (el.tag == 'div') and not ( \\\n ('class' in el.attrib.keys() and el.attrib['class'] in want_divs) or \\\n ('id' in el.attrib.keys() and el.attrib['id'] in want_divs)\n ):\n continue\n content.append(html.tostring(el))\n return \"\".join(content)","def get_webpage(url):\n response = requests.get(url)\n data = response.text\n soup = BeautifulSoup(data, features=\"html.parser\")\n\n for tag in INVALID_TAGS:\n for match in soup.findAll(tag):\n match.replaceWithChildren()\n\n paragraphs = [str.join('', paragraph.children) for paragraph in soup.findAll('p')]\n return paragraphs","def get_tags(self):\n return self.get_url_data(self.api_url + 'refs/tags')","def Soup(s, features='lxml', **kw):\n if isinstance(s, Path):\n src = s.read_text()\n elif s.startswith('http'):\n src = requests.get(s).text\n elif splitext(s)[1] in ('.html', '.xml'):\n src = open(s).read()\n else:\n src = s\n return BeautifulSoup(src, features, **kw)","def get_soup(url):\n url_hash = get_url_hash(url)\n www_cache_file = os.path.join(www_cache_dir, url_hash)\n if os.path.exists(www_cache_file):\n with open(www_cache_file) as file:\n charset = 'utf8'\n data = file.read().encode(charset)\n else:\n print('Downloading %s...' % url, file=sys.stderr)\n with urlopen(url) as stream:\n charset = stream.info().get_param('charset')\n data = stream.read()\n with open(www_cache_file, 'w') as file:\n file.write(data.decode(charset))\n return bs4.BeautifulSoup(data, 'lxml', from_encoding=charset)","def get_soup_alternate(url):\n\theaders = {\"User-Agent\":\"Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/2.0.0.11\"}\n\treq = Request(url, headers=headers)\n\tresponse = urlopen(req)\n\thtml = response.read()\n\tsoup = BeautifulSoup(html, \"html.parser\")\n\tresponse.close()\n\treturn soup","def soup_of_itag(itag):\n if type(itag) == str:\n return bs4.element.NavigableString(itag)\n soup = itag.soup\n soup.contents = [soup_of_itag(child) for child in itag.children]\n return soup","def get_study_data(self, soup, url):\n pass","def get_soup(self):\n page = get(self.url)\n if page.status_code == 200:\n soup = BeautifulSoup(page.text, 'lxml')\n return soup\n else:\n raise ConnectionError('The page is not disponible.')","def get_soup_for_page(url: str) -> BeautifulSoup:\n return BeautifulSoup(get_html(url), 'html.parser')","def read_html(url: str) -> BeautifulSoup:\n try:\n response = requests.get(url, stream=True)\n status_code = response.status_code\n content_type = response.headers[\"Content-Type\"].lower()\n except requests.RequestException as e:\n raise RuntimeError(f\"Error during requests to {url} : {str(e)}\")\n else:\n if (\n status_code == 200\n and content_type is not None\n and content_type.find(\"html\") > -1\n ):\n return BeautifulSoup(response.content, \"html.parser\")","def get_content_from_link(link):\n\n page = requests.get(link)\n soup = BeautifulSoup(page.text, \"lxml\")\n return soup","def read_soup(url, base_url=None,debug=False):\n\n soup = None\n # read local file\n if debug == True:\n print(\"\\n***********************************\")\n print(\"Opening \", url)\n # read url or file\n if url[:4].lower() == \"http\":\n soup = read_soup_from_url(url, debug=debug)\n else:\n soup = read_soup_from_local_html(url, debug=debug)\n if debug is True:\n print(f\"read soup from {url} containing {len(str(soup))} characters\") \n if base_url is not None:\n soup = replace_relative_links(soup,base_url,debug=debug)\n return soup","def parse_soup(self, soup):\n # find all li tags\n return soup.find_all('li', class_='b_algo')","def get_tags(self, tag_name: str):\n return self.soup.find_all(tag_name)","def tags(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'tags')\r\n\r\n return http.Request('GET', url), parsers.parse_json","def parse(self, url):\n pass","def _get_soup_by_path(self, path):\n return BeautifulSoup(requests.get('%s%s' % (self.URL, path), headers=self.HEADERS).content)","def get_data(url):\n\n request = requests.get(url)\n\n soup = BeautifulSoup(request.text, \"lxml\")\n\n ol_tags = soup.find_all('ol')\n\n names_list = []\n\n for li_tags in ol_tags:\n for names in li_tags:\n names_list.append(names.text)\n\n return names_list","def get_soup():\n global soup\n html = urlopen(\"http://www.jrenshaw.com/works-in-progress/\")\n soup = BeautifulSoup(html, \"lxml\")\n return soup","def _get_tags(tempfile=TEMPFILE):\n with open(tempfile) as f:\n content = f.read().lower()\n # take a small subset to keep it performant\n tags = TAG_HTML.findall(content)\n tags = [tag for tag in tags if len(tag) > MIN_TAG_LEN]\n return set(tags)","def get_page(self, url):\n page = self.__open_page(url)\n soup = BeautifulSoup(page, 'html.parser')\n return soup","def _index_document(self, soup):\n class DummyTag(object):\n next = False\n name = ''\n\n class NextTag(object):\n def __init__(self, obj):\n self.next = obj\n\n tag = soup.html\n stack = [DummyTag(), soup.html]\n\n while tag and tag.next:\n tag = tag.next\n\n # html tag\n if isinstance(tag, Tag):\n\n if tag.parent != stack[-1]:\n self._exit[stack[-1].name.lower()](stack[-1])\n stack.pop()\n\n tag_name = tag.name.lower()\n\n # ignore this tag and everything in it\n if tag_name in self._ignored_tags:\n if tag.nextSibling:\n tag = NextTag(tag.nextSibling)\n else:\n self._exit[stack[-1].name.lower()](stack[-1])\n stack.pop()\n tag = NextTag(tag.parent.nextSibling)\n\n continue\n\n # enter the tag\n self._enter[tag_name](tag)\n stack.append(tag)\n\n # text (text, cdata, comments, etc.)\n else:\n self._add_text(tag)","def _index_document(self, soup):\n class DummyTag(object):\n next = False\n name = ''\n\n class NextTag(object):\n def __init__(self, obj):\n self.next = obj\n\n tag = soup.html\n stack = [DummyTag(), soup.html]\n\n while tag and tag.next:\n tag = tag.next\n\n # html tag\n if isinstance(tag, Tag):\n\n if tag.parent != stack[-1]:\n self._exit[stack[-1].name.lower()](stack[-1])\n stack.pop()\n\n tag_name = tag.name.lower()\n\n # ignore this tag and everything in it\n if tag_name in self._ignored_tags:\n if tag.nextSibling:\n tag = NextTag(tag.nextSibling)\n else:\n self._exit[stack[-1].name.lower()](stack[-1])\n stack.pop()\n tag = NextTag(tag.parent.nextSibling)\n\n continue\n\n # enter the tag\n self._enter[tag_name](tag)\n stack.append(tag)\n\n # text (text, cdata, comments, etc.)\n else:\n self._add_text(tag)","def tweet_tags(url:string) -> string:\n \n tweet_request = requests.get('https://publish.twitter.com/oembed?url=' + url + '&omit_script=true')\n tweet_json = tweet_request.json()\n tweet_html = tweet_json['html']\n \n return tweet_html","def get_soup(self, html):\n if html is not None:\n soup = BeautifulSoup(html, \"html.parser\")\n return soup\n else:\n return","def soup_explore(url_or_file, session=None):\n soup = ph.get_soup(url_or_file, session)\n if not soup:\n ph.logger.error('No soup found for {}'.format(url_or_file))\n else:\n print('\\nExplore the \"soup\" object\\n\\n')\n embed()\n return soup","def _get_tree(url):\n\n source = _get_site_html(url)\n try:\n tree = BeautifulSoup(source,'html.parser')\n except:\n tree = ''\n \n return tree","def list(self):\n\n\t\treturn self._list(\"/tag\", \"tag\")","def tags(self):\r\n url = self.base_url + 'tags/'\r\n return json.loads(self.bb.load_url(url))","def make_soup_if_necessary():\n import urllib\n target_url = \"http://sfbay.craigslist.org/sfc/apa\"\n target_url_loc = urllib.urlopen( target_url )\n target_url_data = target_url_loc.read()\n target_url_loc.close()\n target_url_soup = BeautifulSoup( target_url_data )\n\n return target_url_soup","def _get_content(soup: bs4.BeautifulSoup, keyword: str=\"\") -> dict:\n articles = {}\n urls = _filter_duplicate_urls(_get_urls(soup, keyword))\n for url in urls:\n try:\n response = requests.get(url)\n if response.status_code == 200:\n # Comment/Uncomment below line to\n # hide/print url of each article\n url_soup = _get_soup_object(url)\n article_tags = url_soup.find_all('article')\n p_tags = article_tags[0].find_all('p')\n final_article = ''\n list_paragraphs = []\n for p in range(0, len(p_tags)):\n paragraph = p_tags[p].get_text()\n list_paragraphs.append(paragraph)\n final_article = \" \".join(list_paragraphs)\n if final_article:\n articles[url] = final_article\n except Exception as err:\n pass\n return articles","def get_tags_and_contents(html, *tags):\n # return the tags found, plus the stuff between them\n found = []\n for tag in tags:\n start, end = _make_tag_patterns(tag)\n i = 0\n while 1:\n m = re.search(start, html[i:], re.IGNORECASE|re.DOTALL)\n if not m:\n break\n s = m.start()+i\n \n m = re.search(end, html[s:], re.IGNORECASE|re.DOTALL)\n if not m:\n break\n e = m.end()+s\n \n found.append(html[s:e])\n i = e\n # This segfaults sometimes on Python 2.2!\n #reobj = re.compile(r\"%s.*?%s\" % (start, end), re.IGNORECASE|re.DOTALL)\n #found.extend(reobj.findall(html))\n return found","def parse_content(content, parser='html5lib', **kwargs):\n\n return bs4.BeautifulSoup(content, features=parser, **kwargs)","def __g1(soup):\n news = []\n container = soup.select('ul.highlights > li')\n\n for item in container:\n news.append(dict(title=item.a.span.string, link=item.a['href']))\n return news","def get_contents(html, *tags):\n # return the stuff in between the open and close tags.\n tags_and_contents = get_tags_and_contents(html, *tags)\n found = []\n for tac in tags_and_contents:\n tac = tac[tac.find(\">\")+1:] # strip off the tags\n tac = tac[:tac.rfind(\"<\")]\n found.append(tac)\n return found","def get_links() -> list:\n headers = {\n \"User-Agent\": \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36\",\n \"Accept\": \"text/html\",\n \"Accept-Encoding\": \"gzip, deflate\",\n }\n p = re.compile(r'\\d+.html')\n base_url = 'http://stateoftheunion.onetwothree.net/texts/'\n essay_url = base_url + 'index.html'\n res = requests.get(essay_url, headers=headers)\n soup = BeautifulSoup(res.content, 'html')\n links = soup.find_all('a')\n sotu_links = {link.text: base_url + link.get('href', '') for link in links if re.match(p, link.get('href', ''))}\n return sotu_links","def make_soup():\n # It's a pretty complex, auto-generated HTML file. Turns out\n # BeautifulSoup's html.parser, lxml, and xml don't completely parse.\n # Initial workarounds chopped up the file and parsed individually, but the\n # most lenient html5lib parse seems to do the trick.\n response = requests.get(\n 'https://genome.ucsc.edu/goldenPath/help/trackDb/trackDbHub.html')\n soup = bs4.BeautifulSoup(response.text, 'html5lib')\n return soup","def get_soup(session, url, user_agent):\n headers = cs.base_request_headers\n headers['User-Agent'] = user_agent\n\n page = custom_get(session=session, url=url, headers=headers)\n\n return BeautifulSoup(page.text, 'html.parser')","def get_links(tag, attribute, url, content):\n soup = BeautifulSoup(content, 'html.parser')\n links = []\n for link in soup.findAll(tag):\n link = link.get(attribute)\n links.append(sanitize_link(link, url))\n return links","def get_urls(r):\n url_list = find_urls(r)\n url_list += find_tag_urls(r)\n return set(url_list)","def get_document(url):\n r = requests.get(url, timeout=5)\n r.raise_for_status()\n return lxml.html.fromstring(r.content)","def get_article(self, url):\n response = self.opener.open(url)\n doc = lxml.html.document_fromstring(response.read())\n content = doc.find_class(\"post\")[0] # Select content by CSS class \n cleaned_content = clean_html(content)\n str_cleaned_content = lxml.html.tostring(cleaned_content)\n # self.__save_article_to_file(str_cleaned_content)\n return str_cleaned_content","def fetch_url(url):\n try:\n soup = bs(urlopen(url).read(), 'html.parser')\n return soup\n except:\n print \"Couldnot download the content from the URL\", url\n return \"\""],"string":"[\n \"def get_soup(url):\\n return BeautifulSoup(requests.get(url).content, 'lxml')\",\n \"def getSoup(url):\\n return BeautifulSoup(getHtml(url), 'lxml')\",\n \"def find_tag_urls(r):\\n parser = MyHTMLParser()\\n parser.feed(r)\\n return parser.url_list\",\n \"def request(self, url):\\r\\n\\r\\n req = self.get(url)\\r\\n soup = BeautifulSoup(req.content, \\\"lxml\\\")\\r\\n return soup\",\n \"def get_soup(url):\\n\\tr = requests.get(url)\\n\\tdata = r.text\\n\\tsoup = BeautifulSoup(data, \\\"lxml\\\")\\n\\treturn soup\",\n \"def get_soup(url):\\n response = requests.get(url)\\n soup = BeautifulSoup(response.text, 'html.parser')\\n return soup\",\n \"def request(url):\\n response=requests.get(url)\\n soup=BeautifulSoup(response.content,\\\"lxml\\\")\\n return soup\",\n \"def get_soup(url: str):\\n response = requests.get(url)\\n\\n return BeautifulSoup(response.content, \\\"html.parser\\\")\",\n \"def get_soup(url):\\r\\n page=requests.get(url)\\r\\n soup = BeautifulSoup(page.text.encode(\\\"utf-8\\\"), 'html.parser')\\r\\n return soup\",\n \"def get_tags(self):\\r\\n self.tags = []\\r\\n for tag in self.soup.find_all('dl'):\\r\\n name = tag.dt.contents[0]\\r\\n\\r\\n # getting info about tag\\r\\n info = ''\\r\\n for p in tag.dd.find_all('p'):\\r\\n info += p.getText() + ' '\\r\\n\\r\\n # getting reference link and code snippet\\r\\n a_tags = tag.dd.find_all('a')\\r\\n example_id = a_tags[1]['href'].replace('#', '') # code snippet\\r\\n example = self.soup.find('div', {'id': example_id}).getText()\\r\\n\\r\\n # url reference (from HTML5Doctor if exists)\\r\\n reference = ''\\r\\n try:\\r\\n reference = tag.dt.span.a['href'] # url for HTML5Doctor\\r\\n except:\\r\\n reference = a_tags[0]['href'] # url for W3C\\r\\n\\r\\n reference = 'http://html5doctor.com/element-index/#' + name\\r\\n new_tag = Tag(name, info, reference, example)\\r\\n self.tags.append(new_tag)\\r\\n logger.info('Tag parsed: %s' % new_tag.name)\",\n \"def make_soup(url):\\r\\n htmlFile = urllib.request.urlopen(url).read()\\r\\n soup = BeautifulSoup(htmlFile)\\r\\n return soup\",\n \"def _get_soup_object(url: str) -> bs4.BeautifulSoup:\\n request_result=requests.get(url)\\n soup = bs4.BeautifulSoup(request_result.text, \\\"html.parser\\\")\\n return soup\",\n \"def get_document(url):\\n req = requests.get(url)\\n doc = BeautifulSoup(req.content, \\\"html.parser\\\")\\n return doc\",\n \"def get_soup(url: str) -> BeautifulSoup:\\n html = get_html(url)\\n soup = BeautifulSoup(html, 'lxml')\\n return soup\",\n \"def get_soup(url):\\n\\tresponse = urlopen(url)\\n\\thtml = response.read()\\n\\tsoup = BeautifulSoup(html, \\\"html.parser\\\")\\n\\tresponse.close()\\n\\treturn soup\",\n \"def _soup(self, url):\\n r = self.session.get(url)\\n r.raise_for_status()\\n html = Soup(r.text, 'lxml') # lxml is fastert than html.parser\\n r.close()\\n return html\",\n \"def getLinks(self, url, tag = \\\"a\\\", attr = \\\"href\\\"): \\n try: \\n response = open(self.filename(url)).read() #read from the file\\n except IOError:\\n raise IOError\\n parsed_url = urlparse(url)\\n domain = parsed_url[0] + '://' + parsed_url[1]\\n \\n try:\\n soup = BeautifulSoup.BeautifulSoup(response)\\n l = soup.findAll(tag, href = True)\\n except Exception:\\n raise Exception\\n links = []\\n \\n for tag in l:\\n link = str(tag[attr]) #convert the link to a string\\n purl = urlparse(link)\\n if purl[1] == '': #if the link is relative make it absolute\\n link = domain+link\\n #check if the extension is that of a document \\n if splitext(link)[1] in self._invalidExt: \\n self.docs_list.append(link)\\n \\n #append only the html link\\n links.append(link)\\n \\n \\n \\n return list(set(links)) #returns only distinct links\",\n \"def get_soup(url):\\n opener = urllib2.build_opener()\\n request = urllib2.Request(url);\\n request.add_header('User-Agent','Mozilla/6.0 (Windows NT 6.2; WOW64; rv:16.0.1) Gecko/20121011 Firefox/16.0.1');\\n data = opener.open(request).read(); \\n return BeautifulSoup(data);\",\n \"def get_tags(html_soup):\\n \\n tags = html_soup.findAll('a', attrs = {\\\"class\\\" : \\\"tag\\\"})\\n all_tags = []\\n for i in tags:\\n all_tags.append(i.get_text())\\n \\n return all_tags\",\n \"def get_html_parser(url):\\n response = requests.get(url)\\n return BeautifulSoup(response.content, 'html.parser')\",\n \"def _get_tags(self, res):\\n doc = pq(res.content)\\n return (doc('[property=\\\"og:title\\\"]').attr('content'),\\n doc('[property=\\\"og:image\\\"]').attr('content'),\\n doc('[name=\\\"description\\\"]').attr('content'))\",\n \"def make_file_soup(self):\\n soup = BeautifulSoup(self.html, 'html.parser')\\n return soup\",\n \"def page_soup(url):\\n html = requests.get(url).text\\n return bs(html, 'html.parser')\",\n \"def get_content(self):\\n response = requests.get(self.url)\\n soup = BeautifulSoup(response.text, \\\"html.parser\\\")\\n return soup\",\n \"def load_data(url: str):\\n\\n page = requests.get(url=url)\\n soup = BeautifulSoup(page.content, 'html.parser')\\n return soup\",\n \"def get_article(url):\\n \\n r = requests.get(url) \\n html_soup = BeautifulSoup(r.content, 'lxml')\\n return html_soup\",\n \"def _get_soup(self, url):\\n\\n # generate a random header \\n headers = {'User-Agent': self._random_user_agent()}\\n # send a request and get the soup\\n response = requests.get(url, headers=headers)\\n results = response.content\\n if not response.status_code == 404:\\n soup = BeautifulSoup(results, 'lxml')\\n return soup\",\n \"def soup(url):\\n handle = ''\\n max_tries = 10\\n for i in range(max_tries):\\n try:\\n handle = urlopen(url)\\n handle = handle.read()\\n break\\n except:\\n logging.exception('urlopen failed (attempt %d)', i + 1)\\n if i == max_tries - 1:\\n logging.error('the maximum urlopen attempts have been reached')\\n raise\\n time.sleep(1)\\n\\n s = BeautifulSoup(handle)\\n return s\",\n \"def make_soup(self):\\n req = urllib.request.Request(\\n url,\\n data=None,\\n headers={\\n 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36'\\n }\\n )\\n f = urllib.request.urlopen(self.html)\\n soupdata = BeautifulSoup(f, \\\"html.parser\\\")\\n return soupdata\",\n \"def get_url_soup(url):\\n r = requests.get(url)\\n if r.status_code != 200:\\n raise Exception(\\\"Paper request failed '%s'\\\" % url)\\n return get_soup(r.content)\",\n \"def get_html_content(self, url):\\n\\n req = urllib2.Request(url, headers=self.HEADER)\\n page = urllib2.urlopen(req)\\n soup = BeautifulSoup(page)\\n\\n return soup\",\n \"def get_soup_from_url(url, parser='html.parser'):\\n r = requests.get(url)\\n r.raise_for_status()\\n soup = bs4.BeautifulSoup(r.text, parser)\\n return soup\",\n \"def soupify(html):\\n return BeautifulSoup(html, \\\"html.parser\\\")\",\n \"def parse_source(html, encoding='utf-8'):\\n return BeautifulSoup(html, from_encoding=encoding)\",\n \"def return_beautiful_soup_object(url: str) -> bs4.BeautifulSoup:\\n html_filename, headers = urllib.request.urlretrieve(url)\\n with open(html_filename) as file:\\n soup = BeautifulSoup(file, 'html.parser')\\n file.close()\\n return soup\",\n \"def make_request(url):\\r\\n req = requests.get(url, headers)\\r\\n soup = BeautifulSoup (req.content, \\\"html5lib\\\")\\r\\n return soup\",\n \"def create_soup(u):\\n req = requests.get(u)\\n html = req.text\\n s = BeautifulSoup(html, \\\"html.parser\\\")\\n return s\",\n \"def soup_given_url(given_url):\\n url = given_url\\n content = urllib.request.urlopen(url)\\n soup = BeautifulSoup(content, \\\"html.parser\\\")\\n return soup\",\n \"def getHTML(self):\\n html = requests.get(self.URL).text\\n soup = BeautifulSoup(html, \\\"lxml\\\")\\n return soup\",\n \"def make_soup(url, params=None):\\n\\n r = requests.get(url, params=params)\\n if r.status_code != requests.codes.ok:\\n raise Exception('Error: status code is %s for URL: %s' %\\n (str(r.status_code), url))\\n\\n contents = r.content\\n \\n soup = BeautifulSoup(contents, parser, from_encoding='iso-8859-1')\\n return soup\",\n \"def get_site_tags(html, tags=[\\\"a\\\"]):\\n soup = BeautifulSoup(html)\\n\\n # For each of the wanted tags, parse out the tags from the web-page\\n links = list()\\n for t in tags:\\n links.extend(soup.find_all(t))\\n return links\",\n \"def soup(self):\\n if not self._soup:\\n resp = requests.get(self.url)\\n if not resp.ok:\\n logging.warning('Status of request is not ok.')\\n self._soup = BeautifulSoup(resp.content, 'html.parser')\\n\\n return self._soup\",\n \"def load_website(self):\\n# r = urllib.request.urlopen(self.url).read()\\n r = requests.get(self.url).content \\n self.soup = bs(r, \\\"lxml\\\")\",\n \"def hot_soup(url, payload={}):\\r\\n response = query(url, payload)\\r\\n soup = BeautifulSoup(response.content, 'html.parser')\\r\\n return soup\",\n \"def parse(url, conf):\\n try:\\n result = []\\n html = urlopen(url)\\n dom = soupparser.fromstring(html)\\n items = dom.xpath(conf['xpath'])\\n\\n for item in items:\\n result.append(conf['parse_func'](item.getchildren()))\\n return result\\n except Exception , e:\\n raise e\",\n \"def itag_of_soup(soup):\\n if isinstance(soup, bs4.element.NavigableString):\\n return str(soup)\\n to_return = Tag([itag_of_soup(content) for content in soup.contents])\\n to_return.soup = soup\\n return to_return\",\n \"def parse(url, parser='html5lib', **kwargs):\\n return bs4.BeautifulSoup(SESSION.get(url).content, features=parser, **kwargs)\",\n \"def gather_current(url=URL):\\n page = requests.get(url)\\n soup = BeautifulSoup(page.content, 'html.parser')\\n return soup\",\n \"def tags(self):\\r\\n url = '{0}/tags/'.format(self.get_url())\\r\\n request = http.Request('GET', url)\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def get_soup(url, using_TOR = False):\\n try:\\n request = get_request(url, using_TOR = using_TOR)\\n if request == None:\\n logger.debug(\\\"Request is empty, don't create soup.\\\")\\n return None\\n soup = BeautifulSoup(request, 'html.parser')\\n return soup\\n except Exception as error:\\n #logger.warn(traceback.format_exc())\\n raise\\n return None\",\n \"def _html(url: str) -> BeautifulSoup:\\n with urllib3.PoolManager() as manager:\\n res = manager.request(\\\"GET\\\", url, headers={\\\"User-Agent\\\": ua.chrome})\\n if res.status != 200:\\n raise Exception(res.status)\\n soup = BeautifulSoup(res.data, \\\"html.parser\\\")\\n return soup\",\n \"def create_soup(url):\\n ua = UserAgent()\\n user_agent = {'User-agent': ua.random}\\n response_text = requests.get(url, headers=user_agent).text\\n soup = BeautifulSoup(response_text, 'html5lib')\\n return soup\",\n \"def getAllHTMLTags(self, html, tag):\\n soup = BeautifulSoup(html, 'html.parser')\\n content = soup.find_all(tag)\\n return content\",\n \"def getHTML(url):\\n\\n time.sleep(2.00)\\n html = urllib2.urlopen(url,timeout=10).read()\\n urllib2.urlopen(url).close()\\n\\n soup = BeautifulSoup(html)\\n\\n return soup\",\n \"def get_soup(self, url):\\n if self.session is None:\\n return BeautifulSoup(requests.get(url).content, features=\\\"xml\\\")\\n else:\\n return BeautifulSoup(self.session.get(url).content, features=\\\"xml\\\")\",\n \"def parse(self):\\n if not os.path.exists(self.file):\\n raise Exception(\\\"File not found\\\")\\n f = open(self.file)\\n\\n content = f.read()\\n soup = BeautifulSoup(content, \\\"html.parser\\\")\\n if self.prefix:\\n css_selector = \\\"a[href^='\\\"+self.prefix+\\\"']\\\"\\n else:\\n css_selector = 'a'\\n links = soup.select(css_selector)\\n return [item['href'] for item in links]\",\n \"def get_docs_html_content(url):\\n # Relevant tags\\n want_tags = ['p', 'h1', 'h2', 'h3', 'div']\\n # Relevant classes and ids for div elements\\n want_divs = ['variablelist', 'aws-note', 'YAML']\\n # Get request to amazon\\n response = requests.get(url, proxies=urllib.getproxies())\\n # Parse the raw HTML\\n parsed = html.fromstring(response.text)\\n # Print out the HTML elements we want\\n try:\\n main_content = parsed.get_element_by_id(\\\"main-col-body\\\")\\n except KeyError:\\n print(\\\"Sorry! Did not find a document.\\\")\\n print(url)\\n exit(1)\\n content = []\\n for el in main_content:\\n if (el.tag not in want_tags) or \\\\\\n (el.tag == 'div') and not ( \\\\\\n ('class' in el.attrib.keys() and el.attrib['class'] in want_divs) or \\\\\\n ('id' in el.attrib.keys() and el.attrib['id'] in want_divs)\\n ):\\n continue\\n content.append(html.tostring(el))\\n return \\\"\\\".join(content)\",\n \"def get_webpage(url):\\n response = requests.get(url)\\n data = response.text\\n soup = BeautifulSoup(data, features=\\\"html.parser\\\")\\n\\n for tag in INVALID_TAGS:\\n for match in soup.findAll(tag):\\n match.replaceWithChildren()\\n\\n paragraphs = [str.join('', paragraph.children) for paragraph in soup.findAll('p')]\\n return paragraphs\",\n \"def get_tags(self):\\n return self.get_url_data(self.api_url + 'refs/tags')\",\n \"def Soup(s, features='lxml', **kw):\\n if isinstance(s, Path):\\n src = s.read_text()\\n elif s.startswith('http'):\\n src = requests.get(s).text\\n elif splitext(s)[1] in ('.html', '.xml'):\\n src = open(s).read()\\n else:\\n src = s\\n return BeautifulSoup(src, features, **kw)\",\n \"def get_soup(url):\\n url_hash = get_url_hash(url)\\n www_cache_file = os.path.join(www_cache_dir, url_hash)\\n if os.path.exists(www_cache_file):\\n with open(www_cache_file) as file:\\n charset = 'utf8'\\n data = file.read().encode(charset)\\n else:\\n print('Downloading %s...' % url, file=sys.stderr)\\n with urlopen(url) as stream:\\n charset = stream.info().get_param('charset')\\n data = stream.read()\\n with open(www_cache_file, 'w') as file:\\n file.write(data.decode(charset))\\n return bs4.BeautifulSoup(data, 'lxml', from_encoding=charset)\",\n \"def get_soup_alternate(url):\\n\\theaders = {\\\"User-Agent\\\":\\\"Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/2.0.0.11\\\"}\\n\\treq = Request(url, headers=headers)\\n\\tresponse = urlopen(req)\\n\\thtml = response.read()\\n\\tsoup = BeautifulSoup(html, \\\"html.parser\\\")\\n\\tresponse.close()\\n\\treturn soup\",\n \"def soup_of_itag(itag):\\n if type(itag) == str:\\n return bs4.element.NavigableString(itag)\\n soup = itag.soup\\n soup.contents = [soup_of_itag(child) for child in itag.children]\\n return soup\",\n \"def get_study_data(self, soup, url):\\n pass\",\n \"def get_soup(self):\\n page = get(self.url)\\n if page.status_code == 200:\\n soup = BeautifulSoup(page.text, 'lxml')\\n return soup\\n else:\\n raise ConnectionError('The page is not disponible.')\",\n \"def get_soup_for_page(url: str) -> BeautifulSoup:\\n return BeautifulSoup(get_html(url), 'html.parser')\",\n \"def read_html(url: str) -> BeautifulSoup:\\n try:\\n response = requests.get(url, stream=True)\\n status_code = response.status_code\\n content_type = response.headers[\\\"Content-Type\\\"].lower()\\n except requests.RequestException as e:\\n raise RuntimeError(f\\\"Error during requests to {url} : {str(e)}\\\")\\n else:\\n if (\\n status_code == 200\\n and content_type is not None\\n and content_type.find(\\\"html\\\") > -1\\n ):\\n return BeautifulSoup(response.content, \\\"html.parser\\\")\",\n \"def get_content_from_link(link):\\n\\n page = requests.get(link)\\n soup = BeautifulSoup(page.text, \\\"lxml\\\")\\n return soup\",\n \"def read_soup(url, base_url=None,debug=False):\\n\\n soup = None\\n # read local file\\n if debug == True:\\n print(\\\"\\\\n***********************************\\\")\\n print(\\\"Opening \\\", url)\\n # read url or file\\n if url[:4].lower() == \\\"http\\\":\\n soup = read_soup_from_url(url, debug=debug)\\n else:\\n soup = read_soup_from_local_html(url, debug=debug)\\n if debug is True:\\n print(f\\\"read soup from {url} containing {len(str(soup))} characters\\\") \\n if base_url is not None:\\n soup = replace_relative_links(soup,base_url,debug=debug)\\n return soup\",\n \"def parse_soup(self, soup):\\n # find all li tags\\n return soup.find_all('li', class_='b_algo')\",\n \"def get_tags(self, tag_name: str):\\n return self.soup.find_all(tag_name)\",\n \"def tags(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'tags')\\r\\n\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def parse(self, url):\\n pass\",\n \"def _get_soup_by_path(self, path):\\n return BeautifulSoup(requests.get('%s%s' % (self.URL, path), headers=self.HEADERS).content)\",\n \"def get_data(url):\\n\\n request = requests.get(url)\\n\\n soup = BeautifulSoup(request.text, \\\"lxml\\\")\\n\\n ol_tags = soup.find_all('ol')\\n\\n names_list = []\\n\\n for li_tags in ol_tags:\\n for names in li_tags:\\n names_list.append(names.text)\\n\\n return names_list\",\n \"def get_soup():\\n global soup\\n html = urlopen(\\\"http://www.jrenshaw.com/works-in-progress/\\\")\\n soup = BeautifulSoup(html, \\\"lxml\\\")\\n return soup\",\n \"def _get_tags(tempfile=TEMPFILE):\\n with open(tempfile) as f:\\n content = f.read().lower()\\n # take a small subset to keep it performant\\n tags = TAG_HTML.findall(content)\\n tags = [tag for tag in tags if len(tag) > MIN_TAG_LEN]\\n return set(tags)\",\n \"def get_page(self, url):\\n page = self.__open_page(url)\\n soup = BeautifulSoup(page, 'html.parser')\\n return soup\",\n \"def _index_document(self, soup):\\n class DummyTag(object):\\n next = False\\n name = ''\\n\\n class NextTag(object):\\n def __init__(self, obj):\\n self.next = obj\\n\\n tag = soup.html\\n stack = [DummyTag(), soup.html]\\n\\n while tag and tag.next:\\n tag = tag.next\\n\\n # html tag\\n if isinstance(tag, Tag):\\n\\n if tag.parent != stack[-1]:\\n self._exit[stack[-1].name.lower()](stack[-1])\\n stack.pop()\\n\\n tag_name = tag.name.lower()\\n\\n # ignore this tag and everything in it\\n if tag_name in self._ignored_tags:\\n if tag.nextSibling:\\n tag = NextTag(tag.nextSibling)\\n else:\\n self._exit[stack[-1].name.lower()](stack[-1])\\n stack.pop()\\n tag = NextTag(tag.parent.nextSibling)\\n\\n continue\\n\\n # enter the tag\\n self._enter[tag_name](tag)\\n stack.append(tag)\\n\\n # text (text, cdata, comments, etc.)\\n else:\\n self._add_text(tag)\",\n \"def _index_document(self, soup):\\n class DummyTag(object):\\n next = False\\n name = ''\\n\\n class NextTag(object):\\n def __init__(self, obj):\\n self.next = obj\\n\\n tag = soup.html\\n stack = [DummyTag(), soup.html]\\n\\n while tag and tag.next:\\n tag = tag.next\\n\\n # html tag\\n if isinstance(tag, Tag):\\n\\n if tag.parent != stack[-1]:\\n self._exit[stack[-1].name.lower()](stack[-1])\\n stack.pop()\\n\\n tag_name = tag.name.lower()\\n\\n # ignore this tag and everything in it\\n if tag_name in self._ignored_tags:\\n if tag.nextSibling:\\n tag = NextTag(tag.nextSibling)\\n else:\\n self._exit[stack[-1].name.lower()](stack[-1])\\n stack.pop()\\n tag = NextTag(tag.parent.nextSibling)\\n\\n continue\\n\\n # enter the tag\\n self._enter[tag_name](tag)\\n stack.append(tag)\\n\\n # text (text, cdata, comments, etc.)\\n else:\\n self._add_text(tag)\",\n \"def tweet_tags(url:string) -> string:\\n \\n tweet_request = requests.get('https://publish.twitter.com/oembed?url=' + url + '&omit_script=true')\\n tweet_json = tweet_request.json()\\n tweet_html = tweet_json['html']\\n \\n return tweet_html\",\n \"def get_soup(self, html):\\n if html is not None:\\n soup = BeautifulSoup(html, \\\"html.parser\\\")\\n return soup\\n else:\\n return\",\n \"def soup_explore(url_or_file, session=None):\\n soup = ph.get_soup(url_or_file, session)\\n if not soup:\\n ph.logger.error('No soup found for {}'.format(url_or_file))\\n else:\\n print('\\\\nExplore the \\\"soup\\\" object\\\\n\\\\n')\\n embed()\\n return soup\",\n \"def _get_tree(url):\\n\\n source = _get_site_html(url)\\n try:\\n tree = BeautifulSoup(source,'html.parser')\\n except:\\n tree = ''\\n \\n return tree\",\n \"def list(self):\\n\\n\\t\\treturn self._list(\\\"/tag\\\", \\\"tag\\\")\",\n \"def tags(self):\\r\\n url = self.base_url + 'tags/'\\r\\n return json.loads(self.bb.load_url(url))\",\n \"def make_soup_if_necessary():\\n import urllib\\n target_url = \\\"http://sfbay.craigslist.org/sfc/apa\\\"\\n target_url_loc = urllib.urlopen( target_url )\\n target_url_data = target_url_loc.read()\\n target_url_loc.close()\\n target_url_soup = BeautifulSoup( target_url_data )\\n\\n return target_url_soup\",\n \"def _get_content(soup: bs4.BeautifulSoup, keyword: str=\\\"\\\") -> dict:\\n articles = {}\\n urls = _filter_duplicate_urls(_get_urls(soup, keyword))\\n for url in urls:\\n try:\\n response = requests.get(url)\\n if response.status_code == 200:\\n # Comment/Uncomment below line to\\n # hide/print url of each article\\n url_soup = _get_soup_object(url)\\n article_tags = url_soup.find_all('article')\\n p_tags = article_tags[0].find_all('p')\\n final_article = ''\\n list_paragraphs = []\\n for p in range(0, len(p_tags)):\\n paragraph = p_tags[p].get_text()\\n list_paragraphs.append(paragraph)\\n final_article = \\\" \\\".join(list_paragraphs)\\n if final_article:\\n articles[url] = final_article\\n except Exception as err:\\n pass\\n return articles\",\n \"def get_tags_and_contents(html, *tags):\\n # return the tags found, plus the stuff between them\\n found = []\\n for tag in tags:\\n start, end = _make_tag_patterns(tag)\\n i = 0\\n while 1:\\n m = re.search(start, html[i:], re.IGNORECASE|re.DOTALL)\\n if not m:\\n break\\n s = m.start()+i\\n \\n m = re.search(end, html[s:], re.IGNORECASE|re.DOTALL)\\n if not m:\\n break\\n e = m.end()+s\\n \\n found.append(html[s:e])\\n i = e\\n # This segfaults sometimes on Python 2.2!\\n #reobj = re.compile(r\\\"%s.*?%s\\\" % (start, end), re.IGNORECASE|re.DOTALL)\\n #found.extend(reobj.findall(html))\\n return found\",\n \"def parse_content(content, parser='html5lib', **kwargs):\\n\\n return bs4.BeautifulSoup(content, features=parser, **kwargs)\",\n \"def __g1(soup):\\n news = []\\n container = soup.select('ul.highlights > li')\\n\\n for item in container:\\n news.append(dict(title=item.a.span.string, link=item.a['href']))\\n return news\",\n \"def get_contents(html, *tags):\\n # return the stuff in between the open and close tags.\\n tags_and_contents = get_tags_and_contents(html, *tags)\\n found = []\\n for tac in tags_and_contents:\\n tac = tac[tac.find(\\\">\\\")+1:] # strip off the tags\\n tac = tac[:tac.rfind(\\\"<\\\")]\\n found.append(tac)\\n return found\",\n \"def get_links() -> list:\\n headers = {\\n \\\"User-Agent\\\": \\\"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36\\\",\\n \\\"Accept\\\": \\\"text/html\\\",\\n \\\"Accept-Encoding\\\": \\\"gzip, deflate\\\",\\n }\\n p = re.compile(r'\\\\d+.html')\\n base_url = 'http://stateoftheunion.onetwothree.net/texts/'\\n essay_url = base_url + 'index.html'\\n res = requests.get(essay_url, headers=headers)\\n soup = BeautifulSoup(res.content, 'html')\\n links = soup.find_all('a')\\n sotu_links = {link.text: base_url + link.get('href', '') for link in links if re.match(p, link.get('href', ''))}\\n return sotu_links\",\n \"def make_soup():\\n # It's a pretty complex, auto-generated HTML file. Turns out\\n # BeautifulSoup's html.parser, lxml, and xml don't completely parse.\\n # Initial workarounds chopped up the file and parsed individually, but the\\n # most lenient html5lib parse seems to do the trick.\\n response = requests.get(\\n 'https://genome.ucsc.edu/goldenPath/help/trackDb/trackDbHub.html')\\n soup = bs4.BeautifulSoup(response.text, 'html5lib')\\n return soup\",\n \"def get_soup(session, url, user_agent):\\n headers = cs.base_request_headers\\n headers['User-Agent'] = user_agent\\n\\n page = custom_get(session=session, url=url, headers=headers)\\n\\n return BeautifulSoup(page.text, 'html.parser')\",\n \"def get_links(tag, attribute, url, content):\\n soup = BeautifulSoup(content, 'html.parser')\\n links = []\\n for link in soup.findAll(tag):\\n link = link.get(attribute)\\n links.append(sanitize_link(link, url))\\n return links\",\n \"def get_urls(r):\\n url_list = find_urls(r)\\n url_list += find_tag_urls(r)\\n return set(url_list)\",\n \"def get_document(url):\\n r = requests.get(url, timeout=5)\\n r.raise_for_status()\\n return lxml.html.fromstring(r.content)\",\n \"def get_article(self, url):\\n response = self.opener.open(url)\\n doc = lxml.html.document_fromstring(response.read())\\n content = doc.find_class(\\\"post\\\")[0] # Select content by CSS class \\n cleaned_content = clean_html(content)\\n str_cleaned_content = lxml.html.tostring(cleaned_content)\\n # self.__save_article_to_file(str_cleaned_content)\\n return str_cleaned_content\",\n \"def fetch_url(url):\\n try:\\n soup = bs(urlopen(url).read(), 'html.parser')\\n return soup\\n except:\\n print \\\"Couldnot download the content from the URL\\\", url\\n return \\\"\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7076313","0.70216066","0.69696605","0.6889851","0.6826193","0.68196535","0.6767906","0.67462474","0.67079365","0.67003834","0.66789085","0.66782737","0.6670707","0.66667145","0.66216266","0.6597798","0.65232784","0.64535815","0.64357543","0.6435498","0.6426641","0.64046687","0.63789827","0.6362027","0.6353759","0.63476354","0.6329162","0.6290426","0.6284854","0.628321","0.6243383","0.621919","0.6216132","0.61971235","0.6166401","0.6164056","0.61580163","0.6138353","0.61048675","0.60762954","0.6067822","0.6056772","0.6046558","0.60464704","0.6033713","0.6020607","0.6007684","0.60064113","0.59990823","0.5999007","0.59971505","0.5977876","0.5973088","0.5970163","0.59578586","0.5957696","0.59539855","0.59432787","0.59302986","0.58960676","0.58906865","0.5889125","0.58888215","0.5884444","0.5871237","0.5854269","0.58534473","0.58511406","0.584577","0.58266026","0.5815209","0.57886934","0.57866013","0.57732475","0.57728577","0.57674927","0.5760843","0.57522696","0.5745004","0.5745004","0.57373863","0.57328135","0.5732233","0.5726312","0.57241607","0.57129973","0.57119226","0.569366","0.5693227","0.56896454","0.5687636","0.56873363","0.5684082","0.56778735","0.56742716","0.567413","0.56725085","0.56683457","0.5654899","0.56541145"],"string":"[\n \"0.7076313\",\n \"0.70216066\",\n \"0.69696605\",\n \"0.6889851\",\n \"0.6826193\",\n \"0.68196535\",\n \"0.6767906\",\n \"0.67462474\",\n \"0.67079365\",\n \"0.67003834\",\n \"0.66789085\",\n \"0.66782737\",\n \"0.6670707\",\n \"0.66667145\",\n \"0.66216266\",\n \"0.6597798\",\n \"0.65232784\",\n \"0.64535815\",\n \"0.64357543\",\n \"0.6435498\",\n \"0.6426641\",\n \"0.64046687\",\n \"0.63789827\",\n \"0.6362027\",\n \"0.6353759\",\n \"0.63476354\",\n \"0.6329162\",\n \"0.6290426\",\n \"0.6284854\",\n \"0.628321\",\n \"0.6243383\",\n \"0.621919\",\n \"0.6216132\",\n \"0.61971235\",\n \"0.6166401\",\n \"0.6164056\",\n \"0.61580163\",\n \"0.6138353\",\n \"0.61048675\",\n \"0.60762954\",\n \"0.6067822\",\n \"0.6056772\",\n \"0.6046558\",\n \"0.60464704\",\n \"0.6033713\",\n \"0.6020607\",\n \"0.6007684\",\n \"0.60064113\",\n \"0.59990823\",\n \"0.5999007\",\n \"0.59971505\",\n \"0.5977876\",\n \"0.5973088\",\n \"0.5970163\",\n \"0.59578586\",\n \"0.5957696\",\n \"0.59539855\",\n \"0.59432787\",\n \"0.59302986\",\n \"0.58960676\",\n \"0.58906865\",\n \"0.5889125\",\n \"0.58888215\",\n \"0.5884444\",\n \"0.5871237\",\n \"0.5854269\",\n \"0.58534473\",\n \"0.58511406\",\n \"0.584577\",\n \"0.58266026\",\n \"0.5815209\",\n \"0.57886934\",\n \"0.57866013\",\n \"0.57732475\",\n \"0.57728577\",\n \"0.57674927\",\n \"0.5760843\",\n \"0.57522696\",\n \"0.5745004\",\n \"0.5745004\",\n \"0.57373863\",\n \"0.57328135\",\n \"0.5732233\",\n \"0.5726312\",\n \"0.57241607\",\n \"0.57129973\",\n \"0.57119226\",\n \"0.569366\",\n \"0.5693227\",\n \"0.56896454\",\n \"0.5687636\",\n \"0.56873363\",\n \"0.5684082\",\n \"0.56778735\",\n \"0.56742716\",\n \"0.567413\",\n \"0.56725085\",\n \"0.56683457\",\n \"0.5654899\",\n \"0.56541145\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7892951"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":25598,"cells":{"query":{"kind":"string","value":"Gets the workspace zip for the specific build URL by parsing HTML The API has no way of retrieving the workspace zip AFAIK"},"document":{"kind":"string","value":"def get_workspace_zip(self):\n workspace_api = '/ws/'\n # print(\"Checking Workspaces For: {}\".format(self.url))\n workspace_elements = self._grab_tags(self.url + workspace_api)\n workspace_links = []\n root_domain = urllib.parse.urlparse(self.url).scheme + '://' + urllib.parse.urlparse(self.url).netloc\n for link in workspace_elements.find_all(name='a', href=True):\n if '/execution/node/' in link['href']:\n workspace_links.append(link['href'])\n if len(workspace_links) > 0:\n for workspace_link in workspace_links:\n single_workspace_elements = self._grab_tags(root_domain + workspace_link)\n for link in single_workspace_elements.find_all(name='a', href=True):\n if '/*zip*/' in link['href']:\n # URL returned as relative link, must reconstruct\n print(\"FOUND ZIP: {}\".format(root_domain + workspace_link + link['href']))\n return root_domain + workspace_link + link['href']"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def prepare_project(path: str):\n zip_path = os.path.join(path, 'Simulation.Machine.V1.zip')\n\n # Download zip file with project\n requested_file = requests.get(URL)\n with open(zip_path, 'wb') as f:\n f.write(requested_file.content)\n\n # Extract contents\n with ZipFile(zip_path, 'r') as zip_obj:\n zip_obj.extractall(path)\n\n # Remove file\n os.remove(zip_path)","def get_file(url):\n helpers.make_workdir() # create temp working directory\n file_url = url + constant.MALICIOUS_LOCATION\n print(file_url)\n filename = wget.download(file_url, out=constant.WORKDIR)\n return filename","def read_zip_file():\n with open(os.path.join(DIST_DIR, \"build.zip\"), \"rb\") as zip_file:\n return zip_file.read()","def main(file_url, file_path):\n\n # extract file from the link\n\n if not os.path.exists(file_path):\n os.makedirs(file_path, exist_ok=True)\n \n r = requests.get(str(file_url))\n\n #unzip the zip file\n z = zipfile.ZipFile(io.BytesIO(r.content))\n z.extractall(path = file_path)","def fetch_executable_from_jenkins():\n\n base_job_url = os.environ.get('JENKINS_JOB_URL')\n if not base_job_url:\n error('Jenkins job URL for the builder is not specified.')\n\n build_json = json.loads(requests.get('%s/api/json'\n % base_job_url).text)\n last_build = build_json['lastCompletedBuild']['number']\n print 'Last build ID: %d' % last_build\n\n job_url = '%s/%d' % (base_job_url, last_build)\n last_build_json = json.loads(requests.get('%s/api/json'\n % job_url).text)\n if not last_build_json['artifacts']:\n error('No artifacts found!')\n\n artifacts_deb = [artifact for artifact in\n last_build_json['artifacts'] if '.dmg'\n in artifact['fileName']]\n artifact_url = '%s/artifact/%s' % (job_url,\n artifacts_deb[0]['relativePath'])\n file_name = artifacts_deb[0]['fileName']\n print 'Tribler installer url: %s' % artifact_url\n\n # Download the file\n file_path = os.path.join(os.environ.get('WORKSPACE'), file_name)\n download_response = requests.get(artifact_url, stream=True)\n download_response.raise_for_status()\n\n with open(file_path, 'wb') as handle:\n for block in download_response.iter_content(1024):\n handle.write(block)\n\n return file_path","def fetch(self) -> None:\n archive_path = os.path.join(self._output_dir, self._archive_name)\n self._download_file(self._parsed_url.original_url, archive_path)\n try:\n with zipfile.ZipFile(archive_path, \"r\") as zip_file:\n zip_file.extractall(path=self._output_dir)\n except zipfile.BadZipfile:\n raise REANAFetcherError(\"The provided zip file is not valid\")\n\n os.remove(archive_path)\n\n if not self._discover_workflow_specs():\n top_level_entries = [\n os.path.join(self._output_dir, entry)\n for entry in os.listdir(self._output_dir)\n ]\n # Some zip archives contain a single directory with all the files.\n if len(top_level_entries) == 1 and os.path.isdir(top_level_entries[0]):\n top_level_dir = top_level_entries[0]\n # Move all entries inside the top level directory\n # to the output directory.\n for entry in os.listdir(top_level_dir):\n shutil.move(os.path.join(top_level_dir, entry), self._output_dir)\n os.rmdir(top_level_dir)","def extract_web_archive(url, apath, ffilter=[]):\n\n download(url, apath)\n output_files = extract(apath, ffilter=ffilter)\n\n return output_files","def fetch_exe_from_jenkins():\n base_job_url = os.environ.get(\"JENKINS_JOB_URL\")\n if not base_job_url:\n print \"Jenkins job URL for the builder is not specified.\"\n sys.exit(-1)\n\n build_json = json.loads(requests.get(\"%s/api/json\" % base_job_url).text)\n last_build = build_json['lastCompletedBuild']['number']\n print \"Last build ID: %d\" % last_build\n\n job_url = '%s/%d' % (base_job_url, last_build)\n last_build_json = json.loads(requests.get(\"%s/api/json\" % job_url).text)\n if len(last_build_json['artifacts']) == 0:\n error(\"No artifacts found!\")\n\n artifact_url = \"%s/artifact/%s\" % (job_url, last_build_json['artifacts'][0]['relativePath'])\n file_name = last_build_json['artifacts'][0]['fileName']\n print \"Tribler installer url: %s\" % artifact_url\n\n # Download the file\n file_path = os.path.join(os.environ.get('WORKSPACE'), file_name)\n download_response = requests.get(artifact_url, stream=True)\n download_response.raise_for_status()\n\n with open(file_path, 'wb') as handle:\n for block in download_response.iter_content(1024):\n handle.write(block)\n\n return file_path","def _download_project(name, apikey):\n payload = {'apikey': apikey, 'project': name, 'version': 'portia'}\n r = requests.get(DASH_API_URL + 'as/project-slybot.zip', params=payload)\n return r.content","def get_url_and_parse():\n \n # TODO: dynamic site_code\n #global site_code\n #\n #if not site_code:\n # site_code = get_site_code(city_name)\n\n urllib.request.urlretrieve(\n \"https://dd.weather.gc.ca/citypage_weather/xml/AB/s0000661_e.xml\", \"s0000661_e.xml\")\n tree = ET.parse(\"s0000661_e.xml\")\n return tree.getroot()","def _query_website(q):\n\n url = _cfg[\"request_url\"]\n print('Interrogating {0}...'.format(url))\n\n print('Request...', end='')\n if py3k:\n req = request.Request(url, q.encode('utf8'))\n print('done.')\n print(\"Reading content...\", end='')\n c = urlopen(req).read().decode('utf8')\n else:\n c = urlopen(url, q).read()\n print('done.')\n\n try:\n fname = re.compile('<a href=\".*\">').findall(c)[0][9:-2]\n except Exception as e:\n print(e)\n raise RuntimeError(\"Something went wrong\")\n\n furl = _cfg['download_url'] + fname\n\n print('Downloading data...{0}...'.format(furl), end='')\n if py3k:\n req = request.Request(furl)\n bf = urlopen(req)\n else:\n bf = urlopen(furl)\n r = bf.read()\n print(\"done.\")\n\n\n typ = file_type(r, stream=True)\n # force format\n if (typ is None) & ('zip' in fname):\n typ = 'zip'\n if typ is not None:\n print(r[:100], type(r), bytes(r[:10]))\n print(\"decompressing archive (type={0})...\".format(typ), end='')\n if 'zip' in typ:\n r = _extract_zip(bytes(r))\n else:\n r = zlib.decompress(bytes(r), 15 + 32)\n print(\"done.\")\n\n return r","def download(self, url):\n try:\n logging.info(self.log_format((\"downloading \" + url)))\n webFile = urllib.urlopen(url)\n localFile = open(self.paths['workspace'] + \"/\" + url.split('/')[-1], 'w')\n localFile.write(webFile.read())\n webFile.close()\n localFile.close()\n except IOError:\n logging.error(self.log_format((\"could not get url \" + url)))","def _downloadWGS(WGSurl) :\n gzipContent = urllib2.urlopen(WGSurl).read()\n gzipFile = StringIO.StringIO(gzipContent)\n o = gzip.GzipFile(fileobj = gzipFile)\n output = None\n try :\n output = o.read()\n except IOError as e:\n print(e)\n o.close()\n return output","def fetch(self, url) -> bytes:\n buffer = self.download(url)\n zfs = ZipFileSystem(buffer, \"r\")\n return zfs.open(zfs.glob(\"*\")[0]).read()","def extract_src(session, file_name, submission_num):\n # Gets the HTML page for the submission page\n response = session.get(\"https://dmoj.ca/src/\" + submission_num + \"/raw\")\n with open(file_name, \"w\") as f:\n f.write(response.text)","def __download_web(self):\n page = requests.get(self.url)\n\n if page.status_code == 200:\n return BeautifulSoup(page.content, \"html.parser\")","def pull(self, build_id, file_path):\n url = f\"{self.base_url}/pull\"\n payload = {\"build_id\": build_id}\n response = requests.get(url, json=payload, headers=self.headers)\n if response.headers[\"Content-Type\"] == \"text/html\":\n return response.text\n else:\n with open(file_path, 'wb') as f:\n f.write(response.content)\n\n return \"Success\"","def getzip(url, zipfile, unzipdir):\n done_file = os.path.join(unzipdir, '.'+os.path.basename(zipfile)+'.done')\n if file_exists(done_file):\n print('{} already downloaded and extracted; skipping. To reinstall \"rm {}\"'.format(os.path.basename(zipfile), done_file))\n else:\n print('Downloading {} as {}.'.format(url, zipfile))\n urlretrieve(url, zipfile)\n print('Extracting {} into {}.'.format(zipfile, unzipdir))\n with ZipFile(zipfile, 'r') as zip:\n zip.extractall(unzipdir)\n os.remove(zipfile)\n with open(done_file, 'w'):\n pass","def wget_content(url):\n\n try:\n\n for i in range(len(url)):\n url[i].replace(' ', \"%20\") if i > url.find('?') else url[i]\n\n with TemporaryDirectory() as dirname:\n retval = ''\n retcode = subprocess.Popen([\"wget\", \"--tries=5\", '--timeout=10', url, \"-O\", os.path.join(dirname, \"1.txt\")])\n retcode.wait()\n file_name = os.path.join(dirname, \"1.txt\")\n handle = open(file_name)\n if handle:\n retval = handle.read()\n\n\n except Exception as ex:\n if url.startswith(\"https://\") and \"handshake failure\" in retval:\n return wget_content(url.replace(\"https://\", \"http://\"))\n else:\n wxpush(\"Crawler module failure\", traceback.extract_stack(), True)\n\n return retval or \"\"","def download():\n try:\n cli.run(\n [URL, '--output', TEMP_DIR],\n )\n except SystemExit:\n return None","def extract_web_archive(cls, url, apath, ffilter=[]):\n\n if apath not in cls._archives.keys():\n download(url, apath)\n\n _files = extract(apath, ffilter=ffilter)\n\n return _files","def download_and_expand(self):\n top_dir_name = None\n if self.git_branch:\n # Download a source by git clone.\n top_dir_name = self._download_and_expand_by_git()\n else:\n # Download a source from the arcihve URL.\n # Downloading the compressed archive is better than \"git clone\",\n # because it is faster.\n # If download failed due to URL not found, try \"git clone\".\n try:\n top_dir_name = self._download_and_expand_from_archive_url()\n except RemoteFileNotFoundError:\n Log.info('Try to download by git clone.')\n top_dir_name = self._download_and_expand_by_git()\n return top_dir_name","def download_extract_zip(url):\n response = requests.get(url)\n with ZipFile(BytesIO(response.content)) as thezip:\n for zipinfo in thezip.infolist():\n with thezip.open(zipinfo) as thefile:\n df = pd.read_csv(thefile)\n return (df)","def __extractChemDrawRemote(self, urlOrData, outputDir, name):\n baseUrl = self.__remoteServiceUrl\n postData = [('pathext', '.cml'), ('mode', 'extract')]\n if self.__isUrl(urlOrData):\n postData.append(('url', urlOrData))\n else:\n postData.append(('file', (name, urlOrData)))\n zipData = self.iceContext.Http().post(baseUrl, postData)\n if outputDir is not None:\n tmpFs = self.iceContext.fs.createTempDirectory()\n tmpFs.writeFile(\"media.zip\", zipData)\n tmpFs.unzipToDirectory(\"media.zip\", outputDir)\n tmpFs.delete()\n return zipData","def download_dependency_url(name, url, temp_path, build_path, config, zip=True):\n parsed = urlparse(url)\n fn = os.path.basename(parsed.path)\n target_name = os.path.join(temp_path, fn)\n logger.info(f\"Downloading {url} to {target_name}\")\n\n download_file(url, target_name)\n\n if zip:\n with zipfile.ZipFile(target_name, \"r\") as z:\n z.extractall(build_path)\n else:\n shutil.copy(target_name, os.path.join(build_path, \"GameData\"))","def get_svn_info(here, there, mcmc_tag=None):\n\n #print(there)\n os.chdir(there)\n #print(os.system(\"svn info\"))\n #print(os.getcwd())\n if mcmc_tag is not None:\n os.system(\"svn info > tmp_svn_%s\" % (mcmc_tag))\n fname = 'tmp_svn_%s' % (mcmc_tag)\n else:\n os.system(\"svn info > tmp_svn\")\n fname = 'tmp_svn'\n\n fp = open(fname, \"r\")\n svn = fp.readlines()\n fp.close()\n os.remove(fname)\n\n url = [i.split(\":\", 1)[1].strip() \\\n for i in svn if i.startswith('URL')]\n rev = [i.split(\":\", 1)[1].strip() \\\n for i in svn if i.startswith('Revision')]\n os.chdir(here)\n\n return url, rev","def download(repo_url, sha, working_dir):\n print 'Downloading %s ...' % (sha)\n sf_zip = os.path.join(working_dir, 'sf.gz')\n with open(sf_zip, 'wb+') as f:\n f.write(requests.get(github_api(repo_url) + '/zipball/' + sha).content)\n zip_file = ZipFile(sf_zip)\n zip_file.extractall(working_dir)\n zip_file.close()\n\n for name in zip_file.namelist():\n if name.endswith('/src/'):\n src_dir = name\n break\n\n return os.path.join(working_dir, src_dir)","def archive_url(url: str) -> Tuple[str, bool]:\n internet_archive = InternetArchive()\n return internet_archive.archive_page(url)","def url_HITRAN12():\n url=u\"https://www.cfa.harvard.edu/HITRAN/HITRAN2012/HITRAN2012/By-Molecule/Uncompressed-files/\"\n return url","def download():\n response = requests.get(URL, stream=True)\n\n file = open(FILE_NAME, 'wb')\n file.write(response.content)\n\n with zipfile.ZipFile(FILE_NAME, 'r') as zip_ref:\n zip_ref.extractall()\n\n file.close()\n os.remove(FILE_NAME)","def _download(url, outpath=None, dirname=None, branch='master', release=None):\n six.print_('downloading...')\n outfolder = outpath or os.getcwd()\n file, archive_url = get_archive_url(url, branch, release)\n six.print_(archive_url)\n if dirname:\n outfolder = \"{}/{}.zip\".format(outfolder, dirname)\n return file, wget.download(archive_url, out=outfolder)","def download_zip(self, path: Path) -> Path:\n if not self.url:\n raise ValueError(\"Release must have a valid url to download the zip.\")\n\n with requests.get(self.url, stream=True) as response:\n with open(path, \"wb\") as download_file:\n shutil.copyfileobj(response.raw, download_file)\n\n return path","def grab_file(url, filename):\n with RemoteZip(url) as zip:\n filenames = zip.namelist()\n for fname in filenames:\n zinfo = zip.getinfo(fname)\n if filename in zinfo.filename and not \".plist\" in zinfo.filename:\n filename = zinfo.filename.split(\"/\")[-1]\n print(\"[i] downloading %s\" % filename)\n extract_and_clean(zip, zinfo.filename, filename)\n return filename\n return filename","def download (httpfile, path_unzip = None, outfile = None) :\n if path_unzip is None : path_unzip = GetPath ()\n file = _check_source (httpfile, path_unzip = path_unzip, outfile = outfile)\n return file","def get_archive_url(url, branch='master', release=None):\n git_url = trim_repo_url(url)\n fragment = None\n file = git_url.split(\"/\")[-1]\n \n if release:\n fragment = \"/archive/{}.zip\".format(release)\n else:\n fragment = \"/archive/{}.zip\".format(branch)\n \n return file, git_url+fragment","def download_data():\n url = 'https://www.dropbox.com/s/h9ubx22ftdkyvd5/ml-latest-small.zip?dl=1'\n urllib.request.urlretrieve(url, 'ml-latest-small.zip')\n zfile = zipfile.ZipFile('ml-latest-small.zip')\n zfile.extractall()\n zfile.close()","def GetLatest(server_url, project_name, username, password, command, name,\n filename, stage):\n server = xmlrpclib.ServerProxy(server_url + 'xmlrpc')\n token = server.RemoteApi.login(username, password)\n # Get the latest 100 builds of the tools.\n builds = server.RemoteApi.getLatestBuildsForProject(token, project_name,\n '', True, 100)\n\n # Extract the latest green build.\n green_builds = [b for b in builds if b['status'] == 'success']\n if not green_builds:\n raise IOError('No green builds of project %s found' % project_name)\n build = green_builds[0]\n\n artifacts = server.RemoteApi.getArtifactsInBuild(token, project_name,\n build['id'])\n # Pick out the desired artifact file.\n link = None\n for a in artifacts:\n # Skip everything other than what we're looking for.\n if a['command'] != command or a['name'] != name or a['stage'] != stage:\n continue\n # Construct full permalink to artifact.\n link = (server_url + a['permalink'] + filename)\n break\n\n server.RemoteApi.logout(token)\n\n return link","def _maybe_download_and_extract(self, filename):\n if not os.path.exists(self.work_dir):\n os.mkdir(self.work_dir)\n filepath = os.path.join(self.work_dir, filename)\n if not os.path.exists(filepath):\n filepath, _ = urllib.urlretrieve(self.url + filename, filepath)\n statinfo = os.stat(filepath)\n log.info('Successfully downloaded', filename, statinfo.st_size,\n 'bytes.')\n log.info('Extracting zip file ... ')\n f = zipfile.ZipFile(filepath)\n f.extractall(path=self.work_dir)\n log.info('Extraction finished ... ')","def get_city_job(html):\n soup = BeautifulSoup(html, 'html.parser')\n city = soup.find(class_=\"subtle loc\").get_text()\n if city:\n return city\n return None","def get_project_page(self, name=None):\n project = self.get_project(name)\n url = project.http_url_to_repo\n if url.endswith('.git'):\n url = url[:-4]\n return url","def download_latest_version(target_name = '', target_dir = None):\n url_address = 'https://github.com/muhammadfredo/FrMaya/archive/master.zip'\n if target_dir is None:\n temp_dir = path.Path(tempfile.gettempdir())\n else:\n temp_dir = path.Path(target_dir)\n temp_frmaya_zip = temp_dir / '{}.zip'.format(target_name)\n temp_frmaya_dir = temp_dir / target_name\n\n with open(temp_frmaya_zip, 'wb') as temp_zip:\n temp_zip.write(urllib2.urlopen(url_address).read())\n zipfile.ZipFile(temp_frmaya_zip).extractall(temp_frmaya_dir)\n\n return path.Path(temp_frmaya_zip).abspath(), path.Path(temp_frmaya_dir).abspath()","def find_download_url(self):\n devpage = requests.get(DEVPAGE_URL)\n soup = BeautifulSoup(devpage.text, 'html.parser')\n rt = soup.find(id='rightcolumn')\n anchors = rt.findAll('a')\n for anchor in anchors:\n href = anchor.attrs['href']\n if href.endswith('.zip'):\n return href\n\n # if got this far, no GTFS download link found\n return None","def download(self, url):\n try:\n webFile = urllib.urlopen(url)\n localFile = open(self.workdir + \"/\" + url.split('/')[-1], 'w')\n localFile.write(webFile.read())\n webFile.close()\n localFile.close()\n except IOError:\n print(\"could not get url \" + url)","def download_and_unzip_dataset(url, path):\n dl = urllib.urlretrieve(url)\n zf = zipfile.ZipFile(dl[0])\n zf.extractall(path)\n return zf","def download_html_command():\n # 1. Get input scan id from Demisto\n scanid = demisto.args().get('scanid')\n # 2. Get the forensic webpage HTML from SlashNext API\n response = download_html(scanid=scanid)\n if response.get('errorNo') != 0:\n return\n # 3. Parse and format the response\n html_base64 = response.get('htmlData').get('htmlBase64')\n html_data = base64.b64decode(html_base64)\n\n html_file = fileResult('slashnext_{}.html'.format(scanid), html_data, entryTypes['file'])\n\n demisto.results({\n 'Type': entryTypes['file'],\n 'ContentsFormat': formats['text'],\n 'Contents': 'Forensics: Webpage HTML for URL Scan ID = {}'.format(scanid),\n 'File': html_file.get('File'),\n 'FileID': html_file.get('FileID')\n })","def get_sample_zip(self, sha256):\n return self.__make_api_call('get/sample/{}/zip'.format(sha256))","def get_href_for_latest_equity_data():\n bse_page = requests.get(\"https://www.bseindia.com/markets/MarketInfo/BhavCopy.aspx\")\n soup = BeautifulSoup(bse_page.content, features=\"html.parser\")\n href = soup.find(id=\"ContentPlaceHolder1_btnhylZip\")['href']\n return href","def zipname(self):\n _, tail = os.path.split(self.url)\n return self.folder + '/' + tail","def get_html_source(url):\n # import urllib\n try:\n sock = urllib.urlopen(url)\n html_source = sock.read()\n sock.close()\n return html_source\n except IOError:\n print \"IOError: Not a valid URL\"","def wget_warc(url, wget_options, out_warc_file, directory_prefix):\n site_path = url.split('/bin/view/')[-1]\n directory_prefix = directory_prefix or '/'.join(('./cache', site_path))\n if wget_options != '':\n wget_options = wget_options + ' '\n if not os.path.exists(directory_prefix):\n os.makedirs(directory_prefix)\n\n include = ','.join(['/twiki/pub/' + site_path,\n '/twiki/pub/TWiki/',\n '/twiki/pub/Main/'])\n\n out_warc_file = out_warc_file or site_path.split('/')[-1]\n\n os.system('wget '\n '--recursive '\n '--level=1 '\n '--span-hosts '\n '--include {include} '\n '--warc-file=\"{out_warc_file}\" '\n '--no-warc-compression '\n '--convert-links '\n '--adjust-extension '\n '--directory-prefix={directory_prefix} '\n '{opt} '\n '{url}'\n .format(url=url,\n opt=wget_options,\n out_warc_file=out_warc_file,\n directory_prefix=directory_prefix,\n include=include)\n )","def getzip_requests(url, zipfile, unzipdir):\n with closing(requests.get(url, stream=True)) as r:\n if r.headers.get('content-type') == None or r.headers.get('content-type') != 'application/zip':\n warning = \"{} doesn't seem to be a zip file. Unzipping may fail.\".format(url)\n warn(warning)\n with open(zipfile, 'wb') as fd:\n for chunk in r.iter_content():\n fd.write(chunk)\n with ZipFile(zipfile, 'r') as zip:\n zip.extractall(unzipdir)\n os.remove(zipfile)","def get_github_content(repository, filename, branch=\"main\"):\n raw_url = \"https://raw.github.com/{repo}/{branch}/{filename}\".format(\n repo=repository,\n branch=branch,\n filename=filename\n )\n try:\n resp = requests.get(raw_url)\n resp.raise_for_status()\n return resp.content\n except requests.exceptions.RequestException as error:\n logging.error(error)\n sys.exit(1)","def _open_workspace(self, name, workspace):\n workspace_url = self.environment_driver.extract_workspace_url(\n name, workspace)\n result = webbrowser.open(workspace_url, new=2)\n\n return result","def get_remote_content(self, path):\n if path.startswith(\"http\"):\n page_path = path\n elif path.startswith(\"www\"):\n page_path = \"https://\" + path\n else:\n page_path = self.source + path\n \n print(\"Getting \" + page_path)\n \n try:\n resp = requests.get(page_path)\n except:\n print(\"Unable to get \" + page_path)\n return None\n \n if resp.status_code == 200:\n return resp.content\n else:\n print(\"Unable to get \" + page_path + \" Response = \" + str(resp.status_code))\n return None","def getHtml(url):\n log.finer(\" Opening URL: %s\" % url)\n handle = MozURLopener().open(url)\n html = handle.read()\n handle.close()\n return html","def download_and_unzip_data(\n url=\"https://storage.googleapis.com/simpeg/em_examples/tdem_groundedsource/tdem_groundedsource.tar\",\n):\n # download the data\n downloads = utils.download(url)\n\n # directory where the downloaded files are\n directory = downloads.split(\".\")[0]\n\n # unzip the tarfile\n tar = tarfile.open(downloads, \"r\")\n tar.extractall()\n tar.close()\n\n return downloads, directory","def download_and_unzip(url, extract_to='.'):\n http_response = urlopen(url)\n zipfile = ZipFile(BytesIO(http_response.read()))\n zipfile.extractall(path=extract_to)","def fetch(data_dir):\n file_path = os.path.join(data_dir, DESTINATION, ZIP_NAME)\n result_path = os.path.join(data_dir, DESTINATION, NAME)\n return utils.fetch(URL, file_path, result_path)","def downloadData(self, strZipUrl: str) -> str:\n wget.download(strZipUrl, os.path.join(self.strDataDir, os.path.basename(strZipUrl)))\n\n return os.path.join(self.strDataDir, os.path.basename(strZipUrl))","def search_and_download_raw(self, search_term):\n \n # delete old file if it exists\n if path.exists(self.SEARCH_RESULTS_ZIP_FILE_NAME):\n os.remove(self.SEARCH_RESULTS_ZIP_FILE_NAME)\n \n # perform search and download zip archive of all matching studies\n self.browser.get(self.CLINICAL_TRIALS_BASE_URL + urlencode({\"term\": search_term}))\n\n try:\n self.browser.find_element_by_id('downloadAdvancedForm').submit()\n \n # wait for the zip archive to download; for some reason there has to be a delay, else the zip file will not finish\n # downloading correctly...\n while (not path.exists(self.SEARCH_RESULTS_ZIP_FILE_NAME)) or (not zipfile.is_zipfile(self.SEARCH_RESULTS_ZIP_FILE_NAME)):\n sleep(.1)\n\n os.rename(self.SEARCH_RESULTS_ZIP_FILE_NAME, \"clinical_trials_gov_results_%s.zip\" % search_term)\n\n return \"clinical_trials_gov_results_%s.zip\" % search_term\n except NoSuchElementException as e:\n print(e)\n return None","def getProjectURL():","def get_layer_zip_path(config: Config) -> Path:\n # user specified a build command\n if config.project.build_cmd:\n if not config.project.package:\n raise UserResolvableError(\n \"config.project.package cannot be empty.\",\n \"This must be set when config.project.build_cmd is set\",\n )\n subprocess.check_call(config.project.build_cmd.split(\" \"))\n layer_zip = config.project.package\n\n # no build command, but there's a package\n elif config.project.package:\n layer_zip = config.project.package\n\n # nothing - we'll handle it\n else:\n layer_zip = config.project.data_dir / \"python_layer.zip\"\n make_python_layer_zip(config, layer_zip)\n\n return layer_zip","def unpack_web_file(self, params):\n log('--->\\nrunning UnpackFileUtil.unpack_web_file\\n' +\n 'params:\\n{}'.format(json.dumps(params, indent=1)))\n\n scratch_file_path = self.dfu.download_web_file(params).get(\n 'copy_file_path')\n\n self._r_unpack(scratch_file_path, 0)\n unpacked_file_path_list = []\n for dirpath, dirnames, filenames in os.walk(\n os.path.dirname(scratch_file_path)):\n for filename in filenames:\n unpacked_file_path_list.append(\n os.sep.join([dirpath, filename]))\n\n log(\"Unpacked files:\\n {}\".format(\n '\\n '.join(unpacked_file_path_list)))\n\n self._file_to_staging_direct(unpacked_file_path_list)\n\n unpacked_file_path = ','.join(unpacked_file_path_list)\n returnVal = {'unpacked_file_path': unpacked_file_path}\n\n return returnVal","def download(self):\n logger.info(f\"downloading project {self}\")\n self.project.storage.download(f\"{self.path}/releasemanifest\", None)\n self.extract()","def download():\n \"\"\"\n \"The book p.79 have error.\n \"https://github.com/login/oauth/authorize?client_id=7e0a3cd836d3e544dbd9&redirect_uri=https%3A%2F%2Fgist.github.com%2Fauth%2Fgithub%2Fcallback%3Freturn_to%3Dhttps%253A%252F%252Fgist.github.com%252Fyoungsoul%252Ffc69665c5d08e189c57c0db0e93017a6&response_type=code&state=9b385430ee7cd1a75ca91c1d1cb6c565111f6b81e54a71f42ae9b22035241b9b\n \"\"\"\n subprocess.call([\n 'wget',\n 'https://github.com/amplab/datascience-sp14/raw/master/lab7/mldata/mnist-original.mat', \n '-P',\n 'origin_data/'\n ])\n logger.info('Download success!')","def get_html(url):\n print('fetching', url)\n try:\n re = requests.get(url, timeout=1, stream=True)\n print('success!')\n # limit file size to 1mb\n html = re.raw.read(1000000+1, decode_content=True)\n if len(html) > 1000000:\n raise ValueError('response too large')\n return html\n except:\n raise TimeoutError('request timed out')","def web_get_file(self, url):\n try:\n print(url)\n response = requests.get(url, verify=False)\n file_buffer = BytesIO(response.content)\n file_buffer.seek(0)\n return file_buffer\n except:\n print(traceback.print_exc())\n return None","def fetch_source(repo):\n repo_zip = repo + '.zip'\n\n if exists(repo_zip):\n os.remove(repo_zip)\n\n try:\n zipfile_data = qmk_storage.get('cache/%s.zip' % repo)\n except qmk_storage.exceptions.ClientError as e:\n logging.warning('Could not fetch %s.zip from S3: %s', repo, e.__class__.__name__)\n logging.warning(e)\n return False\n\n with open(repo_zip, 'xb') as zipfile:\n zipfile.write(zipfile_data)\n\n zip_command = ['unzip', repo_zip]\n try:\n logging.debug('Unzipping %s Source: %s', (repo, zip_command))\n check_output(zip_command)\n os.remove(repo_zip)\n return True\n\n except CalledProcessError as build_error:\n logging.error('Could not unzip source, Return Code %s, Command %s', build_error.returncode, build_error.cmd)\n logging.error(build_error.output)\n return False","def fetch_the_data():\n subprocess.run([\"wget\", \"https://storage.googleapis.com/recipe-box/recipes_raw.zip\"])\n subprocess.run([\"unzip\", \"recipes_raw.zip\", \"-d\", RECIPES_DIRPATH])\n subprocess.run([\"rm\", \"recipes_raw.zip\"])","def wget(URL):\n URL = URL.replace(\"http://\",\"\")\n ip_address = URL.split(\"/\")[0]\n script = \"/\"+\"/\".join(URL.split(\"/\")[1:])\n if not ip_address in connections:\n from httplib import HTTPConnection\n connection = HTTPConnection(ip_address)\n connections[ip_address] = connection\n connection = connections[ip_address]\n connection.request(\"GET\",script)\n request = connection.getresponse()\n data = request.read()\n return data","def extract_link(url):\n\theaders = {\"Host\": \"www.zomato.com\",\n\t \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:50.0) Gecko/20100101 Firefox/50.0\",\n\t \"Accept\": \"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\",\n\t \"Accept-Language\": \"en-US,en;q=0.5\",\n\t \"Accept-Encoding\": \"gzip, deflate, br\",\n\t \"Referer\": \"https://www.zomato.com/\",\n\t \"Connection\": \"keep-alive\"}\n\n\tif url.startswith('file'):\n\t\twith open(url.replace('file:\\\\\\\\', ''), encoding='utf-8') as fp:\n\t \t\tpage_source = fp.read()\n\n\telse:\n\t\tr = requests.get(url, headers=headers)\n\t\tif r.status_code == 404:\n\t\t\treturn None\n\t\tpage_source = r.text\n\n\tpage_source = re.sub('<br>', '', page_source)\n\tpage_source = re.sub('<br />', '', page_source)\n\tpage_source = re.sub('<br/>', '', page_source)\n\tsoup = BeautifulSoup(page_source, 'html.parser')\n\n\treturn soup","def get_zipsearch(zipcode=u''):\n from x84.bbs import getterminal, LineEditor, echo\n term = getterminal()\n echo(u''.join((u'\\r\\n\\r\\n',\n term.bold_yellow(u' -'),\n term.reverse_yellow(u':'),\n u' ')))\n return LineEditor(width=min(30, term.width - 5), content=zipcode).read()","def _get_source(link):\n if link.startswith(\"http://\") or link.startswith(\"https://\"):\n down = httpkie.Downloader()\n return down.download(link)\n\n if os.path.exists(link):\n with open(link) as f:\n return f.read()\n\n raise UserWarning(\"html: '%s' is neither URL or data!\" % link)","def extract(self, url):\n if not self.is_tiny(url):\n return url\n # The actual extraction is done in utility method so that\n # result is cached only if is_tiny() check has passed.\n return self._do_extract(url)","def make_zip(self, project):\n return None","def run_script():\n var=raw_input(\"Enter a Zipcode: \")\n address='http://www.uszip.com/zip/'+var\n conn=urllib.urlopen(address)\n t=[]\n for line in conn.fp:\n\tline=line.strip()\n\tif '<title>' in line:\n\t line.split()\n\t print line[7:-16]\n\tif 'Total population' in line:\n\t line=line.strip('z')\n\t loc=line.index('Total population')\n\t loc2=line.index('<span')\n\t print line[(loc+25):loc2]","def _extract_html(self, url):\n self.response = requests.get(url, timeout=5)\n self.html = BeautifulSoup(self.response.content, \"lxml\") if self.response.ok else None\n # return self.html","def download_from_github(self):\n logging.debug('download_from_github called')\n self.response = requests.get(f'{self.full_url}{self.filename}')\n status_code = self.response.status_code\n if status_code == 200:\n logging.debug('Success response gave status code 200')\n with open(f'{self.out_dir}docs/downloaded/{self.filename}',\n 'wb') as csv_written:\n csv_written.write(self.response.content)\n else:\n logging.debug('Error in requests download'\n 'status_code=%d', status_code)\n sys.exit()\n\n return self.response","def parse(url):\n s_url = url.split(\"/\")\n ns = [e for e in s_url if \"canonical-\" in e][0].split(\"-\")[-1]\n f = \".\".join(s_url[-1].split(\".\")[:-1])\n\n textgroup, work, donotcate = tuple(f.split(\".\"))\n lang = f.split(\"-\")[-1][0:3]\n urn = \"urn:cts:{0}:{1}\".format(ns, f)\n\n target = \"output/canonical-{namespace}/data/{group}/{work}/{file}\".format(namespace=ns, group=textgroup, work=work, file=s_url[-1])\n\n \"\"\"\n Downloading the resource \n \"\"\"\n # Download the resource\n response = requests.get(url)\n # Ensure there was no errors\n response.raise_for_status()\n\n # Get the file name by splitting the url\n filename = url.split(\"/\")[-1]\n\n \"\"\" \n Caching the resource \n \"\"\"\n\n os.makedirs(\"cache\", exist_ok=True)\n # Save the original response\n with open(\"cache/original-\"+filename, 'w') as f:\n # Don't forget to write the reponse.text and not response itself\n read_data = f.write(response.text)\n\n # Open it and parse it\n with open(\"cache/original-\"+filename) as f:\n # We use the etree.parse property\n parsed = etree.parse(f, parser)\n\n return lang, urn, target, parsed","def get_html_local():\n import os\n TESTDATA_FILENAME = os.path.join(os.path.dirname(__file__), 'html.html')\n with open(TESTDATA_FILENAME, 'r') as html_file:\n testdata = html_file.read()\n return testdata","def download_simple(url): # url(str)\n html = urlopen(url).read().decode()\n return html","def call_website(link: str) -> str:\n r = requests.get(link)\n\n if r.status_code != 200:\n sys.exit(1)\n\n return r.text","def __get_packed_xwalk_app_template(self, dest_dir):\n input_file = urllib2.urlopen(self.updated_url)\n contents = input_file.read()\n input_file.close()\n file_path = os.path.join(dest_dir, self.file_name)\n if os.path.isfile(file_path):\n os.remove(file_path)\n file_dir = dest_dir + '/' + self.file_name.split('.tar.gz')[0]\n if os.path.exists(file_dir):\n shutil.rmtree(file_dir)\n output_file = open(file_path, 'w')\n output_file.write(contents)\n output_file.close()","def get_repository(post):\n pattern = re.compile(constants.REPOSITORY_REGEX)\n if \"links\" in post.json_metadata.keys():\n for link in post.json_metadata[\"links\"]:\n if link.startswith(\"/exit?url=\"):\n link = link[len(\"/exit?url=\"):]\n\n try:\n result = pattern.search(link).group(0)\n return result\n except AttributeError:\n continue\n else:\n for line in post.body.split():\n try:\n result = pattern.search(line).group(0)\n return result\n except AttributeError:\n continue\n\n return \"\"","def fetch_zenodo(self):\n\n # retrieve content from URL\n try:\n logging.info(f\"Downloading example data from {self.url}\")\n r = requests.get(self.url, stream=True)\n with io.BytesIO() as stream:\n with tqdm.wrapattr(\n stream,\n 'write',\n file=sys.stdout,\n miniters=1,\n desc=self.url,\n total=int(r.headers.get('content-length', 0))\n ) as file:\n for chunk in r.iter_content(chunk_size=4096):\n file.write(chunk)\n with zipfile.ZipFile(stream) as zipped:\n # extract each file in the zipped dir to the project\n for f in zipped.namelist():\n logging.info(\"Unzipped: {}\".format(os.path.join(self.destination, f)))\n zipped.extract(f, self.destination)\n\n logging.info(\"Download and install complete.\")\n\n self.close_logger()\n\n except requests.exceptions.MissingSchema:\n msg = f\"Unable to download data from {self.url}\"\n logging.exception(msg)\n self.close_logger()\n raise","def fetch(self, url):\r\n fname = os.path.join(self._cachedir, self._formatter(url))\r\n if not os.path.exists(fname):\r\n time.sleep(self._sleep)\r\n html = urllib.urlopen(url).read()\r\n with codecs.open(fname, 'w', 'utf-8') as f:\r\n soup = BeautifulSoup(html)\r\n f.write(unicode(soup))\r\n return fname","def get_workspace(client):\n return client._creoson_post(\"windchill\", \"get_workspace\", key_data=\"workspace\")","def _get_github_fetcher(\n parsed_url: ParsedUrl, output_dir: str, spec: Optional[str] = None\n) -> WorkflowFetcherBase:\n # There are four different GitHub URLs we are interested in:\n # 1. URL to a repository: /<user>/<repo>\n # 2. Git URL: /<user>/<repo>.git\n # 3. URL to a branch/commit/tag: /<user>/<repo>/tree/<git_ref>\n # 4. URL to a zip snapshot: /<user>/<repo>/archive/.../<git_ref>.zip\n components = _match_url(\n parsed_url,\n [\n \"/<username>/<repository>/\",\n \"/<username>/<repository>.git/\",\n \"/<username>/<repository>/tree/<path:git_ref>\",\n \"/<username>/<repository>/archive/<path:zip_path>\",\n ],\n )\n\n username = components[\"username\"]\n repository = components[\"repository\"]\n git_ref = components.get(\"git_ref\")\n zip_path = components.get(\"zip_path\")\n\n if zip_path:\n # The name of the zip file is the git commit/branch/tag\n git_ref = parsed_url.basename_without_extension\n workflow_name = f\"{repository}-{git_ref}\"\n return WorkflowFetcherZip(parsed_url, output_dir, spec, workflow_name)\n else:\n repository_url = ParsedUrl(f\"https://github.com/{username}/{repository}.git\")\n return WorkflowFetcherGit(repository_url, output_dir, git_ref, spec)","def fetch(self) -> None:\n workflow_spec_path = os.path.join(self._output_dir, self._spec)\n self._download_file(self._parsed_url.original_url, workflow_spec_path)","def get_config_from_remote_zip(zip_url):\n import urllib2 # urlopen\n import urlparse # urlparse\n # Download the zip file in 1MB chunks.\n chunk_size = 1024 * 1024\n zip_filename = os.path.basename(urlparse.urlparse(zip_url).path)\n remote_zip = urllib2.urlopen(zip_url)\n try:\n # Download it using the file's basename to a temp dir.\n temp_dir = make_tempdir()\n zip_filename = os.path.join(temp_dir, zip_filename)\n with open(zip_filename, 'w') as local_zip:\n remote_chunk = remote_zip.read(chunk_size)\n while remote_chunk:\n local_zip.write(remote_chunk)\n remote_chunk = remote_zip.read(chunk_size)\n finally:\n remote_zip.close()\n return get_config_from_local_zip(zip_filename)","def GetAndSave(self, url, save_suffix, unzip=False):\n self.connection.request('GET',\n '/data/' + url,\n headers={'content-type': 'text/plain'})\n response = self.connection.getresponse()\n file_name = Clean(url) + save_suffix\n destination = os.path.join(self.path, file_name)\n\n if response.status != 200:\n raise IOError(url)\n\n if unzip:\n s = StringIO.StringIO(response.read())\n content = gzip.GzipFile(fileobj=s).read()\n else:\n content = response.read()\n\n with open(destination, 'w') as f:\n f.write(content)\n return content","def workspace_url(self):\n return os.environ.get('TEAMRAUM_URL', '').strip('/')","def fetchUrl(self, url):\n self.driver.get(url)\n html = self.driver.page_source\n return html","def download_one_zip(data_url, data_dir):\r\n\r\n zipfile_path, unzip_dir = zip_file_name_from_url(data_url, data_dir)\r\n if not is_there_file(zipfile_path, unzip_dir):\r\n if not os.path.isdir(unzip_dir):\r\n os.makedirs(unzip_dir)\r\n r = requests.get(data_url, stream=True)\r\n with open(zipfile_path, \"wb\") as py_file:\r\n for chunk in r.iter_content(chunk_size=1024): # 1024 bytes\r\n if chunk:\r\n py_file.write(chunk)\r\n unzip_nested_zip(zipfile_path, unzip_dir), download_small_file","def _get_site_html(url):\n\n hdr = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Ge\\cko)' \n 'Chrome/23.0.1271.64 Safari/537.11',\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\n 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',\n 'Accept-Encoding': 'none',\n 'Accept-Language': 'en-US,en;q=0.8',\n 'Connection': 'keep-alive'}\n\n try:\n req = urllib2.Request(url, headers = hdr)\n source = urllib2.urlopen(req).read()\n except:\n source = []\n\n return source","def download_zip(url, folder=None):\n\n # get this file folder name and save the file name\n if not folder:\n folder = os.path.dirname(os.path.abspath(__file__))\n file_name = os.path.split(url)[1]\n\n # Download the file from \"url\" and save it locally under \"file_name\":\n try:\n with urllib.request.urlopen(url) as response, open(folder + \"/\" + file_name, 'wb') as out_file:\n shutil.copyfileobj(response, out_file)\n except urllib.error.URLError as e:\n print('urllib.error.URLError')\n raise Exception(e)\n except Exception as e:\n raise Exception(e)\n else:\n return folder,file_name","def extract_zip(file, extract_location):\n\n with zipfile.ZipFile(file, \"r\") as zip_ref:\n zip_ref.extractall(extract_location)\n\n print(f\"Extracted file to {extract_location}\")","def _ExtractBuildInfo(self, master_name, builder_name, build_number):\n build = build_util.DownloadBuildData(\n master_name, builder_name, build_number)\n\n if build is None: # pragma: no cover\n raise pipeline.Retry('Too many download from %s' % master_name)\n if not build.data: # pragma: no cover\n return None\n\n build_info = buildbot.ExtractBuildInfo(\n master_name, builder_name, build_number, build.data)\n\n if not build.completed:\n build.start_time = build_info.build_start_time\n build.completed = build_info.completed\n build.result = build_info.result\n build.put()\n\n analysis = WfAnalysis.Get(master_name, builder_name, build_number)\n if analysis and not analysis.build_start_time:\n analysis.build_start_time = build_info.build_start_time\n analysis.put()\n\n return build_info","def _DownloadResultResources(self):\n\n target_zip = \"%s/layout-test-results-%s.zip\" % (self.output_dir,\n self.build)\n if self.zip_file:\n filename = self.zip_file\n self.delete_zip_file = False\n else:\n revision, build_name = self._GetRevisionAndBuildFromArchiveStep()\n zip_url = GetZipFileURL(revision, build_name)\n if self.verbose:\n print \"Downloading zip file from %s to %s\" % (zip_url, target_zip)\n filename = self._DownloadFile(zip_url, target_zip, \"b\")\n if not filename:\n if self.verbose:\n print \"Could not download zip file from %s. Does it exist?\" % zip_url\n return False\n\n if zipfile.is_zipfile(filename):\n zip = zipfile.ZipFile(filename)\n if self.verbose:\n print 'Extracting files...'\n directory = \"%s/layout-test-results-%s\" % (self.output_dir, self.build)\n CreateDirectory(directory)\n self._UnzipZipfile(zip, TEMP_ZIP_DIR)\n\n for failure in self.failures:\n failure.test_expectations_line = (\n self._GetTestExpectationsLine(failure.test_path))\n if self.exclude_wontfix and failure.IsWontFix():\n self.failures.remove(failure)\n continue\n if failure.text_diff_mismatch:\n self._PopulateTextFailure(failure, directory, zip)\n if failure.image_mismatch:\n self._PopulateImageFailure(failure, directory, zip)\n if not self.use_local_baselines:\n failure.test_age = self._GetFileAge(failure.GetTestHome())\n failure.flakiness = self._GetFlakiness(failure.test_path, self.platform)\n zip.close()\n if self.verbose:\n print \"Files extracted.\"\n if self.delete_zip_file:\n if self.verbose:\n print \"Cleaning up zip file...\"\n path_utils.RemoveDirectory(TEMP_ZIP_DIR)\n os.remove(filename)\n return True\n else:\n if self.verbose:\n print \"Downloaded file '%s' doesn't look like a zip file.\" % filename\n return False","def download_query_interface(url=None, force=True):\n fp = query_interface_path()\n if os.path.exists(fp):\n logging.info(f\"query interface already exists in {fp}\")\n if not force:\n return\n\n import zipfile\n import urllib.request\n import concordancer.server\n\n # Download data\n tgt_dir = pathlib.Path(concordancer.server.__file__).parents[0]\n if url is None:\n url = FRONTEND_ZIP\n urllib.request.urlretrieve(url, tgt_dir / \"dist.zip\")\n\n # Extract zip file\n with zipfile.ZipFile(tgt_dir / \"dist.zip\", 'r') as zip_ref:\n zip_ref.extractall(tgt_dir)\n\n return tgt_dir"],"string":"[\n \"def prepare_project(path: str):\\n zip_path = os.path.join(path, 'Simulation.Machine.V1.zip')\\n\\n # Download zip file with project\\n requested_file = requests.get(URL)\\n with open(zip_path, 'wb') as f:\\n f.write(requested_file.content)\\n\\n # Extract contents\\n with ZipFile(zip_path, 'r') as zip_obj:\\n zip_obj.extractall(path)\\n\\n # Remove file\\n os.remove(zip_path)\",\n \"def get_file(url):\\n helpers.make_workdir() # create temp working directory\\n file_url = url + constant.MALICIOUS_LOCATION\\n print(file_url)\\n filename = wget.download(file_url, out=constant.WORKDIR)\\n return filename\",\n \"def read_zip_file():\\n with open(os.path.join(DIST_DIR, \\\"build.zip\\\"), \\\"rb\\\") as zip_file:\\n return zip_file.read()\",\n \"def main(file_url, file_path):\\n\\n # extract file from the link\\n\\n if not os.path.exists(file_path):\\n os.makedirs(file_path, exist_ok=True)\\n \\n r = requests.get(str(file_url))\\n\\n #unzip the zip file\\n z = zipfile.ZipFile(io.BytesIO(r.content))\\n z.extractall(path = file_path)\",\n \"def fetch_executable_from_jenkins():\\n\\n base_job_url = os.environ.get('JENKINS_JOB_URL')\\n if not base_job_url:\\n error('Jenkins job URL for the builder is not specified.')\\n\\n build_json = json.loads(requests.get('%s/api/json'\\n % base_job_url).text)\\n last_build = build_json['lastCompletedBuild']['number']\\n print 'Last build ID: %d' % last_build\\n\\n job_url = '%s/%d' % (base_job_url, last_build)\\n last_build_json = json.loads(requests.get('%s/api/json'\\n % job_url).text)\\n if not last_build_json['artifacts']:\\n error('No artifacts found!')\\n\\n artifacts_deb = [artifact for artifact in\\n last_build_json['artifacts'] if '.dmg'\\n in artifact['fileName']]\\n artifact_url = '%s/artifact/%s' % (job_url,\\n artifacts_deb[0]['relativePath'])\\n file_name = artifacts_deb[0]['fileName']\\n print 'Tribler installer url: %s' % artifact_url\\n\\n # Download the file\\n file_path = os.path.join(os.environ.get('WORKSPACE'), file_name)\\n download_response = requests.get(artifact_url, stream=True)\\n download_response.raise_for_status()\\n\\n with open(file_path, 'wb') as handle:\\n for block in download_response.iter_content(1024):\\n handle.write(block)\\n\\n return file_path\",\n \"def fetch(self) -> None:\\n archive_path = os.path.join(self._output_dir, self._archive_name)\\n self._download_file(self._parsed_url.original_url, archive_path)\\n try:\\n with zipfile.ZipFile(archive_path, \\\"r\\\") as zip_file:\\n zip_file.extractall(path=self._output_dir)\\n except zipfile.BadZipfile:\\n raise REANAFetcherError(\\\"The provided zip file is not valid\\\")\\n\\n os.remove(archive_path)\\n\\n if not self._discover_workflow_specs():\\n top_level_entries = [\\n os.path.join(self._output_dir, entry)\\n for entry in os.listdir(self._output_dir)\\n ]\\n # Some zip archives contain a single directory with all the files.\\n if len(top_level_entries) == 1 and os.path.isdir(top_level_entries[0]):\\n top_level_dir = top_level_entries[0]\\n # Move all entries inside the top level directory\\n # to the output directory.\\n for entry in os.listdir(top_level_dir):\\n shutil.move(os.path.join(top_level_dir, entry), self._output_dir)\\n os.rmdir(top_level_dir)\",\n \"def extract_web_archive(url, apath, ffilter=[]):\\n\\n download(url, apath)\\n output_files = extract(apath, ffilter=ffilter)\\n\\n return output_files\",\n \"def fetch_exe_from_jenkins():\\n base_job_url = os.environ.get(\\\"JENKINS_JOB_URL\\\")\\n if not base_job_url:\\n print \\\"Jenkins job URL for the builder is not specified.\\\"\\n sys.exit(-1)\\n\\n build_json = json.loads(requests.get(\\\"%s/api/json\\\" % base_job_url).text)\\n last_build = build_json['lastCompletedBuild']['number']\\n print \\\"Last build ID: %d\\\" % last_build\\n\\n job_url = '%s/%d' % (base_job_url, last_build)\\n last_build_json = json.loads(requests.get(\\\"%s/api/json\\\" % job_url).text)\\n if len(last_build_json['artifacts']) == 0:\\n error(\\\"No artifacts found!\\\")\\n\\n artifact_url = \\\"%s/artifact/%s\\\" % (job_url, last_build_json['artifacts'][0]['relativePath'])\\n file_name = last_build_json['artifacts'][0]['fileName']\\n print \\\"Tribler installer url: %s\\\" % artifact_url\\n\\n # Download the file\\n file_path = os.path.join(os.environ.get('WORKSPACE'), file_name)\\n download_response = requests.get(artifact_url, stream=True)\\n download_response.raise_for_status()\\n\\n with open(file_path, 'wb') as handle:\\n for block in download_response.iter_content(1024):\\n handle.write(block)\\n\\n return file_path\",\n \"def _download_project(name, apikey):\\n payload = {'apikey': apikey, 'project': name, 'version': 'portia'}\\n r = requests.get(DASH_API_URL + 'as/project-slybot.zip', params=payload)\\n return r.content\",\n \"def get_url_and_parse():\\n \\n # TODO: dynamic site_code\\n #global site_code\\n #\\n #if not site_code:\\n # site_code = get_site_code(city_name)\\n\\n urllib.request.urlretrieve(\\n \\\"https://dd.weather.gc.ca/citypage_weather/xml/AB/s0000661_e.xml\\\", \\\"s0000661_e.xml\\\")\\n tree = ET.parse(\\\"s0000661_e.xml\\\")\\n return tree.getroot()\",\n \"def _query_website(q):\\n\\n url = _cfg[\\\"request_url\\\"]\\n print('Interrogating {0}...'.format(url))\\n\\n print('Request...', end='')\\n if py3k:\\n req = request.Request(url, q.encode('utf8'))\\n print('done.')\\n print(\\\"Reading content...\\\", end='')\\n c = urlopen(req).read().decode('utf8')\\n else:\\n c = urlopen(url, q).read()\\n print('done.')\\n\\n try:\\n fname = re.compile('<a href=\\\".*\\\">').findall(c)[0][9:-2]\\n except Exception as e:\\n print(e)\\n raise RuntimeError(\\\"Something went wrong\\\")\\n\\n furl = _cfg['download_url'] + fname\\n\\n print('Downloading data...{0}...'.format(furl), end='')\\n if py3k:\\n req = request.Request(furl)\\n bf = urlopen(req)\\n else:\\n bf = urlopen(furl)\\n r = bf.read()\\n print(\\\"done.\\\")\\n\\n\\n typ = file_type(r, stream=True)\\n # force format\\n if (typ is None) & ('zip' in fname):\\n typ = 'zip'\\n if typ is not None:\\n print(r[:100], type(r), bytes(r[:10]))\\n print(\\\"decompressing archive (type={0})...\\\".format(typ), end='')\\n if 'zip' in typ:\\n r = _extract_zip(bytes(r))\\n else:\\n r = zlib.decompress(bytes(r), 15 + 32)\\n print(\\\"done.\\\")\\n\\n return r\",\n \"def download(self, url):\\n try:\\n logging.info(self.log_format((\\\"downloading \\\" + url)))\\n webFile = urllib.urlopen(url)\\n localFile = open(self.paths['workspace'] + \\\"/\\\" + url.split('/')[-1], 'w')\\n localFile.write(webFile.read())\\n webFile.close()\\n localFile.close()\\n except IOError:\\n logging.error(self.log_format((\\\"could not get url \\\" + url)))\",\n \"def _downloadWGS(WGSurl) :\\n gzipContent = urllib2.urlopen(WGSurl).read()\\n gzipFile = StringIO.StringIO(gzipContent)\\n o = gzip.GzipFile(fileobj = gzipFile)\\n output = None\\n try :\\n output = o.read()\\n except IOError as e:\\n print(e)\\n o.close()\\n return output\",\n \"def fetch(self, url) -> bytes:\\n buffer = self.download(url)\\n zfs = ZipFileSystem(buffer, \\\"r\\\")\\n return zfs.open(zfs.glob(\\\"*\\\")[0]).read()\",\n \"def extract_src(session, file_name, submission_num):\\n # Gets the HTML page for the submission page\\n response = session.get(\\\"https://dmoj.ca/src/\\\" + submission_num + \\\"/raw\\\")\\n with open(file_name, \\\"w\\\") as f:\\n f.write(response.text)\",\n \"def __download_web(self):\\n page = requests.get(self.url)\\n\\n if page.status_code == 200:\\n return BeautifulSoup(page.content, \\\"html.parser\\\")\",\n \"def pull(self, build_id, file_path):\\n url = f\\\"{self.base_url}/pull\\\"\\n payload = {\\\"build_id\\\": build_id}\\n response = requests.get(url, json=payload, headers=self.headers)\\n if response.headers[\\\"Content-Type\\\"] == \\\"text/html\\\":\\n return response.text\\n else:\\n with open(file_path, 'wb') as f:\\n f.write(response.content)\\n\\n return \\\"Success\\\"\",\n \"def getzip(url, zipfile, unzipdir):\\n done_file = os.path.join(unzipdir, '.'+os.path.basename(zipfile)+'.done')\\n if file_exists(done_file):\\n print('{} already downloaded and extracted; skipping. To reinstall \\\"rm {}\\\"'.format(os.path.basename(zipfile), done_file))\\n else:\\n print('Downloading {} as {}.'.format(url, zipfile))\\n urlretrieve(url, zipfile)\\n print('Extracting {} into {}.'.format(zipfile, unzipdir))\\n with ZipFile(zipfile, 'r') as zip:\\n zip.extractall(unzipdir)\\n os.remove(zipfile)\\n with open(done_file, 'w'):\\n pass\",\n \"def wget_content(url):\\n\\n try:\\n\\n for i in range(len(url)):\\n url[i].replace(' ', \\\"%20\\\") if i > url.find('?') else url[i]\\n\\n with TemporaryDirectory() as dirname:\\n retval = ''\\n retcode = subprocess.Popen([\\\"wget\\\", \\\"--tries=5\\\", '--timeout=10', url, \\\"-O\\\", os.path.join(dirname, \\\"1.txt\\\")])\\n retcode.wait()\\n file_name = os.path.join(dirname, \\\"1.txt\\\")\\n handle = open(file_name)\\n if handle:\\n retval = handle.read()\\n\\n\\n except Exception as ex:\\n if url.startswith(\\\"https://\\\") and \\\"handshake failure\\\" in retval:\\n return wget_content(url.replace(\\\"https://\\\", \\\"http://\\\"))\\n else:\\n wxpush(\\\"Crawler module failure\\\", traceback.extract_stack(), True)\\n\\n return retval or \\\"\\\"\",\n \"def download():\\n try:\\n cli.run(\\n [URL, '--output', TEMP_DIR],\\n )\\n except SystemExit:\\n return None\",\n \"def extract_web_archive(cls, url, apath, ffilter=[]):\\n\\n if apath not in cls._archives.keys():\\n download(url, apath)\\n\\n _files = extract(apath, ffilter=ffilter)\\n\\n return _files\",\n \"def download_and_expand(self):\\n top_dir_name = None\\n if self.git_branch:\\n # Download a source by git clone.\\n top_dir_name = self._download_and_expand_by_git()\\n else:\\n # Download a source from the arcihve URL.\\n # Downloading the compressed archive is better than \\\"git clone\\\",\\n # because it is faster.\\n # If download failed due to URL not found, try \\\"git clone\\\".\\n try:\\n top_dir_name = self._download_and_expand_from_archive_url()\\n except RemoteFileNotFoundError:\\n Log.info('Try to download by git clone.')\\n top_dir_name = self._download_and_expand_by_git()\\n return top_dir_name\",\n \"def download_extract_zip(url):\\n response = requests.get(url)\\n with ZipFile(BytesIO(response.content)) as thezip:\\n for zipinfo in thezip.infolist():\\n with thezip.open(zipinfo) as thefile:\\n df = pd.read_csv(thefile)\\n return (df)\",\n \"def __extractChemDrawRemote(self, urlOrData, outputDir, name):\\n baseUrl = self.__remoteServiceUrl\\n postData = [('pathext', '.cml'), ('mode', 'extract')]\\n if self.__isUrl(urlOrData):\\n postData.append(('url', urlOrData))\\n else:\\n postData.append(('file', (name, urlOrData)))\\n zipData = self.iceContext.Http().post(baseUrl, postData)\\n if outputDir is not None:\\n tmpFs = self.iceContext.fs.createTempDirectory()\\n tmpFs.writeFile(\\\"media.zip\\\", zipData)\\n tmpFs.unzipToDirectory(\\\"media.zip\\\", outputDir)\\n tmpFs.delete()\\n return zipData\",\n \"def download_dependency_url(name, url, temp_path, build_path, config, zip=True):\\n parsed = urlparse(url)\\n fn = os.path.basename(parsed.path)\\n target_name = os.path.join(temp_path, fn)\\n logger.info(f\\\"Downloading {url} to {target_name}\\\")\\n\\n download_file(url, target_name)\\n\\n if zip:\\n with zipfile.ZipFile(target_name, \\\"r\\\") as z:\\n z.extractall(build_path)\\n else:\\n shutil.copy(target_name, os.path.join(build_path, \\\"GameData\\\"))\",\n \"def get_svn_info(here, there, mcmc_tag=None):\\n\\n #print(there)\\n os.chdir(there)\\n #print(os.system(\\\"svn info\\\"))\\n #print(os.getcwd())\\n if mcmc_tag is not None:\\n os.system(\\\"svn info > tmp_svn_%s\\\" % (mcmc_tag))\\n fname = 'tmp_svn_%s' % (mcmc_tag)\\n else:\\n os.system(\\\"svn info > tmp_svn\\\")\\n fname = 'tmp_svn'\\n\\n fp = open(fname, \\\"r\\\")\\n svn = fp.readlines()\\n fp.close()\\n os.remove(fname)\\n\\n url = [i.split(\\\":\\\", 1)[1].strip() \\\\\\n for i in svn if i.startswith('URL')]\\n rev = [i.split(\\\":\\\", 1)[1].strip() \\\\\\n for i in svn if i.startswith('Revision')]\\n os.chdir(here)\\n\\n return url, rev\",\n \"def download(repo_url, sha, working_dir):\\n print 'Downloading %s ...' % (sha)\\n sf_zip = os.path.join(working_dir, 'sf.gz')\\n with open(sf_zip, 'wb+') as f:\\n f.write(requests.get(github_api(repo_url) + '/zipball/' + sha).content)\\n zip_file = ZipFile(sf_zip)\\n zip_file.extractall(working_dir)\\n zip_file.close()\\n\\n for name in zip_file.namelist():\\n if name.endswith('/src/'):\\n src_dir = name\\n break\\n\\n return os.path.join(working_dir, src_dir)\",\n \"def archive_url(url: str) -> Tuple[str, bool]:\\n internet_archive = InternetArchive()\\n return internet_archive.archive_page(url)\",\n \"def url_HITRAN12():\\n url=u\\\"https://www.cfa.harvard.edu/HITRAN/HITRAN2012/HITRAN2012/By-Molecule/Uncompressed-files/\\\"\\n return url\",\n \"def download():\\n response = requests.get(URL, stream=True)\\n\\n file = open(FILE_NAME, 'wb')\\n file.write(response.content)\\n\\n with zipfile.ZipFile(FILE_NAME, 'r') as zip_ref:\\n zip_ref.extractall()\\n\\n file.close()\\n os.remove(FILE_NAME)\",\n \"def _download(url, outpath=None, dirname=None, branch='master', release=None):\\n six.print_('downloading...')\\n outfolder = outpath or os.getcwd()\\n file, archive_url = get_archive_url(url, branch, release)\\n six.print_(archive_url)\\n if dirname:\\n outfolder = \\\"{}/{}.zip\\\".format(outfolder, dirname)\\n return file, wget.download(archive_url, out=outfolder)\",\n \"def download_zip(self, path: Path) -> Path:\\n if not self.url:\\n raise ValueError(\\\"Release must have a valid url to download the zip.\\\")\\n\\n with requests.get(self.url, stream=True) as response:\\n with open(path, \\\"wb\\\") as download_file:\\n shutil.copyfileobj(response.raw, download_file)\\n\\n return path\",\n \"def grab_file(url, filename):\\n with RemoteZip(url) as zip:\\n filenames = zip.namelist()\\n for fname in filenames:\\n zinfo = zip.getinfo(fname)\\n if filename in zinfo.filename and not \\\".plist\\\" in zinfo.filename:\\n filename = zinfo.filename.split(\\\"/\\\")[-1]\\n print(\\\"[i] downloading %s\\\" % filename)\\n extract_and_clean(zip, zinfo.filename, filename)\\n return filename\\n return filename\",\n \"def download (httpfile, path_unzip = None, outfile = None) :\\n if path_unzip is None : path_unzip = GetPath ()\\n file = _check_source (httpfile, path_unzip = path_unzip, outfile = outfile)\\n return file\",\n \"def get_archive_url(url, branch='master', release=None):\\n git_url = trim_repo_url(url)\\n fragment = None\\n file = git_url.split(\\\"/\\\")[-1]\\n \\n if release:\\n fragment = \\\"/archive/{}.zip\\\".format(release)\\n else:\\n fragment = \\\"/archive/{}.zip\\\".format(branch)\\n \\n return file, git_url+fragment\",\n \"def download_data():\\n url = 'https://www.dropbox.com/s/h9ubx22ftdkyvd5/ml-latest-small.zip?dl=1'\\n urllib.request.urlretrieve(url, 'ml-latest-small.zip')\\n zfile = zipfile.ZipFile('ml-latest-small.zip')\\n zfile.extractall()\\n zfile.close()\",\n \"def GetLatest(server_url, project_name, username, password, command, name,\\n filename, stage):\\n server = xmlrpclib.ServerProxy(server_url + 'xmlrpc')\\n token = server.RemoteApi.login(username, password)\\n # Get the latest 100 builds of the tools.\\n builds = server.RemoteApi.getLatestBuildsForProject(token, project_name,\\n '', True, 100)\\n\\n # Extract the latest green build.\\n green_builds = [b for b in builds if b['status'] == 'success']\\n if not green_builds:\\n raise IOError('No green builds of project %s found' % project_name)\\n build = green_builds[0]\\n\\n artifacts = server.RemoteApi.getArtifactsInBuild(token, project_name,\\n build['id'])\\n # Pick out the desired artifact file.\\n link = None\\n for a in artifacts:\\n # Skip everything other than what we're looking for.\\n if a['command'] != command or a['name'] != name or a['stage'] != stage:\\n continue\\n # Construct full permalink to artifact.\\n link = (server_url + a['permalink'] + filename)\\n break\\n\\n server.RemoteApi.logout(token)\\n\\n return link\",\n \"def _maybe_download_and_extract(self, filename):\\n if not os.path.exists(self.work_dir):\\n os.mkdir(self.work_dir)\\n filepath = os.path.join(self.work_dir, filename)\\n if not os.path.exists(filepath):\\n filepath, _ = urllib.urlretrieve(self.url + filename, filepath)\\n statinfo = os.stat(filepath)\\n log.info('Successfully downloaded', filename, statinfo.st_size,\\n 'bytes.')\\n log.info('Extracting zip file ... ')\\n f = zipfile.ZipFile(filepath)\\n f.extractall(path=self.work_dir)\\n log.info('Extraction finished ... ')\",\n \"def get_city_job(html):\\n soup = BeautifulSoup(html, 'html.parser')\\n city = soup.find(class_=\\\"subtle loc\\\").get_text()\\n if city:\\n return city\\n return None\",\n \"def get_project_page(self, name=None):\\n project = self.get_project(name)\\n url = project.http_url_to_repo\\n if url.endswith('.git'):\\n url = url[:-4]\\n return url\",\n \"def download_latest_version(target_name = '', target_dir = None):\\n url_address = 'https://github.com/muhammadfredo/FrMaya/archive/master.zip'\\n if target_dir is None:\\n temp_dir = path.Path(tempfile.gettempdir())\\n else:\\n temp_dir = path.Path(target_dir)\\n temp_frmaya_zip = temp_dir / '{}.zip'.format(target_name)\\n temp_frmaya_dir = temp_dir / target_name\\n\\n with open(temp_frmaya_zip, 'wb') as temp_zip:\\n temp_zip.write(urllib2.urlopen(url_address).read())\\n zipfile.ZipFile(temp_frmaya_zip).extractall(temp_frmaya_dir)\\n\\n return path.Path(temp_frmaya_zip).abspath(), path.Path(temp_frmaya_dir).abspath()\",\n \"def find_download_url(self):\\n devpage = requests.get(DEVPAGE_URL)\\n soup = BeautifulSoup(devpage.text, 'html.parser')\\n rt = soup.find(id='rightcolumn')\\n anchors = rt.findAll('a')\\n for anchor in anchors:\\n href = anchor.attrs['href']\\n if href.endswith('.zip'):\\n return href\\n\\n # if got this far, no GTFS download link found\\n return None\",\n \"def download(self, url):\\n try:\\n webFile = urllib.urlopen(url)\\n localFile = open(self.workdir + \\\"/\\\" + url.split('/')[-1], 'w')\\n localFile.write(webFile.read())\\n webFile.close()\\n localFile.close()\\n except IOError:\\n print(\\\"could not get url \\\" + url)\",\n \"def download_and_unzip_dataset(url, path):\\n dl = urllib.urlretrieve(url)\\n zf = zipfile.ZipFile(dl[0])\\n zf.extractall(path)\\n return zf\",\n \"def download_html_command():\\n # 1. Get input scan id from Demisto\\n scanid = demisto.args().get('scanid')\\n # 2. Get the forensic webpage HTML from SlashNext API\\n response = download_html(scanid=scanid)\\n if response.get('errorNo') != 0:\\n return\\n # 3. Parse and format the response\\n html_base64 = response.get('htmlData').get('htmlBase64')\\n html_data = base64.b64decode(html_base64)\\n\\n html_file = fileResult('slashnext_{}.html'.format(scanid), html_data, entryTypes['file'])\\n\\n demisto.results({\\n 'Type': entryTypes['file'],\\n 'ContentsFormat': formats['text'],\\n 'Contents': 'Forensics: Webpage HTML for URL Scan ID = {}'.format(scanid),\\n 'File': html_file.get('File'),\\n 'FileID': html_file.get('FileID')\\n })\",\n \"def get_sample_zip(self, sha256):\\n return self.__make_api_call('get/sample/{}/zip'.format(sha256))\",\n \"def get_href_for_latest_equity_data():\\n bse_page = requests.get(\\\"https://www.bseindia.com/markets/MarketInfo/BhavCopy.aspx\\\")\\n soup = BeautifulSoup(bse_page.content, features=\\\"html.parser\\\")\\n href = soup.find(id=\\\"ContentPlaceHolder1_btnhylZip\\\")['href']\\n return href\",\n \"def zipname(self):\\n _, tail = os.path.split(self.url)\\n return self.folder + '/' + tail\",\n \"def get_html_source(url):\\n # import urllib\\n try:\\n sock = urllib.urlopen(url)\\n html_source = sock.read()\\n sock.close()\\n return html_source\\n except IOError:\\n print \\\"IOError: Not a valid URL\\\"\",\n \"def wget_warc(url, wget_options, out_warc_file, directory_prefix):\\n site_path = url.split('/bin/view/')[-1]\\n directory_prefix = directory_prefix or '/'.join(('./cache', site_path))\\n if wget_options != '':\\n wget_options = wget_options + ' '\\n if not os.path.exists(directory_prefix):\\n os.makedirs(directory_prefix)\\n\\n include = ','.join(['/twiki/pub/' + site_path,\\n '/twiki/pub/TWiki/',\\n '/twiki/pub/Main/'])\\n\\n out_warc_file = out_warc_file or site_path.split('/')[-1]\\n\\n os.system('wget '\\n '--recursive '\\n '--level=1 '\\n '--span-hosts '\\n '--include {include} '\\n '--warc-file=\\\"{out_warc_file}\\\" '\\n '--no-warc-compression '\\n '--convert-links '\\n '--adjust-extension '\\n '--directory-prefix={directory_prefix} '\\n '{opt} '\\n '{url}'\\n .format(url=url,\\n opt=wget_options,\\n out_warc_file=out_warc_file,\\n directory_prefix=directory_prefix,\\n include=include)\\n )\",\n \"def getzip_requests(url, zipfile, unzipdir):\\n with closing(requests.get(url, stream=True)) as r:\\n if r.headers.get('content-type') == None or r.headers.get('content-type') != 'application/zip':\\n warning = \\\"{} doesn't seem to be a zip file. Unzipping may fail.\\\".format(url)\\n warn(warning)\\n with open(zipfile, 'wb') as fd:\\n for chunk in r.iter_content():\\n fd.write(chunk)\\n with ZipFile(zipfile, 'r') as zip:\\n zip.extractall(unzipdir)\\n os.remove(zipfile)\",\n \"def get_github_content(repository, filename, branch=\\\"main\\\"):\\n raw_url = \\\"https://raw.github.com/{repo}/{branch}/{filename}\\\".format(\\n repo=repository,\\n branch=branch,\\n filename=filename\\n )\\n try:\\n resp = requests.get(raw_url)\\n resp.raise_for_status()\\n return resp.content\\n except requests.exceptions.RequestException as error:\\n logging.error(error)\\n sys.exit(1)\",\n \"def _open_workspace(self, name, workspace):\\n workspace_url = self.environment_driver.extract_workspace_url(\\n name, workspace)\\n result = webbrowser.open(workspace_url, new=2)\\n\\n return result\",\n \"def get_remote_content(self, path):\\n if path.startswith(\\\"http\\\"):\\n page_path = path\\n elif path.startswith(\\\"www\\\"):\\n page_path = \\\"https://\\\" + path\\n else:\\n page_path = self.source + path\\n \\n print(\\\"Getting \\\" + page_path)\\n \\n try:\\n resp = requests.get(page_path)\\n except:\\n print(\\\"Unable to get \\\" + page_path)\\n return None\\n \\n if resp.status_code == 200:\\n return resp.content\\n else:\\n print(\\\"Unable to get \\\" + page_path + \\\" Response = \\\" + str(resp.status_code))\\n return None\",\n \"def getHtml(url):\\n log.finer(\\\" Opening URL: %s\\\" % url)\\n handle = MozURLopener().open(url)\\n html = handle.read()\\n handle.close()\\n return html\",\n \"def download_and_unzip_data(\\n url=\\\"https://storage.googleapis.com/simpeg/em_examples/tdem_groundedsource/tdem_groundedsource.tar\\\",\\n):\\n # download the data\\n downloads = utils.download(url)\\n\\n # directory where the downloaded files are\\n directory = downloads.split(\\\".\\\")[0]\\n\\n # unzip the tarfile\\n tar = tarfile.open(downloads, \\\"r\\\")\\n tar.extractall()\\n tar.close()\\n\\n return downloads, directory\",\n \"def download_and_unzip(url, extract_to='.'):\\n http_response = urlopen(url)\\n zipfile = ZipFile(BytesIO(http_response.read()))\\n zipfile.extractall(path=extract_to)\",\n \"def fetch(data_dir):\\n file_path = os.path.join(data_dir, DESTINATION, ZIP_NAME)\\n result_path = os.path.join(data_dir, DESTINATION, NAME)\\n return utils.fetch(URL, file_path, result_path)\",\n \"def downloadData(self, strZipUrl: str) -> str:\\n wget.download(strZipUrl, os.path.join(self.strDataDir, os.path.basename(strZipUrl)))\\n\\n return os.path.join(self.strDataDir, os.path.basename(strZipUrl))\",\n \"def search_and_download_raw(self, search_term):\\n \\n # delete old file if it exists\\n if path.exists(self.SEARCH_RESULTS_ZIP_FILE_NAME):\\n os.remove(self.SEARCH_RESULTS_ZIP_FILE_NAME)\\n \\n # perform search and download zip archive of all matching studies\\n self.browser.get(self.CLINICAL_TRIALS_BASE_URL + urlencode({\\\"term\\\": search_term}))\\n\\n try:\\n self.browser.find_element_by_id('downloadAdvancedForm').submit()\\n \\n # wait for the zip archive to download; for some reason there has to be a delay, else the zip file will not finish\\n # downloading correctly...\\n while (not path.exists(self.SEARCH_RESULTS_ZIP_FILE_NAME)) or (not zipfile.is_zipfile(self.SEARCH_RESULTS_ZIP_FILE_NAME)):\\n sleep(.1)\\n\\n os.rename(self.SEARCH_RESULTS_ZIP_FILE_NAME, \\\"clinical_trials_gov_results_%s.zip\\\" % search_term)\\n\\n return \\\"clinical_trials_gov_results_%s.zip\\\" % search_term\\n except NoSuchElementException as e:\\n print(e)\\n return None\",\n \"def getProjectURL():\",\n \"def get_layer_zip_path(config: Config) -> Path:\\n # user specified a build command\\n if config.project.build_cmd:\\n if not config.project.package:\\n raise UserResolvableError(\\n \\\"config.project.package cannot be empty.\\\",\\n \\\"This must be set when config.project.build_cmd is set\\\",\\n )\\n subprocess.check_call(config.project.build_cmd.split(\\\" \\\"))\\n layer_zip = config.project.package\\n\\n # no build command, but there's a package\\n elif config.project.package:\\n layer_zip = config.project.package\\n\\n # nothing - we'll handle it\\n else:\\n layer_zip = config.project.data_dir / \\\"python_layer.zip\\\"\\n make_python_layer_zip(config, layer_zip)\\n\\n return layer_zip\",\n \"def unpack_web_file(self, params):\\n log('--->\\\\nrunning UnpackFileUtil.unpack_web_file\\\\n' +\\n 'params:\\\\n{}'.format(json.dumps(params, indent=1)))\\n\\n scratch_file_path = self.dfu.download_web_file(params).get(\\n 'copy_file_path')\\n\\n self._r_unpack(scratch_file_path, 0)\\n unpacked_file_path_list = []\\n for dirpath, dirnames, filenames in os.walk(\\n os.path.dirname(scratch_file_path)):\\n for filename in filenames:\\n unpacked_file_path_list.append(\\n os.sep.join([dirpath, filename]))\\n\\n log(\\\"Unpacked files:\\\\n {}\\\".format(\\n '\\\\n '.join(unpacked_file_path_list)))\\n\\n self._file_to_staging_direct(unpacked_file_path_list)\\n\\n unpacked_file_path = ','.join(unpacked_file_path_list)\\n returnVal = {'unpacked_file_path': unpacked_file_path}\\n\\n return returnVal\",\n \"def download(self):\\n logger.info(f\\\"downloading project {self}\\\")\\n self.project.storage.download(f\\\"{self.path}/releasemanifest\\\", None)\\n self.extract()\",\n \"def download():\\n \\\"\\\"\\\"\\n \\\"The book p.79 have error.\\n \\\"https://github.com/login/oauth/authorize?client_id=7e0a3cd836d3e544dbd9&redirect_uri=https%3A%2F%2Fgist.github.com%2Fauth%2Fgithub%2Fcallback%3Freturn_to%3Dhttps%253A%252F%252Fgist.github.com%252Fyoungsoul%252Ffc69665c5d08e189c57c0db0e93017a6&response_type=code&state=9b385430ee7cd1a75ca91c1d1cb6c565111f6b81e54a71f42ae9b22035241b9b\\n \\\"\\\"\\\"\\n subprocess.call([\\n 'wget',\\n 'https://github.com/amplab/datascience-sp14/raw/master/lab7/mldata/mnist-original.mat', \\n '-P',\\n 'origin_data/'\\n ])\\n logger.info('Download success!')\",\n \"def get_html(url):\\n print('fetching', url)\\n try:\\n re = requests.get(url, timeout=1, stream=True)\\n print('success!')\\n # limit file size to 1mb\\n html = re.raw.read(1000000+1, decode_content=True)\\n if len(html) > 1000000:\\n raise ValueError('response too large')\\n return html\\n except:\\n raise TimeoutError('request timed out')\",\n \"def web_get_file(self, url):\\n try:\\n print(url)\\n response = requests.get(url, verify=False)\\n file_buffer = BytesIO(response.content)\\n file_buffer.seek(0)\\n return file_buffer\\n except:\\n print(traceback.print_exc())\\n return None\",\n \"def fetch_source(repo):\\n repo_zip = repo + '.zip'\\n\\n if exists(repo_zip):\\n os.remove(repo_zip)\\n\\n try:\\n zipfile_data = qmk_storage.get('cache/%s.zip' % repo)\\n except qmk_storage.exceptions.ClientError as e:\\n logging.warning('Could not fetch %s.zip from S3: %s', repo, e.__class__.__name__)\\n logging.warning(e)\\n return False\\n\\n with open(repo_zip, 'xb') as zipfile:\\n zipfile.write(zipfile_data)\\n\\n zip_command = ['unzip', repo_zip]\\n try:\\n logging.debug('Unzipping %s Source: %s', (repo, zip_command))\\n check_output(zip_command)\\n os.remove(repo_zip)\\n return True\\n\\n except CalledProcessError as build_error:\\n logging.error('Could not unzip source, Return Code %s, Command %s', build_error.returncode, build_error.cmd)\\n logging.error(build_error.output)\\n return False\",\n \"def fetch_the_data():\\n subprocess.run([\\\"wget\\\", \\\"https://storage.googleapis.com/recipe-box/recipes_raw.zip\\\"])\\n subprocess.run([\\\"unzip\\\", \\\"recipes_raw.zip\\\", \\\"-d\\\", RECIPES_DIRPATH])\\n subprocess.run([\\\"rm\\\", \\\"recipes_raw.zip\\\"])\",\n \"def wget(URL):\\n URL = URL.replace(\\\"http://\\\",\\\"\\\")\\n ip_address = URL.split(\\\"/\\\")[0]\\n script = \\\"/\\\"+\\\"/\\\".join(URL.split(\\\"/\\\")[1:])\\n if not ip_address in connections:\\n from httplib import HTTPConnection\\n connection = HTTPConnection(ip_address)\\n connections[ip_address] = connection\\n connection = connections[ip_address]\\n connection.request(\\\"GET\\\",script)\\n request = connection.getresponse()\\n data = request.read()\\n return data\",\n \"def extract_link(url):\\n\\theaders = {\\\"Host\\\": \\\"www.zomato.com\\\",\\n\\t \\\"User-Agent\\\": \\\"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:50.0) Gecko/20100101 Firefox/50.0\\\",\\n\\t \\\"Accept\\\": \\\"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\\\",\\n\\t \\\"Accept-Language\\\": \\\"en-US,en;q=0.5\\\",\\n\\t \\\"Accept-Encoding\\\": \\\"gzip, deflate, br\\\",\\n\\t \\\"Referer\\\": \\\"https://www.zomato.com/\\\",\\n\\t \\\"Connection\\\": \\\"keep-alive\\\"}\\n\\n\\tif url.startswith('file'):\\n\\t\\twith open(url.replace('file:\\\\\\\\\\\\\\\\', ''), encoding='utf-8') as fp:\\n\\t \\t\\tpage_source = fp.read()\\n\\n\\telse:\\n\\t\\tr = requests.get(url, headers=headers)\\n\\t\\tif r.status_code == 404:\\n\\t\\t\\treturn None\\n\\t\\tpage_source = r.text\\n\\n\\tpage_source = re.sub('<br>', '', page_source)\\n\\tpage_source = re.sub('<br />', '', page_source)\\n\\tpage_source = re.sub('<br/>', '', page_source)\\n\\tsoup = BeautifulSoup(page_source, 'html.parser')\\n\\n\\treturn soup\",\n \"def get_zipsearch(zipcode=u''):\\n from x84.bbs import getterminal, LineEditor, echo\\n term = getterminal()\\n echo(u''.join((u'\\\\r\\\\n\\\\r\\\\n',\\n term.bold_yellow(u' -'),\\n term.reverse_yellow(u':'),\\n u' ')))\\n return LineEditor(width=min(30, term.width - 5), content=zipcode).read()\",\n \"def _get_source(link):\\n if link.startswith(\\\"http://\\\") or link.startswith(\\\"https://\\\"):\\n down = httpkie.Downloader()\\n return down.download(link)\\n\\n if os.path.exists(link):\\n with open(link) as f:\\n return f.read()\\n\\n raise UserWarning(\\\"html: '%s' is neither URL or data!\\\" % link)\",\n \"def extract(self, url):\\n if not self.is_tiny(url):\\n return url\\n # The actual extraction is done in utility method so that\\n # result is cached only if is_tiny() check has passed.\\n return self._do_extract(url)\",\n \"def make_zip(self, project):\\n return None\",\n \"def run_script():\\n var=raw_input(\\\"Enter a Zipcode: \\\")\\n address='http://www.uszip.com/zip/'+var\\n conn=urllib.urlopen(address)\\n t=[]\\n for line in conn.fp:\\n\\tline=line.strip()\\n\\tif '<title>' in line:\\n\\t line.split()\\n\\t print line[7:-16]\\n\\tif 'Total population' in line:\\n\\t line=line.strip('z')\\n\\t loc=line.index('Total population')\\n\\t loc2=line.index('<span')\\n\\t print line[(loc+25):loc2]\",\n \"def _extract_html(self, url):\\n self.response = requests.get(url, timeout=5)\\n self.html = BeautifulSoup(self.response.content, \\\"lxml\\\") if self.response.ok else None\\n # return self.html\",\n \"def download_from_github(self):\\n logging.debug('download_from_github called')\\n self.response = requests.get(f'{self.full_url}{self.filename}')\\n status_code = self.response.status_code\\n if status_code == 200:\\n logging.debug('Success response gave status code 200')\\n with open(f'{self.out_dir}docs/downloaded/{self.filename}',\\n 'wb') as csv_written:\\n csv_written.write(self.response.content)\\n else:\\n logging.debug('Error in requests download'\\n 'status_code=%d', status_code)\\n sys.exit()\\n\\n return self.response\",\n \"def parse(url):\\n s_url = url.split(\\\"/\\\")\\n ns = [e for e in s_url if \\\"canonical-\\\" in e][0].split(\\\"-\\\")[-1]\\n f = \\\".\\\".join(s_url[-1].split(\\\".\\\")[:-1])\\n\\n textgroup, work, donotcate = tuple(f.split(\\\".\\\"))\\n lang = f.split(\\\"-\\\")[-1][0:3]\\n urn = \\\"urn:cts:{0}:{1}\\\".format(ns, f)\\n\\n target = \\\"output/canonical-{namespace}/data/{group}/{work}/{file}\\\".format(namespace=ns, group=textgroup, work=work, file=s_url[-1])\\n\\n \\\"\\\"\\\"\\n Downloading the resource \\n \\\"\\\"\\\"\\n # Download the resource\\n response = requests.get(url)\\n # Ensure there was no errors\\n response.raise_for_status()\\n\\n # Get the file name by splitting the url\\n filename = url.split(\\\"/\\\")[-1]\\n\\n \\\"\\\"\\\" \\n Caching the resource \\n \\\"\\\"\\\"\\n\\n os.makedirs(\\\"cache\\\", exist_ok=True)\\n # Save the original response\\n with open(\\\"cache/original-\\\"+filename, 'w') as f:\\n # Don't forget to write the reponse.text and not response itself\\n read_data = f.write(response.text)\\n\\n # Open it and parse it\\n with open(\\\"cache/original-\\\"+filename) as f:\\n # We use the etree.parse property\\n parsed = etree.parse(f, parser)\\n\\n return lang, urn, target, parsed\",\n \"def get_html_local():\\n import os\\n TESTDATA_FILENAME = os.path.join(os.path.dirname(__file__), 'html.html')\\n with open(TESTDATA_FILENAME, 'r') as html_file:\\n testdata = html_file.read()\\n return testdata\",\n \"def download_simple(url): # url(str)\\n html = urlopen(url).read().decode()\\n return html\",\n \"def call_website(link: str) -> str:\\n r = requests.get(link)\\n\\n if r.status_code != 200:\\n sys.exit(1)\\n\\n return r.text\",\n \"def __get_packed_xwalk_app_template(self, dest_dir):\\n input_file = urllib2.urlopen(self.updated_url)\\n contents = input_file.read()\\n input_file.close()\\n file_path = os.path.join(dest_dir, self.file_name)\\n if os.path.isfile(file_path):\\n os.remove(file_path)\\n file_dir = dest_dir + '/' + self.file_name.split('.tar.gz')[0]\\n if os.path.exists(file_dir):\\n shutil.rmtree(file_dir)\\n output_file = open(file_path, 'w')\\n output_file.write(contents)\\n output_file.close()\",\n \"def get_repository(post):\\n pattern = re.compile(constants.REPOSITORY_REGEX)\\n if \\\"links\\\" in post.json_metadata.keys():\\n for link in post.json_metadata[\\\"links\\\"]:\\n if link.startswith(\\\"/exit?url=\\\"):\\n link = link[len(\\\"/exit?url=\\\"):]\\n\\n try:\\n result = pattern.search(link).group(0)\\n return result\\n except AttributeError:\\n continue\\n else:\\n for line in post.body.split():\\n try:\\n result = pattern.search(line).group(0)\\n return result\\n except AttributeError:\\n continue\\n\\n return \\\"\\\"\",\n \"def fetch_zenodo(self):\\n\\n # retrieve content from URL\\n try:\\n logging.info(f\\\"Downloading example data from {self.url}\\\")\\n r = requests.get(self.url, stream=True)\\n with io.BytesIO() as stream:\\n with tqdm.wrapattr(\\n stream,\\n 'write',\\n file=sys.stdout,\\n miniters=1,\\n desc=self.url,\\n total=int(r.headers.get('content-length', 0))\\n ) as file:\\n for chunk in r.iter_content(chunk_size=4096):\\n file.write(chunk)\\n with zipfile.ZipFile(stream) as zipped:\\n # extract each file in the zipped dir to the project\\n for f in zipped.namelist():\\n logging.info(\\\"Unzipped: {}\\\".format(os.path.join(self.destination, f)))\\n zipped.extract(f, self.destination)\\n\\n logging.info(\\\"Download and install complete.\\\")\\n\\n self.close_logger()\\n\\n except requests.exceptions.MissingSchema:\\n msg = f\\\"Unable to download data from {self.url}\\\"\\n logging.exception(msg)\\n self.close_logger()\\n raise\",\n \"def fetch(self, url):\\r\\n fname = os.path.join(self._cachedir, self._formatter(url))\\r\\n if not os.path.exists(fname):\\r\\n time.sleep(self._sleep)\\r\\n html = urllib.urlopen(url).read()\\r\\n with codecs.open(fname, 'w', 'utf-8') as f:\\r\\n soup = BeautifulSoup(html)\\r\\n f.write(unicode(soup))\\r\\n return fname\",\n \"def get_workspace(client):\\n return client._creoson_post(\\\"windchill\\\", \\\"get_workspace\\\", key_data=\\\"workspace\\\")\",\n \"def _get_github_fetcher(\\n parsed_url: ParsedUrl, output_dir: str, spec: Optional[str] = None\\n) -> WorkflowFetcherBase:\\n # There are four different GitHub URLs we are interested in:\\n # 1. URL to a repository: /<user>/<repo>\\n # 2. Git URL: /<user>/<repo>.git\\n # 3. URL to a branch/commit/tag: /<user>/<repo>/tree/<git_ref>\\n # 4. URL to a zip snapshot: /<user>/<repo>/archive/.../<git_ref>.zip\\n components = _match_url(\\n parsed_url,\\n [\\n \\\"/<username>/<repository>/\\\",\\n \\\"/<username>/<repository>.git/\\\",\\n \\\"/<username>/<repository>/tree/<path:git_ref>\\\",\\n \\\"/<username>/<repository>/archive/<path:zip_path>\\\",\\n ],\\n )\\n\\n username = components[\\\"username\\\"]\\n repository = components[\\\"repository\\\"]\\n git_ref = components.get(\\\"git_ref\\\")\\n zip_path = components.get(\\\"zip_path\\\")\\n\\n if zip_path:\\n # The name of the zip file is the git commit/branch/tag\\n git_ref = parsed_url.basename_without_extension\\n workflow_name = f\\\"{repository}-{git_ref}\\\"\\n return WorkflowFetcherZip(parsed_url, output_dir, spec, workflow_name)\\n else:\\n repository_url = ParsedUrl(f\\\"https://github.com/{username}/{repository}.git\\\")\\n return WorkflowFetcherGit(repository_url, output_dir, git_ref, spec)\",\n \"def fetch(self) -> None:\\n workflow_spec_path = os.path.join(self._output_dir, self._spec)\\n self._download_file(self._parsed_url.original_url, workflow_spec_path)\",\n \"def get_config_from_remote_zip(zip_url):\\n import urllib2 # urlopen\\n import urlparse # urlparse\\n # Download the zip file in 1MB chunks.\\n chunk_size = 1024 * 1024\\n zip_filename = os.path.basename(urlparse.urlparse(zip_url).path)\\n remote_zip = urllib2.urlopen(zip_url)\\n try:\\n # Download it using the file's basename to a temp dir.\\n temp_dir = make_tempdir()\\n zip_filename = os.path.join(temp_dir, zip_filename)\\n with open(zip_filename, 'w') as local_zip:\\n remote_chunk = remote_zip.read(chunk_size)\\n while remote_chunk:\\n local_zip.write(remote_chunk)\\n remote_chunk = remote_zip.read(chunk_size)\\n finally:\\n remote_zip.close()\\n return get_config_from_local_zip(zip_filename)\",\n \"def GetAndSave(self, url, save_suffix, unzip=False):\\n self.connection.request('GET',\\n '/data/' + url,\\n headers={'content-type': 'text/plain'})\\n response = self.connection.getresponse()\\n file_name = Clean(url) + save_suffix\\n destination = os.path.join(self.path, file_name)\\n\\n if response.status != 200:\\n raise IOError(url)\\n\\n if unzip:\\n s = StringIO.StringIO(response.read())\\n content = gzip.GzipFile(fileobj=s).read()\\n else:\\n content = response.read()\\n\\n with open(destination, 'w') as f:\\n f.write(content)\\n return content\",\n \"def workspace_url(self):\\n return os.environ.get('TEAMRAUM_URL', '').strip('/')\",\n \"def fetchUrl(self, url):\\n self.driver.get(url)\\n html = self.driver.page_source\\n return html\",\n \"def download_one_zip(data_url, data_dir):\\r\\n\\r\\n zipfile_path, unzip_dir = zip_file_name_from_url(data_url, data_dir)\\r\\n if not is_there_file(zipfile_path, unzip_dir):\\r\\n if not os.path.isdir(unzip_dir):\\r\\n os.makedirs(unzip_dir)\\r\\n r = requests.get(data_url, stream=True)\\r\\n with open(zipfile_path, \\\"wb\\\") as py_file:\\r\\n for chunk in r.iter_content(chunk_size=1024): # 1024 bytes\\r\\n if chunk:\\r\\n py_file.write(chunk)\\r\\n unzip_nested_zip(zipfile_path, unzip_dir), download_small_file\",\n \"def _get_site_html(url):\\n\\n hdr = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Ge\\\\cko)' \\n 'Chrome/23.0.1271.64 Safari/537.11',\\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\\n 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',\\n 'Accept-Encoding': 'none',\\n 'Accept-Language': 'en-US,en;q=0.8',\\n 'Connection': 'keep-alive'}\\n\\n try:\\n req = urllib2.Request(url, headers = hdr)\\n source = urllib2.urlopen(req).read()\\n except:\\n source = []\\n\\n return source\",\n \"def download_zip(url, folder=None):\\n\\n # get this file folder name and save the file name\\n if not folder:\\n folder = os.path.dirname(os.path.abspath(__file__))\\n file_name = os.path.split(url)[1]\\n\\n # Download the file from \\\"url\\\" and save it locally under \\\"file_name\\\":\\n try:\\n with urllib.request.urlopen(url) as response, open(folder + \\\"/\\\" + file_name, 'wb') as out_file:\\n shutil.copyfileobj(response, out_file)\\n except urllib.error.URLError as e:\\n print('urllib.error.URLError')\\n raise Exception(e)\\n except Exception as e:\\n raise Exception(e)\\n else:\\n return folder,file_name\",\n \"def extract_zip(file, extract_location):\\n\\n with zipfile.ZipFile(file, \\\"r\\\") as zip_ref:\\n zip_ref.extractall(extract_location)\\n\\n print(f\\\"Extracted file to {extract_location}\\\")\",\n \"def _ExtractBuildInfo(self, master_name, builder_name, build_number):\\n build = build_util.DownloadBuildData(\\n master_name, builder_name, build_number)\\n\\n if build is None: # pragma: no cover\\n raise pipeline.Retry('Too many download from %s' % master_name)\\n if not build.data: # pragma: no cover\\n return None\\n\\n build_info = buildbot.ExtractBuildInfo(\\n master_name, builder_name, build_number, build.data)\\n\\n if not build.completed:\\n build.start_time = build_info.build_start_time\\n build.completed = build_info.completed\\n build.result = build_info.result\\n build.put()\\n\\n analysis = WfAnalysis.Get(master_name, builder_name, build_number)\\n if analysis and not analysis.build_start_time:\\n analysis.build_start_time = build_info.build_start_time\\n analysis.put()\\n\\n return build_info\",\n \"def _DownloadResultResources(self):\\n\\n target_zip = \\\"%s/layout-test-results-%s.zip\\\" % (self.output_dir,\\n self.build)\\n if self.zip_file:\\n filename = self.zip_file\\n self.delete_zip_file = False\\n else:\\n revision, build_name = self._GetRevisionAndBuildFromArchiveStep()\\n zip_url = GetZipFileURL(revision, build_name)\\n if self.verbose:\\n print \\\"Downloading zip file from %s to %s\\\" % (zip_url, target_zip)\\n filename = self._DownloadFile(zip_url, target_zip, \\\"b\\\")\\n if not filename:\\n if self.verbose:\\n print \\\"Could not download zip file from %s. Does it exist?\\\" % zip_url\\n return False\\n\\n if zipfile.is_zipfile(filename):\\n zip = zipfile.ZipFile(filename)\\n if self.verbose:\\n print 'Extracting files...'\\n directory = \\\"%s/layout-test-results-%s\\\" % (self.output_dir, self.build)\\n CreateDirectory(directory)\\n self._UnzipZipfile(zip, TEMP_ZIP_DIR)\\n\\n for failure in self.failures:\\n failure.test_expectations_line = (\\n self._GetTestExpectationsLine(failure.test_path))\\n if self.exclude_wontfix and failure.IsWontFix():\\n self.failures.remove(failure)\\n continue\\n if failure.text_diff_mismatch:\\n self._PopulateTextFailure(failure, directory, zip)\\n if failure.image_mismatch:\\n self._PopulateImageFailure(failure, directory, zip)\\n if not self.use_local_baselines:\\n failure.test_age = self._GetFileAge(failure.GetTestHome())\\n failure.flakiness = self._GetFlakiness(failure.test_path, self.platform)\\n zip.close()\\n if self.verbose:\\n print \\\"Files extracted.\\\"\\n if self.delete_zip_file:\\n if self.verbose:\\n print \\\"Cleaning up zip file...\\\"\\n path_utils.RemoveDirectory(TEMP_ZIP_DIR)\\n os.remove(filename)\\n return True\\n else:\\n if self.verbose:\\n print \\\"Downloaded file '%s' doesn't look like a zip file.\\\" % filename\\n return False\",\n \"def download_query_interface(url=None, force=True):\\n fp = query_interface_path()\\n if os.path.exists(fp):\\n logging.info(f\\\"query interface already exists in {fp}\\\")\\n if not force:\\n return\\n\\n import zipfile\\n import urllib.request\\n import concordancer.server\\n\\n # Download data\\n tgt_dir = pathlib.Path(concordancer.server.__file__).parents[0]\\n if url is None:\\n url = FRONTEND_ZIP\\n urllib.request.urlretrieve(url, tgt_dir / \\\"dist.zip\\\")\\n\\n # Extract zip file\\n with zipfile.ZipFile(tgt_dir / \\\"dist.zip\\\", 'r') as zip_ref:\\n zip_ref.extractall(tgt_dir)\\n\\n return tgt_dir\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.556513","0.5522339","0.5424023","0.5417535","0.53908026","0.5365669","0.5358795","0.5332443","0.52523816","0.5220812","0.5178104","0.5170915","0.5148962","0.51238537","0.51191694","0.5066204","0.5062707","0.5060167","0.5052632","0.50380456","0.5033808","0.5027104","0.5015001","0.49825746","0.49419397","0.49217093","0.4903021","0.4860602","0.48565802","0.48460996","0.48460826","0.48448402","0.48372504","0.48287","0.4805135","0.48028985","0.47765204","0.47592494","0.47584423","0.4741757","0.4738235","0.4737863","0.47357225","0.47243127","0.47217253","0.4689154","0.4688501","0.46844476","0.46604148","0.46531376","0.46515825","0.46488932","0.46440473","0.46393758","0.4615973","0.4611567","0.4604367","0.45987228","0.45984685","0.45946348","0.45924476","0.45818582","0.4581018","0.4577525","0.45704335","0.45699298","0.4569071","0.45635337","0.455303","0.45521376","0.45507514","0.45503727","0.4548093","0.45463306","0.454551","0.45435888","0.45411798","0.45339385","0.45323762","0.45293134","0.45236766","0.45150906","0.4507757","0.45059535","0.45004678","0.4496398","0.4492486","0.44831997","0.4482595","0.44731727","0.447198","0.44617966","0.44617513","0.44567254","0.44430688","0.44303775","0.44271362","0.4424649","0.44162813","0.44071802"],"string":"[\n \"0.556513\",\n \"0.5522339\",\n \"0.5424023\",\n \"0.5417535\",\n \"0.53908026\",\n \"0.5365669\",\n \"0.5358795\",\n \"0.5332443\",\n \"0.52523816\",\n \"0.5220812\",\n \"0.5178104\",\n \"0.5170915\",\n \"0.5148962\",\n \"0.51238537\",\n \"0.51191694\",\n \"0.5066204\",\n \"0.5062707\",\n \"0.5060167\",\n \"0.5052632\",\n \"0.50380456\",\n \"0.5033808\",\n \"0.5027104\",\n \"0.5015001\",\n \"0.49825746\",\n \"0.49419397\",\n \"0.49217093\",\n \"0.4903021\",\n \"0.4860602\",\n \"0.48565802\",\n \"0.48460996\",\n \"0.48460826\",\n \"0.48448402\",\n \"0.48372504\",\n \"0.48287\",\n \"0.4805135\",\n \"0.48028985\",\n \"0.47765204\",\n \"0.47592494\",\n \"0.47584423\",\n \"0.4741757\",\n \"0.4738235\",\n \"0.4737863\",\n \"0.47357225\",\n \"0.47243127\",\n \"0.47217253\",\n \"0.4689154\",\n \"0.4688501\",\n \"0.46844476\",\n \"0.46604148\",\n \"0.46531376\",\n \"0.46515825\",\n \"0.46488932\",\n \"0.46440473\",\n \"0.46393758\",\n \"0.4615973\",\n \"0.4611567\",\n \"0.4604367\",\n \"0.45987228\",\n \"0.45984685\",\n \"0.45946348\",\n \"0.45924476\",\n \"0.45818582\",\n \"0.4581018\",\n \"0.4577525\",\n \"0.45704335\",\n \"0.45699298\",\n \"0.4569071\",\n \"0.45635337\",\n \"0.455303\",\n \"0.45521376\",\n \"0.45507514\",\n \"0.45503727\",\n \"0.4548093\",\n \"0.45463306\",\n \"0.454551\",\n \"0.45435888\",\n \"0.45411798\",\n \"0.45339385\",\n \"0.45323762\",\n \"0.45293134\",\n \"0.45236766\",\n \"0.45150906\",\n \"0.4507757\",\n \"0.45059535\",\n \"0.45004678\",\n \"0.4496398\",\n \"0.4492486\",\n \"0.44831997\",\n \"0.4482595\",\n \"0.44731727\",\n \"0.447198\",\n \"0.44617966\",\n \"0.44617513\",\n \"0.44567254\",\n \"0.44430688\",\n \"0.44303775\",\n \"0.44271362\",\n \"0.4424649\",\n \"0.44162813\",\n \"0.44071802\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7396624"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":25599,"cells":{"query":{"kind":"string","value":"Recursively search through all jobs and projects to pull out build URLs"},"document":{"kind":"string","value":"def get_all_build_links(url, auth=None, netloc_force=False):\n all_build_links = []\n if 'api/json' not in url:\n # if the api endpoint isnt appended, then append it:\n url += '/api/json/'\n def recurse_to_build(url):\n orig_url = urllib.parse.urlparse(url)\n try:\n json_reply = json.loads(requests.get(url, verify=False, auth=auth).text)\n except JSONDecodeError:\n return\n if 'builds' in json_reply:\n if len(json_reply['builds']) > 0:\n url_link = json_reply['builds'][0]['url']\n if netloc_force:\n url_link = urllib.parse.urlparse(url_link)\n url_link = url_link._replace(netloc=orig_url.netloc)\n url_link = url_link.geturl()\n print(\"{}\".format(url_link))\n all_build_links.append(url_link)\n if 'jobs' in json_reply:\n for job in json_reply['jobs']:\n url_link = job['url'] + 'api/json/'\n if netloc_force:\n url_link = urllib.parse.urlparse(url_link)\n url_link = url_link._replace(netloc=orig_url.netloc)\n url_link = url_link.geturl()\n recurse_to_build(url_link)\n if 'endpoint' in json_reply:\n url_link = json_reply['endpoint'] + 'api/json/'\n if netloc_force:\n url_link = urllib.parse.urlparse(url_link)\n url_link = url_link._replace(netloc=orig_url.netloc)\n url_link = url_link.geturl()\n recurse_to_build(url_link)\n recurse_to_build(url)\n return all_build_links"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def process_builds(self):\n for p in self.product_config:\n p_str = p[0]\n\n for l in self.link_list:\n if l.startswith(p[1]):\n if not self.builds_list.has_key(p_str):\n self.builds_list[p_str] = []\n b_str = l.replace('/', '')\n self.builds_list[p_str].append(b_str)","def getBuilds():","def grab_project_links(soup):\n project_urls = []\n valid_project_url = \"/?archive/?gsoc/\\d+[0-9]/orgs/[a-zA-Z]+/[a-zA-Z]+/[a-zA-Z]+.html\"\n try:\n # Grab links to all the projects\n all_link = soup.find_all(\"a\")\n for link in all_link:\n if re.match(valid_project_url, link.get(\"href\")):\n project_urls.append(join(melange, link.get(\"href\")[1:]))\n except TypeError:\n print(link)\n\n return project_urls","def getBuildRequests():","def get_projects_url_paths(*args):\n projects_infos = get_projects()\n projects_url_paths = []\n\n for project in projects_infos:\n projects_url_paths.append(BASE_URL + \"/projects/{id}/\".format(id=project[0]))\n return projects_url_paths","def import_builds_for_job(job_pk):\n job = Job.objects.get(pk=job_pk)\n\n logging.info(\"Located job %s\\n\" % job)\n\n client = job.server.get_client()\n\n logging.info(\"Using server at %s\\n\" % job.server.url)\n\n jenkins_job = client.get_job(job.name)\n\n good_build_numbers = list(jenkins_job.get_build_ids())\n logging.info(\"%s\\n\" % good_build_numbers)\n\n for build_number in good_build_numbers:\n import_build_for_job(job.pk, build_number)","def get_job_builds(self, job_id, started=None, finished=None,\n success=None, skipped=None, order='asc', limit=100):\n pass","def get_finished_builds(job_dir, last_processed_log):\n return [\n dir.name\n for dir in os.scandir(job_dir)\n if dir.name.isdigit()\n and int(dir.name) > int(last_processed_log)\n and os.path.isfile(\n functools.reduce(os.path.join, [job_dir, dir.name, \"build.xml\"])\n )\n and grep(\n functools.reduce(os.path.join, [job_dir, dir.name, \"build.xml\"]),\n \"<result>\",\n )\n ]","def Builds():\n return builds","def get_new_running_builds(job_dir, last_processed_log):\n return [\n dir.name\n for dir in os.scandir(job_dir)\n if dir.name.isdigit()\n and int(dir.name) > int(last_processed_log)\n and os.path.isfile(\n functools.reduce(os.path.join, [job_dir, dir.name, \"build.xml\"])\n )\n and not grep(\n functools.reduce(os.path.join, [job_dir, dir.name, \"build.xml\"]), \"<result>\"\n )\n ]","def getPendingBuilds():","def getPendingBuilds():","def getBuild():","def get_jobs():\n jobs = [os.path.join(JOBS_DIR, job)\n for job in os.listdir(JOBS_DIR)\n if job != '.gitignore']\n return jobs","def do_all_projects(args):\n man = load_manifest()\n\n if args[0] == '-p':\n parallel = True\n del args[0]\n else:\n parallel = False\n\n towait = []\n\n for (name, project) in man.projects.iteritems():\n repo = GitRepo(workdir_for_project(project))\n print >>sys.stderr, \"In project: \", name, \" running \", \" \".join(args)\n p = repo.command_process(args)\n if not parallel:\n p.Wait()\n print >>sys.stderr\n else:\n towait.append(p)\n\n for p in towait:\n p.Wait()","def __setup_recursion(folder_found, links_titles):\n urls = []\n if folder_found:\n for element_x, _, element_z in links_titles:\n if element_z == 'folder':\n # fill urls with sub-links to recursively call crawl function on them\n urls.append(element_x)\n return urls","def get_pr_jobs():\n res = requests.get(\n uri + \"/view/Pull%20Requests/api/json\",\n headers={\"accept\": \"application/json\"},\n auth=requests.auth.HTTPBasicAuth(user, password),\n verify=verify,\n )\n if res.status_code != 200:\n raise RuntimeError(\"Received non 200 status code from jenkins\")\n data = res.json()\n for job in data[\"jobs\"]:\n yield job","def pipeline_results(self):\n repo = self.main_gitlab_repo()\n ret = []\n for branch in [\"master\", \"main\", \"devel\"]:\n build = repo.cibuild_set.filter(branch__name__endswith=branch).first()\n if build is not None:\n link = repo.url + f\"/-/pipelines/{build.build_id}\"\n sym = \"✓\" if build.passed else \"✘\"\n ret.append(f'<a href=\"{link}\">{branch}: {sym}</a>')\n\n return mark_safe(\"<br>\".join(ret))","def getURLs():","def recursive_urls(urls):\n if len(urls) == 0:\n return\n rs = [grequests.get(url, hooks=dict(args=print_url)) for url in urls]\n responses = grequests.map(rs)\n url_lists = [get_urls_from_response(response) for response in responses]\n urls = sum(url_lists, []) # flatten list of lists into a list\n recursive_urls(urls)","def urls(gh, user):\n return [repo.url for repo in getuserrepos(gh, user)]","def download_builds(config, builds, force=False):\n if not config.get('datadir'):\n raise ValueError(\"No output dir (--datadir) specified\")\n\n jenkins_client = jenkins.get_client(config)\n download_args = []\n for build in builds:\n if ':' in build:\n (job, build_id) = build.split(':')\n download_args.append(\n (job, build_id, config['datadir'],\n jenkins_client, config.get('groupingParameter'), force)\n )\n else:\n job = build\n for build_id in jenkins_client.fetch_all_build_ids(job):\n download_args.append(\n (job, build_id, config['datadir'],\n jenkins_client, config.get('groupingParameter'), force)\n )\n\n num_threads = config.get('downloadThreads', 7) # arbitrary number\n if num_threads <= 1:\n for args_tuple in download_args:\n _download_one_build(args_tuple)\n else:\n import multiprocessing.pool # only import if we need it!\n pool = multiprocessing.pool.ThreadPool(num_threads)\n pool.map(_download_one_build, download_args)","def get(self, project_slug):\n project = Project.query.filter_by(slug=project_slug).first_or_404()\n\n if not (project.public or current_user.is_authenticated()):\n flask_restful.abort(404)\n\n return [\n dict(name=job.git_branch)\n for job\n in (\n project.jobs.distinct(Job.git_branch)\n .order_by(sqlalchemy.asc(Job.git_branch))\n )\n if job.git_branch is not None\n ]","def list_projects():\n if '.wcscanner' not in os.listdir(context.__BASE_PATH__):\n return []\n return os.listdir(context.__PROJECTS_PATH__)","def build_folder_map(base_url, proxies):\n try:\n LOGGING.info('Requesting: {0}'.format(base_url))\n\n user_agent = {'User-agent': BASECONFIG.user_agent}\n\n request = requests.get(base_url, headers=user_agent, proxies=proxies, timeout=(20, 20))\n\n if request.status_code == 200:\n LOGGING.info('Request OK. Parsing result...')\n\n children = []\n\n content = BeautifulSoup(request.text, 'html.parser')\n links = content.find_all('a', href=True)\n\n for link in links:\n if 'Parent Directory' in link:\n continue\n\n href = link.get('href')\n\n if len(href) > 1 and not any(s in href for s in BAD_CHARS):\n children.append(urljoin(base_url, href))\n\n return children\n\n else:\n LOGGING.warning(\n 'Problem connecting to {0}. Status code: {1}. Aborting task.'.format(\n base_url, request.status_code))\n\n except requests.exceptions.ConnectionError as e:\n LOGGING.warning(\n 'Problem connecting to {0}. Error: {1}'.format(\n base_url, e))\n\n except Exception as e:\n LOGGING.warning(\n 'Problem connecting to {0}. Aborting task.'.format(base_url))\n LOGGING.exception(sys.exc_info())\n LOGGING.exception(type(e))\n LOGGING.exception(e.args)\n LOGGING.exception(e)\n\n return []","def getAllSolutionUrls(urls: list) -> list:\n allSolutionUrls = []\n\n for index, url in enumerate(urls):\n print(\"current puzzle: \" + str(index))\n solutionUrls = getSolutionUrls(url)\n\n if solutionUrls != None:\n allSolutionUrls += solutionUrls\n\n return allSolutionUrls","def getBuildbotURL():","def scan_buildfiles(root_dir, base_path=None):\r\n\r\n buildfiles = []\r\n for root, dirs, files in os.walk(base_path if base_path else root_dir):\r\n for filename in files:\r\n if BuildFile._is_buildfile_name(filename):\r\n buildfile_relpath = os.path.relpath(os.path.join(root, filename), root_dir)\r\n buildfiles.append(BuildFile(root_dir, buildfile_relpath))\r\n return OrderedSet(sorted(buildfiles, key=lambda buildfile: buildfile.full_path))","def _fetch_base_urls(repository_url):\n repo_config = _url_as_ini_file(repository_url)\n config = configparser.ConfigParser()\n config.read_file(repo_config)\n\n base_urls = list()\n for repo in config.sections():\n base_urls.append((config.get(repo, 'name'),\n config.get(repo, 'baseurl')))\n\n return base_urls","def getUrls(self):\n # in case you need to move from a read only Url to a writeable one, here it gets replaced\n repopath = self.repositoryUrl().replace(\"[git]\", \"\")\n repoString = utils.replaceVCSUrl(repopath)\n [repoUrl, repoBranch, repoTag] = utils.splitVCSUrl(repoString)\n if not repoBranch and not repoTag:\n repoBranch = \"master\"\n print(\"|\".join([repoUrl, repoBranch, repoTag]))\n return True","def _get_csvs(self):\n\n stack = [self.root]\n urls = []\n\n while stack:\n curr_dir = stack.pop()\n\n # skip first link which is always the parent dir \n for link in self._soup(curr_dir)('a')[1:]:\n href = link['href']\n next_link = os.path.join(curr_dir, href)\n\n # Case 1: found the csv, add it to the list of URLs we return\n # Case 2: Empty dir or repo.tar.giz. Ignore.\n # Case 3: DFS further down\n if 'csv' in href:\n urls.append(next_link)\n elif href != '/' and href != 'repo.tar.gz':\n stack.append(next_link)\n\n return urls","def siblings(self):\r\n\r\n for build in glob1(self.parent_path, 'BUILD*'):\r\n if self.name != build and BuildFile._is_buildfile_name(build):\r\n siblingpath = os.path.join(os.path.dirname(self.relpath), build)\r\n if not os.path.isdir(os.path.join(self.root_dir, siblingpath)):\r\n yield BuildFile(self.root_dir, siblingpath)","def get_projects(self):\n unaligned_path = self.get_unaligned_path()\n logger.debug(\"collecting list of projects\")\n return [p for p in os.listdir(unaligned_path)\n if len(parsing.get_project_label(p))]","def get_buildroot(self, worker_metadatas):\n buildroots = []\n for platform in sorted(worker_metadatas.keys()):\n for instance in worker_metadatas[platform]['buildroots']:\n instance['id'] = '{}-{}'.format(platform, instance['id'])\n buildroots.append(instance)\n\n return buildroots","def test_get_projects_expanded(self):\n pass","def __Job_list__(self):\n # | - __Job_list__\n\n # | - Adding Jobs From Individual Directory List\n if self.indiv_dir_lst is not None:\n for job_i_dir in self.indiv_dir_lst:\n\n rev_dirs, max_rev = self.__revision_list_and_max__(job_i_dir)\n\n print(job_i_dir)\n if rev_dirs:\n\n print(\"rev_dirs:\", rev_dirs)\n\n if self.parse_all_revisions is False:\n\n last_rev_int = np.sort(\n [int(i.split(\"_\")[-1]) for i in rev_dirs])[-1]\n rev_dirs = [\"_\" + str(last_rev_int), ]\n # rev_dirs = [rev_dirs[-1]]\n\n print(\"rev_dirs:\", rev_dirs)\n print(\"IOPSDFJOKIDSIJFIJDSF\")\n\n for rev_i in rev_dirs:\n path_i = os.path.join(job_i_dir, rev_i)\n path_i = os.path.normpath(path_i)\n\n Job_i = Job(\n path_i=path_i,\n job_params_dict=None,\n max_revision=max_rev,\n root_dir=None,\n )\n\n self.Job_list.append(Job_i)\n else:\n print(\"Didn't find any job dirs here:\")\n print(job_i_dir)\n pass\n # __|\n\n # | - Adding Jobs From Enumerated Job Properties Tree\n if self.job_var_lst is not None:\n for job_i in self.job_var_lst:\n job_var_dict = self.__job_i_vars_to_dict__(job_i)\n\n if self.folders_exist:\n path_i = self.var_lst_to_path(\n job_i,\n job_rev=\"Auto\",\n relative_path=False,\n )\n\n # | - __old__\n # else:\n # print(\"else *s8fs*sdf\")\n # path_i = os.path.join(\n #\n # self.var_lst_to_path(\n # job_i,\n # job_rev=\"Auto\",\n # relative_path=False,\n # ),\n #\n # # self.var_lst_to_path(\n # # job_i,\n # # ),\n #\n # \"_1\",\n # )\n # __|\n\n rev_dirs, max_rev = self.__revision_list_and_max__(\n # path_i\n self.var_lst_to_path(\n job_i,\n job_rev=\"None\",\n relative_path=False,\n )\n )\n\n Job_i = Job(\n path_i=path_i,\n job_params_dict=job_var_dict,\n max_revision=max_rev,\n root_dir=self.root_dir,\n )\n\n self.Job_list.append(Job_i)\n # __|\n\n # | - TEMP | I don't remember why this is here\n indiv_job = self.indiv_job_lst is not None\n level_labels = self.tree_level_labels is not None\n if indiv_job and level_labels:\n print(\"LSKDJFKLDS_-09sdfsdfs9dfas\")\n for job_params_i in self.indiv_job_lst:\n\n job_var_lst_i = self.__job_i_param_dict_to_job_var_lst__(\n job_params_i,\n )\n\n path_i = os.path.join(\n self.new_var_lst_to_path(job_var_lst_i),\n \"_1\",\n )\n\n Job_i = Job(\n path_i=path_i,\n job_params_dict=job_params_i,\n max_revision=None,\n root_dir=self.root_dir,\n )\n\n self.Job_list.append(Job_i)\n # __|\n\n if self.indiv_job_dict_lst is not None:\n self.create_Jobs_from_dicts_and_paths(\n self.indiv_job_dict_lst,\n )\n # __|","def query_jobs_schedule_url(repo_name, revision):\n return buildapi.query_jobs_url(repo_name, revision)","def do_all_projects_remotes(args):\n man = load_manifest()\n\n if args[0] == '-p':\n parallel = True\n del args[0]\n else:\n parallel = False\n towait = []\n\n for (name, project) in man.projects.iteritems():\n repo = GitRepo(workdir_for_project(project))\n for remote_name in project.remotes.keys():\n cmd = args + [remote_name]\n print >>sys.stderr, \"In project: \", name, \" running \", \" \".join(cmd)\n p = repo.command_process(cmd)\n if not parallel:\n p.Wait()\n print >>sys.stderr\n else:\n towait.append(p)\n for p in towait:\n p.Wait()","def getCurrentBuilds():\n # again, we could probably provide an object for 'waiting' and\n # 'interlocked' too, but things like the Change list might still be\n # subject to change","def crawler():\n job_entries = []\n for job in job_info(URL):\n labels = \"\"\n if job[\"labels\"]:\n for label in job[\"labels\"]:\n labels += label[\"name\"]\n if job[\"labels\"].index(label) != len(job[\"labels\"]) - 1:\n labels += \",\"\n job_entries.append((job[\"number\"], job[\"id\"],\n job[\"title\"], job[\"html_url\"], labels))\n\n conn = sqlite3.connect('jobber/jobber.db')\n c = conn.cursor()\n c.executemany(('INSERT OR IGNORE INTO job_entries '\n 'VALUES (?,?,?,?,?)'), job_entries)\n conn.commit()\n conn.close()","def _get_known_urls(self, all_known_urls):\n url_tree = URLTree()\n\n for url in all_known_urls:\n url_tree.add_url(url)\n\n return url_tree","def generateFinishedBuilds(builders=[], branches=[],\n num_builds=None, finished_before=None,\n max_search=200):","def builds(self):\n return self._builds","def _get_results(tree, year):\n projects = []\n \n for t in tree.findAll('li', {'class': 'mdl-list__item mdl-list__item--one-line'}): \n org = _clean(t.findChildren('a')[0].text)\n a = t.findChildren('a')[0]['href']\n\n org_url = 'https://www.google-melange.com' + a\n org_tree = _get_tree(org_url)\n\n for t1 in org_tree.findAll('span', {'class': 'mdl-list__item-primary-content'}):\n a1 = t1.findChildren('a')\n projs = [a['href'] for a in a1]\n\n for p in projs:\n proj_url = 'https://www.google-melange.com' + p\n proj_tree = _get_tree(proj_url)\n \n title = _clean(proj_tree.findAll('h3')[0].text)\n p = proj_tree.findAll('p')\n bio = _clean(p[0].text)\n \n student = bio.split('by')[-1].split('for')[0]\n description = _clean(p[1].text)\n projects.append((title, org, student, description))\n\n _save_results(projects, year)","def eia_cbecs_URL_helper(build_url, config, args):\n # initiate url list for coa cropland data\n urls = []\n # replace \"__xlsx_name__\" in build_url to create three urls\n for x in config['xlsx']:\n url = build_url\n url = url.replace(\"__xlsx__\", x)\n urls.append(url)\n # elif:\n\n return urls","def build(cfg, jobs, watch):\n libjobs.buildJobs(cfg, jobs, watch)","def build(c, force=None):\n for sp_ns in ns_foreach_task_subdir(c):\n print(\"-- running build in \", os.getcwd())\n\n # sp_ns.tasks.build(c, force)\n c.run('invoke build')","def find_files():\n \n p = re.compile(REGEX_PART_NUMBER)\n job_files = []\n \n for root, dirs, files in os.walk(project_path): # r at start of string need to prevent unicode error\n for filename in files:\n re_part_number = p.match(filename)\n if re_part_number:\n file_ext = filename.split(\".\")[-1].lower() # extract file extension \n file_size = os.path.getsize((os.path.join(root, filename))) # filesize in bytes \n \n part_number = re_part_number.group() # extract part number from regular expression match\n part_code = part_number.split(\"-\")[0]\n \n destinations = [] # destinations is a list in case a filetype is both a source and output filetype\n \n if (file_ext in EXTS_SOURCE_FILES) and flag_find_source_files:\n destinations.append(os.path.join(target_source_path,part_code,part_number)) \n \n if (file_ext in EXTS_OUTPUT_FILES) and flag_find_output_files:\n destinations.append(os.path.join(target_source_path,part_code,part_number)) \n \n if destinations: \n job_files.append(File(filename,root,file_size,destinations,part_number,part_code))\n print(f\"Found: {filename}\")\n \n return job_files","def job_info(url):\n for job in requests.get(url).json():\n yield job","def find_projects(self):\n\n attrs = ['name', 'remote', 'revision', 'path', 'groups', 'upstream']\n projects = defaultdict(list)\n\n for project in self.tree.findall('project'):\n values = [project.get(attr) for attr in attrs]\n project_dict = dict(zip(attrs, values))\n project_name = project_dict.pop('name')\n\n if project_dict['groups'] is not None:\n project_dict['groups'] = project_dict['groups'].split(',')\n\n if project_name is None:\n if self.fail_on_invalid:\n raise InvalidManifest(\n 'Project entry missing \"name\" attribute'\n )\n else:\n continue\n\n if project_name in projects:\n paths = [\n p_attr.get('path', project_name)\n for name, p_attrs in projects.items()\n for p_attr in p_attrs if name == project_name\n ]\n\n if project_dict['path'] in paths:\n raise InvalidManifest(\n 'Duplicate project entry with matching \"name\" '\n 'and \"path\" attributes'\n )\n\n children = project.getchildren()\n if children:\n for child in children:\n subelement = child.tag\n\n # Only run the following if the element tag\n # is a string (avoids comments)\n if isinstance(subelement, str):\n subdict = getattr(\n self, 'create_{}_dict'.format(subelement)\n )(child)\n\n if subdict is not None:\n project_dict.setdefault(subelement, []).append(\n subdict\n )\n\n projects[project_name].append(\n self.generate_data_dict(project_dict)\n )\n\n self.projects = projects","def _recursive_gh_get(href, items, password=None):\n response = GitHub._request('GET', href, token=password)\n response.raise_for_status()\n items.extend(response.json())\n if \"link\" not in response.headers:\n return\n # links = link_header.parse(response.headers[\"link\"])\n # rels = {link.rel: link.href for link in links.links}\n # if \"next\" in rels:\n # ghRelease._recursive_gh_get(rels[\"next\"], items)","def relative_to_buildroot(self):\n return [os.path.join(self.rel_path, source) for source in self.source_paths]","def main():\n\n options = parse_arguments()\n\n directories = find_directories(options.folder)\n process_pool = Pool(len(directories))\n\n function_call = partial(find_URLs, options=options)\n\n process_pool.map(function_call, directories)","def get_matching_artifact_urls(user_input):\n # short link to gerrit change id\n regex = REGEX_GERRIT_CHANGE.match(user_input)\n if regex:\n return _gerrit_urls_filtered(int(regex.group(1)))\n\n # short link to gerrit change id and specific revision\n regex = REGEX_GERRIT_REVISION.match(user_input)\n if regex:\n return _gerrit_urls_filtered(int(regex.group(1)), int(regex.group(2)))\n\n # full gerrit url\n parsed = urlparse.urlparse(user_input)\n if parsed.hostname in GERRIT_ALLOWED_HOSTS:\n if len(parsed.path) > 1:\n try:\n return _gerrit_urls_filtered(int(parsed.path[1:]))\n except ValueError:\n pass\n\n if parsed.fragment:\n change_id, revision = _parse_fragment(parsed.fragment)\n if change_id:\n return _gerrit_urls_filtered(change_id, revision)\n\n # direct link to job output\n if parsed.hostname in LOGS_ALLOWED_HOSTS:\n artifact_info = _create_empty_message()\n artifact_job = _create_job('direct-link', user_input)\n artifact_info['jobs'].append(artifact_job)\n\n parsed_artifact_info, parsed_job_info = _parse_logs_path(parsed.path)\n artifact_info.update(parsed_artifact_info)\n artifact_job.update(parsed_job_info)\n\n if 'change_id' in parsed_artifact_info:\n # try to fetch the gerrit change to fill in missing details\n try:\n listing = gerrit_list.GerritListing(\n parsed_artifact_info['change_id'])\n artifact_info['change_project'] = listing.change_project\n artifact_info['change_subject'] = listing.change_subject\n\n job = listing.get_job_by_url(user_input)\n if job:\n artifact_info['status'] = job.status\n artifact_job['status'] = job.status\n except requests.HTTPError:\n pass\n\n return [artifact_info]\n\n return []","def retrieve(cfg, jobs, filter):\n server = jenkins_utils.server_factory(cfg)\n retrieved = libjobs.retrieveJobs(server, jobs, filter)\n for job in retrieved:\n job_file = os.path.join(cfg.jobdir, job.name + '.xml')\n with open(job_file, 'w') as fh:\n fh.write(job.get_config())","def build_list(ctx, show_url, show_data,\n start, count,\n project, build_type_id, branch, status, running, tags, user,\n output_format, columns):\n kwargs = {'start': start,\n 'count': count}\n if build_type_id:\n kwargs['build_type_id'] = build_type_id\n if branch:\n kwargs['branch'] = branch\n if status:\n kwargs['status'] = status\n if running:\n kwargs['running'] = running\n if tags:\n kwargs['tags'] = tags\n if user:\n kwargs['user'] = user\n if project:\n kwargs['project'] = project\n\n func = ctx.obj.get_builds\n\n if show_url:\n kwargs['return_type'] = 'url'\n url = func(**kwargs)\n del kwargs['return_type']\n click.echo(url)\n\n if not show_data:\n return\n\n try:\n data = func(**kwargs)\n except HTTPError as e:\n click.echo('url: %s' % e.url)\n click.echo('status_code: %s' % e.status_code)\n click.echo()\n click.echo(e)\n return\n\n for build in data['build']:\n details = ctx.obj.get_build_by_build_id(build['id'])\n try:\n build['user'] = details['triggered']['user']['username']\n build['statusText'] = details['statusText']\n build['details'] = details\n except KeyError:\n build['user'] = 'N/A'\n\n click.echo('count: %d' % data['count'])\n if data['count'] == 0:\n return\n\n if output_format == 'table':\n column_names = columns.split(',')\n output_table(column_names, data['build'])\n elif output_format == 'json':\n output_json_data(data)","async def org_info_above_14(orgs_urls14):\n org_info_14 = []\n project_urls_from14 = []\n for url in orgs_urls14:\n try:\n soup = await get_page(url)\n org_name = basename(url)\n org_info = soup.find_all('p')\n web_page = org_info[1].text.splitlines()[-1].strip()\n mailing_list = org_info[2].text.split(\":\")[-1].strip()\n description = soup.find('div', {'class': 'main mdl-cell mdl-cell--8-col\\\n mdl-card mdl-shadow--4dp'})\n detail = description.find_all('p')[2].nextSibling\n org_info_14.append({'name': org_name, 'page': web_page,\n 'about': detail, 'mail': mailing_list,\n 'link': url})\n project_urls_from14.extend(grab_project_links(soup))\n except IndexError:\n print(url)\n\n return org_info_14, get_project_info(project_urls_from14)","def build_browse(ctx, args):\n for build_id in args:\n data = ctx.obj.get_build_by_build_id(build_id)\n webbrowser.open(data['webUrl'])","def parse_inner_urls(self, response):\n s = Selector(response)\n\n jobs_per_site = s.xpath('//div[@class=\"col-lg-12 col-md-12 col-sm-12 aggelia-view-title\"]//a/@href').extract()\n print(jobs_per_site)\n\n for inner_site in jobs_per_site:\n url = urljoin(\"https://www.skywalker.gr/\", inner_site)\n yield scrapy.Request(url, callback=self.parse_items)","def process(self):\n\n manager_list = []\n\n with Manager() as manager:\n manager_list = manager.list()\n processes = []\n\n for data in self.repos:\n process = Process(\n target=self.get_repos_lists, args=(data, manager_list)\n )\n process.start()\n processes.append(process)\n\n for proc in processes:\n proc.join()\n\n manager_list = list(manager_list)\n\n for element in manager_list:\n domains, ips = self.__separate_domains_from_ip(element)\n Settings.domains.extend(domains)\n Settings.ips.extend(ips)\n\n del domains, ips\n\n Settings.domains = Helpers.List(Settings.domains).format()\n Settings.ips = Helpers.List(Settings.ips).format()\n\n Helpers.Dict(self.repos).to_json(Settings.repositories_file)\n del Settings.repositories\n\n Generate()\n Compress()\n Deploy()\n Clean()","def getProjectURL():","def buildList(self,list_all=False,push_all=False):\n print \"=== Loading\"\n\n ## Walk in repo and get GitRepo\n for repo in self.repos:\n if repo not in self.ignore or list_all:\n a = GitRepo(repo)\n if not self.animate:\n a.branchStatus()\n if a.globalStatus():\n if a.forward and push_all:\n a.push()\n self.gitrepos.append(a)\n\n print \"\\r=== \"+str(len(self.gitrepos))+\" repos scanned\"","def extract_urls(genome):\n itemid = genome.get('metadata').get('identifier')\n urls = set([url for url in genome['urls'] if 'archive.org' not in url])\n db_urls_found(itemid, urls)","def get_all_jobs(self) -> List[DocumentReference]:\n return self.get_all_documents(Type._JOBS)","def readProjectLinks(configFile):\n config = ConfigParser.ConfigParser()\n if os.path.isfile(configFile):\n config.readfp(open(configFile))\n\n projects = {}\n try:\n projectItems = config.items(\"projects\")\n # tip for this solution found here:\n # http://stackoverflow.com/a/8048529\n for project, link in projectItems:\n projects[project] = link\n except:\n # this is bad error handling\n # on my list to improve in the future\n print \"An error occurred while parsing the projects.conf file.\"\n print \"Make sure it is formatted properly.\"\n quit\n\n return projects","def get_json_job_details(buildurl):\n return requests.get(buildurl + \"/api/json\").json()","def findBuildDirs(tests):\n \n buildDirs = []\n for test in tests:\n\n currentBuildDir = getParam(test + \".buildDir\")\n if (buildDirs.count(currentBuildDir) == 0):\n buildDirs.append(currentBuildDir)\n\n return buildDirs","def _link_jobs(self):\n for i, j in enumerate(self.jobs):\n j.link(self, i)\n j.claim_artifacts()","def _find_files(job_schedule_info):\n files = []\n\n job_status = _status_info(job_schedule_info)\n assert job_status is not None, \\\n \"We should not have received an empty status\"\n\n properties = job_status.get(\"properties\")\n\n if not properties:\n LOG.error(str(job_status))\n raise Exception(\"The status of the job is expected to have a \"\n \"properties key, however, it is missing.\")\n\n LOG.debug(\"We want to find the files needed to trigger %s\" %\n properties[\"buildername\"])\n\n if \"packageUrl\" in properties:\n files.append(properties[\"packageUrl\"])\n if \"testsUrl\" in properties:\n files.append(properties[\"testsUrl\"])\n\n return files","def process_links(self):\n\n self.logger.info(\"Current depth is %d, list contains %d items\" % \n (self.link_depth, len(self.links)))\n\n for url in self.links:\n\n duplicate = True if self.collection.find_one({ \"url\": url }) else False\n if duplicate and self.link_depth == 0:\n self.logger.info(\"Skipping url: %s\" % url)\n continue\n\n try:\n data = self.get_url(url)\n if not duplicate:\n n = self.get_recipe(data, url)\n self.logger.info(\"Found %d recipe(s)\" % n)\n if self.link_depth > 0:\n n = self.get_links(data)\n self.logger.info(\"Added %d link(s) to queue\" % n)\n except Exception as exc:\n self.logger.error(\"Processing %s failed\" % url, exc_info = True)\n time.sleep(self.pause)\n\n if self.link_depth > 0:\n self.links = self.link_queue\n self.link_queue = [ ]\n self.link_depth -= 1\n self.process_links()","def get_old_running_builds(job_dir, job_to_retry, last_processed_log, parser_info_path):\n current_running_builds = [\n dir.name\n for dir in os.scandir(job_dir)\n if dir.name.isdigit()\n and int(dir.name) <= int(last_processed_log)\n and os.path.isfile(\n functools.reduce(os.path.join, [job_dir, dir.name, \"build.xml\"])\n )\n and not grep(\n functools.reduce(os.path.join, [job_dir, dir.name, \"build.xml\"]), \"<result>\"\n )\n ]\n\n # We first check for the old running builds of last run\n with open(parser_info_path, \"r\") as rotation_file:\n old_running_builds_object = json.load(rotation_file)\n old_running_builds_dict = old_running_builds_object[\"parserInfo\"][\n \"runningBuilds\"\n ]\n\n if job_to_retry not in old_running_builds_dict:\n old_running_builds_dict[job_to_retry] = dict()\n old_running_builds = dict()\n else:\n old_running_builds = old_running_builds_dict[job_to_retry]\n\n # Update value of old running builds in the original object to store it again\n for build_number in current_running_builds:\n if (\n build_number\n not in old_running_builds_object[\"parserInfo\"][\"runningBuilds\"][\n job_to_retry\n ].keys()\n ):\n old_running_builds_object[\"parserInfo\"][\"runningBuilds\"][job_to_retry][\n build_number\n ] = \"\"\n\n with open(parser_info_path, \"w\") as rotation_file:\n json.dump(old_running_builds_object, rotation_file)\n\n return current_running_builds, old_running_builds","def check(self):\n json = JsonBackend(\"../src/builder/projects.json\")\n json.load()\n\n TM_ITSELF = 1\n expected_files = TM_ITSELF + sum(p.downloadable is True\n for p in json.projects)\n self.downloads_for_project('tots', expected_files)\n\n expected_files = TM_ITSELF + sum(p.softcatala is True and\n p.downloadable is True\n for p in json.projects)\n\n self.downloads_for_project('softcatala', expected_files)\n\n expected_files = 1\n for project_dto in json.projects:\n if not project_dto.downloadable:\n continue\n\n self.downloads_for_project(project_dto.name, expected_files)\n self.check_project_link(project_dto.projectweb)","def getSolutionUrls(url: str) -> list:\n \n try:\n response = get(url)\n html_soup = BeautifulSoup(response.text, 'html.parser')\n soln_containers = html_soup.find_all('div', class_ = 'result')\n solutionUrls = [website_url + container.h1.a[\"href\"] for container in soln_containers]\n return solutionUrls\n except:\n print(\"getSolutionUrls: URL error: \" + str(url))\n return None","def get_github_jobs_data() -> List[Dict]: # Provided by professor\n all_data = []\n page = 1\n more_data = True\n while more_data:\n url = f\"https://jobs.github.com/positions.json?page={page}\"\n raw_data = requests.get(url)\n raw_data.raise_for_status()\n if \"GitHubber!\" in raw_data: # Avoid error in testing\n continue # Trying continue, but might want break\n partial_jobs_list = raw_data.json()\n all_data.extend(partial_jobs_list)\n if len(partial_jobs_list) < 50:\n more_data = False\n time.sleep(.1) # Avoid overwhelming site.\n page += 1\n return all_data","def _get_grid_jobs():\n output = _general_qstat()\n if not output:\n return None\n tree = ElementTree.fromstring(output)\n jobs = []\n for job in tree.iter('job_list'):\n job_number = job[0].text\n output = subprocess.check_output(\"qstat -j %s -xml\" % job[0].text, shell=True)\n job_tree = ElementTree.fromstring(output)[0][0] # First index is djob_info, second is element\n time_str = _get_job_tree_text(job_tree, \"JB_submission_time\")\n try:\n start_time = int(job_tree.find(\"JB_ja_tasks\")[0].find(\"JAT_start_time\").text)\n except (TypeError, AttributeError):\n # TypeError if JB_ja_tasks not in the tree (which will happen if not started)\n # AttributeError if JAT_start_time not in the subtree\n start_time = 0\n jobs.append({\n \"job_number\": int(job_number),\n \"script\": _get_job_tree_text(job_tree, \"JB_script_file\"),\n \"submission_time\": int(time_str) if time_str else 0,\n \"start_time\": start_time,\n \"cwd\": _get_job_tree_text(job_tree, \"JB_cwd\"),\n })\n return jobs","async def org_info_below_13(org_urls13):\n org_info_till13 = []\n project_urls_till13 = []\n for url in org_urls13:\n # General information about the org\n try:\n soup = await get_page(url)\n org_name = basename(url)\n org_info = soup.find_all('p')\n web_page = org_info[0].text.splitlines()[-1].strip()\n mailing_list = org_info[1].text.split(\":\")[-1].strip()\n detail = org_info[2].text\n org_info_till13.append({'name': org_name, 'about': detail,\n 'page': web_page, 'mail': mailing_list,\n 'link': url})\n project_urls_till13.extend(grab_project_links(soup))\n\n except IndexError:\n print(url)\n\n return org_info_till13, get_project_info(project_urls_till13)","def get_processed_projects(self):\n flowcell_path = self.get_flowcell_path()\n return (pp\n for pp in os.listdir(flowcell_path)\n if re.search('Project_.*Processed', pp))","def find_projects(root_dir) -> typing.Dict[str, Project]:\n logging.debug(\"Finding zmake targets under '%s'.\", root_dir)\n found_projects = {}\n for path in pathlib.Path(root_dir).rglob(\"BUILD.py\"):\n for project in load_config_file(path):\n if project.config.project_name in found_projects:\n raise KeyError(\n \"Duplicate project defined: {} (in {})\".format(\n project.config.project_name, path\n )\n )\n found_projects[project.config.project_name] = project\n return found_projects","def get_projects(self):\n projects = []\n page = 1\n while not len(projects) % 100:\n projects += self._get('/projects?{0}'.format(urllib.urlencode({'per_page': 100, 'page': page})))\n if not projects:\n break\n page += 1\n return projects","def _ParseAllDeps(self, solution_urls, solution_deps_content):\n deps = {}\n for solution in self.GetVar(\"solutions\"):\n custom_vars = solution.get(\"custom_vars\", {})\n solution_deps = self._ParseSolutionDeps(\n solution[\"name\"],\n solution_deps_content[solution[\"name\"]],\n custom_vars)\n\n # If a line is in custom_deps, but not in the solution, we want to append\n # this line to the solution.\n if \"custom_deps\" in solution:\n for d in solution[\"custom_deps\"]:\n if d not in solution_deps:\n solution_deps[d] = solution[\"custom_deps\"][d]\n\n for d in solution_deps:\n if \"custom_deps\" in solution and d in solution[\"custom_deps\"]:\n # Dependency is overriden.\n url = solution[\"custom_deps\"][d]\n if url is None:\n continue\n else:\n url = solution_deps[d]\n # if we have a From reference dependent on another solution, then\n # just skip the From reference. When we pull deps for the solution,\n # we will take care of this dependency.\n #\n # If multiple solutions all have the same From reference, then we\n # should only add one to our list of dependencies.\n if type(url) != str:\n if url.module_name in solution_urls:\n # Already parsed.\n continue\n if d in deps and type(deps[d]) != str:\n if url.module_name == deps[d].module_name:\n continue\n else:\n parsed_url = urlparse.urlparse(url)\n scheme = parsed_url[0]\n if not scheme:\n # A relative url. Fetch the real base.\n path = parsed_url[2]\n if path[0] != \"/\":\n raise gclient_utils.Error(\n \"relative DEPS entry \\\"%s\\\" must begin with a slash\" % d)\n # Create a scm just to query the full url.\n scm = gclient_scm.CreateSCM(solution[\"url\"], self._root_dir,\n None)\n url = scm.FullUrlForRelativeUrl(url)\n if d in deps and deps[d] != url:\n raise gclient_utils.Error(\n \"Solutions have conflicting versions of dependency \\\"%s\\\"\" % d)\n if d in solution_urls and solution_urls[d] != url:\n raise gclient_utils.Error(\n \"Dependency \\\"%s\\\" conflicts with specified solution\" % d)\n # Grab the dependency.\n deps[d] = url\n return deps","def process_builds(\n project: Project,\n config: appconnect.AppStoreConnectConfig,\n to_process: List[appconnect.BuildInfo],\n) -> List[Tuple[appconnect.BuildInfo, AppConnectBuild]]:\n\n pending_builds = []\n\n with sentry_sdk.start_span(\n op=\"appconnect-update-builds\", description=\"Update AppStoreConnect builds in database\"\n ):\n for build in to_process:\n build_state = get_or_create_persisted_build(project, config, build)\n if not build_state.fetched:\n pending_builds.append((build, build_state))\n\n LatestAppConnectBuildsCheck.objects.create_or_update(\n project=project, source_id=config.id, values={\"last_checked\": timezone.now()}\n )\n\n return pending_builds","async def get_project_info(project_urls):\n project_info = []\n for url in project_urls:\n soup = await get_page(url)\n about = soup.find_all(\"p\")\n title = soup.find(\"h3\").text\n student = about[0].text.splitlines()[2].strip()\n details = about[1].text\n name = about[0].find(\"a\").text\n project_info.append({'Organization': name, 'title': title,\n 'student': student, 'details': details,\n 'link': url})\n\n return project_info","def test_list_build_config_for_all_namespaces(self):\n pass","def test_buildAll(self):\n builds = []\n builder = NewsBuilder()\n builder.build = lambda path, output, header: builds.append((\n path, output, header))\n builder.blacklist = ['vfs']\n builder._today = lambda: '2009-12-01'\n\n project = self.createFakeTwistedProject()\n builder.buildAll(project)\n\n coreTopfiles = project.child(\"topfiles\")\n coreNews = coreTopfiles.child(\"NEWS\")\n coreHeader = \"Twisted Core 1.2.3 (2009-12-01)\"\n\n conchTopfiles = project.child(\"conch\").child(\"topfiles\")\n conchNews = conchTopfiles.child(\"NEWS\")\n conchHeader = \"Twisted Conch 3.4.5 (2009-12-01)\"\n\n aggregateNews = project.child(\"NEWS\")\n\n self.assertEquals(\n builds,\n [(conchTopfiles, conchNews, conchHeader),\n (coreTopfiles, coreNews, coreHeader),\n (conchTopfiles, aggregateNews, conchHeader),\n (coreTopfiles, aggregateNews, coreHeader)])","def get_projects_data():\n wcscanner_path = context.__BASE_PATH__ + '/.wcscanner'\n\n data = []\n for project in os.listdir(wcscanner_path):\n if (os.path.isdir(os.path.join(wcscanner_path, project))):\n update_project_data(project)\n project_path = '{}/{}'.format(wcscanner_path, project)\n f = open('{}/.project'.format(project_path), 'r')\n data.append(json.load(f))\n f.close()\n return data","def jobsUrl(self):\n return self.sdaUrl + \"/jobs\"","def result_urls(self, job_id: str, show_progress: bool = False) -> List:\n data = self.result_json(job_id, show_progress)\n urls = [x['href'] for x in data.get('links', []) if x['rel'] == 'data']\n return urls","def get_build_infos(self, start_rev, end_rev, range=60*60*4):\n pushlogs_finder = self._create_pushlog_finder(start_rev, end_rev)\n\n pushlogs = pushlogs_finder.get_pushlogs()\n\n if not pushlogs:\n return []\n\n start_time = pushlogs[0]['date']\n end_time = pushlogs[-1]['date']\n \n build_urls = [(\"%s%s/\" % (self.build_base_url, path), timestamp)\n for path, timestamp in self._extract_paths()]\n\n build_urls_in_range = filter(lambda (u, t): t > (start_time - range)\n and t < (end_time + range), build_urls)\n\n raw_revisions = [push['changesets'][-1] for push in pushlogs]\n all_builds = []\n with futures.ThreadPoolExecutor(max_workers=8) as executor:\n futures_results = {}\n for build_url, timestamp in build_urls_in_range:\n future = executor.submit(self._get_valid_builds,\n build_url,\n timestamp,\n raw_revisions)\n futures_results[future] = build_url\n for future in futures.as_completed(futures_results):\n if future.exception() is not None:\n sys.exit(\"Retrieving valid builds from %r generated an\"\n \" exception: %s\" % (futures_results[future],\n future.exception()))\n all_builds.extend(future.result())\n\n return self._sort_builds(all_builds)","def query_jobs(repo_name, revision):\n return buildapi.query_jobs_schedule(repo_name, revision)","def projects(args):\n _projects = lib.get_projects(\n args.target, username=args.username, password=args.password\n )\n if _projects:\n print(\"\\n\".join(_projects))","def iter_builds(self):\n conf = build_config.BuildConfig(\n cmake_defs={\"BOARD\": self.config.zephyr_board}\n )\n\n kconfig_files = []\n prj_conf = self.config.project_dir / \"prj.conf\"\n if prj_conf.is_file():\n kconfig_files.append(prj_conf)\n kconfig_files.extend(self.config.kconfig_files)\n conf |= build_config.BuildConfig(kconfig_files=kconfig_files)\n\n for build_name, packer_config in self.packer.configs():\n yield build_name, conf | packer_config","def parsing_all_page(url):\n html_doc = get_html(url)\n# html_doc = get_html_local()\n page_count = get_html_count(html_doc)\n print 'All have find pages %d' % page_count\n\n projects = []\n\n for page in range(1, page_count + 1):\n print 'Parsing %d%%' % (page*100/page_count)\n\n url = BASE_URL + '?page=%d' % page\n projects.extend(process_page(url))\n\n return projects","def build_artifacts(self):\n return self._build_artifacts","def blocking_dependencies(projects, py3_projects):\n check = [project.lower()\n for project in projects if project.lower() not in py3_projects]\n reasons = LowerDict({project: None for project in check})\n thread_pool_executor = concurrent.futures.ThreadPoolExecutor(\n max_workers=CPU_COUNT)\n with thread_pool_executor as executor:\n while len(check) > 0:\n new_check = []\n for parent, deps in zip(check, executor.map(dependencies, check)):\n for dep in deps:\n if dep in py3_projects:\n continue\n reasons[dep] = parent\n new_check.append(dep)\n check = new_check\n return reasons_to_paths(reasons)","def getMatchingPaths(cls, repoUrl):\n res = []\n for repository in cls.config['repositories']:\n if repository['url'] == repoUrl:\n res.append(repository['path'])\n return res","def scan_addresses(root_dir, base_path=None):\r\n\r\n addresses = OrderedSet()\r\n for buildfile in BuildFile.scan_buildfiles(root_dir, base_path):\r\n addresses.update(Target.get_all_addresses(buildfile))\r\n return addresses","def api_upwork_get_tasks(request):\n qs = models.JobUpwork.objects.filter(\n is_processed=False).values_list('url', flat=True)\n\n return JsonResponse(list(qs), safe=False)","def concurrent_builds(self):\n return self._concurrent_builds","def build_configs():","def list_build(self, **kwargs):\n\n all_params = ['pretty', 'label_selector', 'field_selector', 'watch', 'resource_version', 'timeout_seconds']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_build\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/oapi/v1/builds'.replace('{format}', 'json')\n path_params = {}\n\n query_params = {}\n if 'pretty' in params:\n query_params['pretty'] = params['pretty']\n if 'label_selector' in params:\n query_params['labelSelector'] = params['label_selector']\n if 'field_selector' in params:\n query_params['fieldSelector'] = params['field_selector']\n if 'watch' in params:\n query_params['watch'] = params['watch']\n if 'resource_version' in params:\n query_params['resourceVersion'] = params['resource_version']\n if 'timeout_seconds' in params:\n query_params['timeoutSeconds'] = params['timeout_seconds']\n\n header_params = {}\n\n form_params = []\n local_var_files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json', 'application/yaml'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['*/*'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, 'GET',\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=local_var_files,\n response_type='V1BuildList',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response"],"string":"[\n \"def process_builds(self):\\n for p in self.product_config:\\n p_str = p[0]\\n\\n for l in self.link_list:\\n if l.startswith(p[1]):\\n if not self.builds_list.has_key(p_str):\\n self.builds_list[p_str] = []\\n b_str = l.replace('/', '')\\n self.builds_list[p_str].append(b_str)\",\n \"def getBuilds():\",\n \"def grab_project_links(soup):\\n project_urls = []\\n valid_project_url = \\\"/?archive/?gsoc/\\\\d+[0-9]/orgs/[a-zA-Z]+/[a-zA-Z]+/[a-zA-Z]+.html\\\"\\n try:\\n # Grab links to all the projects\\n all_link = soup.find_all(\\\"a\\\")\\n for link in all_link:\\n if re.match(valid_project_url, link.get(\\\"href\\\")):\\n project_urls.append(join(melange, link.get(\\\"href\\\")[1:]))\\n except TypeError:\\n print(link)\\n\\n return project_urls\",\n \"def getBuildRequests():\",\n \"def get_projects_url_paths(*args):\\n projects_infos = get_projects()\\n projects_url_paths = []\\n\\n for project in projects_infos:\\n projects_url_paths.append(BASE_URL + \\\"/projects/{id}/\\\".format(id=project[0]))\\n return projects_url_paths\",\n \"def import_builds_for_job(job_pk):\\n job = Job.objects.get(pk=job_pk)\\n\\n logging.info(\\\"Located job %s\\\\n\\\" % job)\\n\\n client = job.server.get_client()\\n\\n logging.info(\\\"Using server at %s\\\\n\\\" % job.server.url)\\n\\n jenkins_job = client.get_job(job.name)\\n\\n good_build_numbers = list(jenkins_job.get_build_ids())\\n logging.info(\\\"%s\\\\n\\\" % good_build_numbers)\\n\\n for build_number in good_build_numbers:\\n import_build_for_job(job.pk, build_number)\",\n \"def get_job_builds(self, job_id, started=None, finished=None,\\n success=None, skipped=None, order='asc', limit=100):\\n pass\",\n \"def get_finished_builds(job_dir, last_processed_log):\\n return [\\n dir.name\\n for dir in os.scandir(job_dir)\\n if dir.name.isdigit()\\n and int(dir.name) > int(last_processed_log)\\n and os.path.isfile(\\n functools.reduce(os.path.join, [job_dir, dir.name, \\\"build.xml\\\"])\\n )\\n and grep(\\n functools.reduce(os.path.join, [job_dir, dir.name, \\\"build.xml\\\"]),\\n \\\"<result>\\\",\\n )\\n ]\",\n \"def Builds():\\n return builds\",\n \"def get_new_running_builds(job_dir, last_processed_log):\\n return [\\n dir.name\\n for dir in os.scandir(job_dir)\\n if dir.name.isdigit()\\n and int(dir.name) > int(last_processed_log)\\n and os.path.isfile(\\n functools.reduce(os.path.join, [job_dir, dir.name, \\\"build.xml\\\"])\\n )\\n and not grep(\\n functools.reduce(os.path.join, [job_dir, dir.name, \\\"build.xml\\\"]), \\\"<result>\\\"\\n )\\n ]\",\n \"def getPendingBuilds():\",\n \"def getPendingBuilds():\",\n \"def getBuild():\",\n \"def get_jobs():\\n jobs = [os.path.join(JOBS_DIR, job)\\n for job in os.listdir(JOBS_DIR)\\n if job != '.gitignore']\\n return jobs\",\n \"def do_all_projects(args):\\n man = load_manifest()\\n\\n if args[0] == '-p':\\n parallel = True\\n del args[0]\\n else:\\n parallel = False\\n\\n towait = []\\n\\n for (name, project) in man.projects.iteritems():\\n repo = GitRepo(workdir_for_project(project))\\n print >>sys.stderr, \\\"In project: \\\", name, \\\" running \\\", \\\" \\\".join(args)\\n p = repo.command_process(args)\\n if not parallel:\\n p.Wait()\\n print >>sys.stderr\\n else:\\n towait.append(p)\\n\\n for p in towait:\\n p.Wait()\",\n \"def __setup_recursion(folder_found, links_titles):\\n urls = []\\n if folder_found:\\n for element_x, _, element_z in links_titles:\\n if element_z == 'folder':\\n # fill urls with sub-links to recursively call crawl function on them\\n urls.append(element_x)\\n return urls\",\n \"def get_pr_jobs():\\n res = requests.get(\\n uri + \\\"/view/Pull%20Requests/api/json\\\",\\n headers={\\\"accept\\\": \\\"application/json\\\"},\\n auth=requests.auth.HTTPBasicAuth(user, password),\\n verify=verify,\\n )\\n if res.status_code != 200:\\n raise RuntimeError(\\\"Received non 200 status code from jenkins\\\")\\n data = res.json()\\n for job in data[\\\"jobs\\\"]:\\n yield job\",\n \"def pipeline_results(self):\\n repo = self.main_gitlab_repo()\\n ret = []\\n for branch in [\\\"master\\\", \\\"main\\\", \\\"devel\\\"]:\\n build = repo.cibuild_set.filter(branch__name__endswith=branch).first()\\n if build is not None:\\n link = repo.url + f\\\"/-/pipelines/{build.build_id}\\\"\\n sym = \\\"✓\\\" if build.passed else \\\"✘\\\"\\n ret.append(f'<a href=\\\"{link}\\\">{branch}: {sym}</a>')\\n\\n return mark_safe(\\\"<br>\\\".join(ret))\",\n \"def getURLs():\",\n \"def recursive_urls(urls):\\n if len(urls) == 0:\\n return\\n rs = [grequests.get(url, hooks=dict(args=print_url)) for url in urls]\\n responses = grequests.map(rs)\\n url_lists = [get_urls_from_response(response) for response in responses]\\n urls = sum(url_lists, []) # flatten list of lists into a list\\n recursive_urls(urls)\",\n \"def urls(gh, user):\\n return [repo.url for repo in getuserrepos(gh, user)]\",\n \"def download_builds(config, builds, force=False):\\n if not config.get('datadir'):\\n raise ValueError(\\\"No output dir (--datadir) specified\\\")\\n\\n jenkins_client = jenkins.get_client(config)\\n download_args = []\\n for build in builds:\\n if ':' in build:\\n (job, build_id) = build.split(':')\\n download_args.append(\\n (job, build_id, config['datadir'],\\n jenkins_client, config.get('groupingParameter'), force)\\n )\\n else:\\n job = build\\n for build_id in jenkins_client.fetch_all_build_ids(job):\\n download_args.append(\\n (job, build_id, config['datadir'],\\n jenkins_client, config.get('groupingParameter'), force)\\n )\\n\\n num_threads = config.get('downloadThreads', 7) # arbitrary number\\n if num_threads <= 1:\\n for args_tuple in download_args:\\n _download_one_build(args_tuple)\\n else:\\n import multiprocessing.pool # only import if we need it!\\n pool = multiprocessing.pool.ThreadPool(num_threads)\\n pool.map(_download_one_build, download_args)\",\n \"def get(self, project_slug):\\n project = Project.query.filter_by(slug=project_slug).first_or_404()\\n\\n if not (project.public or current_user.is_authenticated()):\\n flask_restful.abort(404)\\n\\n return [\\n dict(name=job.git_branch)\\n for job\\n in (\\n project.jobs.distinct(Job.git_branch)\\n .order_by(sqlalchemy.asc(Job.git_branch))\\n )\\n if job.git_branch is not None\\n ]\",\n \"def list_projects():\\n if '.wcscanner' not in os.listdir(context.__BASE_PATH__):\\n return []\\n return os.listdir(context.__PROJECTS_PATH__)\",\n \"def build_folder_map(base_url, proxies):\\n try:\\n LOGGING.info('Requesting: {0}'.format(base_url))\\n\\n user_agent = {'User-agent': BASECONFIG.user_agent}\\n\\n request = requests.get(base_url, headers=user_agent, proxies=proxies, timeout=(20, 20))\\n\\n if request.status_code == 200:\\n LOGGING.info('Request OK. Parsing result...')\\n\\n children = []\\n\\n content = BeautifulSoup(request.text, 'html.parser')\\n links = content.find_all('a', href=True)\\n\\n for link in links:\\n if 'Parent Directory' in link:\\n continue\\n\\n href = link.get('href')\\n\\n if len(href) > 1 and not any(s in href for s in BAD_CHARS):\\n children.append(urljoin(base_url, href))\\n\\n return children\\n\\n else:\\n LOGGING.warning(\\n 'Problem connecting to {0}. Status code: {1}. Aborting task.'.format(\\n base_url, request.status_code))\\n\\n except requests.exceptions.ConnectionError as e:\\n LOGGING.warning(\\n 'Problem connecting to {0}. Error: {1}'.format(\\n base_url, e))\\n\\n except Exception as e:\\n LOGGING.warning(\\n 'Problem connecting to {0}. Aborting task.'.format(base_url))\\n LOGGING.exception(sys.exc_info())\\n LOGGING.exception(type(e))\\n LOGGING.exception(e.args)\\n LOGGING.exception(e)\\n\\n return []\",\n \"def getAllSolutionUrls(urls: list) -> list:\\n allSolutionUrls = []\\n\\n for index, url in enumerate(urls):\\n print(\\\"current puzzle: \\\" + str(index))\\n solutionUrls = getSolutionUrls(url)\\n\\n if solutionUrls != None:\\n allSolutionUrls += solutionUrls\\n\\n return allSolutionUrls\",\n \"def getBuildbotURL():\",\n \"def scan_buildfiles(root_dir, base_path=None):\\r\\n\\r\\n buildfiles = []\\r\\n for root, dirs, files in os.walk(base_path if base_path else root_dir):\\r\\n for filename in files:\\r\\n if BuildFile._is_buildfile_name(filename):\\r\\n buildfile_relpath = os.path.relpath(os.path.join(root, filename), root_dir)\\r\\n buildfiles.append(BuildFile(root_dir, buildfile_relpath))\\r\\n return OrderedSet(sorted(buildfiles, key=lambda buildfile: buildfile.full_path))\",\n \"def _fetch_base_urls(repository_url):\\n repo_config = _url_as_ini_file(repository_url)\\n config = configparser.ConfigParser()\\n config.read_file(repo_config)\\n\\n base_urls = list()\\n for repo in config.sections():\\n base_urls.append((config.get(repo, 'name'),\\n config.get(repo, 'baseurl')))\\n\\n return base_urls\",\n \"def getUrls(self):\\n # in case you need to move from a read only Url to a writeable one, here it gets replaced\\n repopath = self.repositoryUrl().replace(\\\"[git]\\\", \\\"\\\")\\n repoString = utils.replaceVCSUrl(repopath)\\n [repoUrl, repoBranch, repoTag] = utils.splitVCSUrl(repoString)\\n if not repoBranch and not repoTag:\\n repoBranch = \\\"master\\\"\\n print(\\\"|\\\".join([repoUrl, repoBranch, repoTag]))\\n return True\",\n \"def _get_csvs(self):\\n\\n stack = [self.root]\\n urls = []\\n\\n while stack:\\n curr_dir = stack.pop()\\n\\n # skip first link which is always the parent dir \\n for link in self._soup(curr_dir)('a')[1:]:\\n href = link['href']\\n next_link = os.path.join(curr_dir, href)\\n\\n # Case 1: found the csv, add it to the list of URLs we return\\n # Case 2: Empty dir or repo.tar.giz. Ignore.\\n # Case 3: DFS further down\\n if 'csv' in href:\\n urls.append(next_link)\\n elif href != '/' and href != 'repo.tar.gz':\\n stack.append(next_link)\\n\\n return urls\",\n \"def siblings(self):\\r\\n\\r\\n for build in glob1(self.parent_path, 'BUILD*'):\\r\\n if self.name != build and BuildFile._is_buildfile_name(build):\\r\\n siblingpath = os.path.join(os.path.dirname(self.relpath), build)\\r\\n if not os.path.isdir(os.path.join(self.root_dir, siblingpath)):\\r\\n yield BuildFile(self.root_dir, siblingpath)\",\n \"def get_projects(self):\\n unaligned_path = self.get_unaligned_path()\\n logger.debug(\\\"collecting list of projects\\\")\\n return [p for p in os.listdir(unaligned_path)\\n if len(parsing.get_project_label(p))]\",\n \"def get_buildroot(self, worker_metadatas):\\n buildroots = []\\n for platform in sorted(worker_metadatas.keys()):\\n for instance in worker_metadatas[platform]['buildroots']:\\n instance['id'] = '{}-{}'.format(platform, instance['id'])\\n buildroots.append(instance)\\n\\n return buildroots\",\n \"def test_get_projects_expanded(self):\\n pass\",\n \"def __Job_list__(self):\\n # | - __Job_list__\\n\\n # | - Adding Jobs From Individual Directory List\\n if self.indiv_dir_lst is not None:\\n for job_i_dir in self.indiv_dir_lst:\\n\\n rev_dirs, max_rev = self.__revision_list_and_max__(job_i_dir)\\n\\n print(job_i_dir)\\n if rev_dirs:\\n\\n print(\\\"rev_dirs:\\\", rev_dirs)\\n\\n if self.parse_all_revisions is False:\\n\\n last_rev_int = np.sort(\\n [int(i.split(\\\"_\\\")[-1]) for i in rev_dirs])[-1]\\n rev_dirs = [\\\"_\\\" + str(last_rev_int), ]\\n # rev_dirs = [rev_dirs[-1]]\\n\\n print(\\\"rev_dirs:\\\", rev_dirs)\\n print(\\\"IOPSDFJOKIDSIJFIJDSF\\\")\\n\\n for rev_i in rev_dirs:\\n path_i = os.path.join(job_i_dir, rev_i)\\n path_i = os.path.normpath(path_i)\\n\\n Job_i = Job(\\n path_i=path_i,\\n job_params_dict=None,\\n max_revision=max_rev,\\n root_dir=None,\\n )\\n\\n self.Job_list.append(Job_i)\\n else:\\n print(\\\"Didn't find any job dirs here:\\\")\\n print(job_i_dir)\\n pass\\n # __|\\n\\n # | - Adding Jobs From Enumerated Job Properties Tree\\n if self.job_var_lst is not None:\\n for job_i in self.job_var_lst:\\n job_var_dict = self.__job_i_vars_to_dict__(job_i)\\n\\n if self.folders_exist:\\n path_i = self.var_lst_to_path(\\n job_i,\\n job_rev=\\\"Auto\\\",\\n relative_path=False,\\n )\\n\\n # | - __old__\\n # else:\\n # print(\\\"else *s8fs*sdf\\\")\\n # path_i = os.path.join(\\n #\\n # self.var_lst_to_path(\\n # job_i,\\n # job_rev=\\\"Auto\\\",\\n # relative_path=False,\\n # ),\\n #\\n # # self.var_lst_to_path(\\n # # job_i,\\n # # ),\\n #\\n # \\\"_1\\\",\\n # )\\n # __|\\n\\n rev_dirs, max_rev = self.__revision_list_and_max__(\\n # path_i\\n self.var_lst_to_path(\\n job_i,\\n job_rev=\\\"None\\\",\\n relative_path=False,\\n )\\n )\\n\\n Job_i = Job(\\n path_i=path_i,\\n job_params_dict=job_var_dict,\\n max_revision=max_rev,\\n root_dir=self.root_dir,\\n )\\n\\n self.Job_list.append(Job_i)\\n # __|\\n\\n # | - TEMP | I don't remember why this is here\\n indiv_job = self.indiv_job_lst is not None\\n level_labels = self.tree_level_labels is not None\\n if indiv_job and level_labels:\\n print(\\\"LSKDJFKLDS_-09sdfsdfs9dfas\\\")\\n for job_params_i in self.indiv_job_lst:\\n\\n job_var_lst_i = self.__job_i_param_dict_to_job_var_lst__(\\n job_params_i,\\n )\\n\\n path_i = os.path.join(\\n self.new_var_lst_to_path(job_var_lst_i),\\n \\\"_1\\\",\\n )\\n\\n Job_i = Job(\\n path_i=path_i,\\n job_params_dict=job_params_i,\\n max_revision=None,\\n root_dir=self.root_dir,\\n )\\n\\n self.Job_list.append(Job_i)\\n # __|\\n\\n if self.indiv_job_dict_lst is not None:\\n self.create_Jobs_from_dicts_and_paths(\\n self.indiv_job_dict_lst,\\n )\\n # __|\",\n \"def query_jobs_schedule_url(repo_name, revision):\\n return buildapi.query_jobs_url(repo_name, revision)\",\n \"def do_all_projects_remotes(args):\\n man = load_manifest()\\n\\n if args[0] == '-p':\\n parallel = True\\n del args[0]\\n else:\\n parallel = False\\n towait = []\\n\\n for (name, project) in man.projects.iteritems():\\n repo = GitRepo(workdir_for_project(project))\\n for remote_name in project.remotes.keys():\\n cmd = args + [remote_name]\\n print >>sys.stderr, \\\"In project: \\\", name, \\\" running \\\", \\\" \\\".join(cmd)\\n p = repo.command_process(cmd)\\n if not parallel:\\n p.Wait()\\n print >>sys.stderr\\n else:\\n towait.append(p)\\n for p in towait:\\n p.Wait()\",\n \"def getCurrentBuilds():\\n # again, we could probably provide an object for 'waiting' and\\n # 'interlocked' too, but things like the Change list might still be\\n # subject to change\",\n \"def crawler():\\n job_entries = []\\n for job in job_info(URL):\\n labels = \\\"\\\"\\n if job[\\\"labels\\\"]:\\n for label in job[\\\"labels\\\"]:\\n labels += label[\\\"name\\\"]\\n if job[\\\"labels\\\"].index(label) != len(job[\\\"labels\\\"]) - 1:\\n labels += \\\",\\\"\\n job_entries.append((job[\\\"number\\\"], job[\\\"id\\\"],\\n job[\\\"title\\\"], job[\\\"html_url\\\"], labels))\\n\\n conn = sqlite3.connect('jobber/jobber.db')\\n c = conn.cursor()\\n c.executemany(('INSERT OR IGNORE INTO job_entries '\\n 'VALUES (?,?,?,?,?)'), job_entries)\\n conn.commit()\\n conn.close()\",\n \"def _get_known_urls(self, all_known_urls):\\n url_tree = URLTree()\\n\\n for url in all_known_urls:\\n url_tree.add_url(url)\\n\\n return url_tree\",\n \"def generateFinishedBuilds(builders=[], branches=[],\\n num_builds=None, finished_before=None,\\n max_search=200):\",\n \"def builds(self):\\n return self._builds\",\n \"def _get_results(tree, year):\\n projects = []\\n \\n for t in tree.findAll('li', {'class': 'mdl-list__item mdl-list__item--one-line'}): \\n org = _clean(t.findChildren('a')[0].text)\\n a = t.findChildren('a')[0]['href']\\n\\n org_url = 'https://www.google-melange.com' + a\\n org_tree = _get_tree(org_url)\\n\\n for t1 in org_tree.findAll('span', {'class': 'mdl-list__item-primary-content'}):\\n a1 = t1.findChildren('a')\\n projs = [a['href'] for a in a1]\\n\\n for p in projs:\\n proj_url = 'https://www.google-melange.com' + p\\n proj_tree = _get_tree(proj_url)\\n \\n title = _clean(proj_tree.findAll('h3')[0].text)\\n p = proj_tree.findAll('p')\\n bio = _clean(p[0].text)\\n \\n student = bio.split('by')[-1].split('for')[0]\\n description = _clean(p[1].text)\\n projects.append((title, org, student, description))\\n\\n _save_results(projects, year)\",\n \"def eia_cbecs_URL_helper(build_url, config, args):\\n # initiate url list for coa cropland data\\n urls = []\\n # replace \\\"__xlsx_name__\\\" in build_url to create three urls\\n for x in config['xlsx']:\\n url = build_url\\n url = url.replace(\\\"__xlsx__\\\", x)\\n urls.append(url)\\n # elif:\\n\\n return urls\",\n \"def build(cfg, jobs, watch):\\n libjobs.buildJobs(cfg, jobs, watch)\",\n \"def build(c, force=None):\\n for sp_ns in ns_foreach_task_subdir(c):\\n print(\\\"-- running build in \\\", os.getcwd())\\n\\n # sp_ns.tasks.build(c, force)\\n c.run('invoke build')\",\n \"def find_files():\\n \\n p = re.compile(REGEX_PART_NUMBER)\\n job_files = []\\n \\n for root, dirs, files in os.walk(project_path): # r at start of string need to prevent unicode error\\n for filename in files:\\n re_part_number = p.match(filename)\\n if re_part_number:\\n file_ext = filename.split(\\\".\\\")[-1].lower() # extract file extension \\n file_size = os.path.getsize((os.path.join(root, filename))) # filesize in bytes \\n \\n part_number = re_part_number.group() # extract part number from regular expression match\\n part_code = part_number.split(\\\"-\\\")[0]\\n \\n destinations = [] # destinations is a list in case a filetype is both a source and output filetype\\n \\n if (file_ext in EXTS_SOURCE_FILES) and flag_find_source_files:\\n destinations.append(os.path.join(target_source_path,part_code,part_number)) \\n \\n if (file_ext in EXTS_OUTPUT_FILES) and flag_find_output_files:\\n destinations.append(os.path.join(target_source_path,part_code,part_number)) \\n \\n if destinations: \\n job_files.append(File(filename,root,file_size,destinations,part_number,part_code))\\n print(f\\\"Found: {filename}\\\")\\n \\n return job_files\",\n \"def job_info(url):\\n for job in requests.get(url).json():\\n yield job\",\n \"def find_projects(self):\\n\\n attrs = ['name', 'remote', 'revision', 'path', 'groups', 'upstream']\\n projects = defaultdict(list)\\n\\n for project in self.tree.findall('project'):\\n values = [project.get(attr) for attr in attrs]\\n project_dict = dict(zip(attrs, values))\\n project_name = project_dict.pop('name')\\n\\n if project_dict['groups'] is not None:\\n project_dict['groups'] = project_dict['groups'].split(',')\\n\\n if project_name is None:\\n if self.fail_on_invalid:\\n raise InvalidManifest(\\n 'Project entry missing \\\"name\\\" attribute'\\n )\\n else:\\n continue\\n\\n if project_name in projects:\\n paths = [\\n p_attr.get('path', project_name)\\n for name, p_attrs in projects.items()\\n for p_attr in p_attrs if name == project_name\\n ]\\n\\n if project_dict['path'] in paths:\\n raise InvalidManifest(\\n 'Duplicate project entry with matching \\\"name\\\" '\\n 'and \\\"path\\\" attributes'\\n )\\n\\n children = project.getchildren()\\n if children:\\n for child in children:\\n subelement = child.tag\\n\\n # Only run the following if the element tag\\n # is a string (avoids comments)\\n if isinstance(subelement, str):\\n subdict = getattr(\\n self, 'create_{}_dict'.format(subelement)\\n )(child)\\n\\n if subdict is not None:\\n project_dict.setdefault(subelement, []).append(\\n subdict\\n )\\n\\n projects[project_name].append(\\n self.generate_data_dict(project_dict)\\n )\\n\\n self.projects = projects\",\n \"def _recursive_gh_get(href, items, password=None):\\n response = GitHub._request('GET', href, token=password)\\n response.raise_for_status()\\n items.extend(response.json())\\n if \\\"link\\\" not in response.headers:\\n return\\n # links = link_header.parse(response.headers[\\\"link\\\"])\\n # rels = {link.rel: link.href for link in links.links}\\n # if \\\"next\\\" in rels:\\n # ghRelease._recursive_gh_get(rels[\\\"next\\\"], items)\",\n \"def relative_to_buildroot(self):\\n return [os.path.join(self.rel_path, source) for source in self.source_paths]\",\n \"def main():\\n\\n options = parse_arguments()\\n\\n directories = find_directories(options.folder)\\n process_pool = Pool(len(directories))\\n\\n function_call = partial(find_URLs, options=options)\\n\\n process_pool.map(function_call, directories)\",\n \"def get_matching_artifact_urls(user_input):\\n # short link to gerrit change id\\n regex = REGEX_GERRIT_CHANGE.match(user_input)\\n if regex:\\n return _gerrit_urls_filtered(int(regex.group(1)))\\n\\n # short link to gerrit change id and specific revision\\n regex = REGEX_GERRIT_REVISION.match(user_input)\\n if regex:\\n return _gerrit_urls_filtered(int(regex.group(1)), int(regex.group(2)))\\n\\n # full gerrit url\\n parsed = urlparse.urlparse(user_input)\\n if parsed.hostname in GERRIT_ALLOWED_HOSTS:\\n if len(parsed.path) > 1:\\n try:\\n return _gerrit_urls_filtered(int(parsed.path[1:]))\\n except ValueError:\\n pass\\n\\n if parsed.fragment:\\n change_id, revision = _parse_fragment(parsed.fragment)\\n if change_id:\\n return _gerrit_urls_filtered(change_id, revision)\\n\\n # direct link to job output\\n if parsed.hostname in LOGS_ALLOWED_HOSTS:\\n artifact_info = _create_empty_message()\\n artifact_job = _create_job('direct-link', user_input)\\n artifact_info['jobs'].append(artifact_job)\\n\\n parsed_artifact_info, parsed_job_info = _parse_logs_path(parsed.path)\\n artifact_info.update(parsed_artifact_info)\\n artifact_job.update(parsed_job_info)\\n\\n if 'change_id' in parsed_artifact_info:\\n # try to fetch the gerrit change to fill in missing details\\n try:\\n listing = gerrit_list.GerritListing(\\n parsed_artifact_info['change_id'])\\n artifact_info['change_project'] = listing.change_project\\n artifact_info['change_subject'] = listing.change_subject\\n\\n job = listing.get_job_by_url(user_input)\\n if job:\\n artifact_info['status'] = job.status\\n artifact_job['status'] = job.status\\n except requests.HTTPError:\\n pass\\n\\n return [artifact_info]\\n\\n return []\",\n \"def retrieve(cfg, jobs, filter):\\n server = jenkins_utils.server_factory(cfg)\\n retrieved = libjobs.retrieveJobs(server, jobs, filter)\\n for job in retrieved:\\n job_file = os.path.join(cfg.jobdir, job.name + '.xml')\\n with open(job_file, 'w') as fh:\\n fh.write(job.get_config())\",\n \"def build_list(ctx, show_url, show_data,\\n start, count,\\n project, build_type_id, branch, status, running, tags, user,\\n output_format, columns):\\n kwargs = {'start': start,\\n 'count': count}\\n if build_type_id:\\n kwargs['build_type_id'] = build_type_id\\n if branch:\\n kwargs['branch'] = branch\\n if status:\\n kwargs['status'] = status\\n if running:\\n kwargs['running'] = running\\n if tags:\\n kwargs['tags'] = tags\\n if user:\\n kwargs['user'] = user\\n if project:\\n kwargs['project'] = project\\n\\n func = ctx.obj.get_builds\\n\\n if show_url:\\n kwargs['return_type'] = 'url'\\n url = func(**kwargs)\\n del kwargs['return_type']\\n click.echo(url)\\n\\n if not show_data:\\n return\\n\\n try:\\n data = func(**kwargs)\\n except HTTPError as e:\\n click.echo('url: %s' % e.url)\\n click.echo('status_code: %s' % e.status_code)\\n click.echo()\\n click.echo(e)\\n return\\n\\n for build in data['build']:\\n details = ctx.obj.get_build_by_build_id(build['id'])\\n try:\\n build['user'] = details['triggered']['user']['username']\\n build['statusText'] = details['statusText']\\n build['details'] = details\\n except KeyError:\\n build['user'] = 'N/A'\\n\\n click.echo('count: %d' % data['count'])\\n if data['count'] == 0:\\n return\\n\\n if output_format == 'table':\\n column_names = columns.split(',')\\n output_table(column_names, data['build'])\\n elif output_format == 'json':\\n output_json_data(data)\",\n \"async def org_info_above_14(orgs_urls14):\\n org_info_14 = []\\n project_urls_from14 = []\\n for url in orgs_urls14:\\n try:\\n soup = await get_page(url)\\n org_name = basename(url)\\n org_info = soup.find_all('p')\\n web_page = org_info[1].text.splitlines()[-1].strip()\\n mailing_list = org_info[2].text.split(\\\":\\\")[-1].strip()\\n description = soup.find('div', {'class': 'main mdl-cell mdl-cell--8-col\\\\\\n mdl-card mdl-shadow--4dp'})\\n detail = description.find_all('p')[2].nextSibling\\n org_info_14.append({'name': org_name, 'page': web_page,\\n 'about': detail, 'mail': mailing_list,\\n 'link': url})\\n project_urls_from14.extend(grab_project_links(soup))\\n except IndexError:\\n print(url)\\n\\n return org_info_14, get_project_info(project_urls_from14)\",\n \"def build_browse(ctx, args):\\n for build_id in args:\\n data = ctx.obj.get_build_by_build_id(build_id)\\n webbrowser.open(data['webUrl'])\",\n \"def parse_inner_urls(self, response):\\n s = Selector(response)\\n\\n jobs_per_site = s.xpath('//div[@class=\\\"col-lg-12 col-md-12 col-sm-12 aggelia-view-title\\\"]//a/@href').extract()\\n print(jobs_per_site)\\n\\n for inner_site in jobs_per_site:\\n url = urljoin(\\\"https://www.skywalker.gr/\\\", inner_site)\\n yield scrapy.Request(url, callback=self.parse_items)\",\n \"def process(self):\\n\\n manager_list = []\\n\\n with Manager() as manager:\\n manager_list = manager.list()\\n processes = []\\n\\n for data in self.repos:\\n process = Process(\\n target=self.get_repos_lists, args=(data, manager_list)\\n )\\n process.start()\\n processes.append(process)\\n\\n for proc in processes:\\n proc.join()\\n\\n manager_list = list(manager_list)\\n\\n for element in manager_list:\\n domains, ips = self.__separate_domains_from_ip(element)\\n Settings.domains.extend(domains)\\n Settings.ips.extend(ips)\\n\\n del domains, ips\\n\\n Settings.domains = Helpers.List(Settings.domains).format()\\n Settings.ips = Helpers.List(Settings.ips).format()\\n\\n Helpers.Dict(self.repos).to_json(Settings.repositories_file)\\n del Settings.repositories\\n\\n Generate()\\n Compress()\\n Deploy()\\n Clean()\",\n \"def getProjectURL():\",\n \"def buildList(self,list_all=False,push_all=False):\\n print \\\"=== Loading\\\"\\n\\n ## Walk in repo and get GitRepo\\n for repo in self.repos:\\n if repo not in self.ignore or list_all:\\n a = GitRepo(repo)\\n if not self.animate:\\n a.branchStatus()\\n if a.globalStatus():\\n if a.forward and push_all:\\n a.push()\\n self.gitrepos.append(a)\\n\\n print \\\"\\\\r=== \\\"+str(len(self.gitrepos))+\\\" repos scanned\\\"\",\n \"def extract_urls(genome):\\n itemid = genome.get('metadata').get('identifier')\\n urls = set([url for url in genome['urls'] if 'archive.org' not in url])\\n db_urls_found(itemid, urls)\",\n \"def get_all_jobs(self) -> List[DocumentReference]:\\n return self.get_all_documents(Type._JOBS)\",\n \"def readProjectLinks(configFile):\\n config = ConfigParser.ConfigParser()\\n if os.path.isfile(configFile):\\n config.readfp(open(configFile))\\n\\n projects = {}\\n try:\\n projectItems = config.items(\\\"projects\\\")\\n # tip for this solution found here:\\n # http://stackoverflow.com/a/8048529\\n for project, link in projectItems:\\n projects[project] = link\\n except:\\n # this is bad error handling\\n # on my list to improve in the future\\n print \\\"An error occurred while parsing the projects.conf file.\\\"\\n print \\\"Make sure it is formatted properly.\\\"\\n quit\\n\\n return projects\",\n \"def get_json_job_details(buildurl):\\n return requests.get(buildurl + \\\"/api/json\\\").json()\",\n \"def findBuildDirs(tests):\\n \\n buildDirs = []\\n for test in tests:\\n\\n currentBuildDir = getParam(test + \\\".buildDir\\\")\\n if (buildDirs.count(currentBuildDir) == 0):\\n buildDirs.append(currentBuildDir)\\n\\n return buildDirs\",\n \"def _link_jobs(self):\\n for i, j in enumerate(self.jobs):\\n j.link(self, i)\\n j.claim_artifacts()\",\n \"def _find_files(job_schedule_info):\\n files = []\\n\\n job_status = _status_info(job_schedule_info)\\n assert job_status is not None, \\\\\\n \\\"We should not have received an empty status\\\"\\n\\n properties = job_status.get(\\\"properties\\\")\\n\\n if not properties:\\n LOG.error(str(job_status))\\n raise Exception(\\\"The status of the job is expected to have a \\\"\\n \\\"properties key, however, it is missing.\\\")\\n\\n LOG.debug(\\\"We want to find the files needed to trigger %s\\\" %\\n properties[\\\"buildername\\\"])\\n\\n if \\\"packageUrl\\\" in properties:\\n files.append(properties[\\\"packageUrl\\\"])\\n if \\\"testsUrl\\\" in properties:\\n files.append(properties[\\\"testsUrl\\\"])\\n\\n return files\",\n \"def process_links(self):\\n\\n self.logger.info(\\\"Current depth is %d, list contains %d items\\\" % \\n (self.link_depth, len(self.links)))\\n\\n for url in self.links:\\n\\n duplicate = True if self.collection.find_one({ \\\"url\\\": url }) else False\\n if duplicate and self.link_depth == 0:\\n self.logger.info(\\\"Skipping url: %s\\\" % url)\\n continue\\n\\n try:\\n data = self.get_url(url)\\n if not duplicate:\\n n = self.get_recipe(data, url)\\n self.logger.info(\\\"Found %d recipe(s)\\\" % n)\\n if self.link_depth > 0:\\n n = self.get_links(data)\\n self.logger.info(\\\"Added %d link(s) to queue\\\" % n)\\n except Exception as exc:\\n self.logger.error(\\\"Processing %s failed\\\" % url, exc_info = True)\\n time.sleep(self.pause)\\n\\n if self.link_depth > 0:\\n self.links = self.link_queue\\n self.link_queue = [ ]\\n self.link_depth -= 1\\n self.process_links()\",\n \"def get_old_running_builds(job_dir, job_to_retry, last_processed_log, parser_info_path):\\n current_running_builds = [\\n dir.name\\n for dir in os.scandir(job_dir)\\n if dir.name.isdigit()\\n and int(dir.name) <= int(last_processed_log)\\n and os.path.isfile(\\n functools.reduce(os.path.join, [job_dir, dir.name, \\\"build.xml\\\"])\\n )\\n and not grep(\\n functools.reduce(os.path.join, [job_dir, dir.name, \\\"build.xml\\\"]), \\\"<result>\\\"\\n )\\n ]\\n\\n # We first check for the old running builds of last run\\n with open(parser_info_path, \\\"r\\\") as rotation_file:\\n old_running_builds_object = json.load(rotation_file)\\n old_running_builds_dict = old_running_builds_object[\\\"parserInfo\\\"][\\n \\\"runningBuilds\\\"\\n ]\\n\\n if job_to_retry not in old_running_builds_dict:\\n old_running_builds_dict[job_to_retry] = dict()\\n old_running_builds = dict()\\n else:\\n old_running_builds = old_running_builds_dict[job_to_retry]\\n\\n # Update value of old running builds in the original object to store it again\\n for build_number in current_running_builds:\\n if (\\n build_number\\n not in old_running_builds_object[\\\"parserInfo\\\"][\\\"runningBuilds\\\"][\\n job_to_retry\\n ].keys()\\n ):\\n old_running_builds_object[\\\"parserInfo\\\"][\\\"runningBuilds\\\"][job_to_retry][\\n build_number\\n ] = \\\"\\\"\\n\\n with open(parser_info_path, \\\"w\\\") as rotation_file:\\n json.dump(old_running_builds_object, rotation_file)\\n\\n return current_running_builds, old_running_builds\",\n \"def check(self):\\n json = JsonBackend(\\\"../src/builder/projects.json\\\")\\n json.load()\\n\\n TM_ITSELF = 1\\n expected_files = TM_ITSELF + sum(p.downloadable is True\\n for p in json.projects)\\n self.downloads_for_project('tots', expected_files)\\n\\n expected_files = TM_ITSELF + sum(p.softcatala is True and\\n p.downloadable is True\\n for p in json.projects)\\n\\n self.downloads_for_project('softcatala', expected_files)\\n\\n expected_files = 1\\n for project_dto in json.projects:\\n if not project_dto.downloadable:\\n continue\\n\\n self.downloads_for_project(project_dto.name, expected_files)\\n self.check_project_link(project_dto.projectweb)\",\n \"def getSolutionUrls(url: str) -> list:\\n \\n try:\\n response = get(url)\\n html_soup = BeautifulSoup(response.text, 'html.parser')\\n soln_containers = html_soup.find_all('div', class_ = 'result')\\n solutionUrls = [website_url + container.h1.a[\\\"href\\\"] for container in soln_containers]\\n return solutionUrls\\n except:\\n print(\\\"getSolutionUrls: URL error: \\\" + str(url))\\n return None\",\n \"def get_github_jobs_data() -> List[Dict]: # Provided by professor\\n all_data = []\\n page = 1\\n more_data = True\\n while more_data:\\n url = f\\\"https://jobs.github.com/positions.json?page={page}\\\"\\n raw_data = requests.get(url)\\n raw_data.raise_for_status()\\n if \\\"GitHubber!\\\" in raw_data: # Avoid error in testing\\n continue # Trying continue, but might want break\\n partial_jobs_list = raw_data.json()\\n all_data.extend(partial_jobs_list)\\n if len(partial_jobs_list) < 50:\\n more_data = False\\n time.sleep(.1) # Avoid overwhelming site.\\n page += 1\\n return all_data\",\n \"def _get_grid_jobs():\\n output = _general_qstat()\\n if not output:\\n return None\\n tree = ElementTree.fromstring(output)\\n jobs = []\\n for job in tree.iter('job_list'):\\n job_number = job[0].text\\n output = subprocess.check_output(\\\"qstat -j %s -xml\\\" % job[0].text, shell=True)\\n job_tree = ElementTree.fromstring(output)[0][0] # First index is djob_info, second is element\\n time_str = _get_job_tree_text(job_tree, \\\"JB_submission_time\\\")\\n try:\\n start_time = int(job_tree.find(\\\"JB_ja_tasks\\\")[0].find(\\\"JAT_start_time\\\").text)\\n except (TypeError, AttributeError):\\n # TypeError if JB_ja_tasks not in the tree (which will happen if not started)\\n # AttributeError if JAT_start_time not in the subtree\\n start_time = 0\\n jobs.append({\\n \\\"job_number\\\": int(job_number),\\n \\\"script\\\": _get_job_tree_text(job_tree, \\\"JB_script_file\\\"),\\n \\\"submission_time\\\": int(time_str) if time_str else 0,\\n \\\"start_time\\\": start_time,\\n \\\"cwd\\\": _get_job_tree_text(job_tree, \\\"JB_cwd\\\"),\\n })\\n return jobs\",\n \"async def org_info_below_13(org_urls13):\\n org_info_till13 = []\\n project_urls_till13 = []\\n for url in org_urls13:\\n # General information about the org\\n try:\\n soup = await get_page(url)\\n org_name = basename(url)\\n org_info = soup.find_all('p')\\n web_page = org_info[0].text.splitlines()[-1].strip()\\n mailing_list = org_info[1].text.split(\\\":\\\")[-1].strip()\\n detail = org_info[2].text\\n org_info_till13.append({'name': org_name, 'about': detail,\\n 'page': web_page, 'mail': mailing_list,\\n 'link': url})\\n project_urls_till13.extend(grab_project_links(soup))\\n\\n except IndexError:\\n print(url)\\n\\n return org_info_till13, get_project_info(project_urls_till13)\",\n \"def get_processed_projects(self):\\n flowcell_path = self.get_flowcell_path()\\n return (pp\\n for pp in os.listdir(flowcell_path)\\n if re.search('Project_.*Processed', pp))\",\n \"def find_projects(root_dir) -> typing.Dict[str, Project]:\\n logging.debug(\\\"Finding zmake targets under '%s'.\\\", root_dir)\\n found_projects = {}\\n for path in pathlib.Path(root_dir).rglob(\\\"BUILD.py\\\"):\\n for project in load_config_file(path):\\n if project.config.project_name in found_projects:\\n raise KeyError(\\n \\\"Duplicate project defined: {} (in {})\\\".format(\\n project.config.project_name, path\\n )\\n )\\n found_projects[project.config.project_name] = project\\n return found_projects\",\n \"def get_projects(self):\\n projects = []\\n page = 1\\n while not len(projects) % 100:\\n projects += self._get('/projects?{0}'.format(urllib.urlencode({'per_page': 100, 'page': page})))\\n if not projects:\\n break\\n page += 1\\n return projects\",\n \"def _ParseAllDeps(self, solution_urls, solution_deps_content):\\n deps = {}\\n for solution in self.GetVar(\\\"solutions\\\"):\\n custom_vars = solution.get(\\\"custom_vars\\\", {})\\n solution_deps = self._ParseSolutionDeps(\\n solution[\\\"name\\\"],\\n solution_deps_content[solution[\\\"name\\\"]],\\n custom_vars)\\n\\n # If a line is in custom_deps, but not in the solution, we want to append\\n # this line to the solution.\\n if \\\"custom_deps\\\" in solution:\\n for d in solution[\\\"custom_deps\\\"]:\\n if d not in solution_deps:\\n solution_deps[d] = solution[\\\"custom_deps\\\"][d]\\n\\n for d in solution_deps:\\n if \\\"custom_deps\\\" in solution and d in solution[\\\"custom_deps\\\"]:\\n # Dependency is overriden.\\n url = solution[\\\"custom_deps\\\"][d]\\n if url is None:\\n continue\\n else:\\n url = solution_deps[d]\\n # if we have a From reference dependent on another solution, then\\n # just skip the From reference. When we pull deps for the solution,\\n # we will take care of this dependency.\\n #\\n # If multiple solutions all have the same From reference, then we\\n # should only add one to our list of dependencies.\\n if type(url) != str:\\n if url.module_name in solution_urls:\\n # Already parsed.\\n continue\\n if d in deps and type(deps[d]) != str:\\n if url.module_name == deps[d].module_name:\\n continue\\n else:\\n parsed_url = urlparse.urlparse(url)\\n scheme = parsed_url[0]\\n if not scheme:\\n # A relative url. Fetch the real base.\\n path = parsed_url[2]\\n if path[0] != \\\"/\\\":\\n raise gclient_utils.Error(\\n \\\"relative DEPS entry \\\\\\\"%s\\\\\\\" must begin with a slash\\\" % d)\\n # Create a scm just to query the full url.\\n scm = gclient_scm.CreateSCM(solution[\\\"url\\\"], self._root_dir,\\n None)\\n url = scm.FullUrlForRelativeUrl(url)\\n if d in deps and deps[d] != url:\\n raise gclient_utils.Error(\\n \\\"Solutions have conflicting versions of dependency \\\\\\\"%s\\\\\\\"\\\" % d)\\n if d in solution_urls and solution_urls[d] != url:\\n raise gclient_utils.Error(\\n \\\"Dependency \\\\\\\"%s\\\\\\\" conflicts with specified solution\\\" % d)\\n # Grab the dependency.\\n deps[d] = url\\n return deps\",\n \"def process_builds(\\n project: Project,\\n config: appconnect.AppStoreConnectConfig,\\n to_process: List[appconnect.BuildInfo],\\n) -> List[Tuple[appconnect.BuildInfo, AppConnectBuild]]:\\n\\n pending_builds = []\\n\\n with sentry_sdk.start_span(\\n op=\\\"appconnect-update-builds\\\", description=\\\"Update AppStoreConnect builds in database\\\"\\n ):\\n for build in to_process:\\n build_state = get_or_create_persisted_build(project, config, build)\\n if not build_state.fetched:\\n pending_builds.append((build, build_state))\\n\\n LatestAppConnectBuildsCheck.objects.create_or_update(\\n project=project, source_id=config.id, values={\\\"last_checked\\\": timezone.now()}\\n )\\n\\n return pending_builds\",\n \"async def get_project_info(project_urls):\\n project_info = []\\n for url in project_urls:\\n soup = await get_page(url)\\n about = soup.find_all(\\\"p\\\")\\n title = soup.find(\\\"h3\\\").text\\n student = about[0].text.splitlines()[2].strip()\\n details = about[1].text\\n name = about[0].find(\\\"a\\\").text\\n project_info.append({'Organization': name, 'title': title,\\n 'student': student, 'details': details,\\n 'link': url})\\n\\n return project_info\",\n \"def test_list_build_config_for_all_namespaces(self):\\n pass\",\n \"def test_buildAll(self):\\n builds = []\\n builder = NewsBuilder()\\n builder.build = lambda path, output, header: builds.append((\\n path, output, header))\\n builder.blacklist = ['vfs']\\n builder._today = lambda: '2009-12-01'\\n\\n project = self.createFakeTwistedProject()\\n builder.buildAll(project)\\n\\n coreTopfiles = project.child(\\\"topfiles\\\")\\n coreNews = coreTopfiles.child(\\\"NEWS\\\")\\n coreHeader = \\\"Twisted Core 1.2.3 (2009-12-01)\\\"\\n\\n conchTopfiles = project.child(\\\"conch\\\").child(\\\"topfiles\\\")\\n conchNews = conchTopfiles.child(\\\"NEWS\\\")\\n conchHeader = \\\"Twisted Conch 3.4.5 (2009-12-01)\\\"\\n\\n aggregateNews = project.child(\\\"NEWS\\\")\\n\\n self.assertEquals(\\n builds,\\n [(conchTopfiles, conchNews, conchHeader),\\n (coreTopfiles, coreNews, coreHeader),\\n (conchTopfiles, aggregateNews, conchHeader),\\n (coreTopfiles, aggregateNews, coreHeader)])\",\n \"def get_projects_data():\\n wcscanner_path = context.__BASE_PATH__ + '/.wcscanner'\\n\\n data = []\\n for project in os.listdir(wcscanner_path):\\n if (os.path.isdir(os.path.join(wcscanner_path, project))):\\n update_project_data(project)\\n project_path = '{}/{}'.format(wcscanner_path, project)\\n f = open('{}/.project'.format(project_path), 'r')\\n data.append(json.load(f))\\n f.close()\\n return data\",\n \"def jobsUrl(self):\\n return self.sdaUrl + \\\"/jobs\\\"\",\n \"def result_urls(self, job_id: str, show_progress: bool = False) -> List:\\n data = self.result_json(job_id, show_progress)\\n urls = [x['href'] for x in data.get('links', []) if x['rel'] == 'data']\\n return urls\",\n \"def get_build_infos(self, start_rev, end_rev, range=60*60*4):\\n pushlogs_finder = self._create_pushlog_finder(start_rev, end_rev)\\n\\n pushlogs = pushlogs_finder.get_pushlogs()\\n\\n if not pushlogs:\\n return []\\n\\n start_time = pushlogs[0]['date']\\n end_time = pushlogs[-1]['date']\\n \\n build_urls = [(\\\"%s%s/\\\" % (self.build_base_url, path), timestamp)\\n for path, timestamp in self._extract_paths()]\\n\\n build_urls_in_range = filter(lambda (u, t): t > (start_time - range)\\n and t < (end_time + range), build_urls)\\n\\n raw_revisions = [push['changesets'][-1] for push in pushlogs]\\n all_builds = []\\n with futures.ThreadPoolExecutor(max_workers=8) as executor:\\n futures_results = {}\\n for build_url, timestamp in build_urls_in_range:\\n future = executor.submit(self._get_valid_builds,\\n build_url,\\n timestamp,\\n raw_revisions)\\n futures_results[future] = build_url\\n for future in futures.as_completed(futures_results):\\n if future.exception() is not None:\\n sys.exit(\\\"Retrieving valid builds from %r generated an\\\"\\n \\\" exception: %s\\\" % (futures_results[future],\\n future.exception()))\\n all_builds.extend(future.result())\\n\\n return self._sort_builds(all_builds)\",\n \"def query_jobs(repo_name, revision):\\n return buildapi.query_jobs_schedule(repo_name, revision)\",\n \"def projects(args):\\n _projects = lib.get_projects(\\n args.target, username=args.username, password=args.password\\n )\\n if _projects:\\n print(\\\"\\\\n\\\".join(_projects))\",\n \"def iter_builds(self):\\n conf = build_config.BuildConfig(\\n cmake_defs={\\\"BOARD\\\": self.config.zephyr_board}\\n )\\n\\n kconfig_files = []\\n prj_conf = self.config.project_dir / \\\"prj.conf\\\"\\n if prj_conf.is_file():\\n kconfig_files.append(prj_conf)\\n kconfig_files.extend(self.config.kconfig_files)\\n conf |= build_config.BuildConfig(kconfig_files=kconfig_files)\\n\\n for build_name, packer_config in self.packer.configs():\\n yield build_name, conf | packer_config\",\n \"def parsing_all_page(url):\\n html_doc = get_html(url)\\n# html_doc = get_html_local()\\n page_count = get_html_count(html_doc)\\n print 'All have find pages %d' % page_count\\n\\n projects = []\\n\\n for page in range(1, page_count + 1):\\n print 'Parsing %d%%' % (page*100/page_count)\\n\\n url = BASE_URL + '?page=%d' % page\\n projects.extend(process_page(url))\\n\\n return projects\",\n \"def build_artifacts(self):\\n return self._build_artifacts\",\n \"def blocking_dependencies(projects, py3_projects):\\n check = [project.lower()\\n for project in projects if project.lower() not in py3_projects]\\n reasons = LowerDict({project: None for project in check})\\n thread_pool_executor = concurrent.futures.ThreadPoolExecutor(\\n max_workers=CPU_COUNT)\\n with thread_pool_executor as executor:\\n while len(check) > 0:\\n new_check = []\\n for parent, deps in zip(check, executor.map(dependencies, check)):\\n for dep in deps:\\n if dep in py3_projects:\\n continue\\n reasons[dep] = parent\\n new_check.append(dep)\\n check = new_check\\n return reasons_to_paths(reasons)\",\n \"def getMatchingPaths(cls, repoUrl):\\n res = []\\n for repository in cls.config['repositories']:\\n if repository['url'] == repoUrl:\\n res.append(repository['path'])\\n return res\",\n \"def scan_addresses(root_dir, base_path=None):\\r\\n\\r\\n addresses = OrderedSet()\\r\\n for buildfile in BuildFile.scan_buildfiles(root_dir, base_path):\\r\\n addresses.update(Target.get_all_addresses(buildfile))\\r\\n return addresses\",\n \"def api_upwork_get_tasks(request):\\n qs = models.JobUpwork.objects.filter(\\n is_processed=False).values_list('url', flat=True)\\n\\n return JsonResponse(list(qs), safe=False)\",\n \"def concurrent_builds(self):\\n return self._concurrent_builds\",\n \"def build_configs():\",\n \"def list_build(self, **kwargs):\\n\\n all_params = ['pretty', 'label_selector', 'field_selector', 'watch', 'resource_version', 'timeout_seconds']\\n all_params.append('callback')\\n\\n params = locals()\\n for key, val in iteritems(params['kwargs']):\\n if key not in all_params:\\n raise TypeError(\\n \\\"Got an unexpected keyword argument '%s'\\\"\\n \\\" to method list_build\\\" % key\\n )\\n params[key] = val\\n del params['kwargs']\\n\\n\\n resource_path = '/oapi/v1/builds'.replace('{format}', 'json')\\n path_params = {}\\n\\n query_params = {}\\n if 'pretty' in params:\\n query_params['pretty'] = params['pretty']\\n if 'label_selector' in params:\\n query_params['labelSelector'] = params['label_selector']\\n if 'field_selector' in params:\\n query_params['fieldSelector'] = params['field_selector']\\n if 'watch' in params:\\n query_params['watch'] = params['watch']\\n if 'resource_version' in params:\\n query_params['resourceVersion'] = params['resource_version']\\n if 'timeout_seconds' in params:\\n query_params['timeoutSeconds'] = params['timeout_seconds']\\n\\n header_params = {}\\n\\n form_params = []\\n local_var_files = {}\\n\\n body_params = None\\n\\n # HTTP header `Accept`\\n header_params['Accept'] = self.api_client.\\\\\\n select_header_accept(['application/json', 'application/yaml'])\\n if not header_params['Accept']:\\n del header_params['Accept']\\n\\n # HTTP header `Content-Type`\\n header_params['Content-Type'] = self.api_client.\\\\\\n select_header_content_type(['*/*'])\\n\\n # Authentication setting\\n auth_settings = []\\n\\n response = self.api_client.call_api(resource_path, 'GET',\\n path_params,\\n query_params,\\n header_params,\\n body=body_params,\\n post_params=form_params,\\n files=local_var_files,\\n response_type='V1BuildList',\\n auth_settings=auth_settings,\\n callback=params.get('callback'))\\n return response\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6178584","0.612089","0.60826075","0.59894234","0.5935299","0.5781459","0.5699846","0.56969726","0.5667781","0.560925","0.5579634","0.5579634","0.55440015","0.5480648","0.5456297","0.5444982","0.5421424","0.54137886","0.5393616","0.5388915","0.5386272","0.53702515","0.53451747","0.5343377","0.5311376","0.53103757","0.52936214","0.52924657","0.5279329","0.52708733","0.52636117","0.5259003","0.5250357","0.52322114","0.5229535","0.52191514","0.520626","0.51898235","0.51895356","0.5179143","0.51763767","0.51740366","0.51725346","0.5164125","0.5154051","0.5153209","0.51442516","0.5142951","0.51248616","0.5113839","0.5110251","0.51073724","0.51010627","0.51007545","0.5085944","0.50846076","0.5079744","0.5074241","0.5060586","0.50555557","0.504544","0.50436145","0.5042299","0.50383466","0.5034351","0.50297445","0.5023599","0.50227284","0.5013014","0.50124127","0.50111","0.5006865","0.50058216","0.500052","0.50004303","0.49995473","0.49967948","0.4996571","0.4993755","0.49867067","0.4986171","0.49777943","0.4968549","0.49650842","0.4963994","0.49597257","0.4958004","0.49530828","0.49306458","0.49230182","0.49209943","0.49196985","0.49121037","0.49117497","0.4910397","0.49012107","0.4889941","0.48841462","0.48838758","0.48738807"],"string":"[\n \"0.6178584\",\n \"0.612089\",\n \"0.60826075\",\n \"0.59894234\",\n \"0.5935299\",\n \"0.5781459\",\n \"0.5699846\",\n \"0.56969726\",\n \"0.5667781\",\n \"0.560925\",\n \"0.5579634\",\n \"0.5579634\",\n \"0.55440015\",\n \"0.5480648\",\n \"0.5456297\",\n \"0.5444982\",\n \"0.5421424\",\n \"0.54137886\",\n \"0.5393616\",\n \"0.5388915\",\n \"0.5386272\",\n \"0.53702515\",\n \"0.53451747\",\n \"0.5343377\",\n \"0.5311376\",\n \"0.53103757\",\n \"0.52936214\",\n \"0.52924657\",\n \"0.5279329\",\n \"0.52708733\",\n \"0.52636117\",\n \"0.5259003\",\n \"0.5250357\",\n \"0.52322114\",\n \"0.5229535\",\n \"0.52191514\",\n \"0.520626\",\n \"0.51898235\",\n \"0.51895356\",\n \"0.5179143\",\n \"0.51763767\",\n \"0.51740366\",\n \"0.51725346\",\n \"0.5164125\",\n \"0.5154051\",\n \"0.5153209\",\n \"0.51442516\",\n \"0.5142951\",\n \"0.51248616\",\n \"0.5113839\",\n \"0.5110251\",\n \"0.51073724\",\n \"0.51010627\",\n \"0.51007545\",\n \"0.5085944\",\n \"0.50846076\",\n \"0.5079744\",\n \"0.5074241\",\n \"0.5060586\",\n \"0.50555557\",\n \"0.504544\",\n \"0.50436145\",\n \"0.5042299\",\n \"0.50383466\",\n \"0.5034351\",\n \"0.50297445\",\n \"0.5023599\",\n \"0.50227284\",\n \"0.5013014\",\n \"0.50124127\",\n \"0.50111\",\n \"0.5006865\",\n \"0.50058216\",\n \"0.500052\",\n \"0.50004303\",\n \"0.49995473\",\n \"0.49967948\",\n \"0.4996571\",\n \"0.4993755\",\n \"0.49867067\",\n \"0.4986171\",\n \"0.49777943\",\n \"0.4968549\",\n \"0.49650842\",\n \"0.4963994\",\n \"0.49597257\",\n \"0.4958004\",\n \"0.49530828\",\n \"0.49306458\",\n \"0.49230182\",\n \"0.49209943\",\n \"0.49196985\",\n \"0.49121037\",\n \"0.49117497\",\n \"0.4910397\",\n \"0.49012107\",\n \"0.4889941\",\n \"0.48841462\",\n \"0.48838758\",\n \"0.48738807\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6822186"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":255,"numItemsPerPage":100,"numTotalItems":95772,"offset":25500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNjc1Mzc2ODJkMmE2Mjg0NzVhMWJmZmNkIl0sImlhdCI6MTc5MTEwMDA4NSwianRpIjoiOTY4NzNjZjgtMTg3NS00MzVjLWI3MTUtNDg0NzczZGEyYjhhIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3OTExMDM2ODUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.0Ftpc6n_AiWXevPSUI9HIHccToOX1XGHG7B-7PmAPF-8ANdErOziDO0Swx6gQ7crlEbxe-i6PfUDReEtfSx_Cw","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 |
|---|---|---|---|---|---|---|
Returns search results of the query obtained in request args. It Returns four seperate variables containing results for artists, music, albums and records. | def search():
if not request.vars.search_term:
redirect(URL('index'))
term = request.vars.search_term
origterm = term
term = term.replace(' ','|')
artists = db.executesql("select distinct(m1.id), m1.art_name, m1.artist_type, m1.country, m1.b_year,m1.b_month,m1.b_date,m1.e_year,m1.e_month,m1.e_day,ts_rank(to_tsve... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_artists():\n return query_multiple(request.args, artist_search, \\\n artist_filter, Artist, artists_schema)",
"def get(self):\n mb = MusicbrainzClient()\n query = self.get_argument('q')\n artists, tracks = yield [mb.search_artists(query),\n ... | [
"0.6995513",
"0.6946495",
"0.69276816",
"0.6712662",
"0.66553944",
"0.6650486",
"0.66414595",
"0.66204256",
"0.66038275",
"0.65670973",
"0.65214497",
"0.65137446",
"0.64969873",
"0.6442194",
"0.6438711",
"0.6370827",
"0.6355204",
"0.6339323",
"0.6334207",
"0.63236696",
"0.631... | 0.73612744 | 0 |
This action is responsible for obtaining and returning all the information related to a particular release group item. | def album():
if not request.vars.id:
redirect(URL('index'))
id = request.vars.id
releasegroupname = db.executesql("select m1.name, m2.id from release_name as m1, release_group as m2 where m1.id = m2.name and m2.id = "+id+";")
releasegroup = db.executesql("select distinct(m2.id),m3.name,m5.name,m7.track_count,m2.d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_item(group):\n print(\"\\tName: {}\".format(group.name))\n print(\"\\tId: {}\".format(group.id))\n print(\"\\tLocation: {}\".format(group.location))\n print(\"\\tTags: {}\".format(group.tags))\n if hasattr(group, 'properties'):\n print_properties(group.properties)",
"def print_ite... | [
"0.58416325",
"0.5816238",
"0.58002716",
"0.54882723",
"0.54080135",
"0.52620345",
"0.51343477",
"0.5105051",
"0.503373",
"0.5021229",
"0.50112814",
"0.4995143",
"0.49764192",
"0.4962052",
"0.49419135",
"0.492932",
"0.49121702",
"0.49007878",
"0.48873103",
"0.48685712",
"0.48... | 0.4758959 | 33 |
This action is reponsible for displaying the displaying the tracklist of a particular release | def release():
if not request.vars.id:
redirect(URL('index'))
id = request.vars.id
releasename = db.executesql("select m1.name from release_name as m1, release as m2 where m1.id = m2.name and m2.id = "+id+";")
tracklist = db.executesql("select m4.id, m5.name, m4.position, m4.length from release m1,medium m2,track... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_release_details(release):\n def get(key, dictionary=release):\n try:\n return dictionary[key]\n except KeyError as e:\n return None\n\n date = get('date')\n date = date[:4] if date else \"\"\n print(\"{} / {} ({})\".format(get('artist-credit-phrase'), get('t... | [
"0.6434879",
"0.5879494",
"0.57307416",
"0.563012",
"0.5614375",
"0.55647445",
"0.55647445",
"0.5560884",
"0.5560467",
"0.5530062",
"0.54957026",
"0.5479897",
"0.5445508",
"0.5431248",
"0.5370204",
"0.5301003",
"0.52960336",
"0.52862537",
"0.5273142",
"0.526875",
"0.52551377"... | 0.586884 | 2 |
This action is reponsible for displaying all the information related to an artist | def artist():
if not request.vars.id:
redirect(URL('index'))
id = request.vars.id
artistname = db.executesql("select m1.name from artist_name as m1, artist as m2 where m1.id = m2.name and m2.id = "+id+";")
urls = db.executesql("select distinct(m2.url) from l_artist_url m1, url m2 where m2.id = m1.entity1 and m1.e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def artists():\n # TODO: replace with real data returned from querying the database (DONE)\n artists = Artist.query.group_by(Artist.id, Artist.name).all()\n\n data = []\n\n for a in artists :\n data.append({\n 'id' : a.id,\n 'name' : a.name\n })\n\n return render_... | [
"0.7046416",
"0.6953733",
"0.6649395",
"0.66083264",
"0.657852",
"0.65465295",
"0.6491085",
"0.64804745",
"0.64677274",
"0.64607227",
"0.64456445",
"0.6401886",
"0.63846064",
"0.6378521",
"0.6368321",
"0.6331579",
"0.6211678",
"0.62032557",
"0.6153709",
"0.61417043",
"0.61027... | 0.78098094 | 0 |
allows downloading of uploaded files | def download():
return response.download(request, db) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_files(self):",
"def post_download(self, remote_files):\n pass",
"def download_file(self, parsed_event, input_dir_path):",
"def download(self,fn):\n\t\treturn False #TODO: implement meme download",
"def download(self):\n pass",
"def download(self):\n pass",
"def pre_dow... | [
"0.7924571",
"0.7199257",
"0.6978304",
"0.6841495",
"0.6764734",
"0.6764734",
"0.66671187",
"0.6631285",
"0.6588692",
"0.6555494",
"0.65398693",
"0.65012735",
"0.6458808",
"0.6451737",
"0.64442515",
"0.6402176",
"0.63864595",
"0.63758063",
"0.63659835",
"0.6345104",
"0.633138... | 0.0 | -1 |
Assemble a uri based on a base, any number of path segments, and query string parameters. | def urljoin(base, *path, **query):
if base and base.endswith('/'):
base = base[:-1]
retval = [base]
# build the path
path = '/'.join([''] + [quote(s, '') for s in path])
if path:
retval.append(path)
# build the query string
params = []
for name, value in query.items():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_uri(self, uri_base, params):\n if not params:\n return uri_base\n else:\n uri_extension = \"?\"\n for param in params:\n uri_extension = uri_extension + param + \"&\"\n uri_extension = uri_extension[:-1] # clip off the final & \n ... | [
"0.8172769",
"0.7679958",
"0.7513473",
"0.6879448",
"0.68683076",
"0.6697143",
"0.6584741",
"0.64706886",
"0.64205086",
"0.63630056",
"0.63141865",
"0.6287929",
"0.62767005",
"0.6271733",
"0.62544346",
"0.62226605",
"0.62067354",
"0.6118589",
"0.609388",
"0.6077103",
"0.60672... | 0.6343084 | 10 |
Add a listener to be invoked whenever ``for_listeners(name)`` is called. | def add_listener(self, name, callback: Callable[..., Any], filter_fn=None, optional=False) -> 'CallbackDisconnector':
if not callable(callback):
raise ValueError('callback must be callable')
name = self._normalize_name(name)
record = self._records.get(name)
if record is None... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_listener(self, listener):\r\n self.listeners.append(listener)",
"def add_listener(self, listener):\n self.listeners.append(listener)",
"def AddListener(self, listener):\n pass",
"def add_listener(self, listener):\n self._listeners.append(listener)",
"def add_message_listen... | [
"0.75564337",
"0.74877083",
"0.7243794",
"0.72170144",
"0.718768",
"0.707675",
"0.6893153",
"0.68294317",
"0.67576826",
"0.6747247",
"0.6540557",
"0.6404089",
"0.6355143",
"0.62774986",
"0.6263101",
"0.6199482",
"0.61959505",
"0.61842805",
"0.6172105",
"0.61708695",
"0.614587... | 0.67746115 | 8 |
Returns a proxy callback that takes parameters that are passed to each callback as is. Any return values are gathered and returned as a list of Future in the same order as the original callbacks. | def for_listeners(self, name) -> Callable[..., List['CallbackRecord']]:
try:
hash(name)
except TypeError:
LOG.error('Tried to use %s as a key for looking up event handlers.', name)
raise
name = self._normalize_name(name)
cb = self._records.get(name)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute(self):\n results = []\n \n for callback in self.callback:\n results.append(callback(*self.args))\n \n return results",
"def execute(self):\n results = []\n\n for callNumber in xrange(len(self.callback)):\n results.append( (self.ca... | [
"0.75090116",
"0.7237878",
"0.69892627",
"0.6575861",
"0.65059805",
"0.6466124",
"0.6276305",
"0.6188024",
"0.60304135",
"0.60152036",
"0.59994966",
"0.5934425",
"0.5891724",
"0.58878666",
"0.5830869",
"0.5813392",
"0.57927155",
"0.57908887",
"0.57848376",
"0.5717209",
"0.571... | 0.0 | -1 |
Actually invoke the underlying function (but only if it hasn't been invoked already). | def start(self) -> None:
cb = self._callback
if cb is not None:
self._callback = None
propagate(from_=ensure_future(cb()), to=self._future) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call(self):\n self.call() # Call a function",
"def __call__(self, *arg, **kwargs):\n return self._fun(*arg, **kwargs)",
"def __call__(self, *args, **kwargs):\n if Numba.numba_flag:\n return self.numba_fn(*args, **kwargs)\n else:\n return self.function(*arg... | [
"0.645682",
"0.6429473",
"0.64159334",
"0.639884",
"0.6388811",
"0.63531023",
"0.63465124",
"0.63283324",
"0.6302384",
"0.62790745",
"0.6166103",
"0.6166103",
"0.61579746",
"0.6139069",
"0.6121427",
"0.61082965",
"0.61067134",
"0.61054397",
"0.60570645",
"0.605564",
"0.604391... | 0.0 | -1 |
Convert the allowable callback signatures to a function that | def _normalize_callback_implementation(callback: Callable[..., Any]) -> Callable[..., Future]:
if not callable(callback):
raise ValueError('callback must be callable')
@wraps(callback)
def invoke_sync(*args, **kwargs) -> Future:
loop = asyncio.get_event_loop()
try:
resu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_function_callbacks(self):\n res = \"\"\n for node in self.description.definitions():\n if isinstance(node.type.get_type(), pdl.TypeFunction):\n frags={\n \"name\": node.name,\n \"nameupper\": self.python_madz_deftypes + \"___\" ... | [
"0.64135003",
"0.63697374",
"0.5881934",
"0.58109105",
"0.57914805",
"0.57761544",
"0.5667346",
"0.5652006",
"0.559458",
"0.55765367",
"0.557005",
"0.5563907",
"0.55628437",
"0.54764694",
"0.54760617",
"0.5406841",
"0.5405066",
"0.5390303",
"0.53657085",
"0.5351603",
"0.53044... | 0.53438926 | 20 |
Remove an existing callback from the list of callbacks that will be invoked whenever this record is called. | def remove(self, callback) -> bool:
for i, tracker in enumerate(self.trackers):
if tracker.original_callback == callback:
del self.trackers[i]
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_callback(self, callback):\n if callback in self._callbacks:\n self._callbacks.remove(callback)",
"def remove_callback(self, callback):\n if callback in self._async_callbacks:\n self._async_callbacks.remove(callback)",
"def unregister(self, callback):\n\t\tcallback... | [
"0.81763077",
"0.8000942",
"0.7855995",
"0.76857203",
"0.7678713",
"0.7539317",
"0.747451",
"0.74458057",
"0.74337065",
"0.73114634",
"0.7176973",
"0.7165153",
"0.7162398",
"0.7117453",
"0.7117453",
"0.71164805",
"0.7048038",
"0.7043623",
"0.7039069",
"0.6980838",
"0.6967926"... | 0.7058943 | 16 |
Extract consecutive ners from the result of CoreNLPNERTagger | def merge_ners(tokens):
ners = list()
merged_tokens = list()
candid_entity = list()
keep = False
prev_tag = 'O'
for i, (token, tag) in enumerate(tokens):
if keep:
if tag not in IGNORE_NER_TAG:
candid_entity.append(token)
keep = True
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_ngrams(self, sequence):\n sequence = self.prefix + sequence + self.suffix\n for i, event in enumerate(sequence[self.n:], self.n):\n yield event, sequence[i-self.n: i]",
"def extract_nps(text, annotation):\n np_starts = [i for i in range(len(annotation)) if annotation[i] ==... | [
"0.5992052",
"0.58803827",
"0.57412916",
"0.57153046",
"0.56501865",
"0.56453776",
"0.55940616",
"0.5551463",
"0.54952145",
"0.5488924",
"0.54851663",
"0.54851663",
"0.54396814",
"0.53640854",
"0.5351113",
"0.5312324",
"0.5291228",
"0.52684474",
"0.52250415",
"0.5201601",
"0.... | 0.59793997 | 1 |
Load freebase entity dictionary from saved dict | def load_freebase_entity(path="../data/freebase/dict.txt"):
logger.info('Loading freebase entity dictionary...')
name2id = dict()
id2name = dict()
with open(path, 'r', buffering=1024 * 1024 * 100) as f:
for line in f:
tokens = line.split('\t')
_name = tokens[0].strip()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_dict(cls, dikt) -> 'GnbrEntity':\n return util.deserialize_model(dikt, cls)",
"def load_dict(self, dct):\n pass",
"def load(self):\n\n args = self.id, self.name\n self.loader.session.logger.debug(\"loading CDR%d (%r)\", *args)\n cursor = self.loader.dicti... | [
"0.64202756",
"0.6255847",
"0.62532294",
"0.61488426",
"0.59458196",
"0.59139955",
"0.58941555",
"0.5862503",
"0.58609146",
"0.5860008",
"0.5859102",
"0.5848029",
"0.5788074",
"0.57809716",
"0.5733735",
"0.5718896",
"0.5706553",
"0.5698764",
"0.5692765",
"0.56742126",
"0.5661... | 0.7637444 | 0 |
Return position of ner in list of tokens | def get_nerpos(tokens, ner):
loc = list()
for i, token in enumerate(tokens):
if token == ner:
loc.append(i)
return loc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_nerspos(tokens, ners):\n pos_list = list()\n for ner in ners:\n pos = get_nerpos(tokens, ner)\n pos_list.append(pos)\n\n return pos_list",
"def get_head_pos( head, ngram ):\n try:\n tokens = ngram.split( ' ' )\n return str([ i for i, t in enumerate( tokens ) if t.s... | [
"0.68481386",
"0.64260495",
"0.6337191",
"0.6327533",
"0.6311592",
"0.63036317",
"0.62495536",
"0.62290925",
"0.6140072",
"0.6086388",
"0.5966749",
"0.59169406",
"0.59167016",
"0.590555",
"0.5892167",
"0.58879244",
"0.58879244",
"0.58879244",
"0.58823013",
"0.58707553",
"0.58... | 0.81861734 | 0 |
Return positions of ners in list of tokens | def get_nerspos(tokens, ners):
pos_list = list()
for ner in ners:
pos = get_nerpos(tokens, ner)
pos_list.append(pos)
return pos_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_nerpos(tokens, ner):\n\n loc = list()\n for i, token in enumerate(tokens):\n if token == ner:\n loc.append(i)\n return loc",
"def get_positions(token, docs):\n\n all_matches = [token]\n for doc in docs:\n matches = []\n if token in doc:\n indexes ... | [
"0.8392064",
"0.69574887",
"0.6598042",
"0.6516395",
"0.6503853",
"0.63557386",
"0.6345",
"0.6334957",
"0.63280684",
"0.62971956",
"0.6194977",
"0.61768335",
"0.61675954",
"0.61302745",
"0.6104622",
"0.60178024",
"0.60013366",
"0.5981349",
"0.5938564",
"0.59180295",
"0.591576... | 0.78989506 | 1 |
Create the specified path on the filesystem like the `mkdir p` command Creates one or more filesystem directory levels as needed, and does not return an error if the directory already exists. | def mkdir_p(path):
# http://stackoverflow.com/questions/600268/mkdir-p-functionality-in-python
try:
os.makedirs(path)
except OSError as exc: # Python >2.5
if exc.errno == errno.EEXIST and os.path.isdir(path):
pass
else:
raise | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mkdir(path):\n\tif not Path(path).exists():\n\t\tPath(path).mkdir(parents=True, exist_ok=True)",
"def mkdir_p(path):\n\n if os.path.exists(path):\n return\n\n par = os.path.split(path)[0]\n if os.path.exists(par):\n os.mkdir(path)\n getLogger(__name__).debug('created directory: ... | [
"0.8252548",
"0.8147374",
"0.813743",
"0.8125734",
"0.8122502",
"0.8044979",
"0.8040932",
"0.80242634",
"0.79902554",
"0.79894096",
"0.79894096",
"0.79894096",
"0.79894096",
"0.7985319",
"0.79825383",
"0.7970779",
"0.79506147",
"0.79506147",
"0.79506147",
"0.79506147",
"0.794... | 0.78200287 | 40 |
Returns true if arg is a list or another Python Sequence, and false otherwise. | def is_sequence(arg):
return (not hasattr(arg, "strip") and
hasattr(arg, "__getitem__") or
hasattr(arg, "__iter__")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_list(arg):\n return isinstance(arg, collections.Sequence) and not _is_string(arg)",
"def is_sequence(arg):\n\n # np.float{16,32,64} and np.int types have __getitem__ defined\n # this is a long-standing bug in NumPy and unlikely to be fixed\n # todo: backport to qmmlpack, write tests\n if i... | [
"0.842769",
"0.7965603",
"0.7516044",
"0.7451877",
"0.7329391",
"0.73040754",
"0.72747916",
"0.7107596",
"0.70028114",
"0.69910914",
"0.69853663",
"0.6981128",
"0.69492453",
"0.6949044",
"0.6924374",
"0.68378544",
"0.681947",
"0.67969847",
"0.67924744",
"0.6788219",
"0.675699... | 0.79118264 | 2 |
Internal function to configure which subset of the datasets is being used. Helps to choose a reasonable default action based on previous user parameters. | def _update_dataset_param(self, dataset):
if dataset is None and self.dataset is None:
return []
if dataset is 'all':
dataset = ''
if dataset is None and self.dataset is not None:
dataset = self.dataset
return dataset | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataset(options):\n pass",
"def set_default_parameters(self):\n super().set_default_parameters()\n if not \"n_sub_images\" in vars(self):\n self.n_sub_images = -1 # do all-sub-images",
"def set_data_subset(self, subset):\n self.data_subset = subset",
"def selected_datas... | [
"0.6140803",
"0.5858651",
"0.58069193",
"0.57882154",
"0.57795227",
"0.5742967",
"0.5709668",
"0.56961155",
"0.56382173",
"0.56296766",
"0.56248546",
"0.56127524",
"0.55776656",
"0.5573759",
"0.55507874",
"0.5547382",
"0.5512426",
"0.5499787",
"0.54964566",
"0.54803866",
"0.5... | 0.57147396 | 6 |
Get a appropriate OTP for the current Vault version under test. | def get_generate_root_otp():
if vault_version_ge("1.10.0"):
test_otp = "BMjzW3wAsEzINXCM05Wbas3u9zSl"
elif vault_version_ge("1.0.0"):
test_otp = "ygs0vL8GIxu0AjRVEmJ5jLCVq8"
else:
test_otp = "RSMGkAqBH5WnVLrDTbZ+UQ=="
return test_otp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def otp_generate(request):\n phone = request.GET.get('phone', None)\n otp = UserAuth(phone).generate_otp()\n return Response(\n {\n 'success': True,\n 'phone': phone,\n 'otp': otp\n }\n )",
"def generate_otp(email):\n\tprint \"generate_otp\"\n\totp_key =... | [
"0.58393794",
"0.5716151",
"0.56288546",
"0.56154954",
"0.55863196",
"0.55287445",
"0.5509557",
"0.542242",
"0.53520805",
"0.5223635",
"0.52086926",
"0.5172018",
"0.5132177",
"0.50504476",
"0.5044505",
"0.50082654",
"0.50049675",
"0.4994672",
"0.49763277",
"0.49655774",
"0.49... | 0.79360807 | 0 |
Small helper method used to discover an open port to use by mock API HTTP servers. | def get_free_port():
s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
s.bind(("localhost", 0))
address, port = s.getsockname()
s.close()
return port | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_unused_port() -> None:\n available_port = get_unused_port()\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:\n sock.bind((\"\", available_port))\n assert int(sock.getsockname()[1]) == available_port",
"def get_open_port():\n sock = socket.socket(socket.AF_INET... | [
"0.71796995",
"0.706297",
"0.70570284",
"0.7037272",
"0.69158477",
"0.69090056",
"0.6884879",
"0.6799318",
"0.6780961",
"0.6749321",
"0.67204267",
"0.6717844",
"0.67094326",
"0.6703785",
"0.6686551",
"0.665296",
"0.664464",
"0.6629048",
"0.6572091",
"0.65138483",
"0.6497322",... | 0.62442183 | 43 |
Load test config file data for use by various test cases. | def load_config_file(filename):
test_data_path = get_config_file_path(filename)
with open(test_data_path) as f:
test_data = f.read()
return test_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_test_data(self):\n self._save_test_data()",
"def test_load_from_file(self):\n cf = ConfigFile()\n cf.load_from_file(TestConfigFile.TEST_CONFIG)\n\n self.assertEqual(4, len(cf))\n self.assertEqual(cf[\"key1\"], \"val1\")\n self.assertEqual(cf[\"key2\"], \"val2\"... | [
"0.7346483",
"0.7241617",
"0.7041901",
"0.7021762",
"0.69928503",
"0.69685555",
"0.6907617",
"0.68597746",
"0.68017393",
"0.6799866",
"0.67664844",
"0.6723095",
"0.6710996",
"0.6676708",
"0.66698784",
"0.66493666",
"0.6597196",
"0.6592818",
"0.6589089",
"0.65828204",
"0.65756... | 0.7834851 | 0 |
Get the path to a config file under the "tests/config_files" directory. I.e., the directory containing selfsigned certificates, configuration files, etc. that are used for various tests. | def get_config_file_path(filename):
# Use __file__ to derive a path relative to this module's location which points to the tests data directory.
relative_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "..", "config_files"
)
return os.path.join(os.path.abspath(relative_path), f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config_path():\n\n root = os.path.dirname(os.path.abspath(__file__))[:-5]\n config_path = os.path.join(root, 'config.ini')\n\n return config_path",
"def get_config_path(config):\n section = config.sections()[0]\n return Path(config.get(section, \"path\")).expanduser().absolute()",
"def g... | [
"0.80562377",
"0.8025532",
"0.7936335",
"0.7636513",
"0.759419",
"0.75863504",
"0.7586312",
"0.74758565",
"0.7409882",
"0.7362901",
"0.7351157",
"0.73110783",
"0.725994",
"0.725583",
"0.71291775",
"0.70951337",
"0.7093658",
"0.7087657",
"0.708164",
"0.7075927",
"0.70503074",
... | 0.8256649 | 0 |
Decode a newly generated root token via Vault CLI. | def decode_generated_root_token(encoded_token, otp):
command = ["vault"]
if vault_version_ge("0.9.6"):
# before Vault ~0.9.6, the generate-root command was the first positional argument
# afterwards, it was moved under the "operator" category
command.append("operator")
command.exten... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def meraki_vault_r_secret(mount, path):\n read_secret_result = client.secrets.kv.v1.read_secret(path=meraki_vault_path, mount_point=vault_mount_point)\n api_token = read_secret_result['data']['token']\n return api_token",
"def vault_auth():\n # Check if vault is sealed\n if client.sys.is_sealed() ... | [
"0.59399545",
"0.5710058",
"0.56865376",
"0.5683078",
"0.5500785",
"0.5490273",
"0.5472639",
"0.5260887",
"0.5217738",
"0.521536",
"0.5193939",
"0.5115839",
"0.51024985",
"0.5093198",
"0.50621367",
"0.5052655",
"0.5043405",
"0.5037708",
"0.503704",
"0.49572414",
"0.49545163",... | 0.75455594 | 0 |
Helper method to add `encoding='utf8'` to subprocess.Popen. | def get_popen_kwargs(**popen_kwargs):
popen_kwargs["encoding"] = "utf-8"
return popen_kwargs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_terminal_encoding(encoding='utf_8'):\n sys.stdin = codecs.getreader(encoding)(sys.stdin)\n sys.stdout = codecs.getwriter(encoding)(sys.stdout)\n sys.stderr = codecs.getwriter(encoding)(sys.stderr)",
"def defaultProcessOutputEncodingDecider(context, executable, **forfutureuse):\n\treturn __DEFAUL... | [
"0.64557153",
"0.6064261",
"0.5924003",
"0.58920264",
"0.5797352",
"0.57451856",
"0.5647091",
"0.5566803",
"0.5552143",
"0.54971397",
"0.5480613",
"0.5451589",
"0.5397502",
"0.53734374",
"0.5352288",
"0.5268057",
"0.5194355",
"0.51533914",
"0.5115416",
"0.5112865",
"0.5074088... | 0.6455326 | 1 |
Helper method to perform base64 encoding | def base64ify(bytes_or_str):
if isinstance(bytes_or_str, str):
input_bytes = bytes_or_str.encode("utf8")
else:
input_bytes = bytes_or_str
output_bytes = base64.urlsafe_b64encode(input_bytes)
return output_bytes.decode("ascii") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def base64_encode(data):\n return base64.encodestring(data);",
"def my_base64encode(s):\n return base64.b64encode(s).decode(\"utf-8\")",
"def base64_string(self) -> global___Expression:",
"def _encode_base64(data: str) -> str:\n ebytes = base64.b64encode(data.encode(\"utf-8\"))\n estring = str(eb... | [
"0.8336032",
"0.8287229",
"0.8229982",
"0.82246256",
"0.79071426",
"0.7830374",
"0.77805984",
"0.7689982",
"0.7669789",
"0.7659945",
"0.7618254",
"0.76087964",
"0.75895584",
"0.7491684",
"0.7423716",
"0.73868006",
"0.7357054",
"0.73041403",
"0.7277756",
"0.7277756",
"0.724756... | 0.7250471 | 20 |
Helper function to configure a pki backend for integration tests that need to work with lease IDs. | def configure_pki(
client, common_name="hvac.com", role_name="my-role", mount_point="pki"
):
if f"{mount_point}/" in client.sys.list_mounted_secrets_engines():
client.sys.disable_secrets_engine(mount_point)
client.sys.enable_secrets_engine(backend_type="pki", path=mount_point)
client.write(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_global_backends(pytest_config):\n backend_settings = {}\n\n backends = [\"http\", \"mqtt\"]\n for b in backends:\n # similar logic to above - use ini, then cmdline if present\n ini_opt = pytest_config.getini(\"tavern-{}-backend\".format(b))\n cli_opt = pytest_config.getoptio... | [
"0.5777911",
"0.5647634",
"0.5610944",
"0.5572502",
"0.55506784",
"0.5415104",
"0.5322861",
"0.53125286",
"0.5294264",
"0.52423364",
"0.52252173",
"0.5218377",
"0.5196795",
"0.51509863",
"0.5147188",
"0.51185846",
"0.5118058",
"0.5037185",
"0.50200725",
"0.5019633",
"0.500976... | 0.50279945 | 18 |
Disable a previously configured pki backend. | def disable_pki(client, mount_point="pki"):
client.sys.disable_secrets_engine(mount_point) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_auth_backend():\n\n headers = {\"X-Vault-Token\": args.x_vault_token}\n url = \"{0}/sys/auth/{1}\".format(args.vault_url, args.k8s_cluster_name)\n print 'Disabling auth backend for cluster {0}'.format(args.k8s_cluster_name)\n send_delete(url=url, headers=headers)",
"def disable():\n req... | [
"0.66995364",
"0.61998165",
"0.6093094",
"0.5812049",
"0.57911944",
"0.5744036",
"0.5727666",
"0.5665002",
"0.5649514",
"0.5604349",
"0.5598673",
"0.55670303",
"0.55586666",
"0.5540842",
"0.5500927",
"0.5498942",
"0.5472412",
"0.5471941",
"0.5409242",
"0.54068637",
"0.5401836... | 0.61382073 | 2 |
remove the sqlalchemy sesh | def tear(exc):
storage.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove():\n\n db_remove()",
"def tearDown(self):\n #db.session.remove()\n db.drop_all()",
"def teardown_db():\n engine = config['tg.app_globals'].sa_engine\n connection = engine.connect()\n\n # INFO - D.A. - 2014-12-04\n # Recipe taken from bitbucket:\n # https://bitbucket.o... | [
"0.6853588",
"0.6843821",
"0.6779843",
"0.67321277",
"0.67321277",
"0.6699622",
"0.66935766",
"0.66935766",
"0.66935766",
"0.66935766",
"0.66935766",
"0.66935766",
"0.66935766",
"0.668059",
"0.6641767",
"0.6641767",
"0.6641767",
"0.6641767",
"0.6641767",
"0.66150945",
"0.6602... | 0.0 | -1 |
Input file_path, save model weights into a file of given format. | def save_weights(self, file_path, format=None):
_save_weights(self, file_path, format) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, weights_file):\r\n \r\n self.model.save_weights(weights_file)",
"def save_weights_file(self, file_path, file_name):\n\n # Join the path with the file name and append the extension (h5)\n path = join(file_path, \"{}.h5\".format(file_name))\n\n # Store the weights\... | [
"0.7974793",
"0.79393816",
"0.7818803",
"0.76390755",
"0.748463",
"0.7457383",
"0.7365727",
"0.7359829",
"0.7352166",
"0.7283044",
"0.7283044",
"0.7068052",
"0.7067362",
"0.70322907",
"0.7007359",
"0.7005004",
"0.7005004",
"0.7005004",
"0.69427085",
"0.6855376",
"0.68439704",... | 0.8305987 | 0 |
Load model weights from a given file, which should be previously saved by self.save_weights(). | def load_weights(self, file_path, format=None, in_order=True, skip=False):
_load_weights(self, file_path, format, in_order, skip) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_weights(self, weight_file):\r\n self.model.load_weights(weight_file)",
"def load_weights(self, file):\n self.model.load_weights(file)\n return",
"def load_model_weights(self, filename):\n self.model.load_weights(filename)",
"def load_weights(self, filepath):\n self... | [
"0.89469826",
"0.8901181",
"0.8853004",
"0.8774798",
"0.8556394",
"0.8332117",
"0.8260749",
"0.8030833",
"0.799898",
"0.7895191",
"0.78296417",
"0.7825905",
"0.77957875",
"0.7748564",
"0.7748564",
"0.7705152",
"0.7701626",
"0.764279",
"0.7554501",
"0.7549377",
"0.7390658",
... | 0.75612944 | 18 |
Add a LayerNode for this layer given input_tensors, output_tensors. | def _add_node(self, input_tensors, output_tensors):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_layer(inputs, in_size, out_size, n_layer, activation_function=None, ):\r\n layer_name = \"layer%s\" % n_layer\r\n with tf.name_scope(layer_name):\r\n with tf.name_scope(\"Weights\"):\r\n Weights = tf.Variable(tf.random_normal([in_size, out_size]), name=\"W\")\r\n tf.summa... | [
"0.6593948",
"0.6312318",
"0.6243013",
"0.62338334",
"0.6224892",
"0.5977068",
"0.592607",
"0.5898218",
"0.58804685",
"0.5858943",
"0.58344376",
"0.57562846",
"0.5721505",
"0.5678528",
"0.56682277",
"0.56655985",
"0.5646037",
"0.56409556",
"0.56349766",
"0.55707383",
"0.55651... | 0.7810959 | 0 |
Sets the cell to training mode. The cell itself and all children cells will be set to training mode. | def set_train(self):
self._phase = 'train'
self.add_flags_recursive(training=True)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_mode_train(self):\n self._set_mode('train')\n return self",
"def training(self):\n self.training = True",
"def train(self):\n self.training = True",
"def train(self, mode: bool = True):\n if self.nn_module.training != mode:\n self.nn_module.train(mode)",
... | [
"0.6975608",
"0.6717992",
"0.67168665",
"0.6564689",
"0.6497327",
"0.6497327",
"0.6356984",
"0.6347624",
"0.62881464",
"0.62857175",
"0.6089425",
"0.6061524",
"0.6053733",
"0.6053733",
"0.60506725",
"0.59250903",
"0.591193",
"0.5873809",
"0.58694804",
"0.5862343",
"0.58432263... | 0.61627144 | 10 |
Set this network in evaluation mode. After calling this method, all layers in network are in evaluation mode, in particular, BatchNorm, Dropout, etc. Examples >>> import tensorlayer as tl >>> net = tl.models.vgg16() >>> net.eval() do evaluation | def set_eval(self):
self._phase = 'predict'
self.add_flags_recursive(training=False)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_eval(self):\n\n if self.model.__dict__['training']:\n self.model.eval()",
"def eval(self):\n self.train(mode=False)",
"def set_eval(self, eval: bool):\n self.brain.set_eval(eval)",
"def eval(self):\n self.mode = \"eval\"\n self.online_net.eval()",
"def... | [
"0.78309643",
"0.75001425",
"0.74250203",
"0.7406579",
"0.7406579",
"0.73397756",
"0.7029367",
"0.6851151",
"0.67749524",
"0.6703862",
"0.6631509",
"0.6591249",
"0.6569461",
"0.6422038",
"0.637382",
"0.6329969",
"0.6329969",
"0.63081795",
"0.6305343",
"0.6291049",
"0.6288456"... | 0.6941809 | 7 |
Set this network in evaluation mode. | def test(self):
self.eval() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setEvaluationMode(self, newMode):\n \n pass",
"def set_eval(self, eval: bool):\n self.brain.set_eval(eval)",
"def _set_eval(self):\n\n if self.model.__dict__['training']:\n self.model.eval()",
"def set_mode(self, mode):\n if mode == 'train':\n self.net... | [
"0.7694437",
"0.7670649",
"0.7342549",
"0.7151897",
"0.7103393",
"0.7103393",
"0.70450133",
"0.70249236",
"0.7009851",
"0.7001831",
"0.691162",
"0.68425643",
"0.66861284",
"0.6543857",
"0.6487741",
"0.63806707",
"0.6322034",
"0.62210166",
"0.60879964",
"0.60867757",
"0.607585... | 0.0 | -1 |
Set this network in evaluation mode. | def infer(self):
self.eval() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setEvaluationMode(self, newMode):\n \n pass",
"def set_eval(self, eval: bool):\n self.brain.set_eval(eval)",
"def _set_eval(self):\n\n if self.model.__dict__['training']:\n self.model.eval()",
"def set_mode(self, mode):\n if mode == 'train':\n self.net... | [
"0.7694437",
"0.7670649",
"0.7342549",
"0.7151897",
"0.7103393",
"0.7103393",
"0.70450133",
"0.70249236",
"0.7009851",
"0.7001831",
"0.691162",
"0.68425643",
"0.66861284",
"0.6543857",
"0.6487741",
"0.63806707",
"0.6322034",
"0.62210166",
"0.60879964",
"0.60867757",
"0.607585... | 0.0 | -1 |
Returns all trainable weights. Returns a list of all trainable parmeters. | def trainable_weights(self):
self._trainable_weights = list(filter(lambda x: x.requires_grad, self.get_parameters(expand=True)))
return self._trainable_weights | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weights_lst(self):\n assert self.sess is not None, \"Model has not been fitted yet!\"\n return self.sess.run(self.W_lst)",
"def get_weights(self):\n return [self.W]",
"def get_weights(self):\n return [self.W]",
"def get_weights(self):\n return []",
"def get_weights(se... | [
"0.7333756",
"0.70962805",
"0.70962805",
"0.70862687",
"0.7070256",
"0.6915223",
"0.68708634",
"0.6868791",
"0.6868791",
"0.679045",
"0.679045",
"0.6756826",
"0.6756826",
"0.675156",
"0.673351",
"0.673351",
"0.673351",
"0.6731417",
"0.6691864",
"0.66902167",
"0.668324",
"0.... | 0.76837504 | 0 |
Returns all untrainable weights. Returns a list of all untrainable weights. | def nontrainable_weights(self):
return list(filter(lambda x: not x.requires_grad, self.get_parameters(expand=True))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_weights(self):\n return []",
"def trainable_weights(self):\n self._trainable_weights = list(filter(lambda x: x.requires_grad, self.get_parameters(expand=True)))\n return self._trainable_weights",
"def get_weights(self):\n return [self.W]",
"def get_weights(self):\n ... | [
"0.7384943",
"0.7170098",
"0.70482403",
"0.70482403",
"0.6928857",
"0.69194895",
"0.69194895",
"0.69194895",
"0.6848169",
"0.6782915",
"0.6730147",
"0.6730147",
"0.6730147",
"0.6663011",
"0.6663011",
"0.6640928",
"0.6623843",
"0.6623843",
"0.6608877",
"0.65747327",
"0.6571032... | 0.7795881 | 0 |
Indicate whether account registration is currently permitted, based on the value of the setting ``REGISTRATION_OPEN``. This | def registration_allowed(self, request):
return getattr(settings, 'REGISTRATION_OPEN', True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def registration_allowed(self):\n return getattr(settings, 'REGISTRATION_OPEN', True)",
"def registration_allowed(self):\n return getattr(settings, 'REGISTRATION_OPEN', True)",
"def is_registered(self):\n if self.user == getpass.getuser():\n return True\n else:\n ... | [
"0.8357122",
"0.8357122",
"0.65590364",
"0.6422705",
"0.63702977",
"0.6330357",
"0.61983466",
"0.60988814",
"0.60063547",
"0.6001445",
"0.6001445",
"0.6001445",
"0.5912449",
"0.59091336",
"0.59021175",
"0.59021175",
"0.59021175",
"0.58721966",
"0.5866057",
"0.5802698",
"0.579... | 0.8022301 | 2 |
Return the default form class used for user registration. | def get_form_class(self, request):
return RegistrationForm | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_form_class(self, request):\n return RegistrationForm",
"def get_form_class(self):\n return self.form_class",
"def get_form_class(self):\n if self.form_class:\n return self.form_class\n else:\n raise ImproperlyConfigured(\n \"在定义类视图%s的时候,你... | [
"0.7956627",
"0.770102",
"0.74282926",
"0.72233987",
"0.71631217",
"0.7097246",
"0.7082445",
"0.696311",
"0.692484",
"0.6767896",
"0.67418265",
"0.66456175",
"0.66020036",
"0.64767134",
"0.64665145",
"0.64210325",
"0.63494134",
"0.6314577",
"0.62687373",
"0.6240669",
"0.62336... | 0.8111784 | 0 |
Return the name of the URL to redirect to after successful user registration. | def post_registration_redirect(self, request, user):
return ('registration_complete', (), {}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_redirect_url(self):\n return reverse('accounts:home')",
"def create_redirect_url(self):\n return url_for(self.create_redirect_to_view)",
"def get_success_url(self):\n return reverse('account:details',\n kwargs={'username': self.request.user.username})",
"def... | [
"0.73379296",
"0.7324677",
"0.69434536",
"0.69189394",
"0.6870109",
"0.68566924",
"0.67954004",
"0.67184335",
"0.67070496",
"0.66305435",
"0.66210127",
"0.6547608",
"0.65307903",
"0.6493313",
"0.64655125",
"0.64655125",
"0.64608943",
"0.64608943",
"0.64532584",
"0.64532584",
... | 0.66944695 | 9 |
Return the name of the URL to redirect to after successful account activation. | def post_activation_redirect(self, request, user):
newMember = StaffMember.objects.filter(user_id__exact=user.pk).get()
labGroup = LabGroup.objects.filter(pk=1).get()
newMember.lab_group = labGroup
newMember.save()
return ('registration_activation_complete', (), {}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_redirect_url(self):\n return reverse('accounts:home')",
"def get_success_url(self):\n return reverse('account:details',\n kwargs={'username': self.request.user.username})",
"def get_redirect_url(self):\n return reverse(\"accounts:profile\",kwargs={\"username\"... | [
"0.7594355",
"0.74765575",
"0.6963185",
"0.695647",
"0.694857",
"0.69257337",
"0.689037",
"0.6835599",
"0.6769089",
"0.66786706",
"0.66693467",
"0.6649202",
"0.6619501",
"0.6595316",
"0.6586077",
"0.6558655",
"0.65566254",
"0.65478855",
"0.65478855",
"0.6544256",
"0.6531706",... | 0.0 | -1 |
Add a new user location to the system | def add_location(location): # noqa: E501
if connexion.request.is_json:
location = Location.from_dict(connexion.request.get_json()) # noqa: E501
db = PostgresDB()
error = db.insert_new_location(location.location)
if error:
return jsonify(msg=error)
return jsonify(msg='Human detected... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_location():\n\n if not g.user:\n flash(\"Please login to access\", \"danger\")\n return redirect(\"/\")\n \n if g.user.is_admin == False:\n flash (\"Unauthorized\", \"danger\")\n return redirect(\"/login\")\n \n form = Location_Form()\n\n if form.validate_on_su... | [
"0.67645496",
"0.6588918",
"0.6556488",
"0.6494251",
"0.6454458",
"0.64176095",
"0.6245872",
"0.61988354",
"0.61489385",
"0.61150897",
"0.60815144",
"0.59883666",
"0.59883666",
"0.59883666",
"0.59883666",
"0.59883666",
"0.59883666",
"0.59883666",
"0.59876204",
"0.59050107",
"... | 0.62180394 | 7 |
Get a historic of locations | def get_historic_location(): # noqa: E501
db = PostgresDB()
historial = db.get_locations()
if "Error" in historial:
return jsonify(msg=historial)
if len(historial) > 0:
data = {"historial" : []}
for row in historial:
data['historial'].append(
{
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def historic(self) -> dict:\n return await self._request(\n \"get\", \"https://www.asthmaforecast.com/api/forecast/historic/asthma\"\n )",
"def get_historic_data(self):\n\n historic_market_events = []\n\n return historic_market_events",
"def History(self):\n retu... | [
"0.64075005",
"0.6306349",
"0.61227405",
"0.60741436",
"0.5974619",
"0.5956443",
"0.59440225",
"0.5868649",
"0.58360744",
"0.5833078",
"0.5829477",
"0.5814553",
"0.5808685",
"0.5795159",
"0.5782138",
"0.57627606",
"0.5699749",
"0.568246",
"0.5676575",
"0.5676575",
"0.56725854... | 0.77446115 | 0 |
Convert from keras to tf | def keras_to_tensorflow(
keras_model,
output_dir: Path,
model_name,
out_prefix="output_",
log_tensorboard=True,
):
if not output_dir.exists():
output_dir.mkdir(parents=True, exist_ok=True)
output_dir: str = str(output_dir)
out_nodes = []
for i in range(len(keras_model.outpu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert(self, example):\n tf_example = _convert_to_tf_example(example, self.tokenizer, self.rules,\n self.config, self.max_sizes)\n return tf_example",
"def convert_to_tf_record(_):\n\n mnist = input_data.read_data_sets(\n \"/tmp/tensorflow/mnist/input_d... | [
"0.6639992",
"0.6630255",
"0.6283206",
"0.6280251",
"0.6261455",
"0.61814857",
"0.61665124",
"0.6141866",
"0.6130877",
"0.6106019",
"0.60859215",
"0.60848236",
"0.6076101",
"0.60558754",
"0.60113984",
"0.6006671",
"0.59937596",
"0.59848094",
"0.5983833",
"0.5973008",
"0.59620... | 0.67439127 | 0 |
Returns a new keras SqueezeNet model | def SqueezeNet(input_shape=(224, 224, 3)):
image_input = Input(shape=input_shape)
network = Conv2D(64, (3, 3), strides=(2, 2), padding="valid")(image_input)
network = Activation("relu")(network)
network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network)
network = squeezenet_fire_module(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_original_model():\n model = Sequential()\n model.add(Embedding(max_features,\n embedding_dims,\n input_length=maxlen))\n model.add(Dropout(0.2))\n model.add(Conv1D(filters,\n kernel_size,\n padding='valid',... | [
"0.6779109",
"0.6638269",
"0.66308945",
"0.6543631",
"0.65331703",
"0.6512372",
"0.65106356",
"0.6495543",
"0.64914733",
"0.6490912",
"0.6468552",
"0.6449092",
"0.64283264",
"0.64260525",
"0.64073676",
"0.6404156",
"0.64011025",
"0.63759005",
"0.6370142",
"0.6355601",
"0.6339... | 0.66259646 | 3 |
Convert a model from keras to tensorflow lite. | def main(opt):
weights_path: Path = Path("../weights")
model_path = weights_path / opt.model_path
if not model_path.exists():
raise ValueError(f"Invalid model path: {model_path}")
print(f"Loading keras model: '{model_path}'")
keras_model = SqueezeNet()
keras_model.load_weights(model_pat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gensim_to_keras(model):\n layer = model.wv.get_keras_embedding()\n return (layer)",
"def convert_from_keras_model(\n model,\n output_dir='my-hls-test',\n project_name='myproject',\n input_data_tb=None,\n output_data_tb=None,\n backend='Vivado',\n hls_config=None,\n **kwargs,\n):... | [
"0.6945519",
"0.69119895",
"0.67486066",
"0.6652685",
"0.6608672",
"0.66009986",
"0.6539233",
"0.65300494",
"0.6507346",
"0.6503937",
"0.63850594",
"0.6307801",
"0.62692785",
"0.6261237",
"0.6259688",
"0.62363434",
"0.62114567",
"0.62083393",
"0.61811054",
"0.6177432",
"0.615... | 0.0 | -1 |
returns a,b where a <= b | def calcualte_ellipse_radii(guess, eccentricity = 0, perimeter = 2 * np.pi*1):
return fsolve(ellipse_radii_test, guess, args = (eccentricity, perimeter)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_inclusive(a, b):\n c = int(b > a)*2-1\n return range(a, b+c, c)",
"def in_range(x, a, b):\n return (x >= a and x <= b) or (x <= a and x >= b)",
"def inrange ( a , x , b ) :\n _a = float(a)\n _b = float(b)\n _x = float(x)\n return ( _a <= _x or isequal ( _a , _x ) ) and ( _x <= ... | [
"0.7141207",
"0.6981709",
"0.6854545",
"0.67296296",
"0.658509",
"0.64805",
"0.641424",
"0.6400484",
"0.63955367",
"0.6359278",
"0.63141984",
"0.6286686",
"0.6239231",
"0.62344867",
"0.61758864",
"0.61594373",
"0.61306363",
"0.6129907",
"0.6094695",
"0.6094206",
"0.607342",
... | 0.0 | -1 |
The returned tuple should be zero | def ellipse_radii_test(radii, eccentricity = 0, perimeter = 2*np.pi*1):
a,b = radii
return (np.sqrt(np.absolute(1 - (b**2)/(a**2))) - eccentricity,
# perimeter approximation from https://www.mathsisfun.com/geometry/ellipse-perimeter.html
np.pi * (3 * (a + b) - np.sqrt(np.absolute((3 * a ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self) -> tuple:",
"def filtered_xyz(self) -> tuple[int, int, int]:",
"def retrieve_data_tuple(self):\n return ((42,))",
"def empty_tuple():\n empty = ()\n print(type(empty)) # <type 'tuple'>",
"def calibration(self) -> tuple[int, int, int, int, int]:",
"def answer(self):\n\n r... | [
"0.6652293",
"0.6397256",
"0.6196077",
"0.6129998",
"0.6127603",
"0.6054833",
"0.58035886",
"0.5797779",
"0.5754019",
"0.574967",
"0.57462484",
"0.5733556",
"0.57165074",
"0.5707046",
"0.5702668",
"0.5702668",
"0.56937104",
"0.56858724",
"0.56741434",
"0.56697756",
"0.5638495... | 0.0 | -1 |
Currently only works for ellipse centered on origin the points are drawn from the +ve x axis in the order of the quardrants | def get_points_on_ellipse(a, b, numPoints, startAngle = 0, verbose = False, increment = 0.01):
def distance(x1,y1,x2,y2):
return np.sqrt((x2-x1)**2 + (y2-y1)**2)
x0 = a
y0 = 0
angle = 0
d = 0
while(angle <= 360):
x = a * np.cos(np.radians(angle))
y = b * np.sin(np.radians... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ellipse(self):\n f = self.img\n x = self.x\n y = self.y\n x2 = self.x2\n y2 = self.y2\n xy = self.xy\n self.a2 = (x2+y2) + sqrt(((x2-y2)/2.)**2 + xy**2)\n self.b2 = (x2+y2) - sqrt(((x2-y2)/2.)**2 + xy**2)\n self.a = sqrt(self.a2)\n self.b = sqrt(self.... | [
"0.64417464",
"0.6421503",
"0.6344339",
"0.6330868",
"0.62400186",
"0.6224325",
"0.62029326",
"0.616415",
"0.610634",
"0.60904914",
"0.6083488",
"0.6008982",
"0.5992977",
"0.59813225",
"0.59795386",
"0.59648114",
"0.596078",
"0.59202594",
"0.5856401",
"0.5848941",
"0.5840281"... | 0.61181104 | 8 |
this method is used in the scraper to return the last updated station. this lets us pull only updated data. | def last_updated(self):
try:
return max(self.station_usage, key=lambda x: x.last_update).dt_last_update
except ValueError:
return datetime.fromtimestamp(0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n _LOGGER.debug(\"------- Updating AEMET sensor\")\n\n endpoint_url = \"{}{}\".format(\n self.API_URL_BASE,\n self.API_STATION_ENDPOINT.format(self._station_id)\n )\n params = {'api_key': self._api_k... | [
"0.6880449",
"0.66213137",
"0.65706927",
"0.64415693",
"0.6376864",
"0.6356469",
"0.63331",
"0.6162094",
"0.6155076",
"0.6130627",
"0.61070186",
"0.6050127",
"0.6050127",
"0.60353684",
"0.60135305",
"0.598416",
"0.5949982",
"0.59141076",
"0.587603",
"0.5870146",
"0.5856976",
... | 0.6447243 | 3 |
as the method name suggests this returns the up to date station information. | def get_current_station_info(cls, dbsession):
sub = dbsession.query(UsageData.station_id, func.max(UsageData.id).label('max_update')).group_by(
UsageData.station_id).subquery()
return dbsession.query(
UsageData.last_update,
UsageData.available_bike_stands, UsageData.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_station_boroughs(self):\\",
"def show_info(self):\n\n print(\"Querying the station...\")\n val = getvalues(self.station, '', fixed_format)\n\n print('Fine Offset station settings:')\n print('%s: %s' % ('local time'.rjust(30),\n time.strftime('%Y.%m.%d ... | [
"0.66889495",
"0.6452908",
"0.62583035",
"0.62394136",
"0.619208",
"0.6112521",
"0.60889035",
"0.6042705",
"0.6017993",
"0.5981389",
"0.59698784",
"0.5953793",
"0.59492654",
"0.591016",
"0.59028894",
"0.589664",
"0.58665407",
"0.5864966",
"0.58616376",
"0.5854664",
"0.5849501... | 0.71660936 | 0 |
return when was the last update. Once again this is used in the scraper to determine newly updated data. | def dt_last_update(self):
return self.last_update | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def last_update(self):\n return self._last_update",
"def last_update(self):\n return self._last_update",
"def last_updated(self):\n return self._last_updated",
"def updated_on(self):\n return self.get_time(\"updated_on\")",
"def last_update_time(self):\n return self._last... | [
"0.8410479",
"0.8410479",
"0.8173209",
"0.8136815",
"0.8069375",
"0.79213256",
"0.7860239",
"0.78425276",
"0.77858883",
"0.7742599",
"0.7720309",
"0.7720309",
"0.76988846",
"0.7695073",
"0.76872325",
"0.7657064",
"0.7653909",
"0.7651964",
"0.7573087",
"0.7570922",
"0.7544852"... | 0.8191779 | 2 |
creates a datetime object which is added to the database with an update from the dublinbikes api. once again used by the scraper. essentially the adds the time at which the update was entered. | def dt_last_update(self, val):
self.last_update = datetime.fromtimestamp(int(val)/1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def last_update(self):\n date, time = self.data.get(\"update_date\"), self.data.get(\"update_time\")\n if date is not None and time is not None:\n return datetime.strptime(date + time, \"%d-%m-%Y%H:%M\").replace(\n tzinfo=VIENNA_TIME_ZONE\n )",
"def test_save_2_... | [
"0.6314246",
"0.6284306",
"0.622363",
"0.6131683",
"0.6062952",
"0.6007324",
"0.59122413",
"0.5867222",
"0.58476716",
"0.5812767",
"0.5742817",
"0.5728761",
"0.5703045",
"0.56967443",
"0.56705844",
"0.56597465",
"0.5653817",
"0.56500095",
"0.56480604",
"0.56480604",
"0.564188... | 0.5992166 | 6 |
returns a list of bikes for a provided weekday and station. averaged per hour so 24 results. | def get_bikes_for_weekday(cls, dbsession, weekday, station_id):
station = [("Time", "Available Bikes", "Available Stands")]
station_data = dbsession.query(func.hour(cls.last_update),
func.avg(cls.available_bikes),
func.avg(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bikes_for_week(cls, dbsession, station_id):\n station = [(\"Day\", \"Available Bikes\")]\n station_data = dbsession.query(func.weekday(cls.last_update),\n func.avg(cls.available_bikes)) \\\n .filter(cls.station_id == station_id) \\\n ... | [
"0.77892643",
"0.71780616",
"0.69516826",
"0.67270637",
"0.6636598",
"0.6216508",
"0.59292334",
"0.56938154",
"0.5609472",
"0.554261",
"0.55170375",
"0.5512873",
"0.546571",
"0.53780615",
"0.53184694",
"0.5302574",
"0.52739406",
"0.52701545",
"0.52644885",
"0.5257001",
"0.525... | 0.84364945 | 0 |
as method name describes. similar to methods above but averaged over week. | def get_bikes_for_week(cls, dbsession, station_id):
station = [("Day", "Available Bikes")]
station_data = dbsession.query(func.weekday(cls.last_update),
func.avg(cls.available_bikes)) \
.filter(cls.station_id == station_id) \
.group_by(func.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weekly():",
"def averageTime(self):\n \n pass",
"def forecast_weekly():\n forecast = get_forecast()\n daily = forecast.daily()\n return daily.summary",
"def mean_by_airline_dow(flights):\n\n return ...",
"def return_weekly_figure():\n today = datetime.datetime.now()\n\n whil... | [
"0.7532469",
"0.6411122",
"0.61803746",
"0.6157488",
"0.6108338",
"0.60862935",
"0.6068665",
"0.5999342",
"0.59047836",
"0.5893497",
"0.58837366",
"0.58724874",
"0.5833644",
"0.5821823",
"0.5818497",
"0.5785093",
"0.5764682",
"0.5736772",
"0.57038623",
"0.5698677",
"0.5676207... | 0.0 | -1 |
finds days where there was wet weather. | def findWetWeatherDays(self, dbsession, today):
wetDays = dbsession.query(self.dt).filter(or_(self.weather_description == "light rain", self.weather_description == "moderate rain")).all()
# if one of those days is today return it.
# else just return a wet day.
for i in range(len(wetDays)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_typical_days(weather_data, cfg):\n settings = cfg['settings']\n # Flag to determine if any holidays have been found:\n interpolation_freq = pd.Timedelta(settings['intervall'])\n flag_holidays_found = False\n\n # --- Season --------------------------------------------------------------\n #... | [
"0.6345522",
"0.62267625",
"0.620805",
"0.6172952",
"0.6154723",
"0.6078286",
"0.59555215",
"0.5860357",
"0.5847305",
"0.5832294",
"0.5819031",
"0.5799269",
"0.5799269",
"0.57958776",
"0.5793687",
"0.57477695",
"0.57152104",
"0.570199",
"0.57016325",
"0.5699181",
"0.5681354",... | 0.7885582 | 0 |
Calling openChannel() with various wrong arguments | def test_open_channel_call(token_network: Contract, get_accounts: Callable) -> None:
(A, B) = get_accounts(2)
# Validation failure with the number zero instead of an address
with pytest.raises(ValidationError):
token_network.functions.openChannel(0x0, B)
# Validation failure with the empty str... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_open_via_channel(testchannel, callit):\n\n channel = testchannel.channel() if callit else testchannel.channel\n\n with channel as t:\n assert t.state == ChannelState.open\n\n assert testchannel.state == ChannelState.closed",
"def channel_open(self):\n self._chan = self._session.in... | [
"0.66451424",
"0.6250406",
"0.6153946",
"0.61513305",
"0.61273223",
"0.57756436",
"0.5759044",
"0.5668032",
"0.5634415",
"0.5631686",
"0.5622906",
"0.5616735",
"0.5573923",
"0.55352193",
"0.5531159",
"0.55040747",
"0.5495176",
"0.5488037",
"0.54677826",
"0.54428947",
"0.54259... | 0.5625717 | 10 |
For two participants, at most one channel can be opened | def test_max_1_channel(
token_network: Contract, get_accounts: Callable, create_channel: Callable
) -> None:
(A, B) = get_accounts(2)
create_channel(A, B)
with pytest.raises(TransactionFailed, match="TN/open: channel exists for participants"):
token_network.functions.openChannel(A, B).call()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def single_channel():\n return True",
"def have_channel_open(channels, user):\n for x in channels:\n chan = channels[x]\n if 'is_member' in chan:\n continue\n if \"user\" in chan and chan['user'] == user:\n return True\n return False",
"def have_chann... | [
"0.68654567",
"0.6490941",
"0.6464989",
"0.63985145",
"0.6327629",
"0.6311468",
"0.6309975",
"0.6291697",
"0.6276977",
"0.62615794",
"0.6125024",
"0.6120147",
"0.60907483",
"0.6057845",
"0.6023134",
"0.59909755",
"0.5980023",
"0.5967421",
"0.5960192",
"0.5923796",
"0.59115165... | 0.6518068 | 1 |
getParticipantsHash() behaves as get_participants_hash | def test_participants_hash(token_network: Contract, get_accounts: Callable) -> None:
(A, B) = get_accounts(2)
AB_hash = get_participants_hash(A, B)
assert token_network.functions.getParticipantsHash(A, B).call() == AB_hash
assert token_network.functions.getParticipantsHash(B, A).call() == AB_hash | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_hash(self, composition):\n return",
"def __hash__(self):\n return hash((self.member_role, self.member_type, self.member_email))",
"def get_hash(self):\r\n return",
"def get_hash(self):\n return freeze_dict(self.get_hash_params())",
"def get_hash(self):\n return self._... | [
"0.63765395",
"0.63318187",
"0.6321352",
"0.6252258",
"0.6228718",
"0.6136036",
"0.613001",
"0.61032784",
"0.6090188",
"0.60368407",
"0.59734964",
"0.5966896",
"0.5864445",
"0.58352035",
"0.58331984",
"0.5813834",
"0.57882416",
"0.57848483",
"0.57782173",
"0.5753588",
"0.5749... | 0.7115849 | 0 |
getParticipantsHash() behaves as get_participants_hash on equal addresses | def test_participants_hash_equal(token_network: Contract, get_accounts: Callable) -> None:
(A,) = get_accounts(1)
with pytest.raises(ValueError):
get_participants_hash(A, A)
with pytest.raises(TransactionFailed, match="TN: identical addresses"):
token_network.functions.getParticipantsHash(A... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_participants_hash(token_network: Contract, get_accounts: Callable) -> None:\n (A, B) = get_accounts(2)\n\n AB_hash = get_participants_hash(A, B)\n assert token_network.functions.getParticipantsHash(A, B).call() == AB_hash\n assert token_network.functions.getParticipantsHash(B, A).call() == AB_... | [
"0.70927805",
"0.6258063",
"0.6066081",
"0.6022483",
"0.59809077",
"0.5974033",
"0.5940762",
"0.5915285",
"0.5876238",
"0.58748066",
"0.5854341",
"0.5794211",
"0.57636255",
"0.57451165",
"0.57385176",
"0.5730055",
"0.5713905",
"0.5703602",
"0.5702778",
"0.56973827",
"0.569604... | 0.6733924 | 1 |
Open three channels and observe states | def test_counter(
token_network: Contract, get_accounts: Callable, create_channel: Callable
) -> None:
(A, B, C, D) = get_accounts(4)
AB_hash = token_network.functions.getParticipantsHash(A, B).call()
BC_hash = token_network.functions.getParticipantsHash(B, C).call()
CD_hash = token_network.functio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_switch_channels(self):\n\t\t# not available yet, experimental\n\t\tpass",
"def setup_channels():\n\n # Setup channel encoders\n for c in channels:\n channels[c].setup()\n print()",
"def setup(self, channels):\n self.channels = channels[:]",
"def test_open_state(testchannel):\n... | [
"0.5793696",
"0.5630462",
"0.5624394",
"0.5620674",
"0.55608547",
"0.5529064",
"0.5342438",
"0.5337173",
"0.52379125",
"0.51599574",
"0.51407015",
"0.5138206",
"0.513631",
"0.51333195",
"0.51088315",
"0.50961053",
"0.508256",
"0.50556326",
"0.504091",
"0.5036432",
"0.5026253"... | 0.0 | -1 |
getChannelState() returns the empty channel state for onttoobig channelID | def test_state_channel_identifier_invalid(
token_network: Contract, get_accounts: Callable, create_channel: Callable
) -> None:
(A, B, C) = get_accounts(3)
channel_id = 0
pairs = permutations([A, B, C], 2)
for pair in pairs:
state = token_network.functions.getChannelState(channel_id, *pair)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_none2(self, channel):\n pass",
"def is_open(self, channel=None):\n return self.get_state(channel)",
"def test_open_state(testchannel):\n\n with testchannel.open() as t:\n assert t.state == ChannelState.open\n\n assert testchannel.state == ChannelState.closed",
"def __getsta... | [
"0.61654663",
"0.5896519",
"0.586283",
"0.57887614",
"0.55998313",
"0.5566425",
"0.55561423",
"0.55363715",
"0.550702",
"0.5485005",
"0.54813683",
"0.5425511",
"0.5421768",
"0.5409737",
"0.54013985",
"0.5372156",
"0.536304",
"0.5345527",
"0.53410935",
"0.5324677",
"0.53205526... | 0.53508157 | 17 |
Observe the state of the channel after a openChannel() call | def test_open_channel_state(token_network: Contract, get_accounts: Callable) -> None:
(A, B) = get_accounts(2)
channel_counter = token_network.functions.channel_counter().call()
participants_hash = token_network.functions.getParticipantsHash(A, B).call()
assert (
token_network.functions.partic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def channel_connected(self):\n self.update_status()",
"def channel(self):\n\n self._channel = self._connection.channel()\n print(\"Channel opened...\")",
"def on_channel_open(self, channel):\n self.logger.info('Channel opened')\n self._channel = channel\n self.add_on_c... | [
"0.7205853",
"0.71653926",
"0.6919226",
"0.69056886",
"0.6886432",
"0.6766391",
"0.6646003",
"0.6632794",
"0.6582453",
"0.6503419",
"0.639545",
"0.6375993",
"0.63722664",
"0.6370337",
"0.6332137",
"0.6310028",
"0.6302871",
"0.628356",
"0.6197925",
"0.61534774",
"0.6099827",
... | 0.0 | -1 |
Open a second channel after settling one | def test_reopen_channel(
token_network: Contract,
get_accounts: Callable,
create_close_signature_for_no_balance_proof: Callable,
time_travel: Callable,
get_block_timestamp: Callable,
) -> None:
(A, B) = get_accounts(2)
call_and_transact(token_network.functions.openChannel(A, B))
channel_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_channel(self):\n # LOGGER.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_task_open)\n self._connection.channel(on_open_callback=self.on_channel_ctrl_open)",
"def channel_open(self):\n self._chan = self._session.invoke_shell()",
"d... | [
"0.71482056",
"0.71042883",
"0.6652178",
"0.6647473",
"0.6591444",
"0.6469845",
"0.64180195",
"0.6370166",
"0.6346812",
"0.63326895",
"0.6309731",
"0.6277799",
"0.6268313",
"0.61745846",
"0.6156467",
"0.61109924",
"0.6065597",
"0.6009683",
"0.59848595",
"0.597528",
"0.5909403... | 0.0 | -1 |
A successful openChannel() causes an OPENED event | def test_open_channel_event(
get_accounts: Callable, token_network: Contract, event_handler: Callable
) -> None:
ev_handler = event_handler(token_network)
(A, B) = get_accounts(2)
txn_hash = call_and_transact(token_network.functions.openChannel(A, B))
channel_identifier = token_network.functions.ge... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _on_channel_open(self, channel_id: str) -> None:\n self._send_alive(channel_id)",
"def open_channel(self):\n # LOGGER.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_task_open)\n self._connection.channel(on_open_callback=self.on_channel_c... | [
"0.73577046",
"0.7354011",
"0.729137",
"0.72610146",
"0.7230036",
"0.71792716",
"0.717188",
"0.71689665",
"0.7120604",
"0.7002149",
"0.69875485",
"0.6979207",
"0.6953193",
"0.6920781",
"0.6873996",
"0.68318856",
"0.6830546",
"0.68283147",
"0.6792365",
"0.67258024",
"0.6709773... | 0.6202603 | 33 |
Initializes the upper and lower pmos | def add_ptx(self):
self.pmos = ptx(width=self.ptx_width,
tx_type="pmos")
self.add_mod(self.pmos) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n self.upper = 230.0\n self.lower = 195.0",
"def __init__(self, upper_left, lower_right):\n self.upper_left = upper_left\n self.lower_right = lower_right",
"def __init__(self):\n\t\tself.upper, self.lower = 0,0\n\t\tself.timestamp = 0",
"def __init__(self):\n ... | [
"0.6813188",
"0.6626031",
"0.63374364",
"0.60283935",
"0.60178435",
"0.594762",
"0.5900908",
"0.57963645",
"0.57945627",
"0.5754933",
"0.57467234",
"0.5743787",
"0.5730844",
"0.5700219",
"0.56684303",
"0.5618184",
"0.56096613",
"0.56016254",
"0.55860263",
"0.55860263",
"0.558... | 0.0 | -1 |
Adds a vdd rail at the top of the cell | def route_vdd_rail(self):
# adds the rail across the width of the cell
vdd_position = vector(0, self.height - self.m1_width)
self.add_rect(layer="metal1",
offset=vdd_position,
width=self.width,
height=self.m1_width)
pmos_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_border(self):\n top = TopWallCell(self)\n left = SideWallCell(self, False)\n right = SideWallCell(self, True)\n for col in range(self._columns):\n self.cell_at(col, self._rows - 1, top)\n for row in range(self._rows):\n self.cell_at(0, row, left)\n ... | [
"0.5719361",
"0.54055804",
"0.5304635",
"0.53003937",
"0.52842367",
"0.5275856",
"0.5258827",
"0.5232115",
"0.51538235",
"0.51155037",
"0.50955796",
"0.5081745",
"0.506918",
"0.5068402",
"0.50647056",
"0.50580543",
"0.5054077",
"0.50488394",
"0.50478745",
"0.49961856",
"0.494... | 0.6683286 | 0 |
Create both the upper_pmos and lower_pmos to the module | def create_ptx(self):
self.lower_pmos_inst=self.add_inst(name="lower_pmos",
mod=self.pmos)
self.connect_inst(["bl", "en", "br", "vdd"])
self.upper_pmos1_inst=self.add_inst(name="upper_pmos1",
mod=self.pmos)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_modules(self):\n self.nmos = ptx(width=self.nmos_size,\n mults=self.nmos_mults,\n tx_type=\"nmos\")\n self.add_mod(self.nmos)\n\n self.pmos = ptx(width=self.pmos_size,\n mults=self.pmos_mults,\n ... | [
"0.62417173",
"0.5595662",
"0.5592487",
"0.5253398",
"0.5209395",
"0.5176703",
"0.5076419",
"0.5046861",
"0.50380796",
"0.49966943",
"0.4981465",
"0.49621493",
"0.49106213",
"0.49073905",
"0.49046108",
"0.48944435",
"0.48900783",
"0.48836777",
"0.4832847",
"0.48023075",
"0.47... | 0.626209 | 0 |
Place both the upper_pmos and lower_pmos to the module | def place_ptx(self):
# Compute the other pmos2 location, but determining offset to overlap the
# source and drain pins
self.overlap_offset = self.pmos.get_pin("D").ll() - self.pmos.get_pin("S").ll()
# adds the lower pmos to layout
#base = vector(self.width - 2*self.pmos... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modules():",
"def create_modules(self):\n self.nmos = ptx(width=self.nmos_size,\n mults=self.nmos_mults,\n tx_type=\"nmos\")\n self.add_mod(self.nmos)\n\n self.pmos = ptx(width=self.pmos_size,\n mults=self.pmos_mults,\n... | [
"0.5711919",
"0.56773573",
"0.5484845",
"0.5373545",
"0.5269169",
"0.5117529",
"0.503132",
"0.5020452",
"0.49931383",
"0.49220088",
"0.49029332",
"0.4861574",
"0.47709423",
"0.4747098",
"0.47383958",
"0.47374594",
"0.47188666",
"0.47152808",
"0.4713286",
"0.4705685",
"0.47054... | 0.58079857 | 0 |
Connects the upper and lower pmos together | def connect_poly(self):
offset = self.lower_pmos_inst.get_pin("G").ll()
# connects the top and bottom pmos' gates together
ylength = self.upper_pmos1_inst.get_pin("G").ll().y - offset.y
self.add_rect(layer="poly",
offset=offset,
width=self.pol... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect_poly(self):\n # connect pmos1 poly\n nmos_gate = (self.nmos_position1 \n + self.nmos.poly_positions[0]\n + vector(0.5 * drc[\"minwidth_poly\"], 0))\n for i in range(len(self.pmos.poly_positions)):\n pmos_gate = (self.pmos_position1... | [
"0.5922714",
"0.5896698",
"0.5664321",
"0.5499741",
"0.54175603",
"0.53472805",
"0.5343195",
"0.5323919",
"0.5288541",
"0.5283576",
"0.5264222",
"0.5234746",
"0.5233384",
"0.5213443",
"0.5183542",
"0.5177952",
"0.51564336",
"0.515582",
"0.51377267",
"0.5134331",
"0.50970364",... | 0.6478284 | 0 |
Adds the en input rail, en contact/vias, and connects to the pmos | def route_en(self):
# adds the en contact to connect the gates to the en rail on metal1
offset = self.lower_pmos_inst.get_pin("G").ul() + vector(0,0.5*self.poly_space)
self.add_contact_center(layers=("poly", "contact", "metal1"),
offset=offset,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_connections(self):\n\t\t# Lorsque l'on choisi une devise dans la cbb\n\t\tself.cbb_devisesFrom.activated.connect(self.compute)\n\t\tself.cbb_devisesTo.activated.connect(self.compute)\n\t\t# Lorsque l'on change le montant dans la spn\n\t\tself.spn_montant.valueChanged.connect(self.compute)\n\t\tself.spn_m... | [
"0.56937957",
"0.5588377",
"0.5364039",
"0.53394985",
"0.53394985",
"0.5271092",
"0.5241046",
"0.5142711",
"0.5137675",
"0.512801",
"0.5114251",
"0.5101308",
"0.5082479",
"0.50810903",
"0.50637263",
"0.5054848",
"0.50368226",
"0.50169",
"0.50132143",
"0.5012345",
"0.49996084"... | 0.5722017 | 0 |
Adds a nwell tap to connect to the vdd rail | def place_nwell_and_contact(self):
# adds the contact from active to metal1
well_contact_pos = self.upper_pmos1_inst.get_pin("D").center().scale(1,0) \
+ vector(0, self.upper_pmos1_inst.uy() + contact.well.height/2 + drc["well_extend_active"])
self.add_contact_center(l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_bilink(self, nodeport_a, nodeport_b, bilink):",
"def port_nic_add(switch, port, node, nic):\n client.port.connect_nic(switch, port, node, nic)",
"def add_road(ccTremb):\n pass",
"def connect(self, kern):\n self.driver = Board(kern)\n self.print_log(1, \"CONNECTION SUCCESSFUL\")",
... | [
"0.5762853",
"0.546645",
"0.5400702",
"0.5365223",
"0.53347313",
"0.5312553",
"0.5271529",
"0.52679247",
"0.5259497",
"0.5243317",
"0.5153511",
"0.51240474",
"0.5117145",
"0.5093661",
"0.50626403",
"0.5029237",
"0.5029237",
"0.50022084",
"0.50006396",
"0.4997442",
"0.4988631"... | 0.0 | -1 |
Adds both bitline and bitlinebar to the module | def route_bitlines(self):
# adds the BL on metal 2
offset = vector(self.bitcell.get_pin(self.bitcell_bl).cx(),0) - vector(0.5 * self.m2_width,0)
self.add_layout_pin(text="bl",
layer="metal2",
offset=offset,
width... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addToolBarButtons(self):",
"def addBarrelBlue(self, event):\n # let user draw second ROI\n ROI = RoiPoly(color='b') #let user draw ROI\n plt.show(block=False)\n mask = ROI.get_mask(self.greyimg)\n self.ROI += mask",
"def add_modules(self):\n # This is the threshold... | [
"0.5931237",
"0.56883824",
"0.5411799",
"0.5363328",
"0.523951",
"0.5219392",
"0.52153605",
"0.52136797",
"0.5135922",
"0.50847983",
"0.5036947",
"0.50350106",
"0.5027019",
"0.5021388",
"0.5010233",
"0.4987663",
"0.49871254",
"0.49766114",
"0.49440458",
"0.49363413",
"0.48943... | 0.61381006 | 0 |
Adds contacts/via from metal1 to metal2 for bitlines | def add_bitline_contacts(self):
stack=("metal1", "via1", "metal2")
pos = self.lower_pmos_inst.get_pin("S").center()
self.add_contact_center(layers=stack,
offset=pos)
pos = self.lower_pmos_inst.get_pin("D").center()
self.add_contact_center(layers=s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def route_bitlines(self):\n # adds the BL on metal 2\n offset = vector(self.bitcell.get_pin(self.bitcell_bl).cx(),0) - vector(0.5 * self.m2_width,0)\n self.add_layout_pin(text=\"bl\",\n layer=\"metal2\",\n offset=offset,\n ... | [
"0.693796",
"0.67024845",
"0.61300176",
"0.5741309",
"0.5715331",
"0.5709275",
"0.56884384",
"0.55448365",
"0.5517545",
"0.54770654",
"0.54025584",
"0.5344132",
"0.5279721",
"0.52553105",
"0.5248629",
"0.5226081",
"0.5191582",
"0.51813334",
"0.5166011",
"0.5162329",
"0.516208... | 0.73841476 | 0 |
Connect pmos pin to bitline pin | def connect_pmos(self, pmos_pin, bit_pin):
ll_pos = vector(min(pmos_pin.lx(),bit_pin.lx()), pmos_pin.by())
ur_pos = vector(max(pmos_pin.rx(),bit_pin.rx()), pmos_pin.uy())
width = ur_pos.x-ll_pos.x
height = ur_pos.y-ll_pos.y
self.add_rect(layer="metal2",
of... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_pins(self):\n\n for bit in range(self.addr_size):\n self.add_pin(\"addr_{0}\".format(bit),\"INPUT\")\n \n self.add_pin(\"wl_en\", \"INPUT\")\n\n for bit in range(self.num_rows):\n self.add_pin(\"wl_{0}\".format(bit),\"OUTPUT\")\n \n self.add_p... | [
"0.6256124",
"0.6165595",
"0.6141988",
"0.61245584",
"0.612056",
"0.61114496",
"0.60696626",
"0.6058473",
"0.60407984",
"0.60359067",
"0.5940562",
"0.5879642",
"0.5822711",
"0.58177835",
"0.5814207",
"0.57660544",
"0.5757099",
"0.5755097",
"0.5746251",
"0.5702823",
"0.5679750... | 0.74909616 | 0 |
Sort a list using the insertion sort | def insertion_sort(my_list):
# Start at the second element (pos 1).
# Use this element to insert into the
# list.
for key_pos in range(1, len(my_list)): # n
# Get the value of the element to insert
key_value = my_list[key_pos]
# Scan from right to the left (start of list)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insertionSort(list):",
"def insertion_sort(a_list):\n\n i = 0\n while i < len(a_list):\n current = a_list[i]\n j = i\n while j > 0 and a_list[j - 1] > current:\n a_list[j] = a_list[j - 1]\n j -= 1\n a_list[j] = current\n i += 1\n return a_list... | [
"0.9294735",
"0.84433293",
"0.8433886",
"0.8369417",
"0.83684015",
"0.8341289",
"0.8337272",
"0.82814753",
"0.8255657",
"0.82203144",
"0.817608",
"0.8162831",
"0.80360997",
"0.7981972",
"0.797846",
"0.7969085",
"0.79533505",
"0.78883386",
"0.7884372",
"0.7877078",
"0.78731656... | 0.7946972 | 17 |
Custom shared utility setup for tests. | def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.installer = api.portal.get_tool('portal_quickinstaller')
self.view = api.content.get_view(
name="search", context=self.portal, request=self.request
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n # After stage1:\n # TODO: use this form after implementing a fixer to consolidate\n # __future__ imports into a single line:\n # self.headers1 = \"\"\"\n # from __future__ import absolute_import, division, print_function\n # \"\"\"\n self.he... | [
"0.70489055",
"0.69983375",
"0.69934666",
"0.6938551",
"0.6886009",
"0.6853525",
"0.6848782",
"0.6848782",
"0.6814673",
"0.6778472",
"0.67625844",
"0.6757128",
"0.6745611",
"0.6745611",
"0.6745611",
"0.6745611",
"0.6745611",
"0.67200303",
"0.66971433",
"0.66803986",
"0.665251... | 0.0 | -1 |
Compute loss for model. If both `labels` and `mask` are None, | def supcon_loss(features_lst, labels_lst, contrast_mode='all', temperature=0.07, base_temperature=0.07):
res = []
device = features_lst.device
for i in range(11):
features = features_lst[:, :, i].unsqueeze(1)
labels = labels_lst[:, i]
if len(features.shape) < 3:
raise Va... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_unreduced_loss_impl(self, labels, logits, mask=None):\n raise NotImplementedError('Calling an abstract method.')",
"def _compute_unreduced_loss_impl(self, labels, logits, mask=None):\n if mask is None:\n mask = utils.is_label_valid(labels)\n labels = tf.compat.v1.where(mask, labels, tf... | [
"0.7447054",
"0.7227031",
"0.71983606",
"0.7175569",
"0.7107803",
"0.7051049",
"0.7042948",
"0.70405126",
"0.6972529",
"0.69522893",
"0.6914948",
"0.6902001",
"0.6863949",
"0.67680174",
"0.67488766",
"0.6742742",
"0.6711211",
"0.6705183",
"0.66921157",
"0.66846156",
"0.666742... | 0.0 | -1 |
Change first convolution layer input channels. | def patch_first_conv(model, in_channels):
# get first conv
for module in model.modules():
if isinstance(module, nn.Conv2d):
break
# change input channels for first conv
module.in_channels = in_channels
weight = module.weight.detach()
reset = False
if in_channels == 1:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch_first_conv(model, in_channels: int = 4) -> None:\n\n # get first conv\n for module in model.modules():\n if isinstance(module, torch.nn.Conv2d):\n break\n\n # change input channels for first conv\n module.in_channels = in_channels\n weight = module.weight.detach()\n # ... | [
"0.75123245",
"0.6696509",
"0.66346097",
"0.64516467",
"0.64232844",
"0.63495713",
"0.6230231",
"0.62070876",
"0.6168099",
"0.61499965",
"0.60493684",
"0.6044107",
"0.60128045",
"0.59726113",
"0.59684473",
"0.5937715",
"0.5925386",
"0.5920553",
"0.59197867",
"0.5918833",
"0.5... | 0.7558337 | 0 |
Initialize your data structure here. | def __init__(self):
self.root = WordNode() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__... | [
"0.7765608",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7595176",
"0.75853467",
"0.7558298",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.74971247",
"0.74971247",
"0.7478105",
"0.7477832",
"0.7477832",
"0.7477832",
... | 0.0 | -1 |
Adds a word into the data structure. | def addWord(self, word: str) -> None:
cur = self.root
for c in word:
cur = cur.children[c]
cur.end = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, word: str) -> None:\n self.d.add(word)",
"def addWord(self, word):\n if word:\n self.word_dict[len(word)].append(word)",
"def add_word(self, word, data=None):\n self.__word = word\n self.__data = data",
"def addWord(self, word: str) -> None:\n self.... | [
"0.8927149",
"0.8707726",
"0.8691716",
"0.8683696",
"0.866071",
"0.8609965",
"0.8577551",
"0.850608",
"0.8444817",
"0.8438259",
"0.8397973",
"0.83428085",
"0.832509",
"0.82493746",
"0.824884",
"0.8230209",
"0.8217579",
"0.82155204",
"0.8213111",
"0.8212719",
"0.8134825",
"0... | 0.78671056 | 29 |
Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. | def search(self, word: str, cur=None) -> bool:
if cur is None:
cur = self.root
is_exist, flag = True, False
for i, c in enumerate(word):
if c=='.':
flag = False
for child in cur.children:
if self.search(word[i+1:], child... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(self, word):\n if not word:\n return False\n if '.' not in word:\n return word in self.word_dict[len(word)]\n for v in self.word_dict[len(word)]:\n for i, ch in enumerate(word):\n if ch != v[i] and ch != '.':\n break... | [
"0.7730379",
"0.76118255",
"0.7585627",
"0.7579322",
"0.7545671",
"0.74328244",
"0.7381778",
"0.73046196",
"0.7272159",
"0.7260463",
"0.7249184",
"0.7232086",
"0.72108984",
"0.71929723",
"0.7162314",
"0.71533686",
"0.71374553",
"0.7133968",
"0.7133708",
"0.7104273",
"0.709549... | 0.65321076 | 71 |
Creates answer instance and tries to add it into database. | def create(text, is_correct, question_id):
answer = Answer(question_id=question_id, text=text, is_correct=is_correct)
try:
answer.save()
return answer
except IntegrityError:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def store(self) -> None:\n con, c = db.connect()\n if not db.exists('SELECT * FROM answers WHERE id = ?', self.id, con=con):\n c.execute('INSERT INTO answers VALUES (?, ?, ?, ?, ?, ?, ?)', (self.id, self.answer, \n self.likes, self.created, self.tell, self.user.id, sel... | [
"0.74090177",
"0.7360692",
"0.7325249",
"0.6723447",
"0.6708266",
"0.6560831",
"0.65191895",
"0.6512874",
"0.6498012",
"0.6452953",
"0.63771117",
"0.63582677",
"0.6309882",
"0.6295815",
"0.6247545",
"0.62320566",
"0.62159014",
"0.6209142",
"0.6187571",
"0.6144167",
"0.6135668... | 0.7057084 | 3 |
Returns True if user's answer matches with answer from database. | def is_correct_answer(answer):
db_answer = Answer.objects.get(id=int(list(answer.keys())[0]))
return db_answer.is_correct == bool(list(answer.values())[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check(self, answer):\n return self.answer == answer",
"def check_if_correct(self, q, ans):\n answer = OnlyAnswer.objects.get(question=q)\n cleaned_guess = (ans.strip()).lower()\n if answer.content == cleaned_guess:\n return True\n else:\n return Fa... | [
"0.7286002",
"0.72846013",
"0.7091092",
"0.6901954",
"0.67433286",
"0.6692698",
"0.6672469",
"0.655168",
"0.6540481",
"0.65291345",
"0.6469405",
"0.64011556",
"0.6371484",
"0.6338362",
"0.6301711",
"0.62966347",
"0.6283468",
"0.62660295",
"0.6132463",
"0.6112869",
"0.60622096... | 0.7438986 | 0 |
Return a spectrum for the given parameters. If necessary the SSPs are updated, and if necessary the component spectra are updated, before being combined here. | def get_spectrum(self, outwave=None, filters=None, nebular=True, **params):
spec, neb, phot, ex = self.get_components(outwave, filters, **params)
total_spec = (spec * self.params['mass'][:, None]).sum(axis=0)
if nebular:
total_spec += neb
total_phot = (phot * self.params['mas... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_spectrum(self, outwave=None, filters=None, peraa=False, **params):\n self.params.update(**params)\n # Pass the model parameters through to the sps object\n ncomp = len(self.params['mass'])\n for ic in range(ncomp):\n s, p, x = self.one_sed(component_index=ic, filterli... | [
"0.713812",
"0.6641795",
"0.6600415",
"0.6430547",
"0.6319527",
"0.6317205",
"0.6156336",
"0.6150407",
"0.61060166",
"0.6043588",
"0.6030428",
"0.5996301",
"0.5982051",
"0.5974503",
"0.58879244",
"0.58713675",
"0.58588684",
"0.58316994",
"0.5792978",
"0.57904905",
"0.5765851"... | 0.63489866 | 4 |
Return the component spectra for the given parameters, making sure to update the components if necessary. | def get_components(self, outwave, filters, **params):
if outwave is not None:
params['outwave'] = outwave
# This will rebuild the basis if relevant parameters changed
self.update(params)
# distance dimming and conversion from Lsun/AA to cgs
dist10 = self.params.get('... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_spectrum(self, outwave=None, filters=None, peraa=False, **params):\n self.params.update(**params)\n # Pass the model parameters through to the sps object\n ncomp = len(self.params['mass'])\n for ic in range(ncomp):\n s, p, x = self.one_sed(component_index=ic, filterli... | [
"0.650899",
"0.63521004",
"0.62602806",
"0.6212332",
"0.6152562",
"0.61498123",
"0.60125136",
"0.600692",
"0.59775174",
"0.59307957",
"0.58136463",
"0.5777221",
"0.568845",
"0.5676116",
"0.5654231",
"0.5653515",
"0.56379193",
"0.5629634",
"0.56277597",
"0.56085885",
"0.560046... | 0.6034915 | 6 |
Basically do all the COMPSP stuff for one component. | def process_component(self, i, outwave, filters):
cspec = self.basis_spec[i, :].copy()
cphot = 0
inwave = self.ssp.wavelengths
if self.safe:
cspec = np.interp(self.params['outwave'], vac2air(inwave), cspec/a)
cphot = 10**(-0.4 * getSED(inwave, cspec/a, filters))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_component(self):\n raise NotImplementedError",
"def execute(self):\n if self.runVolGrid == 1:\n if self.cshUserBatch1 == 0:\n self.write_mesh_csh()\n if self.runVolGrid == 1:\n self.write_mesh_java()\n if self.runCFD == 1:\n if s... | [
"0.580832",
"0.57996196",
"0.5601529",
"0.5541401",
"0.5448608",
"0.54424137",
"0.53614277",
"0.53517246",
"0.5333314",
"0.5324852",
"0.5324852",
"0.52889913",
"0.526856",
"0.5247708",
"0.5241391",
"0.5210807",
"0.5175131",
"0.5170005",
"0.5151401",
"0.5144587",
"0.51259434",... | 0.0 | -1 |
If the emission_rest_wavelengths parameter is present, return a nebular emission line spectrum. Currently uses several approximations for the velocity broadening. Currently does not affect photometry. Only provides samples of the nebular spectrum at outwave, so will not be correct for total power unless outwave densley... | def nebular(self, params, outwave):
if 'emission_rest_wavelengths' not in params:
return 0.
mu = vac2air(params['emission_rest_wavelengths'])
# try to get a nebular redshift, otherwise use stellar redshift,
# otherwise use no redshift
a1 = params.get('zred_emission',... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_spectrum(self, outwave=None, filters=None, nebular=True, **params):\n spec, neb, phot, ex = self.get_components(outwave, filters, **params)\n total_spec = (spec * self.params['mass'][:, None]).sum(axis=0)\n if nebular:\n total_spec += neb\n total_phot = (phot * self.p... | [
"0.57497835",
"0.5429985",
"0.53425705",
"0.52842164",
"0.52446645",
"0.5162241",
"0.50572604",
"0.5036854",
"0.5012343",
"0.49678618",
"0.4942516",
"0.49243805",
"0.49133074",
"0.49097195",
"0.4870502",
"0.48516658",
"0.48274308",
"0.48018676",
"0.47904533",
"0.47681382",
"0... | 0.6854461 | 0 |
Update the parameters, recording whether it was new for the ssp or basis parameters. If either of those changed, regenerate the relevant spectral grid(s). | def update(self, newparams):
for k, v in list(newparams.items()):
if k in self.basis_params:
# Make sure parameter is in dict, and check if it changed
if k not in self.params:
self.basis_dirty = True
self.params[k] = v
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_parameters(self):\n # We update gamma, gamma0, lambda and nu in turn (Bottolo et al, 2011)\n self.update_gamma()\n self.update_gamma0()\n self.update_lambda()\n self.update_nu()\n if self.sample_xi:\n self.update_xi()",
"def update_parameters(self):... | [
"0.73953754",
"0.71710765",
"0.7023726",
"0.69720674",
"0.68460697",
"0.66629374",
"0.6656813",
"0.6526564",
"0.647887",
"0.6461412",
"0.6455409",
"0.638619",
"0.6373815",
"0.6373815",
"0.6373815",
"0.6373815",
"0.6373815",
"0.6373815",
"0.6373815",
"0.6373815",
"0.63724744",... | 0.74350566 | 0 |
Rebuild the component spectra from the SSPs. The component spectra include dust attenuation, redshifting, and spectral regridding. This is basically a proxy for COMPSP from FSPS, with a few small differences. In particular, there is interpolation in metallicity and the redshift and the output wavelength grid are taken ... | def build_basis(self):
if self.debug:
print('sps_basis: rebuilding basis')
# Setup the internal component basis arrays
inwave = self.ssp.wavelengths
nbasis = len(np.atleast_1d(self.params['mass']))
self.nbasis = nbasis
# nbasis = ( len(np.atleast_1d(self.param... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_component(self, i, outwave, filters):\n cspec = self.basis_spec[i, :].copy()\n cphot = 0\n inwave = self.ssp.wavelengths\n\n if self.safe:\n cspec = np.interp(self.params['outwave'], vac2air(inwave), cspec/a)\n cphot = 10**(-0.4 * getSED(inwave, cspec/a... | [
"0.5937564",
"0.5780565",
"0.5741519",
"0.56655246",
"0.563537",
"0.5506949",
"0.5402162",
"0.5372675",
"0.5352444",
"0.5346785",
"0.532719",
"0.531849",
"0.5266165",
"0.5228784",
"0.5225048",
"0.51991665",
"0.51623684",
"0.5162299",
"0.51584435",
"0.5140857",
"0.5140395",
... | 0.60962576 | 0 |
Given a theta vector, generate spectroscopy, photometry and any extras (e.g. stellar mass). | def get_spectrum(self, outwave=None, filters=None, peraa=False, **params):
self.params.update(**params)
# Pass the model parameters through to the sps object
ncomp = len(self.params['mass'])
for ic in range(ncomp):
s, p, x = self.one_sed(component_index=ic, filterlist=filters... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scattering_direction(v, theta):\r\n # Sample cos_phi and sin_phi, phi is the azimuthal angle of the scattering event\r\n continue_loop = True\r\n while continue_loop:\r\n eta1 = 1-2*random.random()\r\n eta2 = 1-2*random.random()\r\n alpha = eta1**2 + eta2**2\r\n if alpha <=... | [
"0.5524242",
"0.5429524",
"0.539759",
"0.5299873",
"0.5297758",
"0.52611303",
"0.5256927",
"0.52566576",
"0.52441525",
"0.5228684",
"0.5216859",
"0.51940954",
"0.5164453",
"0.5148786",
"0.51425505",
"0.51343614",
"0.513167",
"0.51285547",
"0.5123628",
"0.5120493",
"0.51005423... | 0.0 | -1 |
Get the SED of one component for a multicomponent composite SFH. Should set this up to work as an iterator. | def one_sed(self, component_index=0, filterlist=[]):
# Pass the model parameters through to the sps object, and keep track
# of the mass of this component
mass = 1.0
for k, vs in list(self.params.items()):
try:
v = vs[component_index]
except(IndexE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getComponent(self):\n return _libsbml.SpeciesFeature_getComponent(self)",
"def getComponent(self):\n return _libsbml.SubListOfSpeciesFeatures_getComponent(self)",
"def __iter__(self):\n return self.cli.essids.essids().__iter__()",
"def getComponent(self):\n return _libsbml.Spe... | [
"0.60309696",
"0.5875762",
"0.5732701",
"0.5669978",
"0.54934925",
"0.54934925",
"0.5313908",
"0.5306956",
"0.5271111",
"0.5270919",
"0.52329254",
"0.52045023",
"0.5201842",
"0.5201842",
"0.51868373",
"0.51427984",
"0.51417166",
"0.5088495",
"0.5074315",
"0.5063659",
"0.50567... | 0.5463816 | 6 |
Lay down mutiple gaussians on the xaxis. | def gauss(x, mu, A, sigma):
mu, A, sigma = np.atleast_2d(mu), np.atleast_2d(A), np.atleast_2d(sigma)
val = (A / (sigma * np.sqrt(np.pi * 2)) *
np.exp(-(x[:, None] - mu)**2 / (2 * sigma**2)))
return val.sum(axis=-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __draw_xaxis(self):\n self.ax.set_xlim(self.xlims)\n # put x ticks on top\n xticks = [1]\n xticks.extend(range(5, self.xmax+5, 5))\n fs = self.settings.rcParams[\"axes.labelsize\"] if self.settings.otherParams[\n \"xlabel.fontsize\"] is None else self.settings.othe... | [
"0.60257566",
"0.59820426",
"0.5593813",
"0.55852216",
"0.55148125",
"0.55004704",
"0.5493635",
"0.545422",
"0.54387575",
"0.54352844",
"0.5398524",
"0.53769404",
"0.5369894",
"0.5365591",
"0.5359699",
"0.5343257",
"0.53026277",
"0.52932596",
"0.5254157",
"0.52503586",
"0.525... | 0.0 | -1 |
Validates the data and creates the config objects | def validate(data):
if 'project' not in data:
raise PolyaxonfileError("The Polyaxonfile must contain a project section.")
if 'model' not in data:
raise PolyaxonfileError("The Polyaxonfile must contain a model section.")
validated_data = {
'version': data['version'],
'projec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_config(self):\r\n c = self.config\r\n \r\n # Make sure that we have a database_path, and an image_path...\r\n assert 'database_path' in c\r\n assert 'image_path' in c\r\n # We should probably check if these paths exist and make them as well...\r\n \r\n ... | [
"0.66749805",
"0.65164816",
"0.64016116",
"0.64016116",
"0.6307988",
"0.62377954",
"0.6136363",
"0.61220586",
"0.6081083",
"0.6076208",
"0.6051987",
"0.6048227",
"0.60396284",
"0.6021695",
"0.59975976",
"0.59783435",
"0.5976575",
"0.5976575",
"0.5946913",
"0.59431374",
"0.593... | 0.64124906 | 2 |
r"""align(imgDim, rgbImg, bb=None, landmarks=None, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP) Transform and align a face in an image. | def align(imgDim, rgbImg,
landmarks, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP,
skipMulti=True):
assert imgDim is not None
assert rgbImg is not None
assert landmarks is not None
#if bb is None:
# bb = self.getLargestFaceBoundingBox(rgbImg, skipMult... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def align(self, image, landmark_indices, anchor_points, size=96):\n # Detect face in image and find landmarks\n box = self.detect(image)\n landmarks = self.find_landmarks(image, box)\n\n # Select three points in the landmarks(Eyes and nose)\n points_in_image = landmarks[landmark_... | [
"0.6571622",
"0.65087074",
"0.6424263",
"0.63643926",
"0.62261367",
"0.62224346",
"0.6209903",
"0.60258204",
"0.6018538",
"0.58878434",
"0.5757735",
"0.56468785",
"0.552677",
"0.5469069",
"0.53907555",
"0.5254516",
"0.5184894",
"0.5080917",
"0.50786936",
"0.50399625",
"0.5037... | 0.7130995 | 0 |
Gets console output text from a specific job build | def get_console_text(self):
console_text_api = '/consoleText'
return self._api_request(self.url + console_text_api) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_build_line(latest_build):\n proc = Popen([\"osg-koji\", \"buildinfo\", latest_build],\n stdout=PIPE)\n build_line = proc.stdout.readline().decode(\"latin-1\").strip()\n ret = proc.wait()\n if ret != 0 or not build_line:\n return\n return build_line",
"def general_job... | [
"0.6886761",
"0.6039708",
"0.60122496",
"0.60070854",
"0.60053575",
"0.5946325",
"0.5929492",
"0.5887831",
"0.5874886",
"0.58744806",
"0.58705306",
"0.5813472",
"0.5802365",
"0.5799912",
"0.5730037",
"0.5696503",
"0.56834877",
"0.56523955",
"0.56515515",
"0.56502163",
"0.5633... | 0.0 | -1 |
Gets the prepopulated environment variables for the job build | def get_env_vars(self):
env_vars_api = '/injectedEnvVars/api/json'
env_vars_json = self._api_request(self.url + env_vars_api)
try:
env_vars_json = json.loads(env_vars_json)
return env_vars_json['envMap']
except JSONDecodeError:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_env_vars(self):\n return _untag_env_vars(self._tagged_env_vars, build=True)",
"def environment_variables(\n self,\n ) -> typing.Optional[\n typing.Mapping[str, aws_cdk.aws_codebuild.BuildEnvironmentVariable]\n ]:\n return self._values.get(\"environment_variables\")",
... | [
"0.71218103",
"0.6978689",
"0.6978689",
"0.6978689",
"0.6978689",
"0.6962417",
"0.6928234",
"0.6838894",
"0.6718607",
"0.6701541",
"0.67005",
"0.6680116",
"0.6649582",
"0.66316056",
"0.6587881",
"0.65733594",
"0.6556599",
"0.64912426",
"0.63936",
"0.63538235",
"0.6329612",
... | 0.5978486 | 53 |
Return a bs4 object containing all the tags in doc of the URL | def _grab_tags(self, url):
a = self._api_request(url)
return bs4.BeautifulSoup(a,features="html.parser") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_soup(url):\n return BeautifulSoup(requests.get(url).content, 'lxml')",
"def getSoup(url):\n return BeautifulSoup(getHtml(url), 'lxml')",
"def find_tag_urls(r):\n parser = MyHTMLParser()\n parser.feed(r)\n return parser.url_list",
"def request(self, url):\r\n\r\n req = self.get(u... | [
"0.7076313",
"0.70216066",
"0.69696605",
"0.6889851",
"0.6826193",
"0.68196535",
"0.6767906",
"0.67462474",
"0.67079365",
"0.67003834",
"0.66789085",
"0.66782737",
"0.6670707",
"0.66667145",
"0.66216266",
"0.6597798",
"0.65232784",
"0.64535815",
"0.64357543",
"0.6435498",
"0.... | 0.7892951 | 0 |
Gets the workspace zip for the specific build URL by parsing HTML The API has no way of retrieving the workspace zip AFAIK | def get_workspace_zip(self):
workspace_api = '/ws/'
# print("Checking Workspaces For: {}".format(self.url))
workspace_elements = self._grab_tags(self.url + workspace_api)
workspace_links = []
root_domain = urllib.parse.urlparse(self.url).scheme + '://' + urllib.parse.urlparse(sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_project(path: str):\n zip_path = os.path.join(path, 'Simulation.Machine.V1.zip')\n\n # Download zip file with project\n requested_file = requests.get(URL)\n with open(zip_path, 'wb') as f:\n f.write(requested_file.content)\n\n # Extract contents\n with ZipFile(zip_path, 'r') as... | [
"0.556513",
"0.5522339",
"0.5424023",
"0.5417535",
"0.53908026",
"0.5365669",
"0.5358795",
"0.5332443",
"0.52523816",
"0.5220812",
"0.5178104",
"0.5170915",
"0.5148962",
"0.51238537",
"0.51191694",
"0.5066204",
"0.5062707",
"0.5060167",
"0.5052632",
"0.50380456",
"0.5033808",... | 0.7396624 | 0 |
Recursively search through all jobs and projects to pull out build URLs | def get_all_build_links(url, auth=None, netloc_force=False):
all_build_links = []
if 'api/json' not in url:
# if the api endpoint isnt appended, then append it:
url += '/api/json/'
def recurse_to_build(url):
orig_url = urllib.parse.urlparse(url)
try:
json_reply = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_builds(self):\n for p in self.product_config:\n p_str = p[0]\n\n for l in self.link_list:\n if l.startswith(p[1]):\n if not self.builds_list.has_key(p_str):\n self.builds_list[p_str] = []\n b_str = ... | [
"0.6178584",
"0.612089",
"0.60826075",
"0.59894234",
"0.5935299",
"0.5781459",
"0.5699846",
"0.56969726",
"0.5667781",
"0.560925",
"0.5579634",
"0.5579634",
"0.55440015",
"0.5480648",
"0.5456297",
"0.5444982",
"0.5421424",
"0.54137886",
"0.5393616",
"0.5388915",
"0.5386272",
... | 0.6822186 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.